sync/internal_api/public/base/node_ordinal_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/basictypes.h"
   6 #include "sync/internal_api/public/base/node_ordinal.h"
   7 #include "testing/gtest/include/gtest/gtest.h"
   8
   9 #include <algorithm>
  10 #include <cstddef>
  11
  12 namespace syncer {
  13
  14 namespace {
  15
  16 const int64 kTestValues[] = {
  17   0LL,
  18   1LL, -1LL,
  19   2LL, -2LL,
  20   3LL, -3LL,
  21   0x79LL, -0x79LL,
  22   0x80LL, -0x80LL,
  23   0x81LL, -0x81LL,
  24   0xFELL, -0xFELL,
  25   0xFFLL, -0xFFLL,
  26   0x100LL, -0x100LL,
  27   0x101LL, -0x101LL,
  28   0xFA1AFELL, -0xFA1AFELL,
  29   0xFFFFFFFELL, -0xFFFFFFFELL,
  30   0xFFFFFFFFLL, -0xFFFFFFFFLL,
  31   0x100000000LL, -0x100000000LL,
  32   0x100000001LL, -0x100000001LL,
  33   0xFFFFFFFFFFLL, -0xFFFFFFFFFFLL,
  34   0x112358132134LL, -0x112358132134LL,
  35   0xFEFFBEEFABC1234LL, -0xFEFFBEEFABC1234LL,
  36   kint64max,
  37   kint64min,
  38   kint64min + 1,
  39   kint64max - 1
  40 };
  41
  42 const size_t kNumTestValues = arraysize(kTestValues);
  43
  44 // Convert each test value to an ordinal.  All ordinals should be
  45 // valid.
  46 TEST(NodeOrdinalTest, IsValid) {
  47   for (size_t i = 0; i < kNumTestValues; ++i) {
  48     const NodeOrdinal ordinal = Int64ToNodeOrdinal(kTestValues[i]);
  49     EXPECT_TRUE(ordinal.IsValid()) << "i = " << i;
  50   }
  51 }
  52
  53 // Convert each test value to an ordinal.  All ordinals should have
  54 // 8-byte strings, except for kint64min, which should have a 9-byte
  55 // string.
  56 TEST(NodeOrdinalTest, Size) {
  57   EXPECT_EQ(9U, Int64ToNodeOrdinal(kint64min).ToInternalValue().size());
  58
  59   for (size_t i = 0; i < kNumTestValues; ++i) {
  60     if (kTestValues[i] == kint64min) {
  61       continue;
  62     }
  63     const NodeOrdinal ordinal = Int64ToNodeOrdinal(kTestValues[i]);
  64     EXPECT_EQ(8U, ordinal.ToInternalValue().size()) << "i = " << i;
  65   }
  66 }
  67
  68 // Convert each test value to an ordinal and back.  That resulting
  69 // value should be equal to the original value.
  70 TEST(NodeOrdinalTest, PositionToOrdinalToPosition) {
  71   for (size_t i = 0; i < kNumTestValues; ++i) {
  72     const int64 expected_value = kTestValues[i];
  73     const NodeOrdinal ordinal = Int64ToNodeOrdinal(expected_value);
  74     const int64 value = NodeOrdinalToInt64(ordinal);
  75     EXPECT_EQ(expected_value, value) << "i = " << i;
  76   }
  77 }
  78
  79 template <typename T, typename LessThan = std::less<T> >
  80 class IndexedLessThan {
  81  public:
  82   IndexedLessThan(const T* values) : values_(values) {}
  83
  84   bool operator()(int i1, int i2) {
  85     return less_than_(values_[i1], values_[i2]);
  86   }
  87
  88  private:
  89   const T* values_;
  90   LessThan less_than_;
  91 };
  92
  93 // Sort kTestValues by int64 value and then sort it by NodeOrdinal
  94 // value.  kTestValues should not already be sorted (by either
  95 // comparator) and the two orderings should be the same.
  96 TEST(NodeOrdinalTest, ConsistentOrdering) {
  97   NodeOrdinal ordinals[kNumTestValues];
  98   std::vector<int> original_ordering(kNumTestValues);
  99   std::vector<int> int64_ordering(kNumTestValues);
 100   std::vector<int> ordinal_ordering(kNumTestValues);
 101   for (size_t i = 0; i < kNumTestValues; ++i) {
 102     ordinals[i] = Int64ToNodeOrdinal(kTestValues[i]);
 103     original_ordering[i] = int64_ordering[i] = ordinal_ordering[i] = i;
 104   }
 105
 106   std::sort(int64_ordering.begin(), int64_ordering.end(),
 107             IndexedLessThan<int64>(kTestValues));
 108   std::sort(ordinal_ordering.begin(), ordinal_ordering.end(),
 109             IndexedLessThan<NodeOrdinal, NodeOrdinal::LessThanFn>(ordinals));
 110   EXPECT_NE(original_ordering, int64_ordering);
 111   EXPECT_EQ(int64_ordering, ordinal_ordering);
 112 }
 113
 114 // Create two NodeOrdinals and create another one between them.  It
 115 // should lie halfway between them.
 116 TEST(NodeOrdinalTest, CreateBetween) {
 117   const NodeOrdinal ordinal1("\1\1\1\1\1\1\1\1");
 118   const NodeOrdinal ordinal2("\1\1\1\1\1\1\1\3");
 119   EXPECT_EQ("\1\1\1\1\1\1\1\2",
 120             ordinal1.CreateBetween(ordinal2).ToInternalValue());
 121 }
 122
 123 }  // namespace
 124
 125 }  // namespace syncer