int
main (int __attr_unused___ argc,
char __attr_unused___ **argv)
{
TEST_INIT ();
mem_init ();
for (uint32_t i = 0; i < test_iters; i++)
{
const size_t subiters = ((size_t) rand () % test_max_sub_iters) + 1;
for (size_t j = 0; j < subiters; j++)
{
ptrs[j] = mem_pools_alloc ();
// JERRY_ASSERT (ptrs[j] != NULL);
if (ptrs[j] != NULL)
{
memset (ptrs[j], 0, MEM_POOL_CHUNK_SIZE);
}
}
// mem_heap_print (false);
for (size_t j = 0; j < subiters; j++)
{
if (ptrs[j] != NULL)
{
for (size_t k = 0; k < MEM_POOL_CHUNK_SIZE; k++)
{
JERRY_ASSERT (((uint8_t*) ptrs[j])[k] == 0);
}
mem_pools_free (ptrs[j]);
}
}
}
#ifdef MEM_STATS
mem_pools_stats_t stats;
mem_pools_get_stats (&stats);
printf ("Pools stats:\n");
printf (" Chunk size: %u\n"
" Pools: %lu\n"
" Allocated chunks: %lu\n"
" Free chunks: %lu\n"
" Peak pools: %lu\n"
" Peak allocated chunks: %lu\n\n",
MEM_POOL_CHUNK_SIZE,
stats.pools_count,
stats.allocated_chunks,
stats.free_chunks,
stats.peak_pools_count,
stats.peak_allocated_chunks);
#endif /* MEM_STATS */
return 0;
} /* main */
int
main (int __attr_unused___ argc,
char __attr_unused___ **argv)
{
TEST_INIT ();
jmem_init ();
lit_init ();
ecma_init ();
const uint8_t _1_byte_long1[] = "\\u007F";
const uint8_t _1_byte_long2[] = "\\u0000";
const uint8_t _1_byte_long3[] = "\\u0065";
const uint8_t _2_byte_long1[] = "\\u008F";
const uint8_t _2_byte_long2[] = "\\u00FF";
const uint8_t _2_byte_long3[] = "\\u07FF";
const uint8_t _3_byte_long1[] = "\\u08FF";
const uint8_t _3_byte_long2[] = "\\u0FFF";
const uint8_t _3_byte_long3[] = "\\uFFFF";
size_t length;
// test 1-byte-long unicode sequences
length = lit_char_get_utf8_length (lexer_hex_to_character (0, _1_byte_long1 + 2, 4));
JERRY_ASSERT (length == 1);
length = lit_char_get_utf8_length (lexer_hex_to_character (0, _1_byte_long2 + 2, 4));
JERRY_ASSERT (length == 1);
length = lit_char_get_utf8_length (lexer_hex_to_character (0, _1_byte_long3 + 2, 4));
JERRY_ASSERT (length == 1);
// test 2-byte-long unicode sequences
length = lit_char_get_utf8_length (lexer_hex_to_character (0, _2_byte_long1 + 2, 4));
JERRY_ASSERT (length == 2);
length = lit_char_get_utf8_length (lexer_hex_to_character (0, _2_byte_long2 + 2, 4));
JERRY_ASSERT (length == 2);
length = lit_char_get_utf8_length (lexer_hex_to_character (0, _2_byte_long3 + 2, 4));
JERRY_ASSERT (length == 2);
// test 3-byte-long unicode sequences
length = lit_char_get_utf8_length (lexer_hex_to_character (0, _3_byte_long1 + 2, 4));
JERRY_ASSERT (length != 2);
length = lit_char_get_utf8_length (lexer_hex_to_character (0, _3_byte_long2 + 2, 4));
JERRY_ASSERT (length == 3);
length = lit_char_get_utf8_length (lexer_hex_to_character (0, _3_byte_long3 + 2, 4));
JERRY_ASSERT (length == 3);
ecma_finalize ();
lit_finalize ();
jmem_finalize (true);
return 0;
} /* main */
int
Test::Main()
{
TEST_INIT("false_test");
EXPECT_TRUE(false);
TEST_DONE();
}
int
Test::Main()
{
TEST_INIT("printabletest");
testSimple();
testAsciiVariant();
TEST_DONE();
}
int main(void)
{
TEST_INIT("ewf_session");
TEST_RUN(test_session_add);
TEST_RUN(test_session_remove);
return TEST_RETURN;
}
void
test_list_move_to_last_to_first(
)
{
list_type *list;
TEST_INIT("list_move_to (last -> first)", "gtestin");
list = create_testing();
list = list_move_to(list, NULL, list);
TEST_FINISH(list);
}
int main(void)
{
TEST_INIT("request");
setup();
TEST_RUN(test_request_remove);
teardown();
return TEST_RETURN;
}
int main(void)
{
TEST_INIT("cfgstr");
TEST_RUN(test_cfgstr_init);
TEST_RUN(test_cfgstr_set);
TEST_RUN(test_cfgstr_dup);
TEST_RUN(test_cfgstr_unset);
TEST_RUN(test_cfgstr_move);
return TEST_RETURN;
}
int
main ()
{
TEST_INIT ();
for (int i = 0; i < TEST_ITERATIONS_NUM; i++)
{
test_setjmp_longjmp (0);
}
return 0;
} /* main */
int
main ()
{
TEST_INIT ();
jmem_init ();
for (uint32_t i = 0; i < test_iters; i++)
{
const size_t subiters = ((size_t) rand () % TEST_MAX_SUB_ITERS) + 1;
for (size_t j = 0; j < subiters; j++)
{
ptrs[j] = (uint8_t *) jmem_pools_alloc ();
if (ptrs[j] != NULL)
{
for (size_t k = 0; k < JMEM_POOL_CHUNK_SIZE; k++)
{
ptrs[j][k] = (uint8_t) (rand () % 256);
}
memcpy (data[j], ptrs[j], JMEM_POOL_CHUNK_SIZE);
}
}
/* jmem_heap_print (false); */
for (size_t j = 0; j < subiters; j++)
{
if (rand () % 256 == 0)
{
jmem_pools_collect_empty ();
}
if (ptrs[j] != NULL)
{
JERRY_ASSERT (!memcmp (data[j], ptrs[j], JMEM_POOL_CHUNK_SIZE));
jmem_pools_free (ptrs[j]);
}
}
}
#ifdef JMEM_STATS
jmem_pools_stats_print ();
#endif /* JMEM_STATS */
jmem_finalize (false);
return 0;
} /* main */
/**
* Unit test's main function.
*/
int
main (int __attr_unused___ argc,
char __attr_unused___ **argv)
{
TEST_INIT ();
const bytecode_data_header_t *bytecode_data_p;
jsp_status_t parse_status;
mem_init ();
// #1
char program1[] = "a=1;var a;";
serializer_init ();
parser_set_show_instrs (true);
parse_status = parser_parse_script ((jerry_api_char_t *) program1, strlen (program1), &bytecode_data_p);
JERRY_ASSERT (parse_status == JSP_STATUS_OK && bytecode_data_p != NULL);
vm_instr_t instrs[] =
{
getop_meta (OPCODE_META_TYPE_SCOPE_CODE_FLAGS, // [ ]
OPCODE_SCOPE_CODE_FLAGS_NOT_REF_ARGUMENTS_IDENTIFIER
| OPCODE_SCOPE_CODE_FLAGS_NOT_REF_EVAL_IDENTIFIER,
VM_IDX_EMPTY),
getop_reg_var_decl (VM_REG_FIRST, VM_REG_GENERAL_FIRST, 0),
getop_var_decl (0), // var a;
getop_assignment (130, 1, 1), // $tmp0 = 1;
getop_assignment (0, 6, 130), // a = $tmp0;
getop_ret () // return;
};
JERRY_ASSERT (instrs_equal (bytecode_data_p->instrs_p, instrs, 5));
serializer_free ();
// #2
char program2[] = "var var;";
serializer_init ();
parser_set_show_instrs (true);
parse_status = parser_parse_script ((jerry_api_char_t *) program2, strlen (program2), &bytecode_data_p);
JERRY_ASSERT (parse_status == JSP_STATUS_SYNTAX_ERROR && bytecode_data_p == NULL);
serializer_free ();
mem_finalize (false);
return 0;
} /* main */
void
test_list_move_to_last_from(
)
{
list_type *list;
list_type *ptr;
TEST_INIT("list_move_to (last ->)", "tegstin");
list = create_testing();
ptr = list_find(list, (void *) 's');
list = list_move_to(list, NULL, ptr);
TEST_FINISH(list);
}
int
main (int __attr_unused___ argc,
char __attr_unused___ **argv)
{
TEST_INIT ();
for (int i = 0; i < TEST_ITERATIONS_NUM; i++)
{
test_setjmp_longjmp (0);
}
return 0;
} /* main */
int
Test::Main()
{
TEST_INIT("generationhandler_test");
TEST_DO(requireThatGenerationCanBeIncreased());
TEST_DO(requireThatReadersCanTakeGuards());
TEST_DO(requireThatGuardsCanBeCopied());
TEST_DO(requireThatTheFirstUsedGenerationIsCorrect());
TEST_DO(requireThatGenerationCanGrowLarge());
TEST_DONE();
}
void
test_list_move_to_first_from(
)
{
list_type *list;
list_type *ptr;
TEST_INIT("list_move_to (first ->)", "estitng");
list = create_testing();
ptr = list_find(list, (void *) 'n');
list =llist_move_to(list, list, ptr);
TEST_FINISH(list);
}
void
test_list_move_to_first_to(
)
{
list_type *list;
list_type *ptr;
TEST_INIT("list_move_to (-> first)", "ntestig");
list = create_testing();
ptr = list_find(list, (void *) 'n');
list = list_move_to(list, ptr, list);
TEST_FINISH(list);
}
void
test_list_move_to_last_to(
)
{
list_type *list;
list_type *ptr;
TEST_INIT("list_move_to (-> last)", "testign");
list = create_testing();
ptr = list_find(list, (void *) 'n');
list = list_move_to(list, ptr, NULL);
TEST_FINISH(list);
}
void
test_list_insert_at_last(
)
{
list_type *list;
TEST_INIT("list_insert_at (first)", "testingXXX");
list = create_testing();
list = list_insert_at(list, NULL, (void *) 'X');
list = list_insert_at(list, NULL, (void *) 'X');
list = list_insert_at(list, NULL, (void *) 'X');
TEST_FINISH(list);
}
void
test_list_insert_at_first(
)
{
list_type *list;
TEST_INIT("list_insert_at (first)", "XXXtesting");
list = create_testing();
list = list_insert_at(list, list, (void *) 'X');
list = list_insert_at(list, list, (void *) 'X');
list = list_insert_at(list, list, (void *) 'X');
TEST_FINISH(list);
}
void
test_list_delete_last(
)
{
list_type *list;
TEST_INIT("list_delete (last)", "test");
list = create_testing();
list = list_delete(list, list->last);
list = list_delete(list, list->last);
list = list_delete(list, list->last);
TEST_FINISH(list);
}
void
test_list_delete_first(
)
{
list_type *list;
TEST_INIT("list_delete (first)", "ting");
list = create_testing();
list = list_delete(list, list);
list = list_delete(list, list);
list = list_delete(list, list);
TEST_FINISH(list);
}
void
test_list_move_to_middle(
)
{
list_type *list;
list_type *ptr0, *ptr1;
TEST_INIT("list_move_to (middle)", "tenstig");
list = create_testing();
ptr0 = list_find(list, (void *) 'n');
ptr1 = list_find(list, (void *) 's');
list = list_move_to(list, ptr0, ptr1);
TEST_FINISH(list);
}
int main(void) {
TEST_INIT();
TEST_RUN(bxmlparser_1);
TEST_RUN(bxmlparser_2);
TEST_RUN(bxmlparser_3);
TEST_RUN(bxmlparser_4);
TEST_RUN(bxmlparser_5);
TEST_RUN(bxmlparser_6);
TEST_RUN(bxmlparser_7);
TEST_RUN(bxmlparser_fn_1);
TEST_REPORT();
}
void
test_list_move_first_to_first(
)
{
list_type *list;
TEST_INIT("list_move_first_to (first)", "testing");
list = create_testing();
list = list_move_first_to(list, list);
list = list_move_first_to(list, list);
list = list_move_first_to(list, list);
TEST_FINISH(list);
}
int
Test::Main()
{
TEST_INIT("programoptions_test");
srandom(1);
testSyntaxPage();
testNormalUsage();
testFailures();
testVectorArgument();
testAllHiddenOption();
// Currently not supported
// testOptionsAfterArguments();
TEST_DONE();
}
int
main ()
{
TEST_INIT ();
jmem_heap_init ();
jmem_register_free_unused_memory_callback (test_heap_give_some_memory_back);
#ifdef JMEM_STATS
jmem_heap_stats_print ();
#endif /* JMEM_STATS */
for (uint32_t i = 0; i < test_iters; i++)
{
for (uint32_t j = 0; j < test_sub_iters; j++)
{
size_t size = (size_t) rand () % test_threshold_block_size;
ptrs[j] = (uint8_t *) jmem_heap_alloc_block (size);
sizes[j] = size;
TEST_ASSERT (sizes[j] == 0 || ptrs[j] != NULL);
memset (ptrs[j], 0, sizes[j]);
}
/* jmem_heap_print (true); */
for (uint32_t j = 0; j < test_sub_iters; j++)
{
if (ptrs[j] != NULL)
{
for (size_t k = 0; k < sizes[j]; k++)
{
TEST_ASSERT (ptrs[j][k] == 0);
}
jmem_heap_free_block (ptrs[j], sizes[j]);
ptrs[j] = NULL;
}
}
}
#ifdef JMEM_STATS
jmem_heap_stats_print ();
#endif /* JMEM_STATS */
return 0;
} /* main */
int main(void) {
Buf buf;
Buf * cont;
Mixin * mix;
TEST_INIT();
printf("Offsetof mix1: %u\n", offsetof(Buf, Mixin));
cont = container_of((buf.Mixin), Buf, Mixin);
mix = mixin_of(&buf, Mixin);
//cont = (Buf*)(((char *)&buf.mix1) - offsetof(Buf, mix1));
printf("&buf, cont, mix: %p %p %p %d\n", &buf, cont, mix, cont == &buf);
puts(SI_OS);
TEST_RUN(siwire_new);
TEST_RUN(siwire_const);
TEST_RUN(siwire_dup);
TEST_REPORT();
}
void
test_list_delete_middle(
)
{
list_type *list;
list_type *ptr;
TEST_INIT("list_delete (middle)", "tstg");
list = create_testing();
ptr = list_find(list, (void *) 'i');
list = list_delete(list, ptr);
ptr = list_find(list, (void *) 'e');
list = list_delete(list, ptr);
ptr = list_find(list, (void *) 'n');
list = list_delete(list, ptr);
TEST_FINISH(list);
}
void
test_list_add_head(
)
{
list_type *list;
TEST_INIT("list_add_head", "testing");
list = NULL;
list = list_add_head(list, (void *) 'g'); DUMP_POINTERS(list);
list = list_add_head(list, (void *) 'n'); DUMP_POINTERS(list);
list = list_add_head(list, (void *) 'i'); DUMP_POINTERS(list);
list = list_add_head(list, (void *) 't'); DUMP_POINTERS(list);
list = list_add_head(list, (void *) 's'); DUMP_POINTERS(list);
list = list_add_head(list, (void *) 'e'); DUMP_POINTERS(list);
list = list_add_head(list, (void *) 't'); DUMP_POINTERS(list);
TEST_FINISH(list);
}
void
test_list_insert_at_middle(
)
{
list_type *list;
list_type *ptr;
TEST_INIT("list_insert_at (middle)", "teXstXiXng");
list = create_testing();
ptr = list_find(list, (void *) 'i');
list = list_insert_at(list, ptr, (void *) 'X');
ptr = list_find(list, (void *) 's');
list = list_insert_at(list, ptr, (void *) 'X');
ptr = list_find(list, (void *) 'n');
list = list_insert_at(list, ptr, (void *) 'X');
TEST_FINISH(list);
}
