Create StringOrdinal to allow placement of strings in sorted lists

chrome/common/string_ordinal_unittest.cc

Index: chrome/common/string_ordinal_unittest.cc
diff --git a/chrome/common/string_ordinal_unittest.cc b/chrome/common/string_ordinal_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..f928a682965e455361c1691bc7b03ce7750aeec7
--- /dev/null
+++ b/chrome/common/string_ordinal_unittest.cc
@@ -0,0 +1,135 @@
+// Copyright (c) 2011 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 "chrome/common/string_ordinal.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+TEST(StringOrdinalTest, IsValid) {

[tfarina, 2011/10/18 17:10:54]

please, could you wrap this into an unnamed namespace?

namespace {

...

}  // namespace

+  StringOrdinal index_ = StringOrdinal("b");

[tfarina, 2011/10/18 17:10:54]

index_ -> index

Also can't you create the index object by doing instead:

StringOrdinal index("b")

?

+  EXPECT_TRUE(index_.IsValid());

[akalin, 2011/10/18 17:59:27]

you can just do EXPECT_TRUE(StringOrdinal(...).IsValid()) etc.

+
+  index_ = StringOrdinal("ab");
+  EXPECT_TRUE(index_.IsValid());
+
+  index_ = StringOrdinal("aa");
+  EXPECT_FALSE(index_.IsValid());
+
+  index_ = StringOrdinal();
+  EXPECT_FALSE(index_.IsValid());
+}
+
+TEST(StringOrdinalTest, LessThan) {
+  StringOrdinal small = StringOrdinal("b");

[akalin, 2011/10/18 17:59:27]

const StringOrdinal small(...);

etc.

+  StringOrdinal middle = StringOrdinal("n");
+  StringOrdinal big = StringOrdinal("z");
+
+  EXPECT_TRUE(small.LessThan(middle));
+  EXPECT_TRUE(small.LessThan(big));
+  EXPECT_TRUE(middle.LessThan(big));
+
+  EXPECT_FALSE(big.LessThan(small));
+  EXPECT_FALSE(big.LessThan(middle));
+  EXPECT_FALSE(middle.LessThan(small));
+}
+
+TEST(StringOrdinalTest, CreateBetweenSingleDigit) {
+  StringOrdinal result = StringOrdinal("b").CreateBetween(StringOrdinal("d"));
+  EXPECT_EQ("c", result.ToString());
+
+  result = StringOrdinal("b").CreateBetween(StringOrdinal("e"));
+  EXPECT_EQ("c", result.ToString());
+
+  result = StringOrdinal("b").CreateBetween(StringOrdinal("f"));
+  EXPECT_EQ("d", result.ToString());
+
+  result = StringOrdinal("b").CreateBetween(StringOrdinal("c"));
+  EXPECT_EQ("bn", result.ToString());
+

[akalin, 2011/10/18 17:59:27]

make sure to test the other direction, too

+  result = StringOrdinal("c").CreateBetween(StringOrdinal("d"));
+  EXPECT_EQ("cn", result.ToString());
+}
+
+TEST(StringOrdinalTest, CreateBetweenDifferentLengths) {
+  StringOrdinal result = StringOrdinal("b").CreateBetween(StringOrdinal("bb"));
+  EXPECT_EQ("ban", result.ToString());
+
+  result = StringOrdinal("bz").CreateBetween(StringOrdinal("c"));
+  EXPECT_EQ("bzn", result.ToString());
+}
+
+TEST(StringOrdinalTest, CreateBetweenOverflow) {
+  StringOrdinal result = StringOrdinal("ab").CreateBetween(StringOrdinal("bb"));
+  EXPECT_EQ("ao", result.ToString());
+
+  result = StringOrdinal("bb").CreateBetween(StringOrdinal("cb"));
+  EXPECT_EQ("bo", result.ToString());
+
+  result = StringOrdinal("bbb").CreateBetween(StringOrdinal("bcb"));
+  EXPECT_EQ("bbo", result.ToString());
+
+  result = StringOrdinal("aab").CreateBetween(StringOrdinal("zzz"));
+  EXPECT_EQ("n", result.ToString());
+
+  result = StringOrdinal("yyy").CreateBetween(StringOrdinal("zzz"));
+  EXPECT_EQ("zml", result.ToString());
+
+  result = StringOrdinal("yab").CreateBetween(StringOrdinal("zzz"));
+  EXPECT_EQ("z", result.ToString());
+
+  result = StringOrdinal("aaz").CreateBetween(StringOrdinal("zzz"));
+  EXPECT_EQ("nam", result.ToString());
+}
+
+TEST(StringOrdinalTest, CreateAfter) {
+  StringOrdinal result = StringOrdinal("y").CreateAfter();
+  EXPECT_EQ("yn", result.ToString());
+
+  result = StringOrdinal("zy").CreateAfter();
+  EXPECT_EQ("zyn", result.ToString());
+
+  result = StringOrdinal("zzzy").CreateAfter();
+  EXPECT_EQ("zzzyn", result.ToString());
+
+  result = StringOrdinal("yy").CreateAfter();
+  EXPECT_EQ("zl", result.ToString());
+
+  result = StringOrdinal("yz").CreateAfter();
+  EXPECT_EQ("zm", result.ToString());
+
+  result = StringOrdinal("z").CreateAfter();
+  EXPECT_EQ("zm", result.ToString());
+}
+
+TEST(StringOrdinalTest, CreateBefore) {
+  StringOrdinal result = StringOrdinal("b").CreateBefore();
+  EXPECT_EQ("an", result.ToString());
+
+  result = StringOrdinal("bb").CreateBefore();
+  EXPECT_EQ("ao", result.ToString());
+
+  result = StringOrdinal("bc").CreateBefore();
+  EXPECT_EQ("ao", result.ToString());
+
+  result = StringOrdinal("bd").CreateBefore();
+  EXPECT_EQ("ap", result.ToString());
+}
+
+TEST(StringOrdinalTest, ToString) {
+  StringOrdinal index = StringOrdinal("b");
+  EXPECT_EQ(index.ToString(), "b");
+
+  index = StringOrdinal("aab");
+  EXPECT_EQ(index.ToString(), "aab");
+
+  index = StringOrdinal("zzz");
+  EXPECT_EQ(index.ToString(), "zzz");
+}
+
+TEST(StringOrdinalTest, CrateBetweenLargeValueFirst) {

[akalin, 2011/10/18 17:59:27]

Crate -> Create

+  StringOrdinal result = StringOrdinal("d").CreateBetween(StringOrdinal("b"));
+  EXPECT_EQ("c", result.ToString());
+
+ result = StringOrdinal("zzz").CreateBetween(StringOrdinal("aaz"));

[akalin, 2011/10/18 17:59:27]

indent

+  EXPECT_EQ("nam", result.ToString());
+}