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 */
void
serializer_free (void)
{
lit_finalize ();
while (first_bytecode_header_p != NULL)
{
bytecode_data_header_t *header_p = first_bytecode_header_p;
first_bytecode_header_p = MEM_CP_GET_POINTER (bytecode_data_header_t, header_p->next_header_cp);
mem_heap_free_block (header_p);
}
}
void
serializer_free (void)
{
if (bytecode_data.strings_buffer)
{
mem_heap_free_block ((uint8_t *) bytecode_data.strings_buffer);
}
if (bytecode_data.lit_id_hash != null_hash)
{
lit_id_hash_table_free (bytecode_data.lit_id_hash);
}
mem_heap_free_block ((uint8_t *) bytecode_data.opcodes);
lit_finalize ();
}
void
serializer_free (void)
{
if (bytecode_data.strings_buffer)
{
mem_heap_free_block ((uint8_t *) bytecode_data.strings_buffer);
}
lit_finalize ();
while (bytecode_data.instrs_p != NULL)
{
insts_data_header_t *header_p = GET_BYTECODE_HEADER (bytecode_data.instrs_p);
bytecode_data.instrs_p = MEM_CP_GET_POINTER (vm_instr_t, header_p->next_instrs_cp);
mem_heap_free_block (header_p);
}
}
int
main (int __attr_unused___ argc,
char __attr_unused___ **argv)
{
TEST_INIT ();
const lit_utf8_byte_t *ptrs[test_sub_iters];
ecma_number_t numbers[test_sub_iters];
lit_utf8_byte_t strings[test_sub_iters][max_characters_in_string + 1];
lit_utf8_size_t lengths[test_sub_iters];
jmem_init ();
lit_init ();
for (uint32_t i = 0; i < test_iters; i++)
{
memset (numbers, 0, sizeof (ecma_number_t) * test_sub_iters);
memset (lengths, 0, sizeof (lit_utf8_size_t) * test_sub_iters);
memset (ptrs, 0, sizeof (lit_utf8_byte_t *) * test_sub_iters);
for (uint32_t j = 0; j < test_sub_iters; j++)
{
int type = rand () % 3;
if (type == 0)
{
lengths[j] = (lit_utf8_size_t) (rand () % max_characters_in_string + 1);
generate_string (strings[j], lengths[j]);
lit_create_literal_from_utf8_string (strings[j], lengths[j]);
strings[j][lengths[j]] = '\0';
ptrs[j] = strings[j];
JERRY_ASSERT (ptrs[j]);
}
else if (type == 1)
{
lit_magic_string_id_t msi = (lit_magic_string_id_t) (rand () % LIT_MAGIC_STRING__COUNT);
ptrs[j] = lit_get_magic_string_utf8 (msi);
JERRY_ASSERT (ptrs[j]);
lengths[j] = (lit_utf8_size_t) lit_zt_utf8_string_size (ptrs[j]);
lit_create_literal_from_utf8_string (ptrs[j], lengths[j]);
}
else
{
ecma_number_t num = generate_number ();
lengths[j] = ecma_number_to_utf8_string (num, strings[j], max_characters_in_string);
lit_create_literal_from_num (num);
}
}
// Add empty string
lit_create_literal_from_utf8_string (NULL, 0);
for (uint32_t j = 0; j < test_sub_iters; j++)
{
lit_literal_t lit1;
lit_literal_t lit2;
if (ptrs[j])
{
lit1 = lit_find_or_create_literal_from_utf8_string (ptrs[j], lengths[j]);
lit2 = lit_find_literal_by_utf8_string (ptrs[j], lengths[j]);
JERRY_ASSERT (compare_utf8_string_and_string_literal (ptrs[j], lengths[j], lit1));
JERRY_ASSERT (compare_utf8_string_and_string_literal (ptrs[j], lengths[j], lit2));
}
else
{
lit1 = lit_find_or_create_literal_from_num (numbers[j]);
lit2 = lit_find_literal_by_num (numbers[j]);
JERRY_ASSERT (numbers[j] == lit_number_literal_get_number (lit1));
JERRY_ASSERT (numbers[j] == lit_number_literal_get_number (lit2));
}
JERRY_ASSERT (lit1);
JERRY_ASSERT (lit2);
JERRY_ASSERT (lit1 == lit2);
}
// Check empty string exists
JERRY_ASSERT (lit_find_literal_by_utf8_string (NULL, 0));
}
lit_finalize ();
jmem_finalize (true);
return 0;
} /* main */
int
main (int __attr_unused___ argc,
char __attr_unused___ **argv)
{
TEST_INIT ();
jmem_init ();
lit_init ();
ecma_init ();
lit_utf8_byte_t cesu8_string[max_bytes_in_string];
ecma_char_t code_units[max_code_units_in_string];
const lit_utf8_byte_t *saved_positions[max_code_units_in_string];
for (int i = 0; i < test_iters; i++)
{
lit_utf8_size_t cesu8_string_size = (i == 0) ? 0 : (lit_utf8_size_t) (rand () % max_bytes_in_string);
ecma_length_t length = generate_cesu8_string (cesu8_string, cesu8_string_size);
ecma_string_t *char_collection_string_p = ecma_new_ecma_string_from_utf8 (cesu8_string, cesu8_string_size);
ecma_length_t char_collection_len = ecma_string_get_length (char_collection_string_p);
JERRY_ASSERT (char_collection_len == length);
ecma_deref_ecma_string (char_collection_string_p);
JERRY_ASSERT (lit_utf8_string_length (cesu8_string, cesu8_string_size) == length);
const lit_utf8_byte_t *curr_p = cesu8_string;
const lit_utf8_byte_t *end_p = cesu8_string + cesu8_string_size;
ecma_length_t calculated_length = 0;
ecma_length_t code_units_count = 0;
while (curr_p < end_p)
{
code_units[code_units_count] = lit_utf8_peek_next (curr_p);
saved_positions[code_units_count] = curr_p;
code_units_count++;
calculated_length++;
lit_utf8_incr (&curr_p);
}
JERRY_ASSERT (length == calculated_length);
if (code_units_count > 0)
{
for (int j = 0; j < test_subiters; j++)
{
ecma_length_t index = (ecma_length_t) rand () % code_units_count;
curr_p = saved_positions[index];
JERRY_ASSERT (lit_utf8_peek_next (curr_p) == code_units[index]);
}
}
curr_p = (lit_utf8_byte_t *) end_p;
while (curr_p > cesu8_string)
{
JERRY_ASSERT (code_units_count > 0);
calculated_length--;
JERRY_ASSERT (code_units[calculated_length] == lit_utf8_peek_prev (curr_p));
lit_utf8_decr (&curr_p);
}
JERRY_ASSERT (calculated_length == 0);
while (curr_p < end_p)
{
ecma_char_t code_unit = lit_utf8_read_next (&curr_p);
JERRY_ASSERT (code_unit == code_units[calculated_length]);
calculated_length++;
}
JERRY_ASSERT (length == calculated_length);
while (curr_p > cesu8_string)
{
JERRY_ASSERT (code_units_count > 0);
calculated_length--;
JERRY_ASSERT (code_units[calculated_length] == lit_utf8_read_prev (&curr_p));
}
JERRY_ASSERT (calculated_length == 0);
}
/* Overlong-encoded code point */
lit_utf8_byte_t invalid_cesu8_string_1[] = {0xC0, 0x82};
JERRY_ASSERT (!lit_is_cesu8_string_valid (invalid_cesu8_string_1, sizeof (invalid_cesu8_string_1)));
/* Overlong-encoded code point */
lit_utf8_byte_t invalid_cesu8_string_2[] = {0xE0, 0x80, 0x81};
JERRY_ASSERT (!lit_is_cesu8_string_valid (invalid_cesu8_string_2, sizeof (invalid_cesu8_string_2)));
/* Pair of surrogates: 0xD901 0xDFF0 which encode Unicode character 0x507F0 */
lit_utf8_byte_t invalid_cesu8_string_3[] = {0xED, 0xA4, 0x81, 0xED, 0xBF, 0xB0};
JERRY_ASSERT (lit_is_cesu8_string_valid (invalid_cesu8_string_3, sizeof (invalid_cesu8_string_3)));
/* Isolated high surrogate 0xD901 */
lit_utf8_byte_t valid_utf8_string_1[] = {0xED, 0xA4, 0x81};
JERRY_ASSERT (lit_is_cesu8_string_valid (valid_utf8_string_1, sizeof (valid_utf8_string_1)));
lit_utf8_byte_t res_buf[3];
lit_utf8_size_t res_size;
res_size = lit_code_unit_to_utf8 (0x73, res_buf);
JERRY_ASSERT (res_size == 1);
JERRY_ASSERT (res_buf[0] == 0x73);
res_size = lit_code_unit_to_utf8 (0x41A, res_buf);
JERRY_ASSERT (res_size == 2);
JERRY_ASSERT (res_buf[0] == 0xD0);
JERRY_ASSERT (res_buf[1] == 0x9A);
res_size = lit_code_unit_to_utf8 (0xD7FF, res_buf);
JERRY_ASSERT (res_size == 3);
JERRY_ASSERT (res_buf[0] == 0xED);
JERRY_ASSERT (res_buf[1] == 0x9F);
JERRY_ASSERT (res_buf[2] == 0xBF);
ecma_finalize ();
lit_finalize ();
jmem_finalize (true);
return 0;
} /* main */
int
main (int __attr_unused___ argc,
char __attr_unused___ **argv)
{
const ecma_char_t *ptrs[test_sub_iters];
ecma_number_t numbers[test_sub_iters];
ecma_char_t strings[test_sub_iters][max_characters_in_string + 1];
ecma_length_t lengths[test_sub_iters];
mem_init ();
lit_init ();
srand ((unsigned int) time (NULL));
int k = rand ();
printf ("seed=%d\n", k);
srand ((unsigned int) k);
for (uint32_t i = 0; i < test_iters; i++)
{
memset (numbers, 0, sizeof (ecma_number_t) * test_sub_iters);
memset (lengths, 0, sizeof (ecma_length_t) * test_sub_iters);
memset (ptrs, 0, sizeof (ecma_char_t *) * test_sub_iters);
for (uint32_t j = 0; j < test_sub_iters; j++)
{
int type = rand () % 3;
if (type == 0)
{
lengths[j] = (ecma_length_t) (rand () % max_characters_in_string + 1);
generate_string (strings[j], lengths[j]);
lit_create_literal_from_charset (strings[j], lengths[j]);
strings[j][lengths[j]] = '\0';
ptrs[j] = strings[j];
JERRY_ASSERT (ptrs[j]);
}
else if (type == 1)
{
ecma_magic_string_id_t msi = (ecma_magic_string_id_t) (rand () % ECMA_MAGIC_STRING__COUNT);
ptrs[j] = ecma_get_magic_string_zt (msi);
JERRY_ASSERT (ptrs[j]);
lengths[j] = (ecma_length_t) ecma_zt_string_length (ptrs[j]);
lit_create_literal_from_charset (ptrs[j], lengths[j]);
}
else
{
ecma_number_t num = generate_number ();
lengths[j] = ecma_number_to_zt_string (num, strings[j], max_characters_in_string);
lit_create_literal_from_num (num);
}
}
// Add empty string
lit_create_literal_from_charset (NULL, 0);
for (uint32_t j = 0; j < test_sub_iters; j++)
{
literal_t lit1;
literal_t lit2;
if (ptrs[j])
{
lit1 = lit_find_or_create_literal_from_charset (ptrs[j], lengths[j]);
lit2 = lit_find_literal_by_charset (ptrs[j], lengths[j]);
JERRY_ASSERT (lit_literal_equal_zt (lit1, ptrs[j]));
JERRY_ASSERT (lit_literal_equal_type_zt (lit2, ptrs[j]));
}
else
{
lit1 = lit_find_or_create_literal_from_num (numbers[j]);
lit2 = lit_find_literal_by_num (numbers[j]);
JERRY_ASSERT (lit_literal_equal_num (lit1, numbers[j]));
JERRY_ASSERT (lit_literal_equal_type_num (lit2, numbers[j]));
}
JERRY_ASSERT (lit1);
JERRY_ASSERT (lit2);
JERRY_ASSERT (lit1 == lit2);
JERRY_ASSERT (lit_literal_equal (lit1, lit2));
}
// Check empty string exists
JERRY_ASSERT (lit_find_literal_by_charset (NULL, 0));
lit_storage.cleanup ();
JERRY_ASSERT (lit_storage.get_first () == NULL);
}
lit_finalize ();
mem_finalize (true);
return 0;
}
