commit 40381fb9dc4b4cf274f1e58b2cdf4396202c6189
author Brian Carlstrom <bdc@google.com> Wed Oct 19 14:13:40 2011 -0700
committer Brian Carlstrom <bdc@google.com> Thu Oct 20 12:19:25 2011 -0700
tree 8281b105d3e8a0850984f0ee182db01c33613f27
parent b06631143b944388fc68bedf6679c006dde5f461

Reuse SIRT for C++ references

Change-Id: I8310e55da42f55f7ec60f6b17face436c77a979f

src/intern_table_test.cc

diff --git a/src/intern_table_test.cc b/src/intern_table_test.cc
index d9a6a45..a0c47ec 100644
--- a/src/intern_table_test.cc
+++ b/src/intern_table_test.cc
@@ -11,26 +11,27 @@
 
 TEST_F(InternTableTest, Intern) {
   InternTable intern_table;
-  const String* foo_1 = intern_table.InternStrong(3, "foo");
-  const String* foo_2 = intern_table.InternStrong(3, "foo");
-  const String* foo_3 = String::AllocFromModifiedUtf8("foo");
-  const String* bar = intern_table.InternStrong(3, "bar");
+  SirtRef<String> foo_1(intern_table.InternStrong(3, "foo"));
+  SirtRef<String> foo_2(intern_table.InternStrong(3, "foo"));
+  SirtRef<String> foo_3(String::AllocFromModifiedUtf8("foo"));
+  SirtRef<String> bar(intern_table.InternStrong(3, "bar"));
   EXPECT_TRUE(foo_1->Equals("foo"));
   EXPECT_TRUE(foo_2->Equals("foo"));
   EXPECT_TRUE(foo_3->Equals("foo"));
-  EXPECT_TRUE(foo_1 != NULL);
-  EXPECT_TRUE(foo_2 != NULL);
-  EXPECT_EQ(foo_1, foo_2);
-  EXPECT_NE(foo_1, bar);
-  EXPECT_NE(foo_2, bar);
-  EXPECT_NE(foo_3, bar);
+  EXPECT_TRUE(foo_1.get() != NULL);
+  EXPECT_TRUE(foo_2.get() != NULL);
+  EXPECT_EQ(foo_1.get(), foo_2.get());
+  EXPECT_NE(foo_1.get(), bar.get());
+  EXPECT_NE(foo_2.get(), bar.get());
+  EXPECT_NE(foo_3.get(), bar.get());
 }
 
 TEST_F(InternTableTest, Size) {
   InternTable t;
   EXPECT_EQ(0U, t.Size());
   t.InternStrong(3, "foo");
-  t.InternWeak(String::AllocFromModifiedUtf8("foo"));
+  SirtRef<String> foo(String::AllocFromModifiedUtf8("foo"));
+  t.InternWeak(foo.get());
   EXPECT_EQ(1U, t.Size());
   t.InternStrong(3, "bar");
   EXPECT_EQ(2U, t.Size());
@@ -72,21 +73,24 @@
   InternTable t;
   t.InternStrong(3, "foo");
   t.InternStrong(3, "bar");
-  const String* s0 = t.InternWeak(String::AllocFromModifiedUtf8("hello"));
-  const String* s1 = t.InternWeak(String::AllocFromModifiedUtf8("world"));
+  SirtRef<String> hello(String::AllocFromModifiedUtf8("hello"));
+  SirtRef<String> world(String::AllocFromModifiedUtf8("world"));
+  SirtRef<String> s0(t.InternWeak(hello.get()));
+  SirtRef<String> s1(t.InternWeak(world.get()));
 
   EXPECT_EQ(4U, t.Size());
 
   // We should traverse only the weaks...
   TestPredicate p;
-  p.Expect(s0);
-  p.Expect(s1);
+  p.Expect(s0.get());
+  p.Expect(s1.get());
   t.SweepInternTableWeaks(IsMarked, &p);
 
   EXPECT_EQ(2U, t.Size());
 
   // Just check that we didn't corrupt the unordered_multimap.
-  t.InternWeak(String::AllocFromModifiedUtf8("still here"));
+  SirtRef<String> still_here(String::AllocFromModifiedUtf8("still here"));
+  t.InternWeak(still_here.get());
   EXPECT_EQ(3U, t.Size());
 }
 
@@ -94,41 +98,45 @@
   {
     // Strongs are never weak.
     InternTable t;
-    String* foo_1 = t.InternStrong(3, "foo");
-    EXPECT_FALSE(t.ContainsWeak(foo_1));
-    String* foo_2 = t.InternStrong(3, "foo");
-    EXPECT_FALSE(t.ContainsWeak(foo_2));
-    EXPECT_EQ(foo_1, foo_2);
+    SirtRef<String> interned_foo_1(t.InternStrong(3, "foo"));
+    EXPECT_FALSE(t.ContainsWeak(interned_foo_1.get()));
+    SirtRef<String> interned_foo_2(t.InternStrong(3, "foo"));
+    EXPECT_FALSE(t.ContainsWeak(interned_foo_2.get()));
+    EXPECT_EQ(interned_foo_1.get(), interned_foo_2.get());
   }
 
   {
     // Weaks are always weak.
     InternTable t;
-    String* foo_1 = t.InternWeak(String::AllocFromModifiedUtf8("foo"));
-    EXPECT_TRUE(t.ContainsWeak(foo_1));
-    String* foo_2 = t.InternWeak(String::AllocFromModifiedUtf8("foo"));
-    EXPECT_TRUE(t.ContainsWeak(foo_2));
-    EXPECT_EQ(foo_1, foo_2);
+    SirtRef<String> foo_1(String::AllocFromModifiedUtf8("foo"));
+    SirtRef<String> foo_2(String::AllocFromModifiedUtf8("foo"));
+    EXPECT_NE(foo_1.get(), foo_2.get());
+    SirtRef<String> interned_foo_1(t.InternWeak(foo_1.get()));
+    SirtRef<String> interned_foo_2(t.InternWeak(foo_2.get()));
+    EXPECT_TRUE(t.ContainsWeak(interned_foo_2.get()));
+    EXPECT_EQ(interned_foo_1.get(), interned_foo_2.get());
   }
 
   {
     // A weak can be promoted to a strong.
     InternTable t;
-    String* foo_1 = t.InternWeak(String::AllocFromModifiedUtf8("foo"));
-    EXPECT_TRUE(t.ContainsWeak(foo_1));
-    String* foo_2 = t.InternStrong(3, "foo");
-    EXPECT_FALSE(t.ContainsWeak(foo_2));
-    EXPECT_EQ(foo_1, foo_2);
+    SirtRef<String> foo(String::AllocFromModifiedUtf8("foo"));
+    SirtRef<String> interned_foo_1(t.InternWeak(foo.get()));
+    EXPECT_TRUE(t.ContainsWeak(interned_foo_1.get()));
+    SirtRef<String> interned_foo_2(t.InternStrong(3, "foo"));
+    EXPECT_FALSE(t.ContainsWeak(interned_foo_2.get()));
+    EXPECT_EQ(interned_foo_1.get(), interned_foo_2.get());
   }
 
   {
     // Interning a weak after a strong gets you the strong.
     InternTable t;
-    String* foo_1 = t.InternStrong(3, "foo");
-    EXPECT_FALSE(t.ContainsWeak(foo_1));
-    String* foo_2 = t.InternWeak(String::AllocFromModifiedUtf8("foo"));
-    EXPECT_FALSE(t.ContainsWeak(foo_2));
-    EXPECT_EQ(foo_1, foo_2);
+    SirtRef<String> interned_foo_1(t.InternStrong(3, "foo"));
+    EXPECT_FALSE(t.ContainsWeak(interned_foo_1.get()));
+    SirtRef<String> foo(String::AllocFromModifiedUtf8("foo"));
+    SirtRef<String> interned_foo_2(t.InternWeak(foo.get()));
+    EXPECT_FALSE(t.ContainsWeak(interned_foo_2.get()));
+    EXPECT_EQ(interned_foo_1.get(), interned_foo_2.get());
   }
 }