Merge branch 'break-out-more-tests' into 'master'

Break out more tests from libdbus

See merge request dbus/dbus!121

15 files changed, 994 insertions, 908 deletions

diff --git a/dbus/dbus-address.c b/dbus/dbus-address.c
index 7eb1b1bf..0eafdb2a 100644
--- a/dbus/dbus-address.c
+++ b/dbus/dbus-address.c
@@ -2,7 +2,9 @@
 /* dbus-address.c  Server address parser.
  *
  * Copyright (C) 2003  CodeFactory AB
- * Copyright (C) 2004,2005  Red Hat, Inc.
+ * Copyright (C) 2004-2007  Red Hat, Inc.
+ * Copyright (C) 2007  Ralf Habacker
+ * Copyright (C) 2013  Chengwei Yang / Intel
  *
  * Licensed under the Academic Free License version 2.1
  *
@@ -648,182 +650,3 @@ dbus_address_unescape_value (const char *value,
 }
 
 /** @} */ /* End of public API */
-
-#ifdef DBUS_ENABLE_EMBEDDED_TESTS
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-
-#include "dbus-test.h"
-#include <stdlib.h>
-
-typedef struct
-{
-  const char *escaped;
-  const char *unescaped;
-} EscapeTest;
-
-static const EscapeTest escape_tests[] = {
-  { "abcde", "abcde" },
-  { "", "" },
-  { "%20%20", "  " },
-  { "%24", "$" },
-  { "%25", "%" },
-  { "abc%24", "abc$" },
-  { "%24abc", "$abc" },
-  { "abc%24abc", "abc$abc" },
-  { "/", "/" },
-  { "-", "-" },
-  { "_", "_" },
-  { "A", "A" },
-  { "I", "I" },
-  { "Z", "Z" },
-  { "a", "a" },
-  { "i", "i" },
-  { "z", "z" },
-  /* Bug: https://bugs.freedesktop.org/show_bug.cgi?id=53499 */
-  { "%c3%b6", "\xc3\xb6" }
-};
-
-static const char* invalid_escaped_values[] = {
-  "%a",
-  "%q",
-  "%az",
-  "%%",
-  "%$$",
-  "abc%a",
-  "%axyz",
-  "%",
-  "$",
-  " ",
-};
-
-dbus_bool_t
-_dbus_address_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
-{
-  DBusAddressEntry **entries;
-  int len;
-  DBusError error = DBUS_ERROR_INIT;
-  int i;
-
-  i = 0;
-  while (i < _DBUS_N_ELEMENTS (escape_tests))
-    {
-      const EscapeTest *test = &escape_tests[i];
-      char *escaped;
-      char *unescaped;
-
-      escaped = dbus_address_escape_value (test->unescaped);
-      if (escaped == NULL)
-        _dbus_test_fatal ("oom");
-
-      if (strcmp (escaped, test->escaped) != 0)
-        {
-          _dbus_warn ("Escaped '%s' as '%s' should have been '%s'",
-                      test->unescaped, escaped, test->escaped);
-          exit (1);
-        }
-      dbus_free (escaped);
-
-      unescaped = dbus_address_unescape_value (test->escaped, &error);
-      if (unescaped == NULL)
-        {
-          _dbus_warn ("Failed to unescape '%s': %s",
-                      test->escaped, error.message);
-          dbus_error_free (&error);
-          exit (1);
-        }
-
-      if (strcmp (unescaped, test->unescaped) != 0)
-        {
-          _dbus_warn ("Unescaped '%s' as '%s' should have been '%s'",
-                      test->escaped, unescaped, test->unescaped);
-          exit (1);
-        }
-      dbus_free (unescaped);
-      
-      ++i;
-    }
-
-  i = 0;
-  while (i < _DBUS_N_ELEMENTS (invalid_escaped_values))
-    {
-      char *unescaped;
-
-      unescaped = dbus_address_unescape_value (invalid_escaped_values[i],
-                                               &error);
-      if (unescaped != NULL)
-        {
-          _dbus_warn ("Should not have successfully unescaped '%s' to '%s'",
-                      invalid_escaped_values[i], unescaped);
-          dbus_free (unescaped);
-          exit (1);
-        }
-
-      _dbus_assert (dbus_error_is_set (&error));
-      dbus_error_free (&error);
-
-      ++i;
-    }
-  
-  if (!dbus_parse_address ("unix:path=/tmp/foo;debug:name=test,sliff=sloff;",
-			   &entries, &len, &error))
-    _dbus_test_fatal ("could not parse address");
-  _dbus_assert (len == 2);
-  _dbus_assert (strcmp (dbus_address_entry_get_value (entries[0], "path"), "/tmp/foo") == 0);
-  _dbus_assert (strcmp (dbus_address_entry_get_value (entries[1], "name"), "test") == 0);
-  _dbus_assert (strcmp (dbus_address_entry_get_value (entries[1], "sliff"), "sloff") == 0);
-  
-  dbus_address_entries_free (entries);
-
-  /* Different possible errors */
-  if (dbus_parse_address ("", &entries, &len, &error))
-    _dbus_test_fatal ("Parsed incorrect address.");
-  else
-    dbus_error_free (&error);
-
-  if (dbus_parse_address ("foo", &entries, &len, &error))
-    _dbus_test_fatal ("Parsed incorrect address.");
-  else
-    dbus_error_free (&error);
-  
-  if (dbus_parse_address ("foo:bar", &entries, &len, &error))
-    _dbus_test_fatal ("Parsed incorrect address.");
-  else
-    dbus_error_free (&error);
-  
-  if (dbus_parse_address ("foo:bar,baz", &entries, &len, &error))
-    _dbus_test_fatal ("Parsed incorrect address.");
-  else
-    dbus_error_free (&error);
-  
-  if (dbus_parse_address ("foo:bar=foo,baz", &entries, &len, &error))
-    _dbus_test_fatal ("Parsed incorrect address.");
-  else
-    dbus_error_free (&error);
-  
-  if (dbus_parse_address ("foo:bar=foo;baz", &entries, &len, &error))
-    _dbus_test_fatal ("Parsed incorrect address.");
-  else
-    dbus_error_free (&error);
-  
-  if (dbus_parse_address ("foo:=foo", &entries, &len, &error))
-    _dbus_test_fatal ("Parsed incorrect address.");
-  else
-    dbus_error_free (&error);
-  
-  if (dbus_parse_address ("foo:foo=", &entries, &len, &error))
-    _dbus_test_fatal ("Parsed incorrect address.");
-  else
-    dbus_error_free (&error);
-
-  if (dbus_parse_address ("foo:foo,bar=baz", &entries, &len, &error))
-    _dbus_test_fatal ("Parsed incorrect address.");
-  else
-    dbus_error_free (&error);
-
-  return TRUE;
-}
-
-#endif /* !DOXYGEN_SHOULD_SKIP_THIS */
-
-#endif
diff --git a/dbus/dbus-connection-internal.h b/dbus/dbus-connection-internal.h
index 06302dd0..de4e55b1 100644
--- a/dbus/dbus-connection-internal.h
+++ b/dbus/dbus-connection-internal.h
@@ -136,8 +136,7 @@ void _dbus_connection_get_stats (DBusConnection *connection,
                                  dbus_uint32_t  *out_peak_fds);
 
 
-/* if DBUS_ENABLE_EMBEDDED_TESTS */
-DBUS_PRIVATE_EXPORT
+DBUS_EMBEDDED_TESTS_EXPORT
 const char* _dbus_connection_get_address (DBusConnection *connection);
 
 /* This _dbus_bus_* stuff doesn't really belong here, but dbus-bus-internal.h seems
diff --git a/dbus/dbus-internals.h b/dbus/dbus-internals.h
index 294aef47..94bd7801 100644
--- a/dbus/dbus-internals.h
+++ b/dbus/dbus-internals.h
@@ -35,6 +35,12 @@
 
 DBUS_BEGIN_DECLS
 
+#ifdef DBUS_ENABLE_EMBEDDED_TESTS
+#define DBUS_EMBEDDED_TESTS_EXPORT DBUS_PRIVATE_EXPORT
+#else
+#define DBUS_EMBEDDED_TESTS_EXPORT /* nothing */
+#endif
+
 DBUS_PRIVATE_EXPORT
 void _dbus_warn               (const char *format,
                                ...) _DBUS_GNUC_PRINTF (1, 2);
diff --git a/dbus/dbus-mempool.c b/dbus/dbus-mempool.c
index 638799e1..83aa2722 100644
--- a/dbus/dbus-mempool.c
+++ b/dbus/dbus-mempool.c
@@ -2,6 +2,8 @@
 /* dbus-mempool.h Memory pools
  *
  * Copyright (C) 2002, 2003  Red Hat, Inc.
+ * Copyright (C) 2003  CodeFactory AB
+ * Copyright (C) 2011-2012  Collabora Ltd.
  *
  * Licensed under the Academic Free License version 2.1
  *
@@ -448,200 +450,3 @@ _dbus_mem_pool_get_stats (DBusMemPool   *pool,
 #endif /* DBUS_ENABLE_STATS */
 
 /** @} */
-
-#ifdef DBUS_ENABLE_EMBEDDED_TESTS
-#include "dbus-test.h"
-#include <stdio.h>
-#include <time.h>
-
-static void
-time_for_size (int size)
-{
-  int i;
-  int j;
-#ifdef DBUS_ENABLE_VERBOSE_MODE
-  clock_t start;
-  clock_t end;
-#endif
-#define FREE_ARRAY_SIZE 512
-#define N_ITERATIONS FREE_ARRAY_SIZE * 512
-  void *to_free[FREE_ARRAY_SIZE];
-  DBusMemPool *pool;
-
-  _dbus_verbose ("Timings for size %d\n", size);
-  
-  _dbus_verbose (" malloc\n");
-  
-#ifdef DBUS_ENABLE_VERBOSE_MODE
-  start = clock ();
-#endif
-
-  i = 0;
-  j = 0;
-  while (i < N_ITERATIONS)
-    {
-      to_free[j] = dbus_malloc (size);
-      _dbus_assert (to_free[j] != NULL); /* in a real app of course this is wrong */
-
-      ++j;
-
-      if (j == FREE_ARRAY_SIZE)
-        {
-          j = 0;
-          while (j < FREE_ARRAY_SIZE)
-            {
-              dbus_free (to_free[j]);
-              ++j;
-            }
-
-          j = 0;
-        }
-      
-      ++i;
-    }
-
-#ifdef DBUS_ENABLE_VERBOSE_MODE
-  end = clock ();
-
-  _dbus_verbose ("  created/destroyed %d elements in %g seconds\n",
-                 N_ITERATIONS, (end - start) / (double) CLOCKS_PER_SEC);
-
-
-
-  _dbus_verbose (" mempools\n");
-  
-  start = clock ();
-#endif
-
-  pool = _dbus_mem_pool_new (size, FALSE);
-  
-  i = 0;
-  j = 0;
-  while (i < N_ITERATIONS)
-    {
-      to_free[j] = _dbus_mem_pool_alloc (pool); 
-      _dbus_assert (to_free[j] != NULL);  /* in a real app of course this is wrong */
-
-      ++j;
-
-      if (j == FREE_ARRAY_SIZE)
-        {
-          j = 0;
-          while (j < FREE_ARRAY_SIZE)
-            {
-              _dbus_mem_pool_dealloc (pool, to_free[j]);
-              ++j;
-            }
-
-          j = 0;
-        }
-      
-      ++i;
-    }
-
-  _dbus_mem_pool_free (pool);
-  
-#ifdef DBUS_ENABLE_VERBOSE_MODE
-  end = clock ();
-
-  _dbus_verbose ("  created/destroyed %d elements in %g seconds\n",
-                 N_ITERATIONS, (end - start) / (double) CLOCKS_PER_SEC);
-
-  _dbus_verbose (" zeroed malloc\n");
-    
-  start = clock ();
-#endif
-  
-  i = 0;
-  j = 0;
-  while (i < N_ITERATIONS)
-    {
-      to_free[j] = dbus_malloc0 (size);
-      _dbus_assert (to_free[j] != NULL); /* in a real app of course this is wrong */
-
-      ++j;
-
-      if (j == FREE_ARRAY_SIZE)
-        {
-          j = 0;
-          while (j < FREE_ARRAY_SIZE)
-            {
-              dbus_free (to_free[j]);
-              ++j;
-            }
-
-          j = 0;
-        }
-      
-      ++i;
-    }
-
-#ifdef DBUS_ENABLE_VERBOSE_MODE
-  end = clock ();
-
-  _dbus_verbose ("  created/destroyed %d elements in %g seconds\n",
-                 N_ITERATIONS, (end - start) / (double) CLOCKS_PER_SEC);
-  
-  _dbus_verbose (" zeroed mempools\n");
-  
-  start = clock ();
-#endif
-
-  pool = _dbus_mem_pool_new (size, TRUE);
-  
-  i = 0;
-  j = 0;
-  while (i < N_ITERATIONS)
-    {
-      to_free[j] = _dbus_mem_pool_alloc (pool); 
-      _dbus_assert (to_free[j] != NULL);  /* in a real app of course this is wrong */
-
-      ++j;
-
-      if (j == FREE_ARRAY_SIZE)
-        {
-          j = 0;
-          while (j < FREE_ARRAY_SIZE)
-            {
-              _dbus_mem_pool_dealloc (pool, to_free[j]);
-              ++j;
-            }
-
-          j = 0;
-        }
-      
-      ++i;
-    }
-
-  _dbus_mem_pool_free (pool);
-  
-#ifdef DBUS_ENABLE_VERBOSE_MODE
-  end = clock ();
-
-  _dbus_verbose ("  created/destroyed %d elements in %g seconds\n",
-                 N_ITERATIONS, (end - start) / (double) CLOCKS_PER_SEC);
-#endif
-}
-
-/**
- * @ingroup DBusMemPoolInternals
- * Unit test for DBusMemPool
- * @returns #TRUE on success.
- */
-dbus_bool_t
-_dbus_mem_pool_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
-{
-  int i;
-  int element_sizes[] = { 4, 8, 16, 50, 124 };
-  
-  i = 0;
-  while (i < _DBUS_N_ELEMENTS (element_sizes))
-    {
-      time_for_size (element_sizes[i]);
-      ++i;
-    }
-  
-  return TRUE;
-}
-
-#endif /* DBUS_ENABLE_EMBEDDED_TESTS */
diff --git a/dbus/dbus-sha.c b/dbus/dbus-sha.c
index bbe000d6..6ff2f077 100644
--- a/dbus/dbus-sha.c
+++ b/dbus/dbus-sha.c
@@ -26,7 +26,6 @@
 #include "dbus-internals.h"
 #include "dbus-sha.h"
 #include "dbus-marshal-basic.h" /* for byteswap routines */
-#include <dbus/dbus-test-tap.h>
 #include <string.h>
 
 /* The following comments have the history of where this code
@@ -511,465 +510,3 @@ _dbus_sha_compute (const DBusString *data,
 }
 
 /** @} */ /* end of exported functions */
-
-#ifdef DBUS_ENABLE_EMBEDDED_TESTS
-#include "dbus-test.h"
-#include <stdio.h>
-
-static dbus_bool_t
-check_sha_binary (const unsigned char *input,
-                  int                  input_len,
-                  const char          *expected)
-{
-  DBusString input_str;
-  DBusString expected_str;
-  DBusString results;
-
-  _dbus_string_init_const_len (&input_str, (const char *) input, input_len);
-  _dbus_string_init_const (&expected_str, expected);
-
-  if (!_dbus_string_init (&results))
-    _dbus_test_fatal ("no memory for SHA-1 results");
-
-  if (!_dbus_sha_compute (&input_str, &results))
-    _dbus_test_fatal ("no memory for SHA-1 results");
-
-  if (!_dbus_string_equal (&expected_str, &results))
-    {
-      _dbus_warn ("Expected hash %s got %s for SHA-1 sum",
-                  expected,
-                  _dbus_string_get_const_data (&results));
-      _dbus_string_free (&results);
-      return FALSE;
-    }
-
-  _dbus_string_free (&results);
-  return TRUE;
-}
-
-static dbus_bool_t
-check_sha_str (const char *input,
-               const char *expected)
-{
-  return check_sha_binary ((unsigned char *) input, strlen (input), expected);
-}
-
-static dbus_bool_t
-decode_compact_string (const DBusString *line,
-                       DBusString       *decoded)
-{
-  int n_bits;
-  dbus_bool_t current_b;
-  int offset;
-  int next;
-  long val;
-  int length_bytes;
-  
-  offset = 0;
-  next = 0;
-
-  if (!_dbus_string_parse_int (line, offset, &val, &next))
-    {
-      fprintf (stderr, "could not parse length at start of compact string: %s\n",
-               _dbus_string_get_const_data (line));
-      return FALSE;
-    }
-
-  _dbus_string_skip_blank (line, next, &next);
-  
-  offset = next;
-  if (!_dbus_string_parse_int (line, offset, &val, &next))
-    {
-      fprintf (stderr, "could not parse start bit 'b' in compact string: %s\n",
-               _dbus_string_get_const_data (line));
-      return FALSE;
-    }
-  
-  if (!(val == 0 || val == 1))
-    {
-      fprintf (stderr, "the value 'b' must be 0 or 1, see sha-1/Readme.txt\n");
-      return FALSE;
-    }
-
-  _dbus_string_skip_blank (line, next, &next);
-  
-  current_b = val;
-  n_bits = 0;
-  
-  while (next < _dbus_string_get_length (line))
-    {
-      int total_bits;
-      
-      offset = next;
-
-      if (_dbus_string_get_byte (line, offset) == '^')
-        break;
-      
-      if (!_dbus_string_parse_int (line, offset, &val, &next))
-        {
-          fprintf (stderr, "could not parse bit count in compact string\n");
-          return FALSE;
-        }
-
-      /* We now append "val" copies of "current_b" bits to the string */
-      total_bits = n_bits + val;
-      while (n_bits < total_bits)
-        {
-          int byte_containing_next_bit = n_bits / 8;
-          int bit_containing_next_bit = 7 - (n_bits % 8);
-          unsigned char old_byte;
-          
-          if (byte_containing_next_bit >= _dbus_string_get_length (decoded))
-            {
-              if (!_dbus_string_set_length (decoded, byte_containing_next_bit + 1))
-                _dbus_test_fatal ("no memory to extend to next byte");
-            }
-
-          old_byte = _dbus_string_get_byte (decoded, byte_containing_next_bit);
-          old_byte |= current_b << bit_containing_next_bit;
-
-#if 0
-          _dbus_test_diag ("Appending bit %d to byte %d at bit %d resulting in byte 0x%x",
-                  current_b, byte_containing_next_bit,
-                  bit_containing_next_bit, old_byte);
-#endif
-          
-          _dbus_string_set_byte (decoded, byte_containing_next_bit, old_byte);
-          
-          ++n_bits;
-        }
-
-      _dbus_string_skip_blank (line, next, &next);
-          
-      current_b = !current_b;
-    }
-
-  length_bytes = (n_bits / 8 + ((n_bits % 8) ? 1 : 0));
-  
-  if (_dbus_string_get_length (decoded) != length_bytes)
-    {
-      fprintf (stderr, "Expected length %d bytes %d bits for compact string, got %d bytes\n",
-               length_bytes, n_bits, _dbus_string_get_length (decoded));
-      return FALSE;
-    }
-  else
-    return TRUE;
-}
-
-static dbus_bool_t
-get_next_expected_result (DBusString *results,
-                          DBusString *result)
-{
-  DBusString line;
-  dbus_bool_t retval;
-
-  retval = FALSE;
-  
-  if (!_dbus_string_init (&line))
-    _dbus_test_fatal ("no memory");
-  
- next_iteration:
-  while (_dbus_string_pop_line (results, &line))
-    {
-      _dbus_string_delete_leading_blanks (&line);
-
-      if (_dbus_string_get_length (&line) == 0)
-        goto next_iteration;
-      else if (_dbus_string_starts_with_c_str (&line, "#"))
-        goto next_iteration;
-      else if (_dbus_string_starts_with_c_str (&line, "H>"))
-        {
-          /* don't print */
-        }
-      else if (_dbus_string_starts_with_c_str (&line, "D>") ||
-               _dbus_string_starts_with_c_str (&line, "<D"))
-        goto next_iteration;
-      else
-        {
-          int i;
-          
-          if (!_dbus_string_move (&line, 0, result, 0))
-            _dbus_test_fatal ("no memory");
-
-          i = 0;
-          while (i < _dbus_string_get_length (result))
-            {
-              unsigned char c = _dbus_string_get_byte (result, i);
-
-              switch (c)
-                {
-                case 'A':
-                  _dbus_string_set_byte (result, i, 'a');
-                  break;
-                case 'B':
-                  _dbus_string_set_byte (result, i, 'b');
-                  break;
-                case 'C':
-                  _dbus_string_set_byte (result, i, 'c');
-                  break;
-                case 'D':
-                  _dbus_string_set_byte (result, i, 'd');
-                  break;
-                case 'E':
-                  _dbus_string_set_byte (result, i, 'e');
-                  break;
-                case 'F':
-                  _dbus_string_set_byte (result, i, 'f');
-                  break;
-                case '^':
-                case ' ':
-                  _dbus_string_delete (result, i, 1);
-                  --i; /* to offset ++i below */
-                  break;
-                default:
-                  if ((c < '0' || c > '9') && (c < 'a' || c > 'f'))
-                    _dbus_test_fatal ("invalid SHA-1 test script");
-                }
-
-              ++i;
-            }
-          
-          break;
-        }
-    }
-  
-  retval = TRUE;
-  
-  /* out: */
-  _dbus_string_free (&line);
-  return retval;
-}
-
-static dbus_bool_t
-process_test_data (const char *test_data_dir)
-{
-  DBusString tests_file;
-  DBusString results_file;
-  DBusString tests;
-  DBusString results;
-  DBusString line;
-  DBusString tmp;
-  int line_no;
-  dbus_bool_t retval;
-  int success_count;
-  DBusError error = DBUS_ERROR_INIT;
-
-  retval = FALSE;
-  
-  if (!_dbus_string_init (&tests_file))
-    _dbus_test_fatal ("no memory");
-
-  if (!_dbus_string_init (&results_file))
-    _dbus_test_fatal ("no memory");
-
-  if (!_dbus_string_init (&tests))
-    _dbus_test_fatal ("no memory");
-
-  if (!_dbus_string_init (&results))
-    _dbus_test_fatal ("no memory");
-
-  if (!_dbus_string_init (&line))
-    _dbus_test_fatal ("no memory");
-
-  if (!_dbus_string_append (&tests_file, test_data_dir))
-    _dbus_test_fatal ("no memory");
-
-  if (!_dbus_string_append (&results_file, test_data_dir))
-    _dbus_test_fatal ("no memory");
-
-  _dbus_string_init_const (&tmp, "sha-1/byte-messages.sha1");
-  if (!_dbus_concat_dir_and_file (&tests_file, &tmp))
-    _dbus_test_fatal ("no memory");
-
-  _dbus_string_init_const (&tmp, "sha-1/byte-hashes.sha1");
-  if (!_dbus_concat_dir_and_file (&results_file, &tmp))
-    _dbus_test_fatal ("no memory");
-
-  if (!_dbus_file_get_contents (&tests, &tests_file, &error))
-    {
-      fprintf (stderr, "could not load test data file %s: %s\n",
-               _dbus_string_get_const_data (&tests_file),
-               error.message);
-      dbus_error_free (&error);
-      goto out;
-    }
-
-  if (!_dbus_file_get_contents (&results, &results_file, &error))
-    {
-      fprintf (stderr, "could not load results data file %s: %s\n",
-               _dbus_string_get_const_data (&results_file), error.message);
-      dbus_error_free (&error);
-      goto out;
-    }
-
-  success_count = 0;
-  line_no = 0;
- next_iteration:
-  while (_dbus_string_pop_line (&tests, &line))
-    {
-      line_no += 1;
-
-      _dbus_string_delete_leading_blanks (&line);
-
-      if (_dbus_string_get_length (&line) == 0)
-        goto next_iteration;
-      else if (_dbus_string_starts_with_c_str (&line, "#"))
-        goto next_iteration;
-      else if (_dbus_string_starts_with_c_str (&line, "H>"))
-        {
-          _dbus_test_diag ("SHA-1: %s", _dbus_string_get_const_data (&line));
-
-          if (_dbus_string_find (&line, 0, "Type 3", NULL))
-            {
-              /* See sha-1/Readme.txt - the "Type 3" tests are
-               * random seeds, rather than data to be hashed.
-               * we'd have to do a little bit more implementation
-               * to use those tests.
-               */
-              
-              _dbus_test_diag (" (ending tests due to Type 3 tests seen - this is normal)");
-              break;
-            }
-        }
-      else if (_dbus_string_starts_with_c_str (&line, "D>") ||
-               _dbus_string_starts_with_c_str (&line, "<D"))
-        goto next_iteration;
-      else
-        {
-          DBusString test;
-          DBusString result;
-          DBusString next_line;
-          DBusString expected;
-          dbus_bool_t success;
-
-          success = FALSE;
-          
-          if (!_dbus_string_init (&next_line))
-            _dbus_test_fatal ("no memory");
-
-          if (!_dbus_string_init (&expected))
-            _dbus_test_fatal ("no memory");
-          
-          if (!_dbus_string_init (&test))
-            _dbus_test_fatal ("no memory");
-
-          if (!_dbus_string_init (&result))
-            _dbus_test_fatal ("no memory");
-
-          /* the "compact strings" are "^"-terminated not
-           * newline-terminated so readahead to find the
-           * "^"
-           */
-          while (!_dbus_string_find (&line, 0, "^", NULL) &&
-                 _dbus_string_pop_line (&tests, &next_line))
-            {
-              if (!_dbus_string_append_byte (&line, ' ') ||
-                  !_dbus_string_move (&next_line, 0, &line,
-                                      _dbus_string_get_length (&line)))
-                _dbus_test_fatal ("no memory");
-            }
-          
-          if (!decode_compact_string (&line, &test))
-            {
-              fprintf (stderr, "Failed to decode line %d as a compact string\n",
-                       line_no);
-              goto failure;
-            }
-          
-          if (!_dbus_sha_compute (&test, &result))
-            _dbus_test_fatal ("no memory for SHA-1 result");
-
-          if (!get_next_expected_result (&results, &expected))
-            {
-              fprintf (stderr, "Failed to read an expected result\n");
-              goto failure;
-            }
-          
-          if (!_dbus_string_equal (&result, &expected))
-            {              
-              fprintf (stderr, " for line %d got hash %s expected %s\n",
-                       line_no,
-                       _dbus_string_get_const_data (&result),
-                       _dbus_string_get_const_data (&expected));
-              goto failure;
-            }
-          else
-            {
-              success_count += 1;
-            }
-
-          success = TRUE;
-
-        failure:
-          _dbus_string_free (&test);
-          _dbus_string_free (&result);
-          _dbus_string_free (&next_line);
-          _dbus_string_free (&expected);
-
-          if (!success)
-            goto out;
-        }
-    }
-
-  retval = TRUE;
-
-  _dbus_test_diag ("Passed the %d SHA-1 tests in the test file",
-          success_count);
-  
- out:
-  _dbus_string_free (&tests_file);
-  _dbus_string_free (&results_file);
-  _dbus_string_free (&tests);
-  _dbus_string_free (&results);
-  _dbus_string_free (&line);
-
-  return retval;
-}
-
-/**
- * @ingroup DBusSHAInternals
- * Unit test for SHA computation.
- *
- * @returns #TRUE on success.
- */
-dbus_bool_t
-_dbus_sha_test (const char *test_data_dir)
-{
-  unsigned char all_bytes[256];
-  int i;
-
-  if (test_data_dir != NULL)
-    {
-      if (!process_test_data (test_data_dir))
-        return FALSE;
-    }
-  else
-    _dbus_test_diag ("No test data dir");
-  
-  i = 0;
-  while (i < 256)
-    {
-      all_bytes[i] = i;
-      ++i;
-    }
-
-  if (!check_sha_binary (all_bytes, 256,
-                         "4916d6bdb7f78e6803698cab32d1586ea457dfc8"))
-    return FALSE;
-
-#define CHECK(input,expected) if (!check_sha_str (input, expected)) return FALSE
-
-  CHECK ("", "da39a3ee5e6b4b0d3255bfef95601890afd80709");
-  CHECK ("a", "86f7e437faa5a7fce15d1ddcb9eaeaea377667b8");
-  CHECK ("abc", "a9993e364706816aba3e25717850c26c9cd0d89d");
-  CHECK ("message digest", "c12252ceda8be8994d5fa0290a47231c1d16aae3");
-  CHECK ("abcdefghijklmnopqrstuvwxyz", "32d10c7b8cf96570ca04ce37f2a19d84240d3a89");
-  CHECK ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
-         "761c457bf73b14d27e9e9265c46f4b4dda11f940");
-  CHECK ("12345678901234567890123456789012345678901234567890123456789012345678901234567890",
-         "50abf5706a150990a08b2c5ea40fa0e585554732");
-
-  return TRUE;
-}
-
-#endif /* DBUS_ENABLE_EMBEDDED_TESTS */
diff --git a/dbus/dbus-sha.h b/dbus/dbus-sha.h
index c48035b9..988cd5a9 100644
--- a/dbus/dbus-sha.h
+++ b/dbus/dbus-sha.h
@@ -47,6 +47,7 @@ void        _dbus_sha_update  (DBusSHAContext   *context,
                                const DBusString *data);
 dbus_bool_t _dbus_sha_final   (DBusSHAContext   *context,
                                DBusString       *results);
+DBUS_EMBEDDED_TESTS_EXPORT
 dbus_bool_t _dbus_sha_compute (const DBusString *data,
                                DBusString       *ascii_output);
 
diff --git a/dbus/dbus-test.h b/dbus/dbus-test.h
index 197e0dc7..a8601932 100644
--- a/dbus/dbus-test.h
+++ b/dbus/dbus-test.h
@@ -41,24 +41,12 @@ DBUS_PRIVATE_EXPORT
 dbus_bool_t _dbus_marshal_test           (const char *test_data_dir);
 
 DBUS_PRIVATE_EXPORT
-dbus_bool_t _dbus_mem_pool_test          (const char *test_data_dir);
-
-DBUS_PRIVATE_EXPORT
-dbus_bool_t _dbus_address_test           (const char *test_data_dir);
-
-DBUS_PRIVATE_EXPORT
-dbus_bool_t _dbus_sha_test               (const char *test_data_dir);
-
-DBUS_PRIVATE_EXPORT
 dbus_bool_t _dbus_keyring_test           (const char *test_data_dir);
 
 DBUS_PRIVATE_EXPORT
 dbus_bool_t _dbus_data_slot_test         (const char *test_data_dir);
 
 DBUS_PRIVATE_EXPORT
-dbus_bool_t _dbus_userdb_test            (const char *test_data_dir);
-
-DBUS_PRIVATE_EXPORT
 dbus_bool_t _dbus_memory_test            (const char *test_data_dir);
 
 DBUS_PRIVATE_EXPORT
diff --git a/dbus/dbus-userdb-util.c b/dbus/dbus-userdb-util.c
index 7bbae0ef..a8608fa6 100644
--- a/dbus/dbus-userdb-util.c
+++ b/dbus/dbus-userdb-util.c
@@ -399,56 +399,3 @@ _dbus_groups_from_uid (dbus_uid_t         uid,
   return TRUE;
 }
 /** @} */
-
-#ifdef DBUS_ENABLE_EMBEDDED_TESTS
-#include <stdio.h>
-
-/**
- * Unit test for dbus-userdb.c.
- * 
- * @returns #TRUE on success.
- */
-dbus_bool_t
-_dbus_userdb_test (const char *test_data_dir)
-{
-  const DBusString *username;
-  const DBusString *homedir;
-  dbus_uid_t uid;
-  unsigned long *group_ids;
-  int n_group_ids, i;
-  DBusError error;
-
-  if (!_dbus_username_from_current_process (&username))
-    _dbus_test_fatal ("didn't get username");
-
-  if (!_dbus_homedir_from_current_process (&homedir))
-    _dbus_test_fatal ("didn't get homedir");
-
-  if (!_dbus_get_user_id (username, &uid))
-    _dbus_test_fatal ("didn't get uid");
-
-  if (!_dbus_groups_from_uid (uid, &group_ids, &n_group_ids))
-    _dbus_test_fatal ("didn't get groups");
-
-  _dbus_test_diag ("    Current user: %s homedir: %s gids:",
-          _dbus_string_get_const_data (username),
-          _dbus_string_get_const_data (homedir));
-
-  for (i=0; i<n_group_ids; i++)
-      _dbus_test_diag ("- %ld", group_ids[i]);
-
-  dbus_error_init (&error);
-  _dbus_test_diag ("Is Console user: %i",
-          _dbus_is_console_user (uid, &error));
-  _dbus_test_diag ("Invocation was OK: %s", error.message ? error.message : "yes");
-  dbus_error_free (&error);
-  _dbus_test_diag ("Is Console user 4711: %i",
-          _dbus_is_console_user (4711, &error));
-  _dbus_test_diag ("Invocation was OK: %s", error.message ? error.message : "yes");
-  dbus_error_free (&error);
-
-  dbus_free (group_ids);
-
-  return TRUE;
-}
-#endif /* DBUS_ENABLE_EMBEDDED_TESTS */
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 2b8db2f6..08e7a8b0 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -116,6 +116,7 @@ if(DBUS_ENABLE_EMBEDDED_TESTS)
     set_target_properties(test-message-internals PROPERTIES COMPILE_FLAGS ${DBUS_INTERNAL_CLIENT_DEFINITIONS})
 
     set(SOURCES
+        internals/address.c
         internals/dbus-auth-script.c
         internals/dbus-auth-script.h
         internals/dbus-auth-util.c
@@ -126,8 +127,10 @@ if(DBUS_ENABLE_EMBEDDED_TESTS)
         internals/dbus-marshal-validate-util.c
         internals/dbus-string-util.c
         internals/dbus-sysdeps-util.c
+        internals/mempool.c
         internals/misc-internals.c
         internals/misc-internals.h
+        internals/sha.c
     )
     add_test_executable(test-misc-internals "${SOURCES}" dbus-testutils)
     set_target_properties(test-misc-internals PROPERTIES COMPILE_FLAGS ${DBUS_INTERNAL_CLIENT_DEFINITIONS})
diff --git a/test/Makefile.am b/test/Makefile.am
index 8f14ae18..28be5cdd 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -237,6 +237,7 @@ test_message_internals_SOURCES = \
 test_message_internals_LDADD = libdbus-testutils.la
 
 test_misc_internals_SOURCES = \
+	internals/address.c \
 	internals/dbus-auth-script.c \
 	internals/dbus-auth-script.h \
 	internals/dbus-auth-util.c \
@@ -247,8 +248,10 @@ test_misc_internals_SOURCES = \
 	internals/dbus-marshal-validate-util.c \
 	internals/dbus-string-util.c \
 	internals/dbus-sysdeps-util.c \
+	internals/mempool.c \
 	internals/misc-internals.c \
 	internals/misc-internals.h \
+	internals/sha.c \
 	$(NULL)
 test_misc_internals_LDADD = libdbus-testutils.la
 
diff --git a/test/internals/address.c b/test/internals/address.c
new file mode 100644
index 00000000..dbc8bca2
--- /dev/null
+++ b/test/internals/address.c
@@ -0,0 +1,203 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/* dbus-address.c  Server address parser.
+ *
+ * Copyright (C) 2003  CodeFactory AB
+ * Copyright (C) 2004-2006  Red Hat, Inc.
+ * Copyright (C) 2007  Ralf Habacker
+ * Copyright (C) 2013  Chengwei Yang / Intel
+ *
+ * Licensed under the Academic Free License version 2.1
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#include <config.h>
+#include "misc-internals.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <dbus/dbus.h>
+#include "dbus/dbus-internals.h"
+#include "dbus/dbus-test-tap.h"
+
+typedef struct
+{
+  const char *escaped;
+  const char *unescaped;
+} EscapeTest;
+
+static const EscapeTest escape_tests[] = {
+  { "abcde", "abcde" },
+  { "", "" },
+  { "%20%20", "  " },
+  { "%24", "$" },
+  { "%25", "%" },
+  { "abc%24", "abc$" },
+  { "%24abc", "$abc" },
+  { "abc%24abc", "abc$abc" },
+  { "/", "/" },
+  { "-", "-" },
+  { "_", "_" },
+  { "A", "A" },
+  { "I", "I" },
+  { "Z", "Z" },
+  { "a", "a" },
+  { "i", "i" },
+  { "z", "z" },
+  /* Bug: https://bugs.freedesktop.org/show_bug.cgi?id=53499 */
+  { "%c3%b6", "\xc3\xb6" }
+};
+
+static const char* invalid_escaped_values[] = {
+  "%a",
+  "%q",
+  "%az",
+  "%%",
+  "%$$",
+  "abc%a",
+  "%axyz",
+  "%",
+  "$",
+  " ",
+};
+
+dbus_bool_t
+_dbus_address_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
+{
+  DBusAddressEntry **entries;
+  int len;
+  DBusError error = DBUS_ERROR_INIT;
+  int i;
+
+  i = 0;
+  while (i < _DBUS_N_ELEMENTS (escape_tests))
+    {
+      const EscapeTest *test = &escape_tests[i];
+      char *escaped;
+      char *unescaped;
+
+      escaped = dbus_address_escape_value (test->unescaped);
+      if (escaped == NULL)
+        _dbus_test_fatal ("oom");
+
+      if (strcmp (escaped, test->escaped) != 0)
+        {
+          _dbus_warn ("Escaped '%s' as '%s' should have been '%s'",
+                      test->unescaped, escaped, test->escaped);
+          exit (1);
+        }
+      dbus_free (escaped);
+
+      unescaped = dbus_address_unescape_value (test->escaped, &error);
+      if (unescaped == NULL)
+        {
+          _dbus_warn ("Failed to unescape '%s': %s",
+                      test->escaped, error.message);
+          dbus_error_free (&error);
+          exit (1);
+        }
+
+      if (strcmp (unescaped, test->unescaped) != 0)
+        {
+          _dbus_warn ("Unescaped '%s' as '%s' should have been '%s'",
+                      test->escaped, unescaped, test->unescaped);
+          exit (1);
+        }
+      dbus_free (unescaped);
+
+      ++i;
+    }
+
+  i = 0;
+  while (i < _DBUS_N_ELEMENTS (invalid_escaped_values))
+    {
+      char *unescaped;
+
+      unescaped = dbus_address_unescape_value (invalid_escaped_values[i],
+                                               &error);
+      if (unescaped != NULL)
+        {
+          _dbus_warn ("Should not have successfully unescaped '%s' to '%s'",
+                      invalid_escaped_values[i], unescaped);
+          dbus_free (unescaped);
+          exit (1);
+        }
+
+      _dbus_assert (dbus_error_is_set (&error));
+      dbus_error_free (&error);
+
+      ++i;
+    }
+
+  if (!dbus_parse_address ("unix:path=/tmp/foo;debug:name=test,sliff=sloff;",
+			   &entries, &len, &error))
+    _dbus_test_fatal ("could not parse address");
+  _dbus_assert (len == 2);
+  _dbus_assert (strcmp (dbus_address_entry_get_value (entries[0], "path"), "/tmp/foo") == 0);
+  _dbus_assert (strcmp (dbus_address_entry_get_value (entries[1], "name"), "test") == 0);
+  _dbus_assert (strcmp (dbus_address_entry_get_value (entries[1], "sliff"), "sloff") == 0);
+
+  dbus_address_entries_free (entries);
+
+  /* Different possible errors */
+  if (dbus_parse_address ("", &entries, &len, &error))
+    _dbus_test_fatal ("Parsed incorrect address.");
+  else
+    dbus_error_free (&error);
+
+  if (dbus_parse_address ("foo", &entries, &len, &error))
+    _dbus_test_fatal ("Parsed incorrect address.");
+  else
+    dbus_error_free (&error);
+
+  if (dbus_parse_address ("foo:bar", &entries, &len, &error))
+    _dbus_test_fatal ("Parsed incorrect address.");
+  else
+    dbus_error_free (&error);
+
+  if (dbus_parse_address ("foo:bar,baz", &entries, &len, &error))
+    _dbus_test_fatal ("Parsed incorrect address.");
+  else
+    dbus_error_free (&error);
+
+  if (dbus_parse_address ("foo:bar=foo,baz", &entries, &len, &error))
+    _dbus_test_fatal ("Parsed incorrect address.");
+  else
+    dbus_error_free (&error);
+
+  if (dbus_parse_address ("foo:bar=foo;baz", &entries, &len, &error))
+    _dbus_test_fatal ("Parsed incorrect address.");
+  else
+    dbus_error_free (&error);
+
+  if (dbus_parse_address ("foo:=foo", &entries, &len, &error))
+    _dbus_test_fatal ("Parsed incorrect address.");
+  else
+    dbus_error_free (&error);
+
+  if (dbus_parse_address ("foo:foo=", &entries, &len, &error))
+    _dbus_test_fatal ("Parsed incorrect address.");
+  else
+    dbus_error_free (&error);
+
+  if (dbus_parse_address ("foo:foo,bar=baz", &entries, &len, &error))
+    _dbus_test_fatal ("Parsed incorrect address.");
+  else
+    dbus_error_free (&error);
+
+  return TRUE;
+}
diff --git a/test/internals/mempool.c b/test/internals/mempool.c
new file mode 100644
index 00000000..53a606fd
--- /dev/null
+++ b/test/internals/mempool.c
@@ -0,0 +1,223 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/* dbus-mempool.h Memory pools
+ *
+ * Copyright (C) 2002, 2003  Red Hat, Inc.
+ * Copyright (C) 2003  CodeFactory AB
+ * Copyright (C) 2013  Chengwei Yang / Intel
+ *
+ * Licensed under the Academic Free License version 2.1
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#include <config.h>
+#include "misc-internals.h"
+
+#include <stdio.h>
+#include <time.h>
+
+#include <dbus/dbus-mempool.h>
+#include <dbus/dbus-internals.h>
+
+static void
+time_for_size (int size)
+{
+  int i;
+  int j;
+#ifdef DBUS_ENABLE_VERBOSE_MODE
+  clock_t start;
+  clock_t end;
+#endif
+#define FREE_ARRAY_SIZE 512
+#define N_ITERATIONS FREE_ARRAY_SIZE * 512
+  void *to_free[FREE_ARRAY_SIZE];
+  DBusMemPool *pool;
+
+  _dbus_verbose ("Timings for size %d\n", size);
+
+  _dbus_verbose (" malloc\n");
+
+#ifdef DBUS_ENABLE_VERBOSE_MODE
+  start = clock ();
+#endif
+
+  i = 0;
+  j = 0;
+  while (i < N_ITERATIONS)
+    {
+      to_free[j] = dbus_malloc (size);
+      _dbus_assert (to_free[j] != NULL); /* in a real app of course this is wrong */
+
+      ++j;
+
+      if (j == FREE_ARRAY_SIZE)
+        {
+          j = 0;
+          while (j < FREE_ARRAY_SIZE)
+            {
+              dbus_free (to_free[j]);
+              ++j;
+            }
+
+          j = 0;
+        }
+
+      ++i;
+    }
+
+#ifdef DBUS_ENABLE_VERBOSE_MODE
+  end = clock ();
+
+  _dbus_verbose ("  created/destroyed %d elements in %g seconds\n",
+                 N_ITERATIONS, (end - start) / (double) CLOCKS_PER_SEC);
+
+
+
+  _dbus_verbose (" mempools\n");
+
+  start = clock ();
+#endif
+
+  pool = _dbus_mem_pool_new (size, FALSE);
+
+  i = 0;
+  j = 0;
+  while (i < N_ITERATIONS)
+    {
+      to_free[j] = _dbus_mem_pool_alloc (pool);
+      _dbus_assert (to_free[j] != NULL);  /* in a real app of course this is wrong */
+
+      ++j;
+
+      if (j == FREE_ARRAY_SIZE)
+        {
+          j = 0;
+          while (j < FREE_ARRAY_SIZE)
+            {
+              _dbus_mem_pool_dealloc (pool, to_free[j]);
+              ++j;
+            }
+
+          j = 0;
+        }
+
+      ++i;
+    }
+
+  _dbus_mem_pool_free (pool);
+
+#ifdef DBUS_ENABLE_VERBOSE_MODE
+  end = clock ();
+
+  _dbus_verbose ("  created/destroyed %d elements in %g seconds\n",
+                 N_ITERATIONS, (end - start) / (double) CLOCKS_PER_SEC);
+
+  _dbus_verbose (" zeroed malloc\n");
+
+  start = clock ();
+#endif
+
+  i = 0;
+  j = 0;
+  while (i < N_ITERATIONS)
+    {
+      to_free[j] = dbus_malloc0 (size);
+      _dbus_assert (to_free[j] != NULL); /* in a real app of course this is wrong */
+
+      ++j;
+
+      if (j == FREE_ARRAY_SIZE)
+        {
+          j = 0;
+          while (j < FREE_ARRAY_SIZE)
+            {
+              dbus_free (to_free[j]);
+              ++j;
+            }
+
+          j = 0;
+        }
+
+      ++i;
+    }
+
+#ifdef DBUS_ENABLE_VERBOSE_MODE
+  end = clock ();
+
+  _dbus_verbose ("  created/destroyed %d elements in %g seconds\n",
+                 N_ITERATIONS, (end - start) / (double) CLOCKS_PER_SEC);
+
+  _dbus_verbose (" zeroed mempools\n");
+
+  start = clock ();
+#endif
+
+  pool = _dbus_mem_pool_new (size, TRUE);
+
+  i = 0;
+  j = 0;
+  while (i < N_ITERATIONS)
+    {
+      to_free[j] = _dbus_mem_pool_alloc (pool);
+      _dbus_assert (to_free[j] != NULL);  /* in a real app of course this is wrong */
+
+      ++j;
+
+      if (j == FREE_ARRAY_SIZE)
+        {
+          j = 0;
+          while (j < FREE_ARRAY_SIZE)
+            {
+              _dbus_mem_pool_dealloc (pool, to_free[j]);
+              ++j;
+            }
+
+          j = 0;
+        }
+
+      ++i;
+    }
+
+  _dbus_mem_pool_free (pool);
+
+#ifdef DBUS_ENABLE_VERBOSE_MODE
+  end = clock ();
+
+  _dbus_verbose ("  created/destroyed %d elements in %g seconds\n",
+                 N_ITERATIONS, (end - start) / (double) CLOCKS_PER_SEC);
+#endif
+}
+
+/**
+ * @ingroup DBusMemPoolInternals
+ * Unit test for DBusMemPool
+ * @returns #TRUE on success.
+ */
+dbus_bool_t
+_dbus_mem_pool_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
+{
+  int i;
+  int element_sizes[] = { 4, 8, 16, 50, 124 };
+
+  i = 0;
+  while (i < _DBUS_N_ELEMENTS (element_sizes))
+    {
+      time_for_size (element_sizes[i]);
+      ++i;
+    }
+
+  return TRUE;
+}
diff --git a/test/internals/misc-internals.c b/test/internals/misc-internals.c
index 7661853f..5f290a59 100644
--- a/test/internals/misc-internals.c
+++ b/test/internals/misc-internals.c
@@ -3,7 +3,8 @@
  * Copyright 2002-2011 Red Hat, Inc.
  * Copyright 2006 Julio M. Merino Vidal
  * Copyright 2006 Ralf Habacker
- * Copyright 2011-2018 Collabora Ltd.
+ * Copyright 2011-2019 Collabora Ltd.
+ * Copyright 2012 Lennart Poettering
  *
  * Licensed under the Academic Free License version 2.1
  *
@@ -32,6 +33,10 @@
 #include "dbus/dbus-test-tap.h"
 #include "test/test-utils.h"
 
+#ifdef DBUS_UNIX
+#include "dbus/dbus-userdb.h"
+#endif
+
 #include "misc-internals.h"
 
 static void
@@ -914,6 +919,55 @@ _dbus_transport_unix_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
 
   return ret;
 }
+
+/**
+ * Unit test for dbus-userdb.c.
+ *
+ * @returns #TRUE on success.
+ */
+static dbus_bool_t
+_dbus_userdb_test (const char *test_data_dir)
+{
+  const DBusString *username;
+  const DBusString *homedir;
+  dbus_uid_t uid;
+  unsigned long *group_ids;
+  int n_group_ids, i;
+  DBusError error;
+
+  if (!_dbus_username_from_current_process (&username))
+    _dbus_test_fatal ("didn't get username");
+
+  if (!_dbus_homedir_from_current_process (&homedir))
+    _dbus_test_fatal ("didn't get homedir");
+
+  if (!_dbus_get_user_id (username, &uid))
+    _dbus_test_fatal ("didn't get uid");
+
+  if (!_dbus_groups_from_uid (uid, &group_ids, &n_group_ids))
+    _dbus_test_fatal ("didn't get groups");
+
+  _dbus_test_diag ("    Current user: %s homedir: %s gids:",
+          _dbus_string_get_const_data (username),
+          _dbus_string_get_const_data (homedir));
+
+  for (i=0; i<n_group_ids; i++)
+      _dbus_test_diag ("- %ld", group_ids[i]);
+
+  dbus_error_init (&error);
+  _dbus_test_diag ("Is Console user: %i",
+          _dbus_is_console_user (uid, &error));
+  _dbus_test_diag ("Invocation was OK: %s", error.message ? error.message : "yes");
+  dbus_error_free (&error);
+  _dbus_test_diag ("Is Console user 4711: %i",
+          _dbus_is_console_user (4711, &error));
+  _dbus_test_diag ("Invocation was OK: %s", error.message ? error.message : "yes");
+  dbus_error_free (&error);
+
+  dbus_free (group_ids);
+
+  return TRUE;
+}
 #endif
 
 static DBusTestCase tests[] =
diff --git a/test/internals/misc-internals.h b/test/internals/misc-internals.h
index 700af46e..7f4d2cdf 100644
--- a/test/internals/misc-internals.h
+++ b/test/internals/misc-internals.h
@@ -26,11 +26,14 @@
 
 #include <dbus/dbus-types.h>
 
+dbus_bool_t _dbus_address_test           (const char *test_data_dir);
 dbus_bool_t _dbus_auth_test              (const char *test_data_dir);
 dbus_bool_t _dbus_credentials_test       (const char *test_data_dir);
 dbus_bool_t _dbus_marshal_byteswap_test  (const char *test_data_dir);
 dbus_bool_t _dbus_marshal_validate_test  (const char *test_data_dir);
+dbus_bool_t _dbus_mem_pool_test          (const char *test_data_dir);
 dbus_bool_t _dbus_string_test            (const char *test_data_dir);
 dbus_bool_t _dbus_sysdeps_test           (const char *test_data_dir);
+dbus_bool_t _dbus_sha_test               (const char *test_data_dir);
 
 #endif
diff --git a/test/internals/sha.c b/test/internals/sha.c
new file mode 100644
index 00000000..b6f93caa
--- /dev/null
+++ b/test/internals/sha.c
@@ -0,0 +1,491 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/* dbus-sha.c SHA-1 implementation
+ *
+ * Copyright (C) 2003 Red Hat Inc.
+ * Copyright (C) 1995 A. M. Kuchling
+ * Copyright (C) 2017 Thomas Zimmermann
+ *
+ * Licensed under the Academic Free License version 2.1
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#include <config.h>
+#include "misc-internals.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include <dbus/dbus-internals.h>
+#include <dbus/dbus-sha.h>
+#include <dbus/dbus-test-tap.h>
+#include <dbus/dbus-test.h>
+
+static dbus_bool_t
+check_sha_binary (const unsigned char *input,
+                  int                  input_len,
+                  const char          *expected)
+{
+  DBusString input_str;
+  DBusString expected_str;
+  DBusString results;
+
+  _dbus_string_init_const_len (&input_str, (const char *) input, input_len);
+  _dbus_string_init_const (&expected_str, expected);
+
+  if (!_dbus_string_init (&results))
+    _dbus_test_fatal ("no memory for SHA-1 results");
+
+  if (!_dbus_sha_compute (&input_str, &results))
+    _dbus_test_fatal ("no memory for SHA-1 results");
+
+  if (!_dbus_string_equal (&expected_str, &results))
+    {
+      _dbus_warn ("Expected hash %s got %s for SHA-1 sum",
+                  expected,
+                  _dbus_string_get_const_data (&results));
+      _dbus_string_free (&results);
+      return FALSE;
+    }
+
+  _dbus_string_free (&results);
+  return TRUE;
+}
+
+static dbus_bool_t
+check_sha_str (const char *input,
+               const char *expected)
+{
+  return check_sha_binary ((unsigned char *) input, strlen (input), expected);
+}
+
+static dbus_bool_t
+decode_compact_string (const DBusString *line,
+                       DBusString       *decoded)
+{
+  int n_bits;
+  dbus_bool_t current_b;
+  int offset;
+  int next;
+  long val;
+  int length_bytes;
+
+  offset = 0;
+  next = 0;
+
+  if (!_dbus_string_parse_int (line, offset, &val, &next))
+    {
+      fprintf (stderr, "could not parse length at start of compact string: %s\n",
+               _dbus_string_get_const_data (line));
+      return FALSE;
+    }
+
+  _dbus_string_skip_blank (line, next, &next);
+
+  offset = next;
+  if (!_dbus_string_parse_int (line, offset, &val, &next))
+    {
+      fprintf (stderr, "could not parse start bit 'b' in compact string: %s\n",
+               _dbus_string_get_const_data (line));
+      return FALSE;
+    }
+
+  if (!(val == 0 || val == 1))
+    {
+      fprintf (stderr, "the value 'b' must be 0 or 1, see sha-1/Readme.txt\n");
+      return FALSE;
+    }
+
+  _dbus_string_skip_blank (line, next, &next);
+
+  current_b = val;
+  n_bits = 0;
+
+  while (next < _dbus_string_get_length (line))
+    {
+      int total_bits;
+
+      offset = next;
+
+      if (_dbus_string_get_byte (line, offset) == '^')
+        break;
+
+      if (!_dbus_string_parse_int (line, offset, &val, &next))
+        {
+          fprintf (stderr, "could not parse bit count in compact string\n");
+          return FALSE;
+        }
+
+      /* We now append "val" copies of "current_b" bits to the string */
+      total_bits = n_bits + val;
+      while (n_bits < total_bits)
+        {
+          int byte_containing_next_bit = n_bits / 8;
+          int bit_containing_next_bit = 7 - (n_bits % 8);
+          unsigned char old_byte;
+
+          if (byte_containing_next_bit >= _dbus_string_get_length (decoded))
+            {
+              if (!_dbus_string_set_length (decoded, byte_containing_next_bit + 1))
+                _dbus_test_fatal ("no memory to extend to next byte");
+            }
+
+          old_byte = _dbus_string_get_byte (decoded, byte_containing_next_bit);
+          old_byte |= current_b << bit_containing_next_bit;
+
+#if 0
+          _dbus_test_diag ("Appending bit %d to byte %d at bit %d resulting in byte 0x%x",
+                  current_b, byte_containing_next_bit,
+                  bit_containing_next_bit, old_byte);
+#endif
+
+          _dbus_string_set_byte (decoded, byte_containing_next_bit, old_byte);
+
+          ++n_bits;
+        }
+
+      _dbus_string_skip_blank (line, next, &next);
+
+      current_b = !current_b;
+    }
+
+  length_bytes = (n_bits / 8 + ((n_bits % 8) ? 1 : 0));
+
+  if (_dbus_string_get_length (decoded) != length_bytes)
+    {
+      fprintf (stderr, "Expected length %d bytes %d bits for compact string, got %d bytes\n",
+               length_bytes, n_bits, _dbus_string_get_length (decoded));
+      return FALSE;
+    }
+  else
+    return TRUE;
+}
+
+static dbus_bool_t
+get_next_expected_result (DBusString *results,
+                          DBusString *result)
+{
+  DBusString line;
+  dbus_bool_t retval;
+
+  retval = FALSE;
+
+  if (!_dbus_string_init (&line))
+    _dbus_test_fatal ("no memory");
+
+ next_iteration:
+  while (_dbus_string_pop_line (results, &line))
+    {
+      _dbus_string_delete_leading_blanks (&line);
+
+      if (_dbus_string_get_length (&line) == 0)
+        goto next_iteration;
+      else if (_dbus_string_starts_with_c_str (&line, "#"))
+        goto next_iteration;
+      else if (_dbus_string_starts_with_c_str (&line, "H>"))
+        {
+          /* don't print */
+        }
+      else if (_dbus_string_starts_with_c_str (&line, "D>") ||
+               _dbus_string_starts_with_c_str (&line, "<D"))
+        goto next_iteration;
+      else
+        {
+          int i;
+
+          if (!_dbus_string_move (&line, 0, result, 0))
+            _dbus_test_fatal ("no memory");
+
+          i = 0;
+          while (i < _dbus_string_get_length (result))
+            {
+              unsigned char c = _dbus_string_get_byte (result, i);
+
+              switch (c)
+                {
+                case 'A':
+                  _dbus_string_set_byte (result, i, 'a');
+                  break;
+                case 'B':
+                  _dbus_string_set_byte (result, i, 'b');
+                  break;
+                case 'C':
+                  _dbus_string_set_byte (result, i, 'c');
+                  break;
+                case 'D':
+                  _dbus_string_set_byte (result, i, 'd');
+                  break;
+                case 'E':
+                  _dbus_string_set_byte (result, i, 'e');
+                  break;
+                case 'F':
+                  _dbus_string_set_byte (result, i, 'f');
+                  break;
+                case '^':
+                case ' ':
+                  _dbus_string_delete (result, i, 1);
+                  --i; /* to offset ++i below */
+                  break;
+                default:
+                  if ((c < '0' || c > '9') && (c < 'a' || c > 'f'))
+                    _dbus_test_fatal ("invalid SHA-1 test script");
+                }
+
+              ++i;
+            }
+
+          break;
+        }
+    }
+
+  retval = TRUE;
+
+  /* out: */
+  _dbus_string_free (&line);
+  return retval;
+}
+
+static dbus_bool_t
+process_test_data (const char *test_data_dir)
+{
+  DBusString tests_file;
+  DBusString results_file;
+  DBusString tests;
+  DBusString results;
+  DBusString line;
+  DBusString tmp;
+  int line_no;
+  dbus_bool_t retval;
+  int success_count;
+  DBusError error = DBUS_ERROR_INIT;
+
+  retval = FALSE;
+
+  if (!_dbus_string_init (&tests_file))
+    _dbus_test_fatal ("no memory");
+
+  if (!_dbus_string_init (&results_file))
+    _dbus_test_fatal ("no memory");
+
+  if (!_dbus_string_init (&tests))
+    _dbus_test_fatal ("no memory");
+
+  if (!_dbus_string_init (&results))
+    _dbus_test_fatal ("no memory");
+
+  if (!_dbus_string_init (&line))
+    _dbus_test_fatal ("no memory");
+
+  if (!_dbus_string_append (&tests_file, test_data_dir))
+    _dbus_test_fatal ("no memory");
+
+  if (!_dbus_string_append (&results_file, test_data_dir))
+    _dbus_test_fatal ("no memory");
+
+  _dbus_string_init_const (&tmp, "sha-1/byte-messages.sha1");
+  if (!_dbus_concat_dir_and_file (&tests_file, &tmp))
+    _dbus_test_fatal ("no memory");
+
+  _dbus_string_init_const (&tmp, "sha-1/byte-hashes.sha1");
+  if (!_dbus_concat_dir_and_file (&results_file, &tmp))
+    _dbus_test_fatal ("no memory");
+
+  if (!_dbus_file_get_contents (&tests, &tests_file, &error))
+    {
+      fprintf (stderr, "could not load test data file %s: %s\n",
+               _dbus_string_get_const_data (&tests_file),
+               error.message);
+      dbus_error_free (&error);
+      goto out;
+    }
+
+  if (!_dbus_file_get_contents (&results, &results_file, &error))
+    {
+      fprintf (stderr, "could not load results data file %s: %s\n",
+               _dbus_string_get_const_data (&results_file), error.message);
+      dbus_error_free (&error);
+      goto out;
+    }
+
+  success_count = 0;
+  line_no = 0;
+ next_iteration:
+  while (_dbus_string_pop_line (&tests, &line))
+    {
+      line_no += 1;
+
+      _dbus_string_delete_leading_blanks (&line);
+
+      if (_dbus_string_get_length (&line) == 0)
+        goto next_iteration;
+      else if (_dbus_string_starts_with_c_str (&line, "#"))
+        goto next_iteration;
+      else if (_dbus_string_starts_with_c_str (&line, "H>"))
+        {
+          _dbus_test_diag ("SHA-1: %s", _dbus_string_get_const_data (&line));
+
+          if (_dbus_string_find (&line, 0, "Type 3", NULL))
+            {
+              /* See sha-1/Readme.txt - the "Type 3" tests are
+               * random seeds, rather than data to be hashed.
+               * we'd have to do a little bit more implementation
+               * to use those tests.
+               */
+
+              _dbus_test_diag (" (ending tests due to Type 3 tests seen - this is normal)");
+              break;
+            }
+        }
+      else if (_dbus_string_starts_with_c_str (&line, "D>") ||
+               _dbus_string_starts_with_c_str (&line, "<D"))
+        goto next_iteration;
+      else
+        {
+          DBusString test;
+          DBusString result;
+          DBusString next_line;
+          DBusString expected;
+          dbus_bool_t success;
+
+          success = FALSE;
+
+          if (!_dbus_string_init (&next_line))
+            _dbus_test_fatal ("no memory");
+
+          if (!_dbus_string_init (&expected))
+            _dbus_test_fatal ("no memory");
+
+          if (!_dbus_string_init (&test))
+            _dbus_test_fatal ("no memory");
+
+          if (!_dbus_string_init (&result))
+            _dbus_test_fatal ("no memory");
+
+          /* the "compact strings" are "^"-terminated not
+           * newline-terminated so readahead to find the
+           * "^"
+           */
+          while (!_dbus_string_find (&line, 0, "^", NULL) &&
+                 _dbus_string_pop_line (&tests, &next_line))
+            {
+              if (!_dbus_string_append_byte (&line, ' ') ||
+                  !_dbus_string_move (&next_line, 0, &line,
+                                      _dbus_string_get_length (&line)))
+                _dbus_test_fatal ("no memory");
+            }
+
+          if (!decode_compact_string (&line, &test))
+            {
+              fprintf (stderr, "Failed to decode line %d as a compact string\n",
+                       line_no);
+              goto failure;
+            }
+
+          if (!_dbus_sha_compute (&test, &result))
+            _dbus_test_fatal ("no memory for SHA-1 result");
+
+          if (!get_next_expected_result (&results, &expected))
+            {
+              fprintf (stderr, "Failed to read an expected result\n");
+              goto failure;
+            }
+
+          if (!_dbus_string_equal (&result, &expected))
+            {
+              fprintf (stderr, " for line %d got hash %s expected %s\n",
+                       line_no,
+                       _dbus_string_get_const_data (&result),
+                       _dbus_string_get_const_data (&expected));
+              goto failure;
+            }
+          else
+            {
+              success_count += 1;
+            }
+
+          success = TRUE;
+
+        failure:
+          _dbus_string_free (&test);
+          _dbus_string_free (&result);
+          _dbus_string_free (&next_line);
+          _dbus_string_free (&expected);
+
+          if (!success)
+            goto out;
+        }
+    }
+
+  retval = TRUE;
+
+  _dbus_test_diag ("Passed the %d SHA-1 tests in the test file",
+          success_count);
+
+ out:
+  _dbus_string_free (&tests_file);
+  _dbus_string_free (&results_file);
+  _dbus_string_free (&tests);
+  _dbus_string_free (&results);
+  _dbus_string_free (&line);
+
+  return retval;
+}
+
+/**
+ * @ingroup DBusSHAInternals
+ * Unit test for SHA computation.
+ *
+ * @returns #TRUE on success.
+ */
+dbus_bool_t
+_dbus_sha_test (const char *test_data_dir)
+{
+  unsigned char all_bytes[256];
+  int i;
+
+  if (test_data_dir != NULL)
+    {
+      if (!process_test_data (test_data_dir))
+        return FALSE;
+    }
+  else
+    _dbus_test_diag ("No test data dir");
+
+  i = 0;
+  while (i < 256)
+    {
+      all_bytes[i] = i;
+      ++i;
+    }
+
+  if (!check_sha_binary (all_bytes, 256,
+                         "4916d6bdb7f78e6803698cab32d1586ea457dfc8"))
+    return FALSE;
+
+#define CHECK(input,expected) if (!check_sha_str (input, expected)) return FALSE
+
+  CHECK ("", "da39a3ee5e6b4b0d3255bfef95601890afd80709");
+  CHECK ("a", "86f7e437faa5a7fce15d1ddcb9eaeaea377667b8");
+  CHECK ("abc", "a9993e364706816aba3e25717850c26c9cd0d89d");
+  CHECK ("message digest", "c12252ceda8be8994d5fa0290a47231c1d16aae3");
+  CHECK ("abcdefghijklmnopqrstuvwxyz", "32d10c7b8cf96570ca04ce37f2a19d84240d3a89");
+  CHECK ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
+         "761c457bf73b14d27e9e9265c46f4b4dda11f940");
+  CHECK ("12345678901234567890123456789012345678901234567890123456789012345678901234567890",
+         "50abf5706a150990a08b2c5ea40fa0e585554732");
+
+  return TRUE;
+}