sync: fix a couple less-than comparisons to be less-than-eq in tests.

chrome/browser/sync/engine/syncer_thread2_unittest.cc

 // Copyright (c) 2011 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/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "chrome/browser/sync/engine/mock_model_safe_workers.h"
 #include "chrome/browser/sync/engine/syncer.h"
 #include "chrome/browser/sync/engine/syncer_thread2.h"
 #include "chrome/browser/sync/sessions/test_util.h"
@@ skipping 70 matching lines @@
   }
 
   void AnalyzePollRun(const SyncShareRecords& records, size_t min_num_samples,
       const TimeTicks& optimal_start, const TimeDelta& poll_interval) {
     const std::vector<TimeTicks>& data(records.times);
     EXPECT_GE(data.size(), min_num_samples);
     for (size_t i = 0; i < data.size(); i++) {
       SCOPED_TRACE(testing::Message() << "SyncShare # (" << i << ")");
       TimeTicks optimal_next_sync = optimal_start + poll_interval * i;
       EXPECT_GE(data[i], optimal_next_sync);
-      EXPECT_LT(data[i], optimal_next_sync + poll_interval);
+      EXPECT_LE(data[i], optimal_next_sync + poll_interval);
       EXPECT_EQ(GetUpdatesCallerInfo::PERIODIC,
                 records.snapshots[i]->source.first);
     }
   }
 
   bool GetBackoffAndResetTest(base::WaitableEvent* done) {
     syncable::ModelTypeBitSet nudge_types;
     syncer_thread()->Start(SyncerThread::NORMAL_MODE);
     syncer_thread()->ScheduleNudge(zero(), NUDGE_SOURCE_LOCAL, nudge_types);
     done->TimedWait(timeout());
@@ skipping 393 matching lines @@
       .WillOnce(Invoke(sessions::test_util::SimulateCommitFailed))
       .WillOnce(Invoke(sessions::test_util::SimulateCommitFailed))
       .WillRepeatedly(DoAll(Invoke(sessions::test_util::SimulateSuccess),
           RecordSyncShareAndPostSignal(&r, kMinNumSamples, this, &done)));
   EXPECT_CALL(*delay(), GetDelay(_)).WillOnce(Return(backoff));
 
   // Optimal start for the post-backoff poll party.
   TimeTicks optimal_start = TimeTicks::Now() + poll + backoff;
   syncer_thread()->Start(SyncerThread::NORMAL_MODE);
   done.TimedWait(timeout());
+  syncer_thread()->Stop();
 
   // Check for healthy polling after backoff is relieved.
   // Can't use AnalyzePollRun because first sync is a continuation. Bleh.
   for (size_t i = 0; i < r.times.size(); i++) {
     SCOPED_TRACE(testing::Message() << "SyncShare # (" << i << ")");
     TimeTicks optimal_next_sync = optimal_start + poll * i;
     EXPECT_GE(r.times[i], optimal_next_sync);
-    EXPECT_LT(r.times[i], optimal_next_sync + poll);
+    EXPECT_LE(r.times[i], optimal_next_sync + poll);
     EXPECT_EQ(i == 0 ? GetUpdatesCallerInfo::SYNC_CYCLE_CONTINUATION
                      : GetUpdatesCallerInfo::PERIODIC,
               r.snapshots[i]->source.first);
   }
 }
 
 TEST_F(SyncerThread2Test, GetRecommendedDelay) {
   EXPECT_LE(TimeDelta::FromSeconds(0),
             SyncerThread::GetRecommendedDelay(TimeDelta::FromSeconds(0)));
   EXPECT_LE(TimeDelta::FromSeconds(1),
@@ skipping 22 matching lines @@
 TEST_F(SyncerThread2Test, DISABLED_StartWhenNotConnected) {
 
 }
 
 }  // namespace s3
 }  // namespace browser_sync
 
 // SyncerThread won't outlive the test!
 DISABLE_RUNNABLE_METHOD_REFCOUNT(browser_sync::s3::SyncerThread2Test);