trema 0.4.7 → 0.4.8

data/unittests/lib/external_callback_test.c

@@ -1,282 +0,0 @@
-/*
- * Unit tests for external_callback.
- *
- * Copyright (C) 2013 NEC Corporation
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License, version 2, as
- * published by the Free Software Foundation.
- *
- * 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 <limits.h>
-#include <stdio.h>
-#include <string.h>
-#include "checks.h"
-#include "cmockery_trema.h"
-#include "external_callback.h"
-#include "utility.h"
-
-typedef struct {
-  external_callback_t *buffer;
-  unsigned int size;
-  unsigned int write_position;
-  unsigned int read_position;
-} ring_buffer;
-
-#define MAX_EXTERNAL_CALLBACK 16
-extern ring_buffer *external_callbacks;
-
-
-/********************************************************************************
- * Mock functions.
- ********************************************************************************/
-
-static ring_buffer ring_buffer0;
-static external_callback_t buffer0[ MAX_EXTERNAL_CALLBACK ];
-
-void *
-mock_xcalloc( size_t nmemb, size_t size ) {
-  check_expected( nmemb );
-  check_expected( size );
-  return ( void * ) ( intptr_t ) mock();
-}
-
-
-void
-mock_xfree( void *ptr ) {
-  check_expected( ptr );
-}
-
-
-void
-mock_debug( const char *format, ... ) {
-  UNUSED( format );
-}
-
-
-static void
-reset() {
-  external_callbacks = NULL;
-}
-
-
-static void
-setup() {
-  memset( &ring_buffer0, 0, sizeof( ring_buffer0 ) );
-  memset( buffer0, 0, sizeof( buffer0 ) );
-  external_callbacks = &ring_buffer0;
-  external_callbacks->buffer = buffer0;
-  external_callbacks->size = MAX_EXTERNAL_CALLBACK;
-  external_callbacks->write_position = 0;
-  external_callbacks->read_position = 0;
-}
-
-
-static void
-teardown() {
-  external_callbacks = NULL;
-}
-
-
-/********************************************************************************
- * Tests.
- ********************************************************************************/
-
-static void
-test_init_external_callback() {
-  expect_value( mock_xcalloc, nmemb, 1 );
-  expect_value( mock_xcalloc, size, sizeof( ring_buffer ) );
-  memset( &ring_buffer0, 0, sizeof( ring_buffer0 ) );
-  will_return( mock_xcalloc, &ring_buffer0 );
-  expect_value( mock_xcalloc, nmemb, MAX_EXTERNAL_CALLBACK );
-  expect_value( mock_xcalloc, size, sizeof( external_callback_t ) );
-  memset( buffer0, 0, sizeof( buffer0 ) );
-  will_return( mock_xcalloc, buffer0 );
-
-  init_external_callback();
-
-  assert_true( external_callbacks == &ring_buffer0 );
-  assert_true( external_callbacks->buffer == buffer0 );
-  assert_true( external_callbacks->size == MAX_EXTERNAL_CALLBACK );
-  assert_true( external_callbacks->write_position == 0 );
-  assert_true( external_callbacks->read_position == 0 );
-}
-
-
-static void
-test_init_external_callback_fails_if_already_initialized() {
-  expect_assert_failure( init_external_callback() );
-}
-
-
-static void
-test_finalize_external_callback() {
-  expect_value( mock_xfree, ptr, buffer0 );
-  expect_value( mock_xfree, ptr, &ring_buffer0 );
-
-  finalize_external_callback();
-
-  assert_true( external_callbacks == NULL );
-}
-
-
-static void
-test_finalize_external_callback_fails_if_not_initialized() {
-  expect_assert_failure( finalize_external_callback() );
-}
-
-
-static void
-test_finalize_external_callback_fails_if_already_finalized() {
-  expect_value( mock_xfree, ptr, buffer0 );
-  expect_value( mock_xfree, ptr, &ring_buffer0 );
-  finalize_external_callback();
-
-  expect_assert_failure( finalize_external_callback() );
-}
-
-
-static void
-external_callback_helper() {
-  mock();
-}
-
-
-static void
-test_push_external_callback() {
-  push_external_callback( external_callback_helper );
-
-  assert_true( external_callbacks->write_position == 1 );
-  assert_true( external_callbacks->read_position == 0 );
-  assert_true( external_callbacks->buffer[ 0 ] == external_callback_helper );
-  for ( int i = 1; i < MAX_EXTERNAL_CALLBACK; i++ ) {
-    assert_true( external_callbacks->buffer[ i ] == NULL );
-  }
-}
-
-
-static void
-test_push_external_callback_fails_if_callback_is_NULL() {
-  assert_true( push_external_callback( NULL ) == false );
-}
-
-
-static void
-test_push_external_callback_fails_if_not_initialized() {
-  assert_true( push_external_callback( external_callback_helper ) == false );
-}
-
-
-static void
-test_push_external_callback_succeeds_with_multiple_callbacks() {
-  external_callbacks->write_position = 5;
-  external_callbacks->read_position = 5;
-
-  for ( int i = 0; i < MAX_EXTERNAL_CALLBACK; i++ ) {
-    push_external_callback( external_callback_helper );
-  }
-
-  assert_true( external_callbacks->write_position == 5 + MAX_EXTERNAL_CALLBACK );
-  assert_true( external_callbacks->read_position == 5 );
-  for ( int i = 0; i < MAX_EXTERNAL_CALLBACK; i++ ) {
-    assert_true( external_callbacks->buffer[ i ] == external_callback_helper );
-  }
-}
-
-
-static void
-test_push_external_callback_fails_if_buffer_overflows() {
-  external_callbacks->write_position = 3;
-  external_callbacks->read_position = 3;
-
-  for ( int i = 0; i < MAX_EXTERNAL_CALLBACK; i++ ) {
-    push_external_callback( external_callback_helper );
-  }
-  expect_assert_failure( push_external_callback( external_callback_helper ) );
-}
-
-
-static void
-test_run_external_callback() {
-  external_callbacks->write_position = UINT_MAX;
-  external_callbacks->read_position = UINT_MAX;
-  push_external_callback( external_callback_helper );
-  assert_true( external_callbacks->write_position == UINT_MAX + 1 );
-  assert_true( external_callbacks->read_position == UINT_MAX );
-  will_return( external_callback_helper, 0 );
-
-  run_external_callback();
-
-  assert_true( external_callbacks->write_position == UINT_MAX + 1 );
-  assert_true( external_callbacks->read_position == UINT_MAX + 1 );
-  for ( int i = 0; i < MAX_EXTERNAL_CALLBACK; i++ ) {
-    assert_true( external_callbacks->buffer[ i ] == NULL );
-  }
-}
-
-
-static void
-test_run_external_callback_succeeds_with_multiple_callbacks() {
-  external_callbacks->write_position = UINT_MAX;
-  external_callbacks->read_position = UINT_MAX;
-  for ( int i = 0; i < MAX_EXTERNAL_CALLBACK; i++ ) {
-    push_external_callback( external_callback_helper );
-  }
-  assert_true( external_callbacks->write_position == UINT_MAX + MAX_EXTERNAL_CALLBACK );
-  assert_true( external_callbacks->read_position == UINT_MAX );
-  will_return_count( external_callback_helper, 0, MAX_EXTERNAL_CALLBACK );
-
-  run_external_callback();
-
-  assert_true( external_callbacks->write_position == UINT_MAX + MAX_EXTERNAL_CALLBACK );
-  assert_true( external_callbacks->read_position == UINT_MAX + MAX_EXTERNAL_CALLBACK );
-  for ( int i = 0; i < MAX_EXTERNAL_CALLBACK; i++ ) {
-    assert_true( external_callbacks->buffer[ i ] == NULL );
-  }
-}
-
-/********************************************************************************
- * Run tests.
- ********************************************************************************/
-
-int
-main() {
-  const UnitTest tests[] = {
-    unit_test_setup_teardown( test_init_external_callback, reset, teardown ),
-    unit_test_setup_teardown( test_init_external_callback_fails_if_already_initialized, setup, teardown ),
-
-    unit_test_setup_teardown( test_finalize_external_callback, setup, teardown ),
-    unit_test_setup_teardown( test_finalize_external_callback_fails_if_not_initialized, reset, teardown ),
-    unit_test_setup_teardown( test_finalize_external_callback_fails_if_already_finalized, setup, teardown ),
-
-    unit_test_setup_teardown( test_push_external_callback, setup, teardown ),
-    unit_test_setup_teardown( test_push_external_callback_fails_if_callback_is_NULL, setup, teardown ),
-    unit_test_setup_teardown( test_push_external_callback_fails_if_not_initialized, reset, teardown ),
-
-    unit_test_setup_teardown( test_push_external_callback_succeeds_with_multiple_callbacks, setup, teardown ),
-    unit_test_setup_teardown( test_push_external_callback_fails_if_buffer_overflows, setup, teardown ),
-
-    unit_test_setup_teardown( test_run_external_callback, setup, teardown ),
-    unit_test_setup_teardown( test_run_external_callback_succeeds_with_multiple_callbacks, setup, teardown ),
-  };
-
-  return run_tests( tests );
-}
-
-
-/*
- * Local variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */

data/unittests/lib/hash_table_test.c

@@ -1,278 +0,0 @@
-/*
- * Unit tests for hash table.
- *
- * Copyright (C) 2008-2013 NEC Corporation
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License, version 2, as
- * published by the Free Software Foundation.
- *
- * 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 <setjmp.h>
-#include <stdarg.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "checks.h"
-#include "cmockery_trema.h"
-#include "hash_table.h"
-#include "utility.h"
-
-
-/********************************************************************************
- * Test functions.
- ********************************************************************************/
-
-static hash_table *table;
-
-static char alpha[] = "alpha";
-static char bravo[] = "bravo";
-static char charlie[] = "charlie";
-
-
-static void
-test_lookup_empty_table_returns_NULL() {
-  table = create_hash( compare_string, hash_string );
-
-  assert_true( lookup_hash_entry( table, alpha ) == NULL );
-
-  delete_hash( table );
-}
-
-
-static void
-test_insert_and_lookup() {
-  table = create_hash( compare_string, hash_string );
-
-  insert_hash_entry( table, alpha, alpha );
-  assert_string_equal( lookup_hash_entry( table, alpha ), "alpha" );
-
-  delete_hash( table );
-}
-
-
-typedef struct {
-  const char *key;
-} key;
-
-static void
-test_insert_and_lookup_by_atom_hash() {
-  key mykey = { "alpha" };
-  table = create_hash( compare_atom, hash_atom );
-
-  insert_hash_entry( table, &mykey, alpha );
-  assert_string_equal( lookup_hash_entry( table, &mykey ), "alpha" );
-
-  delete_hash( table );
-}
-
-
-static void
-test_insert_twice_overwrites_old_value() {
-  char *prev;
-  char key[] = "key";
-  table = create_hash( compare_string, hash_string );
-
-  char old_value[] = "old value";
-  char new_value[] = "new value";
-
-  insert_hash_entry( table, key, old_value );
-  prev = insert_hash_entry( table, key, new_value );
-
-  assert_string_equal( lookup_hash_entry( table, key ), "new value" );
-  assert_string_equal( prev, "old value" );
-
-  delete_hash( table );
-}
-
-
-static void
-test_delete_entry() {
-  table = create_hash( compare_string, hash_string );
-
-  insert_hash_entry( table, alpha, alpha );
-  insert_hash_entry( table, bravo, bravo );
-  insert_hash_entry( table, charlie, charlie );
-
-  delete_hash_entry( table, bravo );
-  assert_string_equal( lookup_hash_entry( table, alpha ), "alpha" );
-  assert_true( lookup_hash_entry( table, bravo ) == NULL );
-  assert_string_equal( lookup_hash_entry( table, charlie ), "charlie" );
-
-  delete_hash( table );
-}
-
-
-static void
-test_nonexistent_entry_returns_NULL() {
-  table = create_hash( compare_string, hash_string );
-
-  assert_true( delete_hash_entry( table, "NO SUCH KEY" ) == NULL );
-
-  delete_hash( table );
-}
-
-
-static char *abc[ 3 ] = { NULL, NULL, NULL };
-
-static void
-append_back_foreach( void *key, void *value, void *user_data ) {
-  assert_true( strcmp( key, value ) == 0 );
-  assert_true( user_data == NULL );
-
-  int i;
-  for ( i = 0; i < 3; i++ ) {
-    if ( abc[ i ] == NULL ) {
-      abc[ i ] = value;
-      return;
-    }
-  }
-}
-
-
-static void
-test_foreach() {
-  table = create_hash( compare_string, hash_string );
-  insert_hash_entry( table, alpha, alpha );
-  insert_hash_entry( table, bravo, bravo );
-  insert_hash_entry( table, charlie, charlie );
-  delete_hash_entry( table, bravo );
-  delete_hash_entry( table, charlie );
-
-  foreach_hash( table, append_back_foreach, NULL );
-
-  assert_string_equal( abc[ 0 ], "alpha" );
-  assert_true( abc[ 1 ] == NULL );
-  assert_true( abc[ 2 ] == NULL );
-
-  delete_hash( table );
-}
-
-
-static void
-test_iterator() {
-  table = create_hash( compare_string, hash_string );
-
-  char one[] = "one";
-  insert_hash_entry( table, one, ( void * ) 1 );
-
-  char two[] = "two";
-  insert_hash_entry( table, two, ( void * ) 2 );
-
-  char three[] = "three";
-  insert_hash_entry( table, three, ( void * ) 3 );
-
-  char four[] = "four";
-  insert_hash_entry( table, four, ( void * ) 4 );
-
-  char five[] = "five";
-  insert_hash_entry( table, five, ( void * ) 5 );
-
-  char six[] = "six";
-  insert_hash_entry( table, six, ( void * ) 6 );
-
-  char seven[] = "seven";
-  insert_hash_entry( table, seven, ( void * ) 7 );
-
-  char eight[] = "eight";
-  insert_hash_entry( table, eight, ( void * ) 8 );
-
-  char nine[] = "nine";
-  insert_hash_entry( table, nine, ( void * ) 9 );
-
-  char ten[] = "ten";
-  insert_hash_entry( table, ten, ( void * ) 10 );
-
-  int sum = 0;
-  hash_iterator iter;
-  hash_entry *e;
-  init_hash_iterator( table, &iter );
-  while ( ( e = iterate_hash_next( &iter ) ) != NULL ) {
-    sum += ( int ) ( uintptr_t ) e->value;
-    delete_hash_entry( table, e->key );
-  }
-  assert_true( sum == 55 );
-
-  delete_hash( table );
-}
-
-
-static void
-test_multiple_inserts_and_deletes_then_iterate() {
-  table = create_hash( compare_string, hash_string );
-
-  char one[] = "one";
-  insert_hash_entry( table, one, ( void * ) 1 );
-  delete_hash_entry( table, one );
-  insert_hash_entry( table, one, ( void * ) 1 );
-  delete_hash_entry( table, one );
-  insert_hash_entry( table, one, ( void * ) 1 );
-
-  int sum = 0;
-  hash_iterator iter;
-  hash_entry *e;
-  init_hash_iterator( table, &iter );
-  while ( ( e = iterate_hash_next( &iter ) ) != NULL ) {
-    sum += ( int ) ( uintptr_t ) e->value;
-    delete_hash_entry( table, e->key );
-  }
-  assert_true( sum == 1 );
-
-  delete_hash( table );
-}
-
-
-static void
-test_iterate_empty_hash() {
-  hash_iterator iter;
-  table = create_hash( compare_atom, hash_atom );
-  init_hash_iterator( table, &iter );
-
-  while ( iterate_hash_next( &iter ) != NULL ) {
-    UNREACHABLE_CODE();
-  }
-
-  delete_hash( table );
-}
-
-
-/********************************************************************************
- * Run tests.
- ********************************************************************************/
-
-int
-main() {
-  const UnitTest tests[] = {
-    unit_test( test_lookup_empty_table_returns_NULL ),
-    unit_test( test_insert_and_lookup ),
-    unit_test( test_insert_and_lookup_by_atom_hash ),
-    unit_test( test_insert_twice_overwrites_old_value ),
-    unit_test( test_delete_entry ),
-    unit_test( test_nonexistent_entry_returns_NULL ),
-    unit_test( test_foreach ),
-    unit_test( test_iterator ),
-    unit_test( test_multiple_inserts_and_deletes_then_iterate ),
-    unit_test( test_iterate_empty_hash ),
-  };
-  setup_leak_detector();
-  return run_tests( tests );
-}
-
-
-/*
- * Local variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */