wxDC::GetHandle support for wxMSW

[wxWidgets.git] / tests / fswatcher / fswatchertest.cpp

diff --git a/tests/fswatcher/fswatchertest.cpp b/tests/fswatcher/fswatchertest.cpp
index f28fee917e1111a1516a4bd5ece4f283edf05bba..2f9ff84b853eab840f1f2d705e46dac4ae0dfb75 100644 (file)
--- a/tests/fswatcher/fswatchertest.cpp
+++ b/tests/fswatcher/fswatchertest.cpp
@@ -17,6 +17,10 @@
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 

+#ifndef WX_PRECOMP
+    #include "wx/timer.h"
+#endif
+

 #include "wx/evtloop.h"
 #include "wx/filename.h"
 #include "wx/filefn.h"
 #include "wx/evtloop.h"
 #include "wx/filename.h"
 #include "wx/filefn.h"


@@ -331,19 +335,6 @@ public:
 
         const wxFileSystemWatcherEvent * const e = m_events.front();
 
 
         const wxFileSystemWatcherEvent * const e = m_events.front();
 

-        WX_ASSERT_EQUAL_MESSAGE
-        (
-            (
-                "Extra events received, first is of type %x, for path=\"%s\","
-                "last is of type %x, path=\"%s\"",
-                e->GetChangeType(),
-                e->GetPath().GetFullPath(),
-                m_events.back()->GetChangeType(),
-                m_events.back()->GetPath().GetFullPath()
-            ),
-            1, m_events.size()
-        );
-

         // this is our "reference event"
         const wxFileSystemWatcherEvent expected = ExpectedEvent();
 
         // this is our "reference event"
         const wxFileSystemWatcherEvent expected = ExpectedEvent();
 


@@ -356,6 +347,35 @@ public:
 
         CPPUNIT_ASSERT_EQUAL(expected.GetPath(), e->GetPath());
         CPPUNIT_ASSERT_EQUAL(expected.GetNewPath(), e->GetNewPath());
 
         CPPUNIT_ASSERT_EQUAL(expected.GetPath(), e->GetPath());
         CPPUNIT_ASSERT_EQUAL(expected.GetNewPath(), e->GetNewPath());

+
+        // Under MSW extra modification events are sometimes reported after a
+        // rename and we just can't get rid of them, so ignore them in this
+        // test if they do happen.
+        if ( e->GetChangeType() == wxFSW_EVENT_RENAME &&
+                m_events.size() == 2 )
+        {
+            const wxFileSystemWatcherEvent* const e2 = m_events.back();
+            if ( e2->GetChangeType() == wxFSW_EVENT_MODIFY &&
+                    e2->GetPath() == e->GetNewPath() )
+            {
+                // This is a modify event for the new file, ignore it.
+                return;
+            }
+        }
+
+        WX_ASSERT_EQUAL_MESSAGE
+        (
+            (
+                "Extra events received, last one is of type %x, path=\"%s\" "
+                "(the original event was for \"%s\" (\"%s\")",
+                m_events.back()->GetChangeType(),
+                m_events.back()->GetPath().GetFullPath(),
+                e->GetPath().GetFullPath(),
+                e->GetNewPath().GetFullPath()
+            ),
+            1, m_events.size()
+        );
+

     }
 
     virtual void GenerateEvent() = 0;
     }
 
     virtual void GenerateEvent() = 0;


@@ -398,6 +418,11 @@ private:
         CPPUNIT_TEST( TestEventCreate );
         CPPUNIT_TEST( TestEventDelete );
 
         CPPUNIT_TEST( TestEventCreate );
         CPPUNIT_TEST( TestEventDelete );
 

+        // FIXME: Currently this test fails under Windows.
+#ifndef __WINDOWS__
+        CPPUNIT_TEST( TestTrees );
+#endif // __WINDOWS__
+

         // kqueue-based implementation doesn't collapse create/delete pairs in
         // renames and doesn't detect neither modifications nor access to the
         // files reliably currently so disable these tests
         // kqueue-based implementation doesn't collapse create/delete pairs in
         // renames and doesn't detect neither modifications nor access to the
         // files reliably currently so disable these tests


@@ -408,9 +433,9 @@ private:
         CPPUNIT_TEST( TestEventModify );
 
         // MSW implementation doesn't detect file access events currently
         CPPUNIT_TEST( TestEventModify );
 
         // MSW implementation doesn't detect file access events currently

-#ifndef __WXMSW__
+#ifndef __WINDOWS__

         CPPUNIT_TEST( TestEventAccess );
         CPPUNIT_TEST( TestEventAccess );

-#endif // __WXMSW__
+#endif // __WINDOWS__

 #endif // !wxHAS_KQUEUE
 
         CPPUNIT_TEST( TestNoEventsAfterRemove );
 #endif // !wxHAS_KQUEUE
 
         CPPUNIT_TEST( TestNoEventsAfterRemove );


@@ -421,6 +446,9 @@ private:
     void TestEventRename();
     void TestEventModify();
     void TestEventAccess();
     void TestEventRename();
     void TestEventModify();
     void TestEventAccess();

+#ifndef __WINDOWS__
+    void TestTrees();
+#endif // __WINDOWS__

 
     void TestNoEventsAfterRemove();
 
 
     void TestNoEventsAfterRemove();
 


@@ -610,45 +638,204 @@ void FileSystemWatcherTestCase::TestEventAccess()
     tester.Run();
 }
 
     tester.Run();
 }
 

-void FileSystemWatcherTestCase::TestNoEventsAfterRemove()
+// ----------------------------------------------------------------------------
+// TestTrees
+// ----------------------------------------------------------------------------
+#ifndef __WINDOWS__
+void FileSystemWatcherTestCase::TestTrees()

 {
 {

-    class EventTester : public EventHandler,
-                        public wxTimer
+    class TreeTester : public EventHandler

     {
     {

+        const size_t subdirs;
+        const size_t files;
+

     public:
     public:

-        EventTester()
+        TreeTester() : subdirs(5), files(3) {}
+
+        void GrowTree(wxFileName dir)

         {
         {

-            // We need to use an inactivity timer as we never get any file
-            // system events in this test, so we consider that the test is
-            // finished when this 1s timeout expires instead of, as usual,
-            // stopping after getting the file system events.
-            Start(1000, true);
+            CPPUNIT_ASSERT(dir.Mkdir());
+
+            // Create a branch of 5 numbered subdirs, each containing 3
+            // numbered files
+            for ( unsigned d = 0; d < subdirs; ++d )
+            {
+                dir.AppendDir(wxString::Format("subdir%u", d+1));
+                CPPUNIT_ASSERT(dir.Mkdir());
+
+                const wxString prefix = dir.GetPathWithSep();
+                for ( unsigned f = 0; f < files; ++f )
+                {
+                    // Just create the files.
+                    wxFile(prefix + wxString::Format("file%u", f+1),
+                           wxFile::write);
+                }
+            }

         }
 
         }
 

-        virtual void GenerateEvent()
+        void RmDir(wxFileName dir)

         {
         {

-            m_watcher->Remove(EventGenerator::GetWatchDir());
-            CPPUNIT_ASSERT(eg.CreateFile());
+            CPPUNIT_ASSERT(dir.DirExists());
+
+            CPPUNIT_ASSERT(dir.Rmdir(wxPATH_RMDIR_RECURSIVE));

         }
 
         }
 

-        virtual void CheckResult()
+        void WatchDir(wxFileName dir)

         {
         {

-            CPPUNIT_ASSERT( m_events.empty() );
+            CPPUNIT_ASSERT(m_watcher);
+
+            // Store the initial count; there may already be some watches
+            const int initial = m_watcher->GetWatchedPathsCount();
+
+            m_watcher->Add(dir);
+            CPPUNIT_ASSERT_EQUAL(initial + 1,
+                                 m_watcher->GetWatchedPathsCount());
+        }
+
+        void RemoveSingleWatch(wxFileName dir)
+        {
+            CPPUNIT_ASSERT(m_watcher);
+
+            const int initial = m_watcher->GetWatchedPathsCount();
+
+            m_watcher->Remove(dir);
+            CPPUNIT_ASSERT_EQUAL(initial - 1,
+                                 m_watcher->GetWatchedPathsCount());
+        }
+
+        void WatchTree(const wxFileName& dir)
+        {
+            CPPUNIT_ASSERT(m_watcher);
+
+            const size_t
+                treeitems = (subdirs*files) + subdirs + 1; // +1 for the trunk
+
+            // Store the initial count; there may already be some watches
+            const int initial = m_watcher->GetWatchedPathsCount();
+
+            GrowTree(dir);
+
+            m_watcher->AddTree(dir);
+            const int plustree = m_watcher->GetWatchedPathsCount();
+
+            CPPUNIT_ASSERT_EQUAL(initial + treeitems, plustree);
+
+            m_watcher->RemoveTree(dir);
+            CPPUNIT_ASSERT_EQUAL(initial, m_watcher->GetWatchedPathsCount());
+        }
+
+        void RemoveAllWatches()
+        {
+            CPPUNIT_ASSERT(m_watcher);
+
+            m_watcher->RemoveAll();
+            CPPUNIT_ASSERT_EQUAL(0, m_watcher->GetWatchedPathsCount());
+        }
+
+        virtual void GenerateEvent()
+        {
+            // We don't use this function for events. Just run the tests
+
+            wxFileName watchdir = EventGenerator::GetWatchDir();
+            CPPUNIT_ASSERT(watchdir.DirExists());
+
+            wxFileName treedir(watchdir);
+            treedir.AppendDir("treetrunk");
+            CPPUNIT_ASSERT(!treedir.DirExists());
+
+            wxFileName singledir(watchdir);
+            singledir.AppendDir("single");
+            CPPUNIT_ASSERT(!singledir.DirExists());
+            CPPUNIT_ASSERT(singledir.Mkdir());
+
+            WatchDir(singledir);
+            WatchTree(treedir);
+
+            RemoveSingleWatch(singledir);
+            // Add it back again, ready to test RemoveAll()
+            WatchDir(singledir);
+
+            RemoveAllWatches();
+
+            // Clean up
+            RmDir(singledir);
+            RmDir(treedir);
+
+            Exit();

         }
 
         virtual wxFileSystemWatcherEvent ExpectedEvent()
         {
         }
 
         virtual wxFileSystemWatcherEvent ExpectedEvent()
         {

-            CPPUNIT_FAIL( "Shouldn't be called" );
+            CPPUNIT_FAIL("Shouldn't be called");

 
             return wxFileSystemWatcherEvent(wxFSW_EVENT_ERROR);
         }
 
 
             return wxFileSystemWatcherEvent(wxFSW_EVENT_ERROR);
         }
 

-        virtual void Notify()
+        virtual void CheckResult()

         {
         {

-            SendIdle();
+            // Do nothing. We override this to prevent receiving events in
+            // ExpectedEvent()

         }
     };
 
         }
     };
 

-    EventTester tester;
+    TreeTester tester;
+    tester.Run();
+}
+#endif // __WINDOWS__
+
+namespace
+{
+
+// We can't define this class locally inside TestNoEventsAfterRemove() for some
+// reason with g++ 4.0 under OS X 10.5, it results in the following mysterious
+// error:
+//
+// /var/tmp//ccTkNCkc.s:unknown:Non-global symbol:
+// __ZThn80_ZN25FileSystemWatcherTestCase23TestNoEventsAfterRemoveEvEN11EventTester6NotifyEv.eh
+// can't be a weak_definition
+//
+// So define this class outside the function instead.
+class NoEventsAfterRemoveEventTester : public EventHandler,
+                                       public wxTimer
+{
+public:
+    NoEventsAfterRemoveEventTester()
+    {
+        // We need to use an inactivity timer as we never get any file
+        // system events in this test, so we consider that the test is
+        // finished when this 1s timeout expires instead of, as usual,
+        // stopping after getting the file system events.
+        Start(1000, true);
+    }
+
+    virtual void GenerateEvent()
+    {
+        m_watcher->Remove(EventGenerator::GetWatchDir());
+        CPPUNIT_ASSERT(eg.CreateFile());
+    }
+
+    virtual void CheckResult()
+    {
+        CPPUNIT_ASSERT( m_events.empty() );
+    }
+
+    virtual wxFileSystemWatcherEvent ExpectedEvent()
+    {
+        CPPUNIT_FAIL( "Shouldn't be called" );
+
+        return wxFileSystemWatcherEvent(wxFSW_EVENT_ERROR);
+    }
+
+    virtual void Notify()
+    {
+        SendIdle();
+    }
+};
+
+} // anonymous namespace
+
+void FileSystemWatcherTestCase::TestNoEventsAfterRemove()
+{
+    NoEventsAfterRemoveEventTester tester;

     tester.Run();
 }
     tester.Run();
 }