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

components/sync/base/ordinal_unittest.cc

 // 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 "components/sync/base/ordinal.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <cctype>
 #include <cstddef>
 #include <string>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 19 matching lines @@
   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::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(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::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(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");
+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' };
+  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());
@@ skipping 111 matching lines @@
   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().ToDebugString()));
   EXPECT_TRUE(
       IsNonEmptyPrintableString(TestOrdinal("invalid string").ToDebugString()));
-  EXPECT_TRUE(
-      IsNonEmptyPrintableString(TestOrdinal("2").ToDebugString()));
-  EXPECT_TRUE(
-      IsNonEmptyPrintableString(LongOrdinal("12345").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");
@@ skipping 123 matching lines @@
   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