unique_position_unittest.cc | Explore in Territory

// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "components/sync/base/unique_position.h"

#include <algorithm>
#include <functional>
#include <memory>
#include <vector>

#include "base/base64.h"
#include "base/hash/sha1.h"
#include "base/logging.h"
#include "base/memory/raw_ptr.h"
#include "base/ranges/algorithm.h"
#include "base/strings/string_number_conversions.h"
#include "components/sync/protocol/unique_position.pb.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace syncer {

namespace {

// This function exploits internal knowledge of how the protobufs are serialized
// to help us build UniquePositions from strings described in this file.
static UniquePosition FromBytes(const std::string& bytes) { … }

class UniquePositionTest : public ::testing::Test { … };

static constexpr char kMinSuffix[] = …;
static_assert …;

static constexpr char kMaxSuffix[] = …;
static_assert …;

static constexpr char kNormalSuffix[] = …;
static_assert …;

::testing::AssertionResult LessThan(const char* m_expr,
                                    const char* n_expr,
                                    const UniquePosition& m,
                                    const UniquePosition& n) { … }

::testing::AssertionResult Equals(const char* m_expr,
                                  const char* n_expr,
                                  const UniquePosition& m,
                                  const UniquePosition& n) { … }

// Test that the code can read the uncompressed serialization format.
TEST_F(UniquePositionTest, DeserializeObsoleteUncompressedPosition) { … }

// Test that the code can read the gzip serialization format.
TEST_F(UniquePositionTest, DeserializeObsoleteGzippedPosition) { … }

class RelativePositioningTest : public UniquePositionTest { … };

struct PositionLessThan { … };

// Returns true iff the given position's suffix matches the input parameter.
static bool IsSuffixInUse(const UniquePosition& pos,
                          const std::string& suffix) { … }

// Test some basic properties of comparison and equality.
TEST_F(RelativePositioningTest, ComparisonSanityTest1) { … }

// Test some more properties of comparison and equality.
TEST_F(RelativePositioningTest, ComparisonSanityTest2) { … }

// Exercise comparision functions by sorting and re-sorting the list.
TEST_F(RelativePositioningTest, SortPositions) { … }

// Some more exercise for the comparison function.
TEST_F(RelativePositioningTest, ReverseSortPositions) { … }

class PositionInsertTest : public RelativePositioningTest,
                           public ::testing::WithParamInterface<std::string> { … };

// Exercise InsertBetween with various insertion operations.
TEST_P(PositionInsertTest, InsertBetween) { … }

TEST_P(PositionInsertTest, InsertBefore) { … }

TEST_P(PositionInsertTest, InsertAfter) { … }

TEST_P(PositionInsertTest, StressInsertAfter) { … }

TEST_P(PositionInsertTest, StressInsertBefore) { … }

TEST_P(PositionInsertTest, StressLeftInsertBetween) { … }

TEST_P(PositionInsertTest, StressRightInsertBetween) { … }

// Generates suffixes similar to those generated by the legacy Directory.
// This may become obsolete if the suffix generation code is modified.
class SuffixGenerator { … };

// Cache guids generated in the same style as real clients.
static const char kCacheGuidStr1[] = …;
static const char kCacheGuidStr2[] = …;

class PositionScenariosTest : public UniquePositionTest { … };

// One client creating new bookmarks, always inserting at the end.
TEST_F(PositionScenariosTest, OneClientInsertAtEnd) { … }

// Two clients alternately inserting entries at the end, with a strong
// bias towards insertions by the first client.
TEST_F(PositionScenariosTest, TwoClientsInsertAtEnd_A) { … }

// Two clients alternately inserting entries at the end.
TEST_F(PositionScenariosTest, TwoClientsInsertAtEnd_B) { … }

INSTANTIATE_TEST_SUITE_P(…);
INSTANTIATE_TEST_SUITE_P(…);
INSTANTIATE_TEST_SUITE_P(…);

class PositionFromIntTest : public UniquePositionTest { … };

TEST_F(PositionFromIntTest, IsValid) { … }

template <typename T, typename LessThan = std::less<T>>
class IndexedLessThan {
 public:
  explicit IndexedLessThan(base::span<const T> values) : … { … }

  bool operator()(int i1, int i2) { … }

 private:
  base::span<const T> values_;
  LessThan less_than_;
};

TEST_F(PositionFromIntTest, ConsistentOrdering) { … }

class CompressedPositionTest : public UniquePositionTest { … };

UniquePosition CompressedPositionTest::MakePosition(
    const std::string& compressed_prefix,
    const std::string& compressed_suffix) { … }

std::string CompressedPositionTest::MakeSuffix(char unique_value) { … }

// Make sure that serialization and deserialization routines are correct.
TEST_F(CompressedPositionTest, SerializeAndDeserialize) { … }

// Test that deserialization failures of protobufs where we know none of its
// fields is not catastrophic.  This may happen if all the fields currently
// known to this client become deprecated in the future.
TEST_F(CompressedPositionTest, DeserializeProtobufFromTheFuture) { … }

// Make sure the comparison functions are working correctly.
// This requires values in the test harness to be hard-coded in ascending order.
TEST_F(CompressedPositionTest, OrderingTest) { … }

}  // namespace

}  // namespace syncer
chromium/components/sync/base/unique_position_unittest.cc
