Initial commit of sync engine code to browser/sync....

chrome/browser/sync/engine/syncer_thread_unittest.cc

Index: chrome/browser/sync/engine/syncer_thread_unittest.cc
===================================================================
--- chrome/browser/sync/engine/syncer_thread_unittest.cc	(revision 0)
+++ chrome/browser/sync/engine/syncer_thread_unittest.cc	(revision 0)
@@ -0,0 +1,299 @@
+// Copyright (c) 2009 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 <list>
+#include <map>
+#include <set>
+#include <strstream>
+
+#include "base/scoped_ptr.h"
+#include "chrome/browser/sync/engine/syncer_thread.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace browser_sync {
+
+class SyncerThreadTest : public testing::Test {
+ protected:
+  SyncerThreadTest() {}
+  virtual ~SyncerThreadTest() {}
+  virtual void SetUp() {}
+  virtual void TearDown() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SyncerThreadTest);
+};
+
+TEST_F(SyncerThreadTest, Construction) {
+  SyncerThread syncer_thread(NULL, NULL, NULL, NULL, NULL);
+}
+
+TEST_F(SyncerThreadTest, CalculateSyncWaitTime) {
+  SyncerThread syncer_thread(NULL, NULL, NULL, NULL, NULL);
+  syncer_thread.DisableIdleDetection();
+
+  // Syncer_polling_interval_ is less than max poll interval
+  int syncer_polling_interval = 1;  // Needed since AssertionResult is not a
+                                    // friend of SyncerThread
+  syncer_thread.syncer_polling_interval_ = syncer_polling_interval;
+
+  // user_idle_ms is less than 10 * (syncer_polling_interval*1000).
+  ASSERT_EQ(syncer_polling_interval * 1000,
+            syncer_thread.CalculateSyncWaitTime(1000, 0));
+  ASSERT_EQ(syncer_polling_interval * 1000,
+            syncer_thread.CalculateSyncWaitTime(1000, 1));
+
+  // user_idle_ms is ge than 10 * (syncer_polling_interval*1000).
+  int last_poll_time = 2000;
+  ASSERT_LE(last_poll_time,
+            syncer_thread.CalculateSyncWaitTime(last_poll_time, 10000));
+  ASSERT_GE(last_poll_time*3,
+            syncer_thread.CalculateSyncWaitTime(last_poll_time, 10000));
+  ASSERT_LE(last_poll_time,
+            syncer_thread.CalculateSyncWaitTime(last_poll_time, 100000));
+  ASSERT_GE(last_poll_time*3,
+            syncer_thread.CalculateSyncWaitTime(last_poll_time, 100000));
+
+  // Maximum backoff time should be syncer_max_interval.
+  int near_threshold = SyncerThread::kDefaultMaxPollIntervalMs / 2 - 1;
+  int threshold = SyncerThread::kDefaultMaxPollIntervalMs;
+  int over_threshold = SyncerThread::kDefaultMaxPollIntervalMs + 1;
+  ASSERT_LE(near_threshold,
+            syncer_thread.CalculateSyncWaitTime(near_threshold, 10000));
+  ASSERT_GE(SyncerThread::kDefaultMaxPollIntervalMs,
+            syncer_thread.CalculateSyncWaitTime(near_threshold, 10000));
+  ASSERT_EQ(SyncerThread::kDefaultMaxPollIntervalMs,
+            syncer_thread.CalculateSyncWaitTime(threshold, 10000));
+  ASSERT_EQ(SyncerThread::kDefaultMaxPollIntervalMs,
+            syncer_thread.CalculateSyncWaitTime(over_threshold, 10000));
+
+  // Possible idle time must be capped by syncer_max_interval.
+  int over_sync_max_interval =
+      SyncerThread::kDefaultMaxPollIntervalMs + 1;
+  syncer_polling_interval = over_sync_max_interval / 100;  // so 1000* is right
+  syncer_thread.syncer_polling_interval_ = syncer_polling_interval;
+  ASSERT_EQ(syncer_polling_interval * 1000,
+            syncer_thread.CalculateSyncWaitTime(1000, over_sync_max_interval));
+  syncer_polling_interval = 1;
+  syncer_thread.syncer_polling_interval_ = syncer_polling_interval;
+  ASSERT_LE(last_poll_time,
+            syncer_thread.CalculateSyncWaitTime(last_poll_time,
+                                                over_sync_max_interval));
+  ASSERT_GE(last_poll_time * 3,
+            syncer_thread.CalculateSyncWaitTime(last_poll_time,
+                                                over_sync_max_interval));
+}
+
+TEST_F(SyncerThreadTest, CalculatePollingWaitTime) {
+  // Set up the environment
+  int user_idle_milliseconds_param = 0;
+
+  SyncerThread syncer_thread(NULL, NULL, NULL, NULL, NULL);
+  syncer_thread.DisableIdleDetection();
+
+  // Notifications disabled should result in a polling interval of
+  // kDefaultShortPollInterval
+  {
+    AllStatus::Status status = {};
+    status.notifications_enabled = 0;
+    bool continue_sync_cycle_param = false;
+
+    // No work and no backoff.
+    ASSERT_EQ(SyncerThread::kDefaultShortPollIntervalSeconds,
+              syncer_thread.CalculatePollingWaitTime(
+                  status,
+                  0,
+                  &user_idle_milliseconds_param,
+                  &continue_sync_cycle_param));
+    ASSERT_FALSE(continue_sync_cycle_param);
+
+    // In this case the continue_sync_cycle is turned off.
+    continue_sync_cycle_param = true;
+    ASSERT_EQ(SyncerThread::kDefaultShortPollIntervalSeconds,
+              syncer_thread.CalculatePollingWaitTime(
+                  status,
+                  0,
+                  &user_idle_milliseconds_param,
+                  &continue_sync_cycle_param));
+    ASSERT_FALSE(continue_sync_cycle_param);
+
+    // TODO(brg) : Find a way to test exponential backoff is inoperable.
+    // Exponential backoff should be turned on when notifications are disabled
+    // but this can not be tested since we can not set the last input info.
+  }
+
+  // Notifications enabled should result in a polling interval of
+  // SyncerThread::kDefaultLongPollIntervalSeconds
+  {
+    AllStatus::Status status = {};
+    status.notifications_enabled = 1;
+    bool continue_sync_cycle_param = false;
+
+    // No work and no backoff.
+    ASSERT_EQ(SyncerThread::kDefaultLongPollIntervalSeconds,
+              syncer_thread.CalculatePollingWaitTime(
+                  status,
+                  0,
+                  &user_idle_milliseconds_param,
+                  &continue_sync_cycle_param));
+    ASSERT_FALSE(continue_sync_cycle_param);
+
+    // In this case the continue_sync_cycle is turned off.
+    continue_sync_cycle_param = true;
+    ASSERT_EQ(SyncerThread::kDefaultLongPollIntervalSeconds,
+              syncer_thread.CalculatePollingWaitTime(
+                  status,
+                  0,
+                  &user_idle_milliseconds_param,
+                  &continue_sync_cycle_param));
+    ASSERT_FALSE(continue_sync_cycle_param);
+
+    // TODO(brg) : Find a way to test exponential backoff.
+    // Exponential backoff should be turned off when notifications are enabled,
+    // but this can not be tested since we can not set the last input info.
+  }
+
+  // There are two states which can cause a continuation, either the updates
+  // available do not match the updates received, or the unsynced count is
+  // non-zero.
+  {
+    AllStatus::Status status = {};
+    status.updates_available = 1;
+    status.updates_received = 0;
+    bool continue_sync_cycle_param = false;
+
+    ASSERT_LE(0, syncer_thread.CalculatePollingWaitTime(
+                     status,
+                     0,
+                     &user_idle_milliseconds_param,
+                     &continue_sync_cycle_param));
+    ASSERT_TRUE(continue_sync_cycle_param);
+
+    continue_sync_cycle_param = false;
+    ASSERT_GE(3, syncer_thread.CalculatePollingWaitTime(
+                     status,
+                     0,
+                     &user_idle_milliseconds_param,
+                     &continue_sync_cycle_param));
+    ASSERT_TRUE(continue_sync_cycle_param);
+
+    ASSERT_LE(0, syncer_thread.CalculatePollingWaitTime(
+                     status,
+                     0,
+                     &user_idle_milliseconds_param,
+                     &continue_sync_cycle_param));
+    ASSERT_GE(2, syncer_thread.CalculatePollingWaitTime(
+                     status,
+                     0,
+                     &user_idle_milliseconds_param,
+                     &continue_sync_cycle_param));
+    ASSERT_TRUE(continue_sync_cycle_param);
+
+    status.updates_received = 1;
+    ASSERT_EQ(SyncerThread::kDefaultShortPollIntervalSeconds,
+              syncer_thread.CalculatePollingWaitTime(
+                  status,
+                  10,
+                  &user_idle_milliseconds_param,
+                  &continue_sync_cycle_param));
+    ASSERT_FALSE(continue_sync_cycle_param);
+  }
+
+  {
+    AllStatus::Status status = {};
+    status.unsynced_count = 1;
+    bool continue_sync_cycle_param = false;
+
+    ASSERT_LE(0, syncer_thread.CalculatePollingWaitTime(
+                     status,
+                     0,
+                     &user_idle_milliseconds_param,
+                     &continue_sync_cycle_param));
+    ASSERT_TRUE(continue_sync_cycle_param);
+
+    continue_sync_cycle_param = false;
+    ASSERT_GE(2, syncer_thread.CalculatePollingWaitTime(
+                     status,
+                     0,
+                     &user_idle_milliseconds_param,
+                     &continue_sync_cycle_param));
+    ASSERT_TRUE(continue_sync_cycle_param);
+
+    status.unsynced_count = 0;
+    ASSERT_EQ(SyncerThread::kDefaultShortPollIntervalSeconds,
+              syncer_thread.CalculatePollingWaitTime(
+                  status,
+                  4,
+                  &user_idle_milliseconds_param,
+                  &continue_sync_cycle_param));
+    ASSERT_FALSE(continue_sync_cycle_param);
+  }
+
+  // Regression for exponential backoff reset when the
+  // syncer is nudged.
+  {
+    AllStatus::Status status = {};
+    status.unsynced_count = 1;
+    bool continue_sync_cycle_param = false;
+
+    // Expect move from default polling interval to exponential backoff due to
+    // unsynced_count != 0.
+    ASSERT_LE(0, syncer_thread.CalculatePollingWaitTime(
+                     status,
+                     3600,
+                     &user_idle_milliseconds_param,
+                     &continue_sync_cycle_param));
+    ASSERT_TRUE(continue_sync_cycle_param);
+
+    continue_sync_cycle_param = false;
+    ASSERT_GE(2, syncer_thread.CalculatePollingWaitTime(
+                     status,
+                     3600,
+                     &user_idle_milliseconds_param,
+                     &continue_sync_cycle_param));
+    ASSERT_TRUE(continue_sync_cycle_param);
+
+    // Expect exponential backoff.
+    ASSERT_LE(2, syncer_thread.CalculatePollingWaitTime(
+                     status,
+                     2,
+                     &user_idle_milliseconds_param,
+                     &continue_sync_cycle_param));
+    ASSERT_GE(6, syncer_thread.CalculatePollingWaitTime(
+                     status,
+                     2,
+                     &user_idle_milliseconds_param,
+                     &continue_sync_cycle_param));
+    ASSERT_TRUE(continue_sync_cycle_param);
+
+    // A nudge resets the continue_sync_cycle_param value, so our backoff
+    // should return to the minimum.
+    continue_sync_cycle_param = false;
+    ASSERT_LE(0, syncer_thread.CalculatePollingWaitTime(
+                     status,
+                     3600,
+                     &user_idle_milliseconds_param,
+                     &continue_sync_cycle_param));
+    ASSERT_TRUE(continue_sync_cycle_param);
+
+    continue_sync_cycle_param = false;
+    ASSERT_GE(2, syncer_thread.CalculatePollingWaitTime(
+                     status,
+                     3600,
+                     &user_idle_milliseconds_param,
+                     &continue_sync_cycle_param));
+    ASSERT_TRUE(continue_sync_cycle_param);
+
+    // Setting unsynced_count = 0 returns us to the default polling interval.
+    status.unsynced_count = 0;
+    ASSERT_EQ(SyncerThread::kDefaultShortPollIntervalSeconds,
+              syncer_thread.CalculatePollingWaitTime(
+                  status,
+                  4,
+                  &user_idle_milliseconds_param,
+                  &continue_sync_cycle_param));
+    ASSERT_FALSE(continue_sync_cycle_param);
+  }
+}
+
+}  // namespace browser_sync
Property changes on: chrome\browser\sync\engine\syncer_thread_unittest.cc
___________________________________________________________________
Added: svn:eol-style
   + LF