subversion-1.9.7HEADsubversion-1.9.7master

1 files changed, 318 insertions, 0 deletions

diff --git a/subversion/tests/libsvn_fs_x/string-table-test.c b/subversion/tests/libsvn_fs_x/string-table-test.c
new file mode 100644
index 0000000..2633bfa
--- /dev/null
+++ b/subversion/tests/libsvn_fs_x/string-table-test.c
@@ -0,0 +1,318 @@
+/* string-table-test.c --- tests for string tables
+ *
+ * ====================================================================
+ *    Licensed to the Apache Software Foundation (ASF) under one
+ *    or more contributor license agreements.  See the NOTICE file
+ *    distributed with this work for additional information
+ *    regarding copyright ownership.  The ASF licenses this file
+ *    to you under the Apache License, Version 2.0 (the
+ *    "License"); you may not use this file except in compliance
+ *    with the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing,
+ *    software distributed under the License is distributed on an
+ *    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *    KIND, either express or implied.  See the License for the
+ *    specific language governing permissions and limitations
+ *    under the License.
+ * ====================================================================
+ */
+
+#include "../svn_test.h"
+#include "../../libsvn_fs_x/string_table.h"
+#include "svn_pools.h"
+#include "svn_sorts.h"
+
+/* Some tests use this list of strings as is.  They are all "short strings"
+ * in the terminology of string tables.  We use them also as an input to
+ * generate strings of arbitrary length.
+ */
+enum { STRING_COUNT = 12 };
+static const char *basic_strings[STRING_COUNT] =
+  {
+     "some string",
+     "this is another string",
+     "this is a duplicate",
+     "some longer string",
+     "this is a very long string",
+     "and here is another",
+     "this is a duplicate",
+     "/some/path/to/a/dir",
+     "/some/path/to/a/file",
+     "/some/other/dir",
+     "/some/other/file",
+     ""
+  };
+
+/* Generate a string of exactly LEN chars (plus terminating NUL).  KEY is
+ * an arbitrary integer that will be transformed into a character sequence
+ * using entries of BASIC_STRINGS.  The result will be allocated in POOL.
+ */
+static svn_stringbuf_t *
+generate_string(apr_uint64_t key, apr_size_t len, apr_pool_t *pool)
+{
+  svn_stringbuf_t *result = svn_stringbuf_create_ensure(len, pool);
+  apr_uint64_t temp = key;
+  apr_uint64_t run = 0;
+
+  while (len)
+    {
+      apr_size_t idx;
+      apr_size_t add_len;
+
+      if (temp == 0)
+        {
+          temp = key;
+          run++;
+        }
+
+      idx = (temp + run) % STRING_COUNT;
+      temp /= STRING_COUNT;
+
+      add_len = strlen(basic_strings[idx]);
+      add_len = MIN(len, add_len);
+
+      svn_stringbuf_appendbytes(result, basic_strings[idx], add_len);
+      len -= add_len;
+    }
+
+  return result;
+}
+
+static svn_error_t *
+store_and_load_table(string_table_t **table, apr_pool_t *pool)
+{
+  svn_stringbuf_t *stream_buffer = svn_stringbuf_create_empty(pool);
+  svn_stream_t *stream;
+
+  stream = svn_stream_from_stringbuf(stream_buffer, pool);
+  SVN_ERR(svn_fs_x__write_string_table(stream, *table, pool));
+  SVN_ERR(svn_stream_close(stream));
+
+  *table = NULL;
+
+  stream = svn_stream_from_stringbuf(stream_buffer, pool);
+  SVN_ERR(svn_fs_x__read_string_table(table, stream, pool, pool));
+  SVN_ERR(svn_stream_close(stream));
+
+  return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+create_empty_table_body(svn_boolean_t do_load_store,
+                        apr_pool_t *pool)
+{
+  string_table_builder_t *builder
+    = svn_fs_x__string_table_builder_create(pool);
+  string_table_t *table
+    = svn_fs_x__string_table_create(builder, pool);
+
+  SVN_TEST_STRING_ASSERT(svn_fs_x__string_table_get(table, 0, NULL, pool), "");
+
+  if (do_load_store)
+    SVN_ERR(store_and_load_table(&table, pool));
+
+  SVN_TEST_STRING_ASSERT(svn_fs_x__string_table_get(table, 0, NULL, pool), "");
+
+  return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+short_string_table_body(svn_boolean_t do_load_store,
+                        apr_pool_t *pool)
+{
+  apr_size_t indexes[STRING_COUNT] = { 0 };
+
+  string_table_builder_t *builder;
+  string_table_t *table;
+  int i;
+
+  builder = svn_fs_x__string_table_builder_create(pool);
+  for (i = 0; i < STRING_COUNT; ++i)
+    indexes[i] = svn_fs_x__string_table_builder_add(builder, basic_strings[i], 0);
+
+  table = svn_fs_x__string_table_create(builder, pool);
+  if (do_load_store)
+    SVN_ERR(store_and_load_table(&table, pool));
+
+  SVN_TEST_ASSERT(indexes[2] == indexes[6]);
+  for (i = 0; i < STRING_COUNT; ++i)
+    {
+      apr_size_t len;
+      const char *string
+        = svn_fs_x__string_table_get(table, indexes[i], &len, pool);
+
+      SVN_TEST_STRING_ASSERT(string, basic_strings[i]);
+      SVN_TEST_ASSERT(len == strlen(string));
+      SVN_TEST_ASSERT(len == strlen(basic_strings[i]));
+    }
+
+  SVN_TEST_STRING_ASSERT(svn_fs_x__string_table_get(table, STRING_COUNT,
+                                                    NULL, pool), "");
+
+  return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+large_string_table_body(svn_boolean_t do_load_store,
+                        apr_pool_t *pool)
+{
+  enum { COUNT = 10 };
+
+  svn_stringbuf_t *strings[COUNT] = { 0 };
+  apr_size_t indexes[COUNT] = { 0 };
+
+  string_table_builder_t *builder;
+  string_table_t *table;
+  int i;
+
+  builder = svn_fs_x__string_table_builder_create(pool);
+  for (i = 0; i < COUNT; ++i)
+    {
+      strings[i] = generate_string(APR_UINT64_C(0x1234567876543210) * (i + 1),
+                                   73000 + 1000 * i,  pool);
+      indexes[i] = svn_fs_x__string_table_builder_add(builder,
+                                                      strings[i]->data,
+                                                      strings[i]->len);
+    }
+
+  table = svn_fs_x__string_table_create(builder, pool);
+  if (do_load_store)
+    SVN_ERR(store_and_load_table(&table, pool));
+
+  for (i = 0; i < COUNT; ++i)
+    {
+      apr_size_t len;
+      const char *string
+        = svn_fs_x__string_table_get(table, indexes[i], &len, pool);
+
+      SVN_TEST_STRING_ASSERT(string, strings[i]->data);
+      SVN_TEST_ASSERT(len == strlen(string));
+      SVN_TEST_ASSERT(len == strings[i]->len);
+    }
+
+  return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+many_strings_table_body(svn_boolean_t do_load_store,
+                        apr_pool_t *pool)
+{
+  /* cause multiple sub-tables (6 to be exact) to be created */
+  enum { COUNT = 100 };
+
+  svn_stringbuf_t *strings[COUNT] = { 0 };
+  apr_size_t indexes[COUNT] = { 0 };
+
+  string_table_builder_t *builder;
+  string_table_t *table;
+  int i;
+
+  builder = svn_fs_x__string_table_builder_create(pool);
+  for (i = 0; i < COUNT; ++i)
+    {
+      strings[i] = generate_string(APR_UINT64_C(0x1234567876543210) * (i + 1),
+                                   (i * i) % 23000,  pool);
+      indexes[i] = svn_fs_x__string_table_builder_add(builder,
+                                                      strings[i]->data,
+                                                      strings[i]->len);
+    }
+
+  table = svn_fs_x__string_table_create(builder, pool);
+  if (do_load_store)
+    SVN_ERR(store_and_load_table(&table, pool));
+
+  for (i = 0; i < COUNT; ++i)
+    {
+      apr_size_t len;
+      const char *string
+        = svn_fs_x__string_table_get(table, indexes[i], &len, pool);
+
+      SVN_TEST_STRING_ASSERT(string, strings[i]->data);
+      SVN_TEST_ASSERT(len == strlen(string));
+      SVN_TEST_ASSERT(len == strings[i]->len);
+    }
+
+  return SVN_NO_ERROR;
+}
+
+static svn_error_t *
+create_empty_table(apr_pool_t *pool)
+{
+  return svn_error_trace(create_empty_table_body(FALSE, pool));
+}
+
+static svn_error_t *
+short_string_table(apr_pool_t *pool)
+{
+  return svn_error_trace(short_string_table_body(FALSE, pool));
+}
+
+static svn_error_t *
+large_string_table(apr_pool_t *pool)
+{
+  return svn_error_trace(large_string_table_body(FALSE, pool));
+}
+
+static svn_error_t *
+many_strings_table(apr_pool_t *pool)
+{
+  return svn_error_trace(many_strings_table_body(FALSE, pool));
+}
+
+static svn_error_t *
+store_load_short_string_table(apr_pool_t *pool)
+{
+  return svn_error_trace(short_string_table_body(TRUE, pool));
+}
+
+static svn_error_t *
+store_load_large_string_table(apr_pool_t *pool)
+{
+  return svn_error_trace(large_string_table_body(TRUE, pool));
+}
+
+static svn_error_t *
+store_load_empty_table(apr_pool_t *pool)
+{
+  return svn_error_trace(create_empty_table_body(TRUE, pool));
+}
+
+static svn_error_t *
+store_load_many_strings_table(apr_pool_t *pool)
+{
+  return svn_error_trace(many_strings_table_body(TRUE, pool));
+}
+
+
+/* ------------------------------------------------------------------------ */
+
+/* The test table.  */
+
+static int max_threads = 4;
+
+static struct svn_test_descriptor_t test_funcs[] =
+  {
+    SVN_TEST_NULL,
+    SVN_TEST_PASS2(create_empty_table,
+                   "create an empty string table"),
+    SVN_TEST_PASS2(short_string_table,
+                   "string table with short strings only"),
+    SVN_TEST_PASS2(large_string_table,
+                   "string table with large strings only"),
+    SVN_TEST_PASS2(many_strings_table,
+                   "string table with many strings"),
+    SVN_TEST_PASS2(store_load_empty_table,
+                   "store and load an empty string table"),
+    SVN_TEST_PASS2(store_load_short_string_table,
+                   "store and load table with short strings only"),
+    SVN_TEST_PASS2(store_load_large_string_table,
+                   "store and load table with large strings only"),
+    SVN_TEST_PASS2(store_load_many_strings_table,
+                   "store and load string table with many strings"),
+    SVN_TEST_NULL
+  };
+
+SVN_TEST_MAIN