]> git.saurik.com Git - wxWidgets.git/blob - tests/fswatcher/fswatchertest.cpp
5b238a49d54d4681d26b17bbee132f274f19c99a
[wxWidgets.git] / tests / fswatcher / fswatchertest.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: tests/fswatcher/fswatchertest.cpp
3 // Purpose: wxFileSystemWatcher unit test
4 // Author: Bartosz Bekier
5 // Created: 2009-06-11
6 // RCS-ID: $Id$
7 // Copyright: (c) 2009 Bartosz Bekier
8 ///////////////////////////////////////////////////////////////////////////////
9
10 // ----------------------------------------------------------------------------
11 // headers
12 // ----------------------------------------------------------------------------
13
14 #include "testprec.h"
15
16 #ifdef __BORLANDC__
17 #pragma hdrstop
18 #endif
19
20 #ifndef WX_PRECOMP
21 #include "wx/timer.h"
22 #endif
23
24 #include "wx/evtloop.h"
25 #include "wx/filename.h"
26 #include "wx/filefn.h"
27 #include "wx/stdpaths.h"
28 #include "wx/fswatcher.h"
29
30 #include "testfile.h"
31
32 // ----------------------------------------------------------------------------
33 // local functions
34 // ----------------------------------------------------------------------------
35
36 // class generating file system events
37 class EventGenerator
38 {
39 public:
40 static EventGenerator& Get()
41 {
42 if (!ms_instance)
43 ms_instance = new EventGenerator(GetWatchDir());
44
45 return *ms_instance;
46 }
47
48 EventGenerator(const wxFileName& path) : m_base(path)
49 {
50 m_old = wxFileName();
51 m_file = RandomName();
52 m_new = RandomName();
53 }
54
55 // operations
56 bool CreateFile()
57 {
58 wxFile file(m_file.GetFullPath(), wxFile::write);
59 return file.IsOpened() && m_file.FileExists();
60 }
61
62 bool RenameFile()
63 {
64 CPPUNIT_ASSERT(m_file.FileExists());
65
66 wxLogDebug("Renaming %s=>%s", m_file.GetFullPath(), m_new.GetFullPath());
67
68 bool ret = wxRenameFile(m_file.GetFullPath(), m_new.GetFullPath());
69 if (ret)
70 {
71 m_old = m_file;
72 m_file = m_new;
73 m_new = RandomName();
74 }
75
76 return ret;
77 }
78
79 bool DeleteFile()
80 {
81 CPPUNIT_ASSERT(m_file.FileExists());
82
83 bool ret = wxRemoveFile(m_file.GetFullPath());
84 if (ret)
85 {
86 m_old = m_file;
87 m_file = m_new;
88 m_new = RandomName();
89 }
90
91 return ret;
92 }
93
94 bool TouchFile()
95 {
96 return m_file.Touch();
97 }
98
99 bool ReadFile()
100 {
101 wxFile f(m_file.GetFullPath());
102 CPPUNIT_ASSERT(f.IsOpened());
103
104 char buf[1];
105 ssize_t count = f.Read(buf, sizeof(buf));
106 CPPUNIT_ASSERT(count > 0);
107
108 return true;
109 }
110
111 bool ModifyFile()
112 {
113 CPPUNIT_ASSERT(m_file.FileExists());
114
115 wxFile file(m_file.GetFullPath(), wxFile::write_append);
116 CPPUNIT_ASSERT(file.IsOpened());
117
118 CPPUNIT_ASSERT(file.Write("Words of Wisdom, Lloyd. Words of wisdom\n"));
119 return file.Close();
120 }
121
122 // helpers
123 wxFileName RandomName(int length = 10)
124 {
125 return RandomName(m_base, length);
126 }
127
128 // static helpers
129 static const wxFileName& GetWatchDir()
130 {
131 static wxFileName dir;
132
133 if (dir.DirExists())
134 return dir;
135
136 wxString tmp = wxStandardPaths::Get().GetTempDir();
137 dir.AssignDir(tmp);
138
139 // XXX look for more unique name? there is no function to generate
140 // unique filename, the file always get created...
141 dir.AppendDir("fswatcher_test");
142 CPPUNIT_ASSERT(!dir.DirExists());
143 CPPUNIT_ASSERT(dir.Mkdir());
144
145 return dir;
146 }
147
148 static void RemoveWatchDir()
149 {
150 wxFileName dir = GetWatchDir();
151 CPPUNIT_ASSERT(dir.DirExists());
152
153 // just to be really sure we know what we remove
154 CPPUNIT_ASSERT_EQUAL( "fswatcher_test", dir.GetDirs().Last() );
155
156 // FIXME-VC6: using non-static Rmdir() results in ICE
157 CPPUNIT_ASSERT( wxFileName::Rmdir(dir.GetFullPath(), wxPATH_RMDIR_RECURSIVE) );
158 }
159
160 static wxFileName RandomName(const wxFileName& base, int length = 10)
161 {
162 static int ALFA_CNT = 'z' - 'a';
163
164 wxString s;
165 for (int i = 0 ; i < length; ++i)
166 {
167 char c = 'a' + (rand() % ALFA_CNT);
168 s += c;
169 }
170
171 return wxFileName(base.GetFullPath(), s);
172 }
173
174 public:
175 wxFileName m_base; // base dir for doing operations
176 wxFileName m_file; // current file name
177 wxFileName m_old; // previous file name
178 wxFileName m_new; // name after renaming
179
180 protected:
181 static EventGenerator* ms_instance;
182 };
183
184 EventGenerator* EventGenerator::ms_instance = 0;
185
186
187 // custom event handler
188 class EventHandler : public wxEvtHandler
189 {
190 public:
191 enum { WAIT_DURATION = 3 };
192
193 EventHandler(int types = wxFSW_EVENT_ALL) :
194 eg(EventGenerator::Get()), m_loop(0), m_count(0), m_watcher(0),
195 m_eventTypes(types)
196 {
197 m_loop = new wxEventLoop();
198 Connect(wxEVT_IDLE, wxIdleEventHandler(EventHandler::OnIdle));
199 Connect(wxEVT_FSWATCHER, wxFileSystemWatcherEventHandler(
200 EventHandler::OnFileSystemEvent));
201 }
202
203 virtual ~EventHandler()
204 {
205 delete m_watcher;
206 if (m_loop)
207 {
208 if (m_loop->IsRunning())
209 m_loop->Exit();
210 delete m_loop;
211 }
212 }
213
214 void Exit()
215 {
216 m_loop->Exit();
217 }
218
219 // sends idle event, so we get called in a moment
220 void SendIdle()
221 {
222 wxIdleEvent* e = new wxIdleEvent();
223 QueueEvent(e);
224 }
225
226 void Run()
227 {
228 SendIdle();
229 m_loop->Run();
230 }
231
232 void OnIdle(wxIdleEvent& /*evt*/)
233 {
234 bool more = Action();
235 m_count++;
236
237 if (more)
238 {
239 SendIdle();
240 }
241 }
242
243 // returns whether we should produce more idle events
244 virtual bool Action()
245 {
246 switch (m_count)
247 {
248 case 0:
249 CPPUNIT_ASSERT(Init());
250 break;
251 case 1:
252 GenerateEvent();
253 break;
254 case 2:
255 // actual test
256 CheckResult();
257 Exit();
258 break;
259
260 // TODO a mechanism that will break the loop in case we
261 // don't receive a file system event
262 // this below doesn't quite work, so all tests must pass :-)
263 #if 0
264 case 2:
265 m_loop.Yield();
266 m_loop.WakeUp();
267 CPPUNIT_ASSERT(KeepWaiting());
268 m_loop.Yield();
269 break;
270 case 3:
271 break;
272 case 4:
273 CPPUNIT_ASSERT(AfterWait());
274 break;
275 #endif
276 } // switch (m_count)
277
278 return m_count <= 0;
279 }
280
281 virtual bool Init()
282 {
283 // test we're good to go
284 CPPUNIT_ASSERT(wxEventLoopBase::GetActive());
285
286 // XXX only now can we construct Watcher, because we need
287 // active loop here
288 m_watcher = new wxFileSystemWatcher();
289 m_watcher->SetOwner(this);
290
291 // add dir to be watched
292 wxFileName dir = EventGenerator::GetWatchDir();
293 CPPUNIT_ASSERT(m_watcher->Add(dir, m_eventTypes));
294
295 return true;
296 }
297
298 virtual bool KeepWaiting()
299 {
300 // did we receive event already?
301 if (!tested)
302 {
303 // well, let's wait a bit more
304 wxSleep(WAIT_DURATION);
305 }
306
307 return true;
308 }
309
310 virtual bool AfterWait()
311 {
312 // fail if still no events
313 WX_ASSERT_MESSAGE
314 (
315 ("No events during %d seconds!", static_cast<int>(WAIT_DURATION)),
316 tested
317 );
318
319 return true;
320 }
321
322 virtual void OnFileSystemEvent(wxFileSystemWatcherEvent& evt)
323 {
324 wxLogDebug("--- %s ---", evt.ToString());
325 m_lastEvent = wxDynamicCast(evt.Clone(), wxFileSystemWatcherEvent);
326 m_events.Add(m_lastEvent);
327
328 // test finished
329 SendIdle();
330 tested = true;
331 }
332
333 virtual void CheckResult()
334 {
335 CPPUNIT_ASSERT_MESSAGE( "No events received", !m_events.empty() );
336
337 const wxFileSystemWatcherEvent * const e = m_events.front();
338
339 // this is our "reference event"
340 const wxFileSystemWatcherEvent expected = ExpectedEvent();
341
342 CPPUNIT_ASSERT_EQUAL( expected.GetChangeType(), e->GetChangeType() );
343
344 CPPUNIT_ASSERT_EQUAL((int)wxEVT_FSWATCHER, e->GetEventType());
345
346 // XXX this needs change
347 CPPUNIT_ASSERT_EQUAL(wxEVT_CATEGORY_UNKNOWN, e->GetEventCategory());
348
349 CPPUNIT_ASSERT_EQUAL(expected.GetPath(), e->GetPath());
350 CPPUNIT_ASSERT_EQUAL(expected.GetNewPath(), e->GetNewPath());
351
352 // Under MSW extra modification events are sometimes reported after a
353 // rename and we just can't get rid of them, so ignore them in this
354 // test if they do happen.
355 if ( e->GetChangeType() == wxFSW_EVENT_RENAME &&
356 m_events.size() == 2 )
357 {
358 const wxFileSystemWatcherEvent* const e2 = m_events.back();
359 if ( e2->GetChangeType() == wxFSW_EVENT_MODIFY &&
360 e2->GetPath() == e->GetNewPath() )
361 {
362 // This is a modify event for the new file, ignore it.
363 return;
364 }
365 }
366
367 WX_ASSERT_EQUAL_MESSAGE
368 (
369 (
370 "Extra events received, last one is of type %x, path=\"%s\" "
371 "(the original event was for \"%s\" (\"%s\")",
372 m_events.back()->GetChangeType(),
373 m_events.back()->GetPath().GetFullPath(),
374 e->GetPath().GetFullPath(),
375 e->GetNewPath().GetFullPath()
376 ),
377 1, m_events.size()
378 );
379
380 }
381
382 virtual void GenerateEvent() = 0;
383
384 virtual wxFileSystemWatcherEvent ExpectedEvent() = 0;
385
386
387 protected:
388 EventGenerator& eg;
389 wxEventLoopBase* m_loop; // loop reference
390 int m_count; // idle events count
391
392 wxFileSystemWatcher* m_watcher;
393 int m_eventTypes; // Which event-types to watch. Normally all of them
394 bool tested; // indicates, whether we have already passed the test
395
396 #include "wx/arrimpl.cpp"
397 WX_DEFINE_ARRAY_PTR(wxFileSystemWatcherEvent*, wxArrayEvent);
398 wxArrayEvent m_events;
399 wxFileSystemWatcherEvent* m_lastEvent;
400 };
401
402
403 // ----------------------------------------------------------------------------
404 // test class
405 // ----------------------------------------------------------------------------
406
407 class FileSystemWatcherTestCase : public CppUnit::TestCase
408 {
409 public:
410 FileSystemWatcherTestCase() { }
411
412 virtual void setUp();
413 virtual void tearDown();
414
415 protected:
416 wxEventLoopBase* m_loop;
417
418 private:
419 CPPUNIT_TEST_SUITE( FileSystemWatcherTestCase );
420 CPPUNIT_TEST( TestEventCreate );
421 CPPUNIT_TEST( TestEventDelete );
422 #if !defined(__VISUALC__) || wxCHECK_VISUALC_VERSION(7)
423 CPPUNIT_TEST( TestTrees );
424 #endif
425
426 // kqueue-based implementation doesn't collapse create/delete pairs in
427 // renames and doesn't detect neither modifications nor access to the
428 // files reliably currently so disable these tests
429 //
430 // FIXME: fix the code and reenable them
431 #ifndef wxHAS_KQUEUE
432 CPPUNIT_TEST( TestEventRename );
433 CPPUNIT_TEST( TestEventModify );
434
435 // MSW implementation doesn't detect file access events currently
436 #ifndef __WINDOWS__
437 CPPUNIT_TEST( TestEventAccess );
438 #endif // __WINDOWS__
439 #endif // !wxHAS_KQUEUE
440
441 #ifdef wxHAS_INOTIFY
442 CPPUNIT_TEST( TestEventAttribute );
443 CPPUNIT_TEST( TestSingleWatchtypeEvent );
444 #endif // wxHAS_INOTIFY
445
446 CPPUNIT_TEST( TestNoEventsAfterRemove );
447 CPPUNIT_TEST_SUITE_END();
448
449 void TestEventCreate();
450 void TestEventDelete();
451 void TestEventRename();
452 void TestEventModify();
453 void TestEventAccess();
454 #ifdef wxHAS_INOTIFY
455 void TestEventAttribute();
456 void TestSingleWatchtypeEvent();
457 #endif // wxHAS_INOTIFY
458 #if !defined(__VISUALC__) || wxCHECK_VISUALC_VERSION(7)
459 void TestTrees(); // Visual C++ 6 can't build this
460 #endif
461 void TestNoEventsAfterRemove();
462
463 DECLARE_NO_COPY_CLASS(FileSystemWatcherTestCase)
464 };
465
466 // the test currently hangs under OS X for some reason and this prevents tests
467 // ran by buildbot from completing so disable it until someone has time to
468 // debug it
469 //
470 // FIXME: debug and fix this!
471 #ifndef __WXOSX__
472 // register in the unnamed registry so that these tests are run by default
473 CPPUNIT_TEST_SUITE_REGISTRATION( FileSystemWatcherTestCase );
474 #endif
475
476 // also include in its own registry so that these tests can be run alone
477 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( FileSystemWatcherTestCase,
478 "FileSystemWatcherTestCase" );
479
480 void FileSystemWatcherTestCase::setUp()
481 {
482 wxLog::AddTraceMask(wxTRACE_FSWATCHER);
483 EventGenerator::Get().GetWatchDir();
484 }
485
486 void FileSystemWatcherTestCase::tearDown()
487 {
488 EventGenerator::Get().RemoveWatchDir();
489 }
490
491 // ----------------------------------------------------------------------------
492 // TestEventCreate
493 // ----------------------------------------------------------------------------
494 void FileSystemWatcherTestCase::TestEventCreate()
495 {
496 wxLogDebug("TestEventCreate()");
497
498 class EventTester : public EventHandler
499 {
500 public:
501 virtual void GenerateEvent()
502 {
503 CPPUNIT_ASSERT(eg.CreateFile());
504 }
505
506 virtual wxFileSystemWatcherEvent ExpectedEvent()
507 {
508 wxFileSystemWatcherEvent event(wxFSW_EVENT_CREATE);
509 event.SetPath(eg.m_file);
510 event.SetNewPath(eg.m_file);
511 return event;
512 }
513 };
514
515 EventTester tester;
516
517 wxLogTrace(wxTRACE_FSWATCHER, "TestEventCreate tester created()");
518
519 tester.Run();
520 }
521
522 // ----------------------------------------------------------------------------
523 // TestEventDelete
524 // ----------------------------------------------------------------------------
525 void FileSystemWatcherTestCase::TestEventDelete()
526 {
527 wxLogDebug("TestEventDelete()");
528
529 class EventTester : public EventHandler
530 {
531 public:
532 virtual void GenerateEvent()
533 {
534 CPPUNIT_ASSERT(eg.DeleteFile());
535 }
536
537 virtual wxFileSystemWatcherEvent ExpectedEvent()
538 {
539 wxFileSystemWatcherEvent event(wxFSW_EVENT_DELETE);
540 event.SetPath(eg.m_old);
541
542 // CHECK maybe new path here could be NULL or sth?
543 event.SetNewPath(eg.m_old);
544 return event;
545 }
546 };
547
548 // we need to create a file now, so we can delete it
549 EventGenerator::Get().CreateFile();
550
551 EventTester tester;
552 tester.Run();
553 }
554
555 // ----------------------------------------------------------------------------
556 // TestEventRename
557 // ----------------------------------------------------------------------------
558 void FileSystemWatcherTestCase::TestEventRename()
559 {
560 wxLogDebug("TestEventRename()");
561
562 class EventTester : public EventHandler
563 {
564 public:
565 virtual void GenerateEvent()
566 {
567 CPPUNIT_ASSERT(eg.RenameFile());
568 }
569
570 virtual wxFileSystemWatcherEvent ExpectedEvent()
571 {
572 wxFileSystemWatcherEvent event(wxFSW_EVENT_RENAME);
573 event.SetPath(eg.m_old);
574 event.SetNewPath(eg.m_file);
575 return event;
576 }
577 };
578
579 // need a file to rename later
580 EventGenerator::Get().CreateFile();
581
582 EventTester tester;
583 tester.Run();
584 }
585
586 // ----------------------------------------------------------------------------
587 // TestEventModify
588 // ----------------------------------------------------------------------------
589 void FileSystemWatcherTestCase::TestEventModify()
590 {
591 wxLogDebug("TestEventModify()");
592
593 class EventTester : public EventHandler
594 {
595 public:
596 virtual void GenerateEvent()
597 {
598 CPPUNIT_ASSERT(eg.ModifyFile());
599 }
600
601 virtual wxFileSystemWatcherEvent ExpectedEvent()
602 {
603 wxFileSystemWatcherEvent event(wxFSW_EVENT_MODIFY);
604 event.SetPath(eg.m_file);
605 event.SetNewPath(eg.m_file);
606 return event;
607 }
608 };
609
610 // we need to create a file to modify
611 EventGenerator::Get().CreateFile();
612
613 EventTester tester;
614 tester.Run();
615 }
616
617 // ----------------------------------------------------------------------------
618 // TestEventAccess
619 // ----------------------------------------------------------------------------
620 void FileSystemWatcherTestCase::TestEventAccess()
621 {
622 wxLogDebug("TestEventAccess()");
623
624 class EventTester : public EventHandler
625 {
626 public:
627 virtual void GenerateEvent()
628 {
629 CPPUNIT_ASSERT(eg.ReadFile());
630 }
631
632 virtual wxFileSystemWatcherEvent ExpectedEvent()
633 {
634 wxFileSystemWatcherEvent event(wxFSW_EVENT_ACCESS);
635 event.SetPath(eg.m_file);
636 event.SetNewPath(eg.m_file);
637 return event;
638 }
639 };
640
641 // we need to create a file to read from it and write sth to it
642 EventGenerator::Get().CreateFile();
643 EventGenerator::Get().ModifyFile();
644
645 EventTester tester;
646 tester.Run();
647 }
648
649 #ifdef wxHAS_INOTIFY
650 // ----------------------------------------------------------------------------
651 // TestEventAttribute
652 // ----------------------------------------------------------------------------
653 void FileSystemWatcherTestCase::TestEventAttribute()
654 {
655 wxLogDebug("TestEventAttribute()");
656
657 class EventTester : public EventHandler
658 {
659 public:
660 virtual void GenerateEvent()
661 {
662 CPPUNIT_ASSERT(eg.TouchFile());
663 }
664
665 virtual wxFileSystemWatcherEvent ExpectedEvent()
666 {
667 wxFileSystemWatcherEvent event(wxFSW_EVENT_ATTRIB);
668 event.SetPath(eg.m_file);
669 event.SetNewPath(eg.m_file);
670 return event;
671 }
672 };
673
674 // we need to create a file to touch
675 EventGenerator::Get().CreateFile();
676
677 EventTester tester;
678 tester.Run();
679 }
680
681 // ----------------------------------------------------------------------------
682 // TestSingleWatchtypeEvent: Watch only wxFSW_EVENT_ACCESS
683 // ----------------------------------------------------------------------------
684 void FileSystemWatcherTestCase::TestSingleWatchtypeEvent()
685 {
686 wxLogDebug("TestSingleWatchtypeEvent()");
687
688 class EventTester : public EventHandler
689 {
690 public:
691 // We could pass wxFSW_EVENT_CREATE or MODIFY instead, but not RENAME or
692 // DELETE as the event path fields would be wrong in CheckResult()
693 EventTester() : EventHandler(wxFSW_EVENT_ACCESS) {}
694
695 virtual void GenerateEvent()
696 {
697 // As wxFSW_EVENT_ACCESS is passed to the ctor only ReadFile() will
698 // generate an event. Without it they all will, and the test fails
699 CPPUNIT_ASSERT(eg.CreateFile());
700 CPPUNIT_ASSERT(eg.ModifyFile());
701 CPPUNIT_ASSERT(eg.ReadFile());
702 }
703
704 virtual wxFileSystemWatcherEvent ExpectedEvent()
705 {
706 wxFileSystemWatcherEvent event(wxFSW_EVENT_ACCESS);
707 event.SetPath(eg.m_file);
708 event.SetNewPath(eg.m_file);
709 return event;
710 }
711 };
712
713 EventTester tester;
714 tester.Run();
715 }
716 #endif // wxHAS_INOTIFY
717
718 // ----------------------------------------------------------------------------
719 // TestTrees
720 // ----------------------------------------------------------------------------
721
722 #if !defined(__VISUALC__) || wxCHECK_VISUALC_VERSION(7)
723 void FileSystemWatcherTestCase::TestTrees()
724 {
725 class TreeTester : public EventHandler
726 {
727 const size_t subdirs;
728 const size_t files;
729
730 public:
731 TreeTester() : subdirs(5), files(3) {}
732
733 void GrowTree(wxFileName dir
734 #ifdef __UNIX__
735 , bool withSymlinks = false
736 #endif
737 )
738 {
739 CPPUNIT_ASSERT(dir.Mkdir());
740 // Now add a subdir with an easy name to remember in WatchTree()
741 dir.AppendDir("child");
742 CPPUNIT_ASSERT(dir.Mkdir());
743 wxFileName child(dir); // Create a copy to which to symlink
744
745 // Create a branch of 5 numbered subdirs, each containing 3
746 // numbered files
747 for ( unsigned d = 0; d < subdirs; ++d )
748 {
749 dir.AppendDir(wxString::Format("subdir%u", d+1));
750 CPPUNIT_ASSERT(dir.Mkdir());
751
752 const wxString prefix = dir.GetPathWithSep();
753 const wxString ext[] = { ".txt", ".log", "" };
754 for ( unsigned f = 0; f < files; ++f )
755 {
756 // Just create the files.
757 wxFile(prefix + wxString::Format("file%u", f+1) + ext[f],
758 wxFile::write);
759 }
760 #if defined(__UNIX__)
761 if ( withSymlinks )
762 {
763 // Create a symlink to a files, and another to 'child'
764 CPPUNIT_ASSERT_EQUAL(0,
765 symlink(wxString(prefix + "file1").c_str(),
766 wxString(prefix + "file.lnk").c_str()));
767 CPPUNIT_ASSERT_EQUAL(0,
768 symlink(child.GetFullPath().c_str(),
769 wxString(prefix + "dir.lnk").c_str()));
770 }
771 #endif // __UNIX__
772 }
773 }
774
775 void RmDir(wxFileName dir)
776 {
777 CPPUNIT_ASSERT(dir.DirExists());
778
779 CPPUNIT_ASSERT(dir.Rmdir(wxPATH_RMDIR_RECURSIVE));
780 }
781
782 void WatchDir(wxFileName dir)
783 {
784 CPPUNIT_ASSERT(m_watcher);
785
786 // Store the initial count; there may already be some watches
787 const int initial = m_watcher->GetWatchedPathsCount();
788
789 m_watcher->Add(dir);
790 CPPUNIT_ASSERT_EQUAL(initial + 1,
791 m_watcher->GetWatchedPathsCount());
792 }
793
794 void RemoveSingleWatch(wxFileName dir)
795 {
796 CPPUNIT_ASSERT(m_watcher);
797
798 const int initial = m_watcher->GetWatchedPathsCount();
799
800 m_watcher->Remove(dir);
801 CPPUNIT_ASSERT_EQUAL(initial - 1,
802 m_watcher->GetWatchedPathsCount());
803 }
804
805 void WatchTree(const wxFileName& dir)
806 {
807 CPPUNIT_ASSERT(m_watcher);
808
809 size_t treeitems = 1; // the trunk
810 #ifndef __WINDOWS__
811 // When there's no file mask, wxMSW sets a single watch
812 // on the trunk which is implemented recursively.
813 // wxGTK always sets an additional watch for each subdir
814 treeitems += subdirs + 1; // +1 for 'child'
815 #endif // __WINDOWS__
816
817 // Store the initial count; there may already be some watches
818 const int initial = m_watcher->GetWatchedPathsCount();
819
820 GrowTree(dir);
821
822 m_watcher->AddTree(dir);
823 const int plustree = m_watcher->GetWatchedPathsCount();
824
825 CPPUNIT_ASSERT_EQUAL(initial + treeitems, plustree);
826
827 m_watcher->RemoveTree(dir);
828 CPPUNIT_ASSERT_EQUAL(initial, m_watcher->GetWatchedPathsCount());
829
830 // Now test the refcount mechanism by watching items more than once
831 wxFileName child(dir);
832 child.AppendDir("child");
833 m_watcher->AddTree(child);
834 // Check some watches were added; we don't care about the number
835 CPPUNIT_ASSERT(initial < m_watcher->GetWatchedPathsCount());
836 // Now watch the whole tree and check that the count is the same
837 // as it was the first time, despite also adding 'child' separately
838 // Except that in wxMSW this isn't true: each watch will be a
839 // single, recursive dir; so fudge the count
840 size_t fudge = 0;
841 #ifdef __WINDOWS__
842 fudge = 1;
843 #endif // __WINDOWS__
844 m_watcher->AddTree(dir);
845 CPPUNIT_ASSERT_EQUAL(plustree + fudge, m_watcher->GetWatchedPathsCount());
846 m_watcher->RemoveTree(child);
847 CPPUNIT_ASSERT(initial < m_watcher->GetWatchedPathsCount());
848 m_watcher->RemoveTree(dir);
849 CPPUNIT_ASSERT_EQUAL(initial, m_watcher->GetWatchedPathsCount());
850 #if defined(__UNIX__)
851 // Finally, test a tree containing internal symlinks
852 RmDir(dir);
853 GrowTree(dir, true /* test symlinks */);
854
855 // Without the DontFollowLink() call AddTree() would now assert
856 // (and without the assert, it would infinitely loop)
857 wxFileName fn = dir;
858 fn.DontFollowLink();
859 CPPUNIT_ASSERT(m_watcher->AddTree(fn));
860 CPPUNIT_ASSERT(m_watcher->RemoveTree(fn));
861
862 // Regrow the tree without symlinks, ready for the next test
863 RmDir(dir);
864 GrowTree(dir, false);
865 #endif // __UNIX__
866 }
867
868 void WatchTreeWithFilespec(const wxFileName& dir)
869 {
870 CPPUNIT_ASSERT(m_watcher);
871 CPPUNIT_ASSERT(dir.DirExists()); // Was built in WatchTree()
872
873 // Store the initial count; there may already be some watches
874 const int initial = m_watcher->GetWatchedPathsCount();
875
876 // When we use a filter, both wxMSW and wxGTK implementations set
877 // an additional watch for each subdir (+1 for the root dir itself
878 // and another +1 for "child").
879 const size_t treeitems = subdirs + 2;
880 m_watcher->AddTree(dir, wxFSW_EVENT_ALL, "*.txt");
881
882 const int plustree = m_watcher->GetWatchedPathsCount();
883 CPPUNIT_ASSERT_EQUAL(initial + treeitems, plustree);
884
885 // RemoveTree should try to remove only those files that were added
886 m_watcher->RemoveTree(dir);
887 CPPUNIT_ASSERT_EQUAL(initial, m_watcher->GetWatchedPathsCount());
888 }
889
890 void RemoveAllWatches()
891 {
892 CPPUNIT_ASSERT(m_watcher);
893
894 m_watcher->RemoveAll();
895 CPPUNIT_ASSERT_EQUAL(0, m_watcher->GetWatchedPathsCount());
896 }
897
898 virtual void GenerateEvent()
899 {
900 // We don't use this function for events. Just run the tests
901
902 wxFileName watchdir = EventGenerator::GetWatchDir();
903 CPPUNIT_ASSERT(watchdir.DirExists());
904
905 wxFileName treedir(watchdir);
906 treedir.AppendDir("treetrunk");
907 CPPUNIT_ASSERT(!treedir.DirExists());
908
909 wxFileName singledir(watchdir);
910 singledir.AppendDir("single");
911 CPPUNIT_ASSERT(!singledir.DirExists());
912 CPPUNIT_ASSERT(singledir.Mkdir());
913
914 WatchDir(singledir);
915 WatchTree(treedir);
916 // Now test adding and removing a tree using a filespec
917 // wxMSW uses the generic method to add matching files; which fails
918 // as it doesn't support adding files :/ So disable the test
919 #ifndef __WINDOWS__
920 WatchTreeWithFilespec(treedir);
921 #endif // __WINDOWS__
922
923 RemoveSingleWatch(singledir);
924 // Add it back again, ready to test RemoveAll()
925 WatchDir(singledir);
926
927 RemoveAllWatches();
928
929 // Clean up
930 RmDir(singledir);
931 RmDir(treedir);
932
933 Exit();
934 }
935
936 virtual wxFileSystemWatcherEvent ExpectedEvent()
937 {
938 CPPUNIT_FAIL("Shouldn't be called");
939
940 return wxFileSystemWatcherEvent(wxFSW_EVENT_ERROR);
941 }
942
943 virtual void CheckResult()
944 {
945 // Do nothing. We override this to prevent receiving events in
946 // ExpectedEvent()
947 }
948 };
949
950 TreeTester tester;
951 tester.Run();
952 }
953 #endif // !defined(__VISUALC__) || wxCHECK_VISUALC_VERSION(7)
954
955
956 namespace
957 {
958
959 // We can't define this class locally inside TestNoEventsAfterRemove() for some
960 // reason with g++ 4.0 under OS X 10.5, it results in the following mysterious
961 // error:
962 //
963 // /var/tmp//ccTkNCkc.s:unknown:Non-global symbol:
964 // __ZThn80_ZN25FileSystemWatcherTestCase23TestNoEventsAfterRemoveEvEN11EventTester6NotifyEv.eh
965 // can't be a weak_definition
966 //
967 // So define this class outside the function instead.
968 class NoEventsAfterRemoveEventTester : public EventHandler,
969 public wxTimer
970 {
971 public:
972 NoEventsAfterRemoveEventTester()
973 {
974 // We need to use an inactivity timer as we never get any file
975 // system events in this test, so we consider that the test is
976 // finished when this 1s timeout expires instead of, as usual,
977 // stopping after getting the file system events.
978 Start(1000, true);
979 }
980
981 virtual void GenerateEvent()
982 {
983 m_watcher->Remove(EventGenerator::GetWatchDir());
984 CPPUNIT_ASSERT(eg.CreateFile());
985 }
986
987 virtual void CheckResult()
988 {
989 CPPUNIT_ASSERT( m_events.empty() );
990 }
991
992 virtual wxFileSystemWatcherEvent ExpectedEvent()
993 {
994 CPPUNIT_FAIL( "Shouldn't be called" );
995
996 return wxFileSystemWatcherEvent(wxFSW_EVENT_ERROR);
997 }
998
999 virtual void Notify()
1000 {
1001 SendIdle();
1002 }
1003 };
1004
1005 } // anonymous namespace
1006
1007 void FileSystemWatcherTestCase::TestNoEventsAfterRemove()
1008 {
1009 NoEventsAfterRemoveEventTester tester;
1010 tester.Run();
1011 }