[Sync] Move //sync to //components/sync.

sync/internal_api/public/base/ordinal_unittest.cc

Index: sync/internal_api/public/base/ordinal_unittest.cc
diff --git a/sync/internal_api/public/base/ordinal_unittest.cc b/sync/internal_api/public/base/ordinal_unittest.cc
deleted file mode 100644
index 02d77324fb12adebd4cc2c54e45b8c3289c41a80..0000000000000000000000000000000000000000
--- a/sync/internal_api/public/base/ordinal_unittest.cc
+++ /dev/null
@@ -1,378 +0,0 @@
-// Copyright (c) 2012 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 "sync/internal_api/public/base/ordinal.h"
-
-#include <stdint.h>
-
-#include <algorithm>
-#include <cctype>
-#include <cstddef>
-#include <string>
-#include <vector>
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace syncer {
-
-namespace {
-
-struct TestOrdinalTraits {
-  static const uint8_t kZeroDigit = '0';
-  static const uint8_t kMaxDigit = '3';
-  static const size_t kMinLength = 1;
-};
-
-struct LongOrdinalTraits {
-  static const uint8_t kZeroDigit = '0';
-  static const uint8_t kMaxDigit = '9';
-  static const size_t kMinLength = 5;
-};
-
-struct LargeOrdinalTraits {
-  static const uint8_t kZeroDigit = 0;
-  static const uint8_t kMaxDigit = UINT8_MAX;
-  static const size_t kMinLength = 1;
-};
-
-typedef Ordinal<TestOrdinalTraits> TestOrdinal;
-typedef Ordinal<LongOrdinalTraits> LongOrdinal;
-typedef Ordinal<LargeOrdinalTraits> LargeOrdinal;
-
-static_assert(TestOrdinal::kZeroDigit == '0',
-              "incorrect TestOrdinal zero digit");
-static_assert(TestOrdinal::kOneDigit == '1',
-              "incorrect TestOrdinal one digit");
-static_assert(TestOrdinal::kMidDigit == '2',
-              "incorrect TestOrdinal min digit");
-static_assert(TestOrdinal::kMaxDigit == '3',
-              "incorrect TestOrdinal max digit");
-static_assert(TestOrdinal::kMidDigitValue == 2,
-              "incorrect TestOrdinal mid digit value");
-static_assert(TestOrdinal::kMaxDigitValue == 3,
-              "incorrect TestOrdinal max digit value");
-static_assert(TestOrdinal::kRadix == 4,
-              "incorrect TestOrdinal radix");
-
-static_assert(LongOrdinal::kZeroDigit == '0',
-              "incorrect LongOrdinal zero digit");
-static_assert(LongOrdinal::kOneDigit == '1',
-              "incorrect LongOrdinal one digit");
-static_assert(LongOrdinal::kMidDigit == '5',
-              "incorrect LongOrdinal mid digit");
-static_assert(LongOrdinal::kMaxDigit == '9',
-              "incorrect LongOrdinal max digit");
-static_assert(LongOrdinal::kMidDigitValue == 5,
-              "incorrect LongOrdinal mid digit value");
-static_assert(LongOrdinal::kMaxDigitValue == 9,
-              "incorrect LongOrdinal max digit value");
-static_assert(LongOrdinal::kRadix == 10,
-              "incorrect LongOrdinal radix");
-
-static_assert(static_cast<char>(LargeOrdinal::kZeroDigit) == '\x00',
-              "incorrect LargeOrdinal zero digit");
-static_assert(static_cast<char>(LargeOrdinal::kOneDigit) == '\x01',
-              "incorrect LargeOrdinal one digit");
-static_assert(static_cast<char>(LargeOrdinal::kMidDigit) == '\x80',
-              "incorrect LargeOrdinal mid digit");
-static_assert(static_cast<char>(LargeOrdinal::kMaxDigit) == '\xff',
-              "incorrect LargeOrdinal max digit");
-static_assert(LargeOrdinal::kMidDigitValue == 128,
-              "incorrect LargeOrdinal mid digit value");
-static_assert(LargeOrdinal::kMaxDigitValue == 255,
-              "incorrect LargeOrdinal max digit value");
-static_assert(LargeOrdinal::kRadix == 256,
-              "incorrect LargeOrdinal radix");
-
-// Create Ordinals that satisfy all but one criterion for validity.
-// IsValid() should return false for all of them.
-TEST(Ordinal, Invalid) {
-  // Length criterion.
-  EXPECT_FALSE(TestOrdinal(std::string()).IsValid());
-  EXPECT_FALSE(LongOrdinal("0001").IsValid());
-
-  const char kBeforeZero[] = { '0' - 1, '\0' };
-  const char kAfterNine[] = { '9' + 1, '\0' };
-
-  // Character criterion.
-  EXPECT_FALSE(TestOrdinal(kBeforeZero).IsValid());
-  EXPECT_FALSE(TestOrdinal("4").IsValid());
-  EXPECT_FALSE(LongOrdinal(std::string("0000") + kBeforeZero).IsValid());
-  EXPECT_FALSE(LongOrdinal(std::string("0000") + kAfterNine).IsValid());
-
-  // Zero criterion.
-  EXPECT_FALSE(TestOrdinal("0").IsValid());
-  EXPECT_FALSE(TestOrdinal("00000").IsValid());
-
-  // Trailing zero criterion.
-  EXPECT_FALSE(TestOrdinal("10").IsValid());
-  EXPECT_FALSE(TestOrdinal("111110").IsValid());
-}
-
-// Create Ordinals that satisfy all criteria for validity.
-// IsValid() should return true for all of them.
-TEST(Ordinal, Valid) {
-  // Length criterion.
-  EXPECT_TRUE(TestOrdinal("1").IsValid());
-  EXPECT_TRUE(LongOrdinal("10000").IsValid());
-}
-
-// Create Ordinals from CreateInitialOrdinal.  They should be valid
-// and close to the middle of the range.
-TEST(Ordinal, CreateInitialOrdinal) {
-  const TestOrdinal& ordinal1 = TestOrdinal::CreateInitialOrdinal();
-  const LongOrdinal& ordinal2 = LongOrdinal::CreateInitialOrdinal();
-  ASSERT_TRUE(ordinal1.IsValid());
-  ASSERT_TRUE(ordinal2.IsValid());
-  EXPECT_TRUE(ordinal1.Equals(TestOrdinal("2")));
-  EXPECT_TRUE(ordinal2.Equals(LongOrdinal("50000")));
-}
-
-// Create an invalid and a valid Ordinal.  EqualsOrBothInvalid should
-// return true if called reflexively and false otherwise.
-TEST(Ordinal, EqualsOrBothInvalid) {
-  const TestOrdinal& valid_ordinal = TestOrdinal::CreateInitialOrdinal();
-  const TestOrdinal invalid_ordinal;
-
-  EXPECT_TRUE(valid_ordinal.EqualsOrBothInvalid(valid_ordinal));
-  EXPECT_TRUE(invalid_ordinal.EqualsOrBothInvalid(invalid_ordinal));
-  EXPECT_FALSE(invalid_ordinal.EqualsOrBothInvalid(valid_ordinal));
-  EXPECT_FALSE(valid_ordinal.EqualsOrBothInvalid(invalid_ordinal));
-}
-
-// Create three Ordinals in order.  LessThan should return values
-// consistent with that order.
-TEST(Ordinal, LessThan) {
-  const TestOrdinal small_ordinal("1");
-  const TestOrdinal middle_ordinal("2");
-  const TestOrdinal big_ordinal("3");
-
-  EXPECT_FALSE(small_ordinal.LessThan(small_ordinal));
-  EXPECT_TRUE(small_ordinal.LessThan(middle_ordinal));
-  EXPECT_TRUE(small_ordinal.LessThan(big_ordinal));
-
-  EXPECT_FALSE(middle_ordinal.LessThan(small_ordinal));
-  EXPECT_FALSE(middle_ordinal.LessThan(middle_ordinal));
-  EXPECT_TRUE(middle_ordinal.LessThan(big_ordinal));
-
-  EXPECT_FALSE(big_ordinal.LessThan(small_ordinal));
-  EXPECT_FALSE(big_ordinal.LessThan(middle_ordinal));
-  EXPECT_FALSE(big_ordinal.LessThan(big_ordinal));
-}
-
-// Create two single-digit ordinals with byte values 0 and 255.  The
-// former should compare as less than the latter, even though the
-// native char type may be signed.
-TEST(Ordinal, LessThanLarge) {
-  const LargeOrdinal small_ordinal("\x01");
-  const LargeOrdinal big_ordinal("\xff");
-
-  EXPECT_TRUE(small_ordinal.LessThan(big_ordinal));
-}
-
-// Create three Ordinals in order.  GreaterThan should return values
-// consistent with that order.
-TEST(Ordinal, GreaterThan) {
-  const LongOrdinal small_ordinal("10000");
-  const LongOrdinal middle_ordinal("55555");
-  const LongOrdinal big_ordinal("99999");
-
-  EXPECT_FALSE(small_ordinal.GreaterThan(small_ordinal));
-  EXPECT_FALSE(small_ordinal.GreaterThan(middle_ordinal));
-  EXPECT_FALSE(small_ordinal.GreaterThan(big_ordinal));
-
-  EXPECT_TRUE(middle_ordinal.GreaterThan(small_ordinal));
-  EXPECT_FALSE(middle_ordinal.GreaterThan(middle_ordinal));
-  EXPECT_FALSE(middle_ordinal.GreaterThan(big_ordinal));
-
-  EXPECT_TRUE(big_ordinal.GreaterThan(small_ordinal));
-  EXPECT_TRUE(big_ordinal.GreaterThan(middle_ordinal));
-  EXPECT_FALSE(big_ordinal.GreaterThan(big_ordinal));
-}
-
-// Create two valid Ordinals.  Equals should return true only when
-// called reflexively.
-TEST(Ordinal, Equals) {
-  const TestOrdinal ordinal1("1");
-  const TestOrdinal ordinal2("2");
-
-  EXPECT_TRUE(ordinal1.Equals(ordinal1));
-  EXPECT_FALSE(ordinal1.Equals(ordinal2));
-
-  EXPECT_FALSE(ordinal2.Equals(ordinal1));
-  EXPECT_TRUE(ordinal2.Equals(ordinal2));
-}
-
-// Create some valid ordinals from some byte strings.
-// ToInternalValue() should return the original byte string.
-TEST(OrdinalTest, ToInternalValue) {
-  EXPECT_EQ("2", TestOrdinal("2").ToInternalValue());
-  EXPECT_EQ("12345", LongOrdinal("12345").ToInternalValue());
-  EXPECT_EQ("\1\2\3\4\5", LargeOrdinal("\1\2\3\4\5").ToInternalValue());
-}
-
-bool IsNonEmptyPrintableString(const std::string& str) {
-  if (str.empty())
-    return false;
-  for (size_t i = 0; i < str.length(); ++i) {
-    if (!isprint(str[i]))
-      return false;
-  }
-  return true;
-}
-
-// Create some invalid/valid ordinals.  ToDebugString() should always
-// return a non-empty printable string.
-TEST(OrdinalTest, ToDebugString) {
-  EXPECT_TRUE(
-      IsNonEmptyPrintableString(TestOrdinal().ToDebugString()));
-  EXPECT_TRUE(
-      IsNonEmptyPrintableString(TestOrdinal("invalid string").ToDebugString()));
-  EXPECT_TRUE(
-      IsNonEmptyPrintableString(TestOrdinal("2").ToDebugString()));
-  EXPECT_TRUE(
-      IsNonEmptyPrintableString(LongOrdinal("12345").ToDebugString()));
-  EXPECT_TRUE(
-      IsNonEmptyPrintableString(LargeOrdinal("\1\2\3\4\5").ToDebugString()));
-}
-
-// Create three Ordinals in order.  LessThanFn should return values
-// consistent with that order.
-TEST(Ordinal, LessThanFn) {
-  const TestOrdinal small_ordinal("1");
-  const TestOrdinal middle_ordinal("2");
-  const TestOrdinal big_ordinal("3");
-
-  const TestOrdinal::LessThanFn less_than;
-
-  EXPECT_FALSE(less_than(small_ordinal, small_ordinal));
-  EXPECT_TRUE(less_than(small_ordinal, middle_ordinal));
-  EXPECT_TRUE(less_than(small_ordinal, big_ordinal));
-
-  EXPECT_FALSE(less_than(middle_ordinal, small_ordinal));
-  EXPECT_FALSE(less_than(middle_ordinal, middle_ordinal));
-  EXPECT_TRUE(less_than(middle_ordinal, big_ordinal));
-
-  EXPECT_FALSE(less_than(big_ordinal, small_ordinal));
-  EXPECT_FALSE(less_than(big_ordinal, middle_ordinal));
-  EXPECT_FALSE(less_than(big_ordinal, big_ordinal));
-}
-
-template <typename Traits>
-std::string GetBetween(const std::string& ordinal_string1,
-                       const std::string& ordinal_string2) {
-  const Ordinal<Traits> ordinal1(ordinal_string1);
-  const Ordinal<Traits> ordinal2(ordinal_string2);
-  const Ordinal<Traits> between1 = ordinal1.CreateBetween(ordinal2);
-  const Ordinal<Traits> between2 = ordinal2.CreateBetween(ordinal1);
-  EXPECT_TRUE(between1.Equals(between2));
-  return between1.ToInternalValue();
-}
-
-// Create some Ordinals from single-digit strings.  Given two strings
-// from this set, CreateBetween should return an Ordinal roughly between
-// them that are also single-digit when possible.
-TEST(Ordinal, CreateBetweenSingleDigit) {
-  EXPECT_EQ("2", GetBetween<TestOrdinal>("1", "3"));
-  EXPECT_EQ("12", GetBetween<TestOrdinal>("1", "2"));
-  EXPECT_EQ("22", GetBetween<TestOrdinal>("2", "3"));
-}
-
-// Create some Ordinals from strings of various lengths.  Given two
-// strings from this set, CreateBetween should return an Ordinal roughly
-// between them that have as few digits as possible.
-TEST(Ordinal, CreateBetweenDifferentLengths) {
-  EXPECT_EQ("102", GetBetween<TestOrdinal>("1", "11"));
-  EXPECT_EQ("2", GetBetween<TestOrdinal>("1", "31"));
-  EXPECT_EQ("132", GetBetween<TestOrdinal>("13", "2"));
-  EXPECT_EQ("2", GetBetween<TestOrdinal>("10001", "3"));
-  EXPECT_EQ("20000", GetBetween<LongOrdinal>("10001", "30000"));
-  EXPECT_EQ("2", GetBetween<TestOrdinal>("10002", "3"));
-  EXPECT_EQ("20001", GetBetween<LongOrdinal>("10002", "30000"));
-  EXPECT_EQ("2", GetBetween<TestOrdinal>("1", "30002"));
-  EXPECT_EQ("20001", GetBetween<LongOrdinal>("10000", "30002"));
-}
-
-// Create some Ordinals specifically designed to trigger overflow
-// cases.  Given two strings from this set, CreateBetween should
-// return an Ordinal roughly between them that have as few digits as
-// possible.
-TEST(Ordinal, CreateBetweenOverflow) {
-  EXPECT_EQ("03", GetBetween<TestOrdinal>("01", "11"));
-  EXPECT_EQ("13", GetBetween<TestOrdinal>("11", "21"));
-  EXPECT_EQ("113", GetBetween<TestOrdinal>("111", "121"));
-  EXPECT_EQ("2", GetBetween<TestOrdinal>("001", "333"));
-  EXPECT_EQ("31", GetBetween<TestOrdinal>("222", "333"));
-  EXPECT_EQ("3", GetBetween<TestOrdinal>("201", "333"));
-  EXPECT_EQ("2", GetBetween<TestOrdinal>("003", "333"));
-  EXPECT_EQ("2", GetBetween<TestOrdinal>("2223", "1113"));
-}
-
-// Create some Ordinals specifically designed to trigger digit
-// overflow cases.  Given two strings from this set, CreateBetween
-// should return an Ordinal roughly between them that have as few digits
-// as possible.
-TEST(Ordinal, CreateBetweenOverflowLarge) {
-  EXPECT_EQ("\x80", GetBetween<LargeOrdinal>("\x01\xff", "\xff\xff"));
-  EXPECT_EQ("\xff\xfe\x80", GetBetween<LargeOrdinal>("\xff\xfe", "\xff\xff"));
-}
-
-// Create some Ordinals.  CreateBefore should return an Ordinal
-// roughly halfway towards 0.
-TEST(Ordinal, CreateBefore) {
-  EXPECT_EQ("02", TestOrdinal("1").CreateBefore().ToInternalValue());
-  EXPECT_EQ("03", TestOrdinal("11").CreateBefore().ToInternalValue());
-  EXPECT_EQ("03", TestOrdinal("12").CreateBefore().ToInternalValue());
-  EXPECT_EQ("1", TestOrdinal("13").CreateBefore().ToInternalValue());
-}
-
-// Create some Ordinals.  CreateAfter should return an Ordinal
-// roughly halfway towards 0.
-TEST(Ordinal, CreateAfter) {
-  EXPECT_EQ("31", TestOrdinal("3").CreateAfter().ToInternalValue());
-  EXPECT_EQ("322", TestOrdinal("32").CreateAfter().ToInternalValue());
-  EXPECT_EQ("33322", TestOrdinal("3332").CreateAfter().ToInternalValue());
-  EXPECT_EQ("3", TestOrdinal("22").CreateAfter().ToInternalValue());
-  EXPECT_EQ("3", TestOrdinal("23").CreateAfter().ToInternalValue());
-}
-
-// Create two valid Ordinals.  EqualsFn should return true only when
-// called reflexively.
-TEST(Ordinal, EqualsFn) {
-  const TestOrdinal ordinal1("1");
-  const TestOrdinal ordinal2("2");
-
-  const TestOrdinal::EqualsFn equals;
-
-  EXPECT_TRUE(equals(ordinal1, ordinal1));
-  EXPECT_FALSE(equals(ordinal1, ordinal2));
-
-  EXPECT_FALSE(equals(ordinal2, ordinal1));
-  EXPECT_TRUE(equals(ordinal2, ordinal2));
-}
-
-// Create some Ordinals and shuffle them.  Sorting them using
-// LessThanFn should produce the correct order.
-TEST(Ordinal, Sort) {
-  const LongOrdinal ordinal1("12345");
-  const LongOrdinal ordinal2("54321");
-  const LongOrdinal ordinal3("87654");
-  const LongOrdinal ordinal4("98765");
-
-  std::vector<LongOrdinal> sorted_ordinals;
-  sorted_ordinals.push_back(ordinal1);
-  sorted_ordinals.push_back(ordinal2);
-  sorted_ordinals.push_back(ordinal3);
-  sorted_ordinals.push_back(ordinal4);
-
-  std::vector<LongOrdinal> ordinals = sorted_ordinals;
-  std::random_shuffle(ordinals.begin(), ordinals.end());
-  std::sort(ordinals.begin(), ordinals.end(), LongOrdinal::LessThanFn());
-  EXPECT_TRUE(std::equal(ordinals.begin(), ordinals.end(),
-                         sorted_ordinals.begin(), LongOrdinal::EqualsFn()));
-}
-
-}  // namespace
-
-}  // namespace syncer