string_ordinal_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/model/string_ordinal.h"

#include <algorithm>
#include <vector>

#include "base/rand_util.h"
#include "base/ranges/algorithm.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/abseil-cpp/absl/strings/ascii.h"

namespace syncer {

namespace {

// Create StringOrdinals that satisfy all but one criterion for validity.
// IsValid() should return false for all of them.
TEST(StringOrdinalTest, Invalid) { … }

// Create StringOrdinals that satisfy all criteria for validity.
// IsValid() should return true for all of them.
TEST(StringOrdinalTest, Valid) { … }

// Create StringOrdinals from CreateInitialOrdinal.  They should be valid
// and close to the middle of the range.
TEST(StringOrdinalTest, CreateInitialOrdinal) { … }

// Create an invalid and a valid StringOrdinal.  EqualsOrBothInvalid should
// return true if called reflexively and false otherwise.
TEST(StringOrdinalTest, EqualsOrBothInvalid) { … }

// Create three StringOrdinals in order.  LessThan should return values
// consistent with that order.
TEST(StringOrdinalTest, LessThan) { … }

// Create three StringOrdinals in order.  GreaterThan should return values
// consistent with that order.
TEST(StringOrdinalTest, GreaterThan) { … }

// Create two valid StringOrdinals.  Equals should return true only when
// called reflexively.
TEST(StringOrdinalTest, Equals) { … }

// Create some valid ordinals from some byte strings.
// ToInternalValue() should return the original byte string.
TEST(StringOrdinalTest, ToInternalValue) { … }

bool IsNonEmptyPrintableString(const std::string& str) { … }

// Create some invalid/valid ordinals.  ToDebugString() should always
// return a non-empty printable string.
TEST(StringOrdinalTest, ToDebugString) { … }

// Create three StringOrdinals in order.  LessThanFn should return values
// consistent with that order.
TEST(StringOrdinalTest, LessThanFn) { … }

std::string GetBetween(const std::string& ordinal_string1,
                       const std::string& ordinal_string2) { … }

// Create some StringOrdinals from single-digit strings.  Given two strings
// from this set, CreateBetween should return a StringOrdinal roughly between
// them that are also single-digit when possible.
TEST(StringOrdinalTest, CreateBetweenSingleDigit) { … }

// Create some StringOrdinals from strings of various lengths.  Given two
// strings from this set, CreateBetween should return an StringOrdinal roughly
// between them that have as few digits as possible.
TEST(StringOrdinalTest, CreateBetweenDifferentLengths) { … }

// Create some StringOrdinals specifically designed to trigger overflow
// cases.  Given two strings from this set, CreateBetween should
// return a StringOrdinal roughly between them that have as few digits as
// possible.
TEST(StringOrdinalTest, CreateBetweenOverflow) { … }

// Create some StringOrdinals.  CreateBefore should return a StringOrdinal
// roughly halfway towards "a".
TEST(StringOrdinalTest, CreateBefore) { … }

// Create some StringOrdinals.  CreateAfter should return a StringOrdinal
// roughly halfway towards "a".
TEST(StringOrdinalTest, CreateAfter) { … }

// Create two valid StringOrdinals.  EqualsFn should return true only when
// called reflexively.
TEST(StringOrdinalTest, EqualsFn) { … }

// Create some StringOrdinals and shuffle them.  Sorting them using
// LessThanFn should produce the correct order.
TEST(StringOrdinalTest, Sort) { … }

}  // namespace

}  // namespace syncer
chromium/components/sync/model/string_ordinal_unittest.cc
