fdo-mirrors/dbus
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/dbus/dbus.git synced 2026-01-28 16:30:26 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

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

Browse source 
Break out more tests from libdbus

See merge request dbus/dbus!121
This commit is contained in:
Simon McVittie 2019-07-03 13:43:25 +00:00
commit ac5cdd281a
15 changed files with 994 additions and 908 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

183
dbus/dbus-address.c
View file

@ -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

3
dbus/dbus-connection-internal.h
View file

@ -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

6
dbus/dbus-internals.h
View file

@ -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);

199
dbus/dbus-mempool.c
View file

@ -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 */

463
dbus/dbus-sha.c
View file

@ -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 */

1
dbus/dbus-sha.h
View file

@ -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);

12
dbus/dbus-test.h
View file

@ -40,24 +40,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);

53
dbus/dbus-userdb-util.c
View file

@ -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 */

3
test/CMakeLists.txt
View file

@ -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})

3
test/Makefile.am
View file

@ -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

203
test/internals/address.c Normal file
View file

@ -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;
}

223
test/internals/mempool.c Normal file
View file

@ -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;
}

56
test/internals/misc-internals.c
View file

@ -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[] =

3
test/internals/misc-internals.h
View file

@ -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

491
test/internals/sha.c Normal file
View file

@ -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;
}