[GTTF] Make DirectoryWatcher tests faster by about 15 seconds.

base/directory_watcher_unittest.cc

 // Copyright (c) 2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/directory_watcher.h"
 
 #include <limits>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/platform_thread.h"
 #include "base/string_util.h"
 #include "base/thread.h"
 #if defined(OS_WIN)
 #include "base/win_util.h"
 #endif  // defined(OS_WIN)
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 // For tests where we wait a bit to verify nothing happened
-const int kWaitForEventTime = 1000;
+const int kWaitForEventTime = 500;

[M-A Ruel, 2009/11/09 18:33:19]

I'm just afraid it'll fail on slow VMs. That's the reason for this slow wait
time.

 
 class DirectoryWatcherTest : public testing::Test {
  public:
   // Implementation of DirectoryWatcher on Mac requires UI loop.
   DirectoryWatcherTest()
       : loop_(MessageLoop::TYPE_UI),
         notified_delegates_(0),
         expected_notified_delegates_(0) {
   }
 
@@ skipping 43 matching lines @@
 
   void SetExpectedNumberOfNotifiedDelegates(int n) {
     notified_delegates_ = 0;
     expected_notified_delegates_ = n;
   }
 
   void VerifyExpectedNumberOfNotifiedDelegates() {
     // Check that we get at least the expected number of notified delegates.
     if (expected_notified_delegates_ - notified_delegates_ > 0)
       loop_.Run();
+    EXPECT_EQ(expected_notified_delegates_, notified_delegates_);
+  }
 
+  void VerifyNoExtraNotifications() {
     // Check that we get no more than the expected number of notified delegates.
     loop_.PostDelayedTask(FROM_HERE, new MessageLoop::QuitTask,
                           kWaitForEventTime);
     loop_.Run();
     EXPECT_EQ(expected_notified_delegates_, notified_delegates_);
   }
 
   // We need this function for reliable tests on Mac OS X. FSEvents API
   // has a latency interval and can merge multiple events into one,
   // and we need a clear distinction between events triggered by test setup code
@@ skipping 101 matching lines @@
     DirectoryWatcher watcher;
     ASSERT_TRUE(watcher.Watch(test_dir_, &delegate, NULL, false));
 
     // And then let it fall out of scope, clearing its watch.
   }
 
   // Write a file to the test dir.
   SetExpectedNumberOfNotifiedDelegates(0);
   ASSERT_TRUE(WriteTestFile(test_dir_.AppendASCII("test_file"), "content"));
   VerifyExpectedNumberOfNotifiedDelegates();
+  VerifyNoExtraNotifications();
 }
 
 TEST_F(DirectoryWatcherTest, SubDirRecursive) {
   FilePath subdir(CreateTestDirDirectoryASCII("SubDir", true));
 
   // Verify that modifications to a subdirectory are noticed by recursive watch.
   TestDelegate delegate(this);
   DirectoryWatcher watcher;
   ASSERT_TRUE(watcher.Watch(test_dir_, &delegate, NULL, true));
   // Write a file to the subdir.
@@ skipping 21 matching lines @@
   // Verify that modifications to a subdirectory are not noticed
   // by a not-recursive watch.
   DirectoryWatcher watcher;
   TestDelegate delegate(this);
   ASSERT_TRUE(watcher.Watch(test_dir_, &delegate, NULL, false));
 
   // Modify the test file. There should be no notifications.
   SetExpectedNumberOfNotifiedDelegates(0);
   ASSERT_TRUE(WriteTestFile(subdir.AppendASCII("test_file"), "other content"));
   VerifyExpectedNumberOfNotifiedDelegates();
+  VerifyNoExtraNotifications();
 }
 
 namespace {
 // Used by the DeleteDuringNotify test below.
 // Deletes the DirectoryWatcher when it's notified.
 class Deleter : public DirectoryWatcher::Delegate {
  public:
   Deleter(DirectoryWatcher* watcher, MessageLoop* loop)
       : watcher_(watcher),
         loop_(loop) {
@@ skipping 38 matching lines @@
   TestDelegate delegate1(this), delegate2(this);
   ASSERT_TRUE(watcher1.Watch(test_dir_, &delegate1, NULL, false));
   ASSERT_TRUE(watcher2.Watch(test_dir_, &delegate2, NULL, false));
 
   SetExpectedNumberOfNotifiedDelegates(2);
   ASSERT_TRUE(WriteTestFile(test_dir_.AppendASCII("test_file"), "content"));
   VerifyExpectedNumberOfNotifiedDelegates();
 }
 
 TEST_F(DirectoryWatcherTest, MultipleWatchersDifferentFiles) {
-  const int kNumberOfWatchers = 5;
+  const int kNumberOfWatchers = 3;
   DirectoryWatcher watchers[kNumberOfWatchers];
   TestDelegate delegates[kNumberOfWatchers] = {
     TestDelegate(this),
     TestDelegate(this),
     TestDelegate(this),
-    TestDelegate(this),
-    TestDelegate(this)
   };
   FilePath subdirs[kNumberOfWatchers];
   for (int i = 0; i < kNumberOfWatchers; i++) {
     subdirs[i] = CreateTestDirDirectoryASCII("Dir" + IntToString(i), false);
     ASSERT_TRUE(watchers[i].Watch(subdirs[i], &delegates[i],
                                   NULL, ((i % 2) == 0)));
   }
   for (int i = 0; i < kNumberOfWatchers; i++) {
     // Verify that we only get modifications from one watcher (each watcher has
     // different directory).
 
     for (int j = 0; j < kNumberOfWatchers; j++)
       delegates[j].reset();
 
     // Write a file to the subdir.
     SetExpectedNumberOfNotifiedDelegates(1);
     ASSERT_TRUE(WriteTestFile(subdirs[i].AppendASCII("test_file"), "content"));
     VerifyExpectedNumberOfNotifiedDelegates();
+    VerifyNoExtraNotifications();
 
     loop_.RunAllPending();
   }
 }
 
 #if defined(OS_WIN) || defined(OS_MACOSX)
 // TODO(phajdan.jr): Enable when support for Linux recursive watches is added.
 
 TEST_F(DirectoryWatcherTest, WatchCreatedDirectory) {
   TestDelegate delegate(this);
@@ skipping 37 matching lines @@
 
   TestDelegate delegate1(this), delegate2(this);
   DirectoryWatcher watcher1, watcher2;
   ASSERT_TRUE(watcher1.Watch(subdir1, &delegate1, NULL, true));
   ASSERT_TRUE(watcher2.Watch(subdir2, &delegate2, NULL, true));
 
   SetExpectedNumberOfNotifiedDelegates(1);
   ASSERT_TRUE(WriteTestFile(subdir1.AppendASCII("file"), "some content"));
   SyncIfPOSIX();
   VerifyExpectedNumberOfNotifiedDelegates();
+  VerifyNoExtraNotifications();
 
   delegate1.reset();
   delegate2.reset();
 
   SetExpectedNumberOfNotifiedDelegates(2);
   ASSERT_TRUE(file_util::Move(subdir1.AppendASCII("file"),
                               subdir2.AppendASCII("file")));
   VerifyExpectedNumberOfNotifiedDelegates();
 
   delegate1.reset();
   delegate2.reset();
 
   SetExpectedNumberOfNotifiedDelegates(1);
   ASSERT_TRUE(WriteTestFile(subdir2.AppendASCII("file"), "other content"));
   VerifyExpectedNumberOfNotifiedDelegates();
+  VerifyNoExtraNotifications();
 }
 #endif  // defined(OS_WIN) || defined(OS_MACOSX)
 
 // Verify that watching a directory that doesn't exist fails, but doesn't
 // asssert.
 // Basic test: add a file and verify we notice it.
 TEST_F(DirectoryWatcherTest, NonExistentDirectory) {
   DirectoryWatcher watcher;
   ASSERT_FALSE(watcher.Watch(test_dir_.AppendASCII("does-not-exist"),
                              NULL, NULL, false));
 }
 
 }  // namespace