//TODO: add more tests
static bool testCreate() {
ASSERT_NULL(dishCreate(NULL,NULL,0));
ASSERT_NULL(dishCreate(NULL,NULL,1));
ASSERT_NULL(dishCreate("string",NULL,0));
ASSERT_NULL(dishCreate("",NULL,0));
ASSERT_NULL(dishCreate("","",0));
Dish dish = dishCreate("","",1);
ASSERT_NOT_NULL(dish);
dishDestroy(dish);
ASSERT_NULL(dishCreate(NULL, "Dor", 4));
ASSERT_NULL(dishCreate("Soup", "Shlomo", -1));
char name[] = "Soup";
Dish soup = dishCreate(name, "Shlomo", 5);
ASSERT_NOT_NULL(soup);
name[0] = 'R';
dishDestroy(soup);
char * name1 = (char*)malloc(sizeof(char)*4);
strcpy(name1,"ttl");
char * name2 = (char*)malloc(sizeof(char)*4);
strcpy(name2,"ttl");
free(name1);
//ASSERT_NULL(dishCreate(name1,name2,2)); no idea if this can be made not to crash
free(name2);
//ASSERT_NULL(dishCreate(name1,name2,2));
return true;
}
SSOERROR
SSOStringConcatenate(
PCSTRING psz1,
PCSTRING psz2,
PSTRING* ppsz /* OUT */)
{
SSOERROR e = SSOERROR_NONE;
size_t length1 = 0;
size_t length2 = 0;
char* p = NULL;
ASSERT_NOT_NULL(psz1);
ASSERT_NOT_NULL(psz2);
ASSERT_NOT_NULL(ppsz);
length1 = strlen(psz1);
length2 = strlen(psz2);
p = calloc(length1 + length2 + 1, sizeof(char));
if (NULL == p)
{
e = SSOERROR_OUT_OF_MEMORY;
BAIL_ON_ERROR(e);
}
strcpy(p, psz1);
strcpy(p + length1, psz2);
*ppsz = p;
error:
return e;
}
void test_list_for_each()
{
KAA_TRACE_IN(logger);
kaa_list_t *list = kaa_list_create();
ASSERT_NOT_NULL(list);
int32_t *number1_ptr;
int node_number = 4;
for (int i = 0; i < node_number; ++i) {
number1_ptr = (int32_t *)KAA_MALLOC(sizeof(int32_t *));
ASSERT_NOT_NULL(number1_ptr);
*number1_ptr = rand();
kaa_list_push_back(list, number1_ptr);
}
int number2 = rand();
kaa_list_for_each(kaa_list_begin(list), kaa_list_back(list), (process_data)&test_process_data, &number2);
kaa_list_node_t *it = kaa_list_begin(list);
while (it) {
ASSERT_EQUAL(*(int32_t *)kaa_list_get_data(kaa_list_begin(list)), number2);
it = kaa_list_next(it);
}
kaa_list_destroy(list, NULL);
KAA_TRACE_OUT(logger);
}
static void test_list_sort()
{
kaa_list_t *list = kaa_list_create();
ASSERT_NOT_NULL(list);
uint64_t node_number = 100;
for (uint64_t i = 0; i < node_number; ++i) {
test_list_node_t *node = KAA_MALLOC(sizeof(test_list_node_t));
ASSERT_NOT_NULL(node);
node->id = (uint64_t) rand();
kaa_list_push_back(list, node);
}
ASSERT_EQUAL(kaa_list_get_size(list), node_number);
kaa_list_sort(list,&test_kaa_list_predicate);
kaa_list_node_t *it,*next;
it = kaa_list_begin(list);
next = kaa_list_next(it);
while (it && next) {
ASSERT_TRUE(((test_list_node_t*)kaa_list_get_data(it))->id <=
((test_list_node_t*)kaa_list_get_data(next))->id);
it = next;
next = kaa_list_next(it);
}
kaa_list_destroy(list, NULL);
}
SSOERROR
SSOStringAllocate(
PCSTRING psz,
PSTRING* ppsz /* OUT */)
{
SSOERROR e = SSOERROR_NONE;
size_t length = 0;
char* p = NULL;
ASSERT_NOT_NULL(psz);
ASSERT_NOT_NULL(ppsz);
length = strlen(psz);
p = calloc(length + 1, sizeof(char));
if (NULL == p)
{
e = SSOERROR_OUT_OF_MEMORY;
BAIL_ON_ERROR(e);
}
strcpy(p, psz);
*ppsz = p;
error:
return e;
}
static void
contract_and_expand(const char *data, size_t s_window, uint32_t base, size_t s_pcodes)
{
struct diag_vcdiff_script *script;
struct diag_rollinghash32 *rh;
size_t size, s;
uint8_t *result;
char *result0;
size = strlen(data);
rh = (struct diag_rollinghash32 *)diag_rollinghash32_new_rabin_karp((const uint8_t *)data, size, s_window, base);
ASSERT_NOT_NULL(rh);
script = diag_vcdiff_contract(rh);
ASSERT_NOT_NULL(script);
dump_pcodes(script);
ASSERT_EQ_UINT(s_pcodes, script->s_pcodes);
result = diag_vcdiff_expand(script, &s);
ASSERT_EQ_UINT(size, s);
result0 = diag_malloc(s + 1);
(void)memcpy(result0, result, s);
result0[s] = '\0';
ASSERT_EQ_STRING(data, result0);
diag_free(result0);
diag_free(result);
diag_vcdiff_script_destroy(script);
diag_rollinghash32_destroy(rh);
}
static void test_fixed_deserialize(void **state)
{
(void)state;
const uint8_t plain_fixed1[] = { 0x0, 0x1, 0x2, 0x3, 0x4 };
size_t plain_fixed1_size = sizeof(plain_fixed1) / sizeof(char);
kaa_bytes_t *kaa_fixed1 = kaa_fixed_copy_create(plain_fixed1, plain_fixed1_size);
ASSERT_NOT_NULL(kaa_fixed1);
size_t expected_size = kaa_fixed_get_size(kaa_fixed1);
char buffer[expected_size];
avro_writer_t avro_writer = avro_writer_memory(buffer, expected_size);
kaa_fixed_serialize(avro_writer, kaa_fixed1);
avro_reader_t avro_reader = avro_reader_memory(buffer, expected_size);
kaa_bytes_t *kaa_fixed2 = kaa_fixed_deserialize(avro_reader, &expected_size);
ASSERT_NOT_NULL(kaa_fixed2);
ASSERT_EQUAL(memcmp(kaa_fixed2->buffer, plain_fixed1, plain_fixed1_size), 0);
ASSERT_EQUAL(memcmp(kaa_fixed2->buffer, kaa_fixed1->buffer, plain_fixed1_size), 0);
kaa_fixed_destroy(kaa_fixed2);
avro_reader_free(avro_reader);
avro_writer_free(avro_writer);
kaa_fixed_destroy(kaa_fixed1);
}
static void test_string_move_create(void **state)
{
(void)state;
ASSERT_NULL(kaa_string_move_create(NULL, NULL));
const char *plain_test_str1 = "test";
kaa_string_t *kaa_str1 = kaa_string_move_create(plain_test_str1, NULL);
ASSERT_NOT_NULL(kaa_str1);
ASSERT_NOT_NULL(kaa_str1->data);
ASSERT_NULL(kaa_str1->destroy);
ASSERT_EQUAL(strcmp(kaa_str1->data, plain_test_str1), 0);
kaa_string_destroy(kaa_str1);
kaa_str1 = NULL;
char *plain_test_str2 = (char *)KAA_MALLOC(strlen(plain_test_str1) + 1);
ASSERT_NOT_NULL(plain_test_str2);
strcpy(plain_test_str2, plain_test_str1);
kaa_string_t *kaa_str2 = kaa_string_move_create(plain_test_str2, &kaa_data_destroy);
ASSERT_NOT_NULL(kaa_str2);
ASSERT_NOT_NULL(kaa_str2->data);
ASSERT_EQUAL(kaa_str2->destroy, &kaa_data_destroy);
ASSERT_EQUAL(strcmp(kaa_str2->data, plain_test_str1), 0);
kaa_string_destroy(kaa_str2);
}
void rot2d_calc(rot2d_context_t *context, float out[2], const float in[2], float angle)
{
ASSERT_NOT_NULL(context->matrix);
ASSERT_NOT_NULL(context->in);
ASSERT_NOT_NULL(context->out);
/*
* copy arguments to input vector:
*/
context->in->ve[0] = in[0];
context->in->ve[1] = in[1];
/*
* build rotation matrix:
*
* | cos(x) -sin(x) |
* | sin(x) cos(x) |
*/
context->matrix->me[0][0] = cosf(angle);
context->matrix->me[0][1] = sinf(angle);
context->matrix->me[1][0] = -sinf(angle);
context->matrix->me[1][1] = cosf(angle);
/*
* perform rotation and result output:
*/
vm_mlt(context->matrix, context->in, context->out);
out[0] = context->out->ve[0];
out[1] = context->out->ve[1];
}
void test_list_push_front()
{
KAA_TRACE_IN(logger);
kaa_list_t *list = kaa_list_create();
ASSERT_NOT_NULL(list);
int32_t *number;
int node_number = 2;
for (int i = 0; i < node_number; ++i) {
number = (int32_t *)KAA_MALLOC(sizeof(int32_t *));
ASSERT_NOT_NULL(number);
*number = rand();
kaa_list_push_front(list, number);
}
ASSERT_EQUAL(kaa_list_get_size(list), node_number);
ASSERT_NOT_NULL(kaa_list_begin(list));
ASSERT_NULL(kaa_list_prev(kaa_list_begin(list)));
ASSERT_EQUAL((*(int32_t *)kaa_list_get_data(kaa_list_begin(list))), *number);
kaa_list_destroy(list, NULL);
KAA_TRACE_OUT(logger);
}
PERIODIC_THREAD_END
void mon_init(void)
{
ASSERT_ONCE();
/* open monitoring socket: */
mon_socket = scl_get_socket("ap_mon");
ASSERT_NOT_NULL(mon_socket);
int64_t hwm = 1;
zmq_setsockopt(mon_socket, ZMQ_SNDHWM, &hwm, sizeof(hwm));
/* create monitoring connection: */
const struct timespec period = {0, 20 * NSEC_PER_MSEC};
pthread_mutexattr_init(&mutexattr);
pthread_mutexattr_setprotocol(&mutexattr, PTHREAD_PRIO_INHERIT);
pthread_mutex_init(&mutex, &mutexattr);
/* init msgpack buffer: */
ASSERT_NULL(msgpack_buf);
msgpack_buf = msgpack_sbuffer_new();
ASSERT_NOT_NULL(msgpack_buf);
ASSERT_NULL(pk);
pk = msgpack_packer_new(msgpack_buf, msgpack_sbuffer_write);
periodic_thread_start(&emitter_thread, mon_emitter, "mon_thread", THREAD_PRIORITY, period, NULL);
}
void assert_parse_package(const char* package_name, const char* java_text) {
JavaDocStructure* java_doc = parse_text(java_text, TRUE, FALSE);
ASSERT_NOT_NULL(java_doc);
ASSERT_NOT_NULL(java_doc->package_declaration);
ASSERT_STR_EQ(package_name, java_doc->package_declaration->package_name);
java_doc_free(java_doc);
}
static void destroy_ship(struct GameState *game_state, struct Ship *ship)
{
struct UIntHashPair *pair = find_pair(&game_state->ship_id_map, ship->id);
ASSERT_NOT_NULL(pair);
uint32 array_index = pair->value;
ASSERT(array_index < game_state->ship_count);
remove_pair(&game_state->ship_id_map, ship->id);
// Ship is already at the end of the array.
if (array_index == game_state->ship_count - 1)
{
--game_state->ship_count;
return;
}
// Swap the destroyed ship with the last active ship in the array.
struct Ship last = game_state->ships[game_state->ship_count - 1];
game_state->ships[array_index] = last;
--game_state->ship_count;
// Update the ship ID map with the swapped ship's new array index.
struct UIntHashPair *last_pair = find_pair(&game_state->ship_id_map, last.id);
ASSERT_NOT_NULL(last_pair);
last_pair->value = array_index;
}
static void test_string_deserialize(void **state)
{
(void)state;
const char *plain_test_str1 = "test";
kaa_string_t *kaa_str1 = kaa_string_copy_create(plain_test_str1);
ASSERT_NOT_NULL(kaa_str1);
size_t expected_size = kaa_string_get_size(kaa_str1);
char buffer[expected_size];
avro_writer_t avro_writer = avro_writer_memory(buffer, expected_size);
kaa_string_serialize(avro_writer, kaa_str1);
avro_reader_t avro_reader = avro_reader_memory(buffer, expected_size);
kaa_string_t *kaa_str2 = kaa_string_deserialize(avro_reader);
ASSERT_NOT_NULL(kaa_str2);
ASSERT_EQUAL(strcmp(kaa_str2->data, plain_test_str1), 0);
ASSERT_EQUAL(strcmp(kaa_str2->data, kaa_str1->data), 0);
kaa_string_destroy(kaa_str2);
avro_reader_free(avro_reader);
avro_writer_free(avro_writer);
kaa_string_destroy(kaa_str1);
}
SSOERROR
SSOKeyValuePairNew(
PSSO_KEY_VALUE_PAIR* pp,
PCSTRING pszKey,
PCSTRING pszValue)
{
SSOERROR e = SSOERROR_NONE;
PSSO_KEY_VALUE_PAIR p = NULL;
ASSERT_NOT_NULL(pp);
ASSERT_NOT_NULL(pszKey);
ASSERT_NOT_NULL(pszValue);
e = SSOMemoryAllocate(sizeof(SSO_KEY_VALUE_PAIR), (void**) &p);
BAIL_ON_ERROR(e);
e = SSOStringAllocate(pszKey, &p->pszKey);
BAIL_ON_ERROR(e);
e = SSOStringAllocate(pszValue, &p->pszValue);
BAIL_ON_ERROR(e);
*pp = p;
error:
if (e != SSOERROR_NONE)
{
SSOKeyValuePairDelete(p);
}
return e;
}
static void print_mac(char *buf, mac_addr *e)
{
ASSERT_NOT_NULL(buf);
ASSERT_NOT_NULL(e);
snprintf(buf, macbuf_size, mac_fmt, mac_str(e->a));
}
void test_kaa_deque_first_last()
{
kaa_error_t error_code = KAA_ERR_NONE;
error_code = kaa_deque_first(NULL, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_BADPARAM);
error_code = kaa_deque_last(NULL, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_BADPARAM);
kaa_deque_t *deque = NULL;
error_code = kaa_deque_create(&deque);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NOT_NULL(deque);
error_code = kaa_deque_first(deque, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_BADPARAM);
error_code = kaa_deque_last(deque, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_BADPARAM);
kaa_deque_iterator_t *it = NULL;
error_code = kaa_deque_first(NULL, &it);
ASSERT_EQUAL(error_code, KAA_ERR_BADPARAM);
error_code = kaa_deque_last(NULL, &it);
ASSERT_EQUAL(error_code, KAA_ERR_BADPARAM);
error_code = kaa_deque_first(deque, &it);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NULL(it);
error_code = kaa_deque_last(deque, &it);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NULL(it);
kaa_deque_push_back_data(deque, "data");
ASSERT_EQUAL(kaa_deque_size(deque), 1);
kaa_deque_iterator_t *it1 = NULL;
error_code = kaa_deque_first(deque, &it1);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NOT_NULL(it1);
kaa_deque_iterator_t *it2 = NULL;
error_code = kaa_deque_last(deque, &it2);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NOT_NULL(it2);
ASSERT_EQUAL(it1, it2);
kaa_deque_push_back_data(deque, "data");
ASSERT_EQUAL(kaa_deque_size(deque), 2);
error_code = kaa_deque_first(deque, &it1);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NOT_NULL(it1);
error_code = kaa_deque_last(deque, &it2);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NOT_NULL(it2);
ASSERT_NOT_EQUAL(it1, it2);
kaa_deque_destroy(deque, &test_kaa_deque_destroy_stub);
}
static void print_ip(char *buf, ip_addr *i)
{
ASSERT_NOT_NULL(buf);
ASSERT_NOT_NULL(i);
l4_uint32_t addr = i->a;
snprintf(buf, ipbuf_size, ip_fmt, ip_str(&addr));
}
void threadManagerSetUp(swTestSuite *suite)
{
swEdgeLoop *loop = swEdgeLoopNew();
ASSERT_NOT_NULL(loop);
swThreadManager *manager = swThreadManagerNew(loop, 1000);
ASSERT_NOT_NULL(manager);
swTestSuiteDataSet(suite, manager);
}
void stopFunction(void *arg)
{
swTestLogLine("Terminating thread\n");
swTreadTestData *testData = arg;
ASSERT_NOT_NULL(testData);
ASSERT_NOT_NULL(testData->terminate);
*(testData->terminate) = 1L;
}
cddb_error_t cddb_site_get_description(const cddb_site_t *site,
const char **desc)
{
ASSERT_NOT_NULL(site);
ASSERT_NOT_NULL(desc);
*desc = site->desc;
return CDDB_ERR_OK;
}
cddb_error_t cddb_site_get_submit_path(const cddb_site_t *site,
const char **path)
{
ASSERT_NOT_NULL(site);
ASSERT_NOT_NULL(path);
*path = site->submit_path;
return CDDB_ERR_OK;
}
static void test_metadata_grammar(void)
{
struct cspeech_srgs_parser *parser;
struct cspeech_srgs_grammar *grammar;
parser = cspeech_srgs_parser_new("1234");
ASSERT_NOT_NULL((grammar = cspeech_srgs_parse(parser, metadata_grammar)));
ASSERT_NOT_NULL(cspeech_srgs_grammar_to_jsgf(grammar));
}
Exception::Exception (String* message, List* stack_trace)
{
ASSERT_NOT_NULL(message);
ASSERT_NOT_NULL(stack_trace);
this->message = message;
this->stack_trace = stack_trace;
this->type = EXCEPTION_TYPE;
}
cddb_error_t cddb_site_get_location(const cddb_site_t *site,
float *latitude, float *longitude)
{
ASSERT_NOT_NULL(site);
ASSERT_NOT_NULL(latitude);
ASSERT_NOT_NULL(longitude);
*latitude = site->latitude;
*longitude = site->longitude;
return CDDB_ERR_OK;
}
cddb_error_t cddb_site_get_address(const cddb_site_t *site,
const char **address, unsigned int *port)
{
ASSERT_NOT_NULL(site);
ASSERT_NOT_NULL(address);
ASSERT_NOT_NULL(port);
*address = site->address;
*port = site->port;
return CDDB_ERR_OK;
}
static bool THPModule_loadClasses(PyObject *self)
{
#define ASSERT_NOT_NULL(ptr) if (!(ptr)) { THPUtils_setError("couldn't load classes"); return false; }
PyObject *torch_module = PyImport_ImportModule("torch");
if (!torch_module) {
THPUtils_setError("class loader couldn't access torch module");
return false;
}
ASSERT_NOT_NULL(tensor_classes = PyObject_GetAttrString(torch_module, "_tensor_classes"));
if (!THPDoubleTensor_postInit(torch_module)) return false;
if (!THPFloatTensor_postInit(torch_module)) return false;
if (!THPHalfTensor_postInit(torch_module)) return false;
if (!THPLongTensor_postInit(torch_module)) return false;
if (!THPIntTensor_postInit(torch_module)) return false;
if (!THPShortTensor_postInit(torch_module)) return false;
if (!THPCharTensor_postInit(torch_module)) return false;
if (!THPByteTensor_postInit(torch_module)) return false;
ASSERT_NOT_NULL(THPDoubleStorageClass = PyObject_GetAttrString(torch_module,(char*)"DoubleStorage"));
ASSERT_NOT_NULL(THPFloatStorageClass = PyObject_GetAttrString(torch_module,(char*)"FloatStorage"));
ASSERT_NOT_NULL(THPHalfStorageClass = PyObject_GetAttrString(torch_module,(char*)"HalfStorage"));
ASSERT_NOT_NULL(THPLongStorageClass = PyObject_GetAttrString(torch_module,(char*)"LongStorage"));
ASSERT_NOT_NULL(THPIntStorageClass = PyObject_GetAttrString(torch_module,(char*)"IntStorage"));
ASSERT_NOT_NULL(THPShortStorageClass = PyObject_GetAttrString(torch_module,(char*)"ShortStorage"));
ASSERT_NOT_NULL(THPCharStorageClass = PyObject_GetAttrString(torch_module,(char*)"CharStorage"));
ASSERT_NOT_NULL(THPByteStorageClass = PyObject_GetAttrString(torch_module,(char*)"ByteStorage"));
return true;
#undef ASSERT_NOT_NULL
}
int mod_okioki_view_execute(request_rec *http_request, mod_okioki_dir_config *cfg, view_t *view, apr_hash_t *arguments, const apr_dbd_driver_t **db_driver, apr_dbd_results_t **db_result, char **error)
{
apr_pool_t *pool = http_request->pool;
ap_dbd_t *db_conn;
apr_dbd_prepared_t *db_statement;
char *arg;
int argc = view->nr_sql_params;
char *argv[argc + 1];
off_t i;
int ret;
// Copy the pointers parameters in the right order for the SQL statement.
for (i = 0; i < argc; i++) {
ASSERT_NOT_NULL(
arg = (char *)apr_hash_get(arguments, view->sql_params[i], view->sql_params_len[i]),
HTTP_INTERNAL_SERVER_ERROR, "Could not find parameter '%s' in request.", view->sql_params[i]
)
argv[i] = arg;
}
argv[i] = NULL;
// Retrieve a database connection from the resource pool.
ASSERT_NOT_NULL(
db_conn = ap_dbd_acquire(http_request),
HTTP_INTERNAL_SERVER_ERROR, "Can not get database connection."
)
*db_driver = db_conn->driver;
// Get the prepared statement.
ASSERT_NOT_NULL(
db_statement = apr_hash_get((db_conn)->prepared, view->sql, view->sql_len),
HTTP_INTERNAL_SERVER_ERROR, "Can not find '%s'", view->sql
)
// Execute the statement.
*db_result = NULL;
// Execute a select statement. We allow random access here as it allows easier configuration because the number
// of columns and the name of the columns are known when random access is enabled.
// Also because we use buckets and brigades everything is done in memory already, so streaming data would not
// have worked anyway.
ASSERT_APR_SUCCESS(
ret = apr_dbd_pselect(db_conn->driver, db_conn->pool, db_conn->handle, db_result, db_statement, 1, argc, (const char **)argv),
HTTP_BAD_GATEWAY, "%s", apr_dbd_error(db_conn->driver, db_conn->handle, ret)
)
ASSERT_NOT_NULL(
*db_result,
HTTP_BAD_GATEWAY, "Result was not set by apr_dbd_pselect."
)
return HTTP_OK;
}
static void test_normal_cdata(void)
{
iks *iq = NULL;
iks *input = NULL;
iksparser *p = iks_dom_new(&iq);
const char *cdata;
ASSERT_EQUALS(IKS_OK, iks_parse(p, normal_cdata, 0, 1));
iks_parser_delete(p);
ASSERT_NOT_NULL((input = iks_find(iq, "input")));
ASSERT_NOT_NULL((cdata = iks_find_cdata(input, "grammar")));
ASSERT_STRING_EQUALS("1 DIGITS", cdata);
iks_delete(iq);
}
cddb_error_t cddb_site_set_address(cddb_site_t *site,
const char *address, unsigned int port)
{
ASSERT_NOT_NULL(site);
ASSERT_NOT_NULL(address);
FREE_NOT_NULL(site->address);
site->address = strdup(address);
if (!site->address) {
return CDDB_ERR_OUT_OF_MEMORY;
}
site->port = port;
return CDDB_ERR_OK;
}
