From e29bf964d1716398e8354a50f506906a307298e5 Mon Sep 17 00:00:00 2001
From: Joshua Haberman <joshua@reverberate.org>
Date: Sat, 10 Jul 2010 12:15:31 -0700
Subject: Tests for string and fleshed out implementation.

---
 tests/test_string.c | 56 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 tests/test_table.cc | 13 ++++++++++++-
 2 files changed, 68 insertions(+), 1 deletion(-)
 create mode 100644 tests/test_string.c

(limited to 'tests')

diff --git a/tests/test_string.c b/tests/test_string.c
new file mode 100644
index 0000000..4fdab6c
--- /dev/null
+++ b/tests/test_string.c
@@ -0,0 +1,56 @@
+
+#undef NDEBUG  /* ensure tests always assert. */
+#include "upb_string.h"
+
+char static_str[] = "Static string.";
+
+int main() {
+  upb_string *str = upb_string_new();
+  assert(str != NULL);
+  upb_string_unref(str);
+
+  // Can also create a string by tryrecycle(NULL).
+  str = upb_string_tryrecycle(NULL);
+  assert(str != NULL);
+
+  upb_strcpyc(str, static_str);
+  assert(upb_string_len(str) == (sizeof(static_str) - 1));
+  const char *robuf = upb_string_getrobuf(str);
+  assert(robuf != NULL);
+  assert(memcmp(robuf, static_str, upb_string_len(str)) == 0);
+  upb_string_endread(str);
+
+  upb_string *str2 = upb_string_tryrecycle(str);
+  // No other referents, so should return the same string.
+  assert(str2 == str);
+
+  // Write a shorter string, the same memory should be reused.
+  upb_strcpyc(str, "XX");
+  const char *robuf2 = upb_string_getrobuf(str);
+  assert(robuf2 == robuf);
+  assert(memcmp(robuf2, "XX", 2) == 0);
+
+  // Make string alias part of another string.
+  str2 = upb_strdupc("WXYZ");
+  upb_string_substr(str, str2, 1, 2);
+  assert(upb_string_len(str) == 2);
+  assert(upb_string_len(str2) == 4);
+  // The two string should be aliasing the same data.
+  const char *robuf3 = upb_string_getrobuf(str);
+  const char *robuf4 = upb_string_getrobuf(str2);
+  assert(robuf3 == robuf4 + 1);
+  // The aliased string should have an extra ref.
+  assert(upb_atomic_read(&str2->refcount) == 2);
+
+  // Recycling str should eliminate the extra ref.
+  str = upb_string_tryrecycle(str);
+  assert(upb_atomic_read(&str2->refcount) == 1);
+
+  // Resetting str should reuse its old data.
+  upb_strcpyc(str, "XX");
+  const char *robuf5 = upb_string_getrobuf(str);
+  assert(robuf5 == robuf);
+
+  upb_string_unref(str);
+  upb_string_unref(str2);
+}
diff --git a/tests/test_table.cc b/tests/test_table.cc
index 37e14a8..47d5e57 100644
--- a/tests/test_table.cc
+++ b/tests/test_table.cc
@@ -12,6 +12,8 @@
 #include <sys/resource.h>
 #include <iostream>
 
+bool benchmark = false;
+
 using std::string;
 using std::vector;
 
@@ -116,6 +118,11 @@ void test_inttable(int32_t *keys, size_t num_entries)
     }
   }
 
+  if(!benchmark) {
+    upb_inttable_free(&table);
+    return;
+  }
+
   /* Test performance. We only test lookups for keys that are known to exist. */
   uintptr_t x = 0;
   const unsigned int iterations = 0xFFFFFF;
@@ -219,8 +226,12 @@ int32_t *get_contiguous_keys(int32_t num)
   return buf;
 }
 
-int main()
+int main(int argc, char *argv[])
 {
+  for (int i = 1; i < argc; i++) {
+    if (strcmp(argv[i], "--benchmark") == 0) benchmark = true;
+  }
+
   vector<string> keys;
   keys.push_back("google.protobuf.FileDescriptorSet");
   keys.push_back("google.protobuf.FileDescriptorProto");
-- 
cgit v1.2.3