YourWishes/jerryscript
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Re-thinking the build system to bring it more into line with the conventions.

Browse Source 
We removed that implementation where the build directory isn't set up to build with exactly one
configuration of the project but potentially several variants: the same build directory
can/must be used for debug and release builds, for full or compact profile versions, etc.
So we reworked the CMakeLists, and now one build dir deal with exactly one configuration
of the project's libraries and tools.

JerryScript-DCO-1.0-Signed-off-by: Zsolt Borbély zsborbely.u-szeged@partner.samsung.com
JerryScript-DCO-1.0-Signed-off-by: Robert Sipka rsipka.uszeged@partner.samsung.com
This commit is contained in:
Robert Sipka
2016-07-27 09:48:10 +02:00
parent 778f3c001e
commit ddab1d8152
48 changed files with 1107 additions and 1927 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/unit/CMakeLists.txt
+54
View File
@@ -0,0 +1,54 @@
# Copyright 2016 Samsung Electronics Co., Ltd.
# Copyright 2016 University of Szeged.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
cmake_minimum_required (VERSION 2.8.12)
project (Unittest C)
if(NOT FEATURE_PROFILE STREQUAL "full")
message(FATAL_ERROR "FEATURE_PROFILE='${FEATURE_PROFILE}' doesn't supported with UNITTESTS=ON option")
endif()
# Unit tests main modules
file(GLOB SOURCE_UNIT_TEST_MAIN_MODULES *.c)
# Unit tests declaration
add_custom_target(unittests)
foreach(SOURCE_UNIT_TEST_MAIN ${SOURCE_UNIT_TEST_MAIN_MODULES})
get_filename_component(TARGET_NAME ${SOURCE_UNIT_TEST_MAIN} NAME_WE)
set(TARGET_NAME unit-${TARGET_NAME})
add_executable(${TARGET_NAME} ${SOURCE_UNIT_TEST_MAIN})
set_property(TARGET ${TARGET_NAME}
PROPERTY LINK_FLAGS "${LINKER_FLAGS_COMMON}")
link_directories(${CMAKE_BINARY_DIR})
set(JERRY_LIBS jerry-core)
if(JERRY_LIBM)
set(JERRY_LIBS ${JERRY_LIBS} jerry-libm)
endif()
if(JERRY_LIBC)
set(JERRY_LIBS ${JERRY_LIBS} jerry-libc)
endif()
set(JERRY_LIBS ${JERRY_LIBS} ${IMPORTED_LIB})
target_link_libraries(${TARGET_NAME} ${JERRY_LIBS})
add_dependencies(unittests ${TARGET_NAME})
endforeach()
tests/unit/test-api.c
+25 -23
View File
@@ -73,7 +73,7 @@ handler (const jerry_value_t func_obj_val, /**< function object */
printf ("ok %d %d %p %d\n", func_obj_val, this_val, args_p, args_cnt);
JERRY_ASSERT (args_cnt == 2);
TEST_ASSERT (args_cnt == 2);
JERRY_ASSERT (jerry_value_is_string (args_p[0]));
sz = jerry_get_string_size (args_p[0]);
@@ -81,10 +81,10 @@ handler (const jerry_value_t func_obj_val, /**< function object */
sz = jerry_string_to_char_buffer (args_p[0],
(jerry_char_t *) buffer,
sz);
JERRY_ASSERT (sz == 1);
JERRY_ASSERT (!strncmp (buffer, "1", (size_t) sz));
TEST_ASSERT (sz == 1);
TEST_ASSERT (!strncmp (buffer, "1", (size_t) sz));
JERRY_ASSERT (jerry_value_is_boolean (args_p[1]));
TEST_ASSERT (jerry_value_is_boolean (args_p[1]));
return jerry_create_string ((jerry_char_t *) "string from handler");
} /* handler */
@@ -103,7 +103,7 @@ handler_throw_test (const jerry_value_t func_obj_val, /**< function object */
static void
handler_construct_freecb (uintptr_t native_p)
{
JERRY_ASSERT (native_p == (uintptr_t) 0x0012345678abcdefull);
TEST_ASSERT (native_p == (uintptr_t) 0x0012345678abcdefull);
printf ("ok object free callback\n");
test_api_is_free_callback_was_called = true;
@@ -117,11 +117,11 @@ handler_construct (const jerry_value_t func_obj_val, /**< function object */
{
printf ("ok construct %d %d %p %d\n", func_obj_val, this_val, args_p, args_cnt);
JERRY_ASSERT (jerry_value_is_object (this_val));
TEST_ASSERT (jerry_value_is_object (this_val));
JERRY_ASSERT (args_cnt == 1);
JERRY_ASSERT (jerry_value_is_boolean (args_p[0]));
JERRY_ASSERT (jerry_get_boolean_value (args_p[0]) == true);
TEST_ASSERT (args_cnt == 1);
TEST_ASSERT (jerry_value_is_boolean (args_p[0]));
TEST_ASSERT (jerry_get_boolean_value (args_p[0]) == true);
jerry_value_t field_name = jerry_create_string ((jerry_char_t *) "value_field");
jerry_set_property (this_val, field_name, args_p[0]);
@@ -131,7 +131,7 @@ handler_construct (const jerry_value_t func_obj_val, /**< function object */
(uintptr_t) 0x0000000000000000ull,
handler_construct_freecb);
uintptr_t ptr;
uintptr_t ptr = (uintptr_t) NULL;
bool is_ok = jerry_get_object_native_handle (this_val, &ptr);
JERRY_ASSERT (is_ok && ptr == (uintptr_t) 0x0000000000000000ull);
@@ -226,6 +226,8 @@ foreach (const jerry_value_t name, /**< field name */
JERRY_ASSERT (false);
return false;
} /* foreach */
static bool
@@ -241,7 +243,7 @@ foreach_exception (const jerry_value_t name, /**< field name */
if (!strncmp (str_buf_p, "foxtrot", (size_t) sz))
{
JERRY_ASSERT (false);
TEST_ASSERT (false);
}
return true;
@@ -389,7 +391,7 @@ main (void)
sz = jerry_string_to_char_buffer (res, (jerry_char_t *) buffer, sz);
JERRY_ASSERT (sz == 4);
jerry_release_value (res);
JERRY_ASSERT (!strncmp (buffer, "abcd", (size_t) sz));
TEST_ASSERT (!strncmp (buffer, "abcd", (size_t) sz));
jerry_release_value (args[0]);
jerry_release_value (args[1]);
@@ -482,7 +484,7 @@ main (void)
sz = jerry_string_to_char_buffer (res, (jerry_char_t *) buffer, sz);
JERRY_ASSERT (sz == 19);
jerry_release_value (res);
JERRY_ASSERT (!strncmp (buffer, "string from handler", (size_t) sz));
TEST_ASSERT (!strncmp (buffer, "string from handler", (size_t) sz));
// Create native handler bound function object and set it to 'external_construct' variable
external_construct_val = jerry_create_external_function (handler_construct);
@@ -508,7 +510,7 @@ main (void)
jerry_release_value (val_value_field);
jerry_release_value (external_construct_val);
uintptr_t ptr;
uintptr_t ptr = (uintptr_t) NULL;
is_ok = jerry_get_object_native_handle (res, &ptr);
JERRY_ASSERT (is_ok
&& ptr == (uintptr_t) 0x0012345678abcdefull);
@@ -545,7 +547,7 @@ main (void)
jerry_release_value (val_t);
// 'res' should contain exception object
JERRY_ASSERT (jerry_value_is_object (res));
TEST_ASSERT (jerry_value_is_object (res));
jerry_release_value (res);
// Test: Call of non-function
@@ -554,7 +556,7 @@ main (void)
JERRY_ASSERT (jerry_value_has_error_flag (res));
// 'res' should contain exception object
JERRY_ASSERT (jerry_value_is_object (res));
TEST_ASSERT (jerry_value_is_object (res));
jerry_release_value (res);
jerry_release_value (obj_val);
@@ -569,7 +571,7 @@ main (void)
jerry_release_value (val_t);
// 'res' should contain exception object
JERRY_ASSERT (jerry_value_is_object (res));
TEST_ASSERT (jerry_value_is_object (res));
jerry_release_value (res);
// Test: Call of non-function as constructor
@@ -578,7 +580,7 @@ main (void)
JERRY_ASSERT (jerry_value_has_error_flag (res));
// 'res' should contain exception object
JERRY_ASSERT (jerry_value_is_object (res));
TEST_ASSERT (jerry_value_is_object (res));
jerry_release_value (res);
jerry_release_value (obj_val);
@@ -592,7 +594,7 @@ main (void)
jerry_set_property_by_index (array_obj_val, 5, v_in);
jerry_value_t v_out = jerry_get_property_by_index (array_obj_val, 5);
JERRY_ASSERT (jerry_value_is_number (v_out)
TEST_ASSERT (jerry_value_is_number (v_out)
&& jerry_get_number_value (v_out) == 10.5);
jerry_release_value (v_in);
@@ -703,7 +705,7 @@ main (void)
jerry_cleanup ();
JERRY_ASSERT (test_api_is_free_callback_was_called);
TEST_ASSERT (test_api_is_free_callback_was_called);
// External Magic String
jerry_init (JERRY_INIT_SHOW_OPCODES);
@@ -739,7 +741,7 @@ main (void)
false,
global_mode_snapshot_buffer,
sizeof (global_mode_snapshot_buffer));
JERRY_ASSERT (global_mode_snapshot_size != 0);
TEST_ASSERT (global_mode_snapshot_size != 0);
jerry_cleanup ();
jerry_init (JERRY_INIT_SHOW_OPCODES);
@@ -749,7 +751,7 @@ main (void)
false,
eval_mode_snapshot_buffer,
sizeof (eval_mode_snapshot_buffer));
JERRY_ASSERT (eval_mode_snapshot_size != 0);
TEST_ASSERT (eval_mode_snapshot_size != 0);
jerry_cleanup ();
jerry_init (JERRY_INIT_SHOW_OPCODES);
@@ -778,7 +780,7 @@ main (void)
sz = jerry_string_to_char_buffer (res, (jerry_char_t *) buffer, sz);
JERRY_ASSERT (sz == 20);
jerry_release_value (res);
JERRY_ASSERT (!strncmp (buffer, "string from snapshot", (size_t) sz));
TEST_ASSERT (!strncmp (buffer, "string from snapshot", (size_t) sz));
jerry_cleanup ();
}
tests/unit/test-common.h
+2 -6
View File
@@ -25,12 +25,8 @@
#include <stdarg.h>
#include <string.h>
/**
* Verify that unit tests are built with enabled debug check
*/
#ifdef JERRY_NDEBUG
# error "defined (JERRY_NDEBUG) in a unit test"
#endif /* JERRY_NDEBUG */
#define TEST_ASSERT(x) do { if (__builtin_expect (!(x), 0)) { \
jerry_assert_fail (#x, __FILE__, __func__, __LINE__); } } while (0)
/**
* Test initialization statement that should be included
tests/unit/test-date-helpers.c
+63 -63
View File
@@ -36,53 +36,53 @@ main ()
{
/* int ecma_date_day (time)*/
JERRY_ASSERT (ecma_date_day (0) == 0);
JERRY_ASSERT (ecma_date_day (MS_PER_DAY) == 1);
TEST_ASSERT (ecma_date_day (0) == 0);
TEST_ASSERT (ecma_date_day (MS_PER_DAY) == 1);
/* ecma_number_t ecma_date_time_within_day (time) */
JERRY_ASSERT (ecma_date_time_within_day (0) == 0);
JERRY_ASSERT (ecma_date_time_within_day (42) == 42);
JERRY_ASSERT (ecma_date_time_within_day (42.51) == 42.51);
JERRY_ASSERT (ecma_date_time_within_day (MS_PER_DAY + 42) == 42);
TEST_ASSERT (ecma_date_time_within_day (0) == 0);
TEST_ASSERT (ecma_date_time_within_day (42) == 42);
TEST_ASSERT (ecma_date_time_within_day (42.51) == 42.51);
TEST_ASSERT (ecma_date_time_within_day (MS_PER_DAY + 42) == 42);
/* int ecma_date_days_in_year (year) */
JERRY_ASSERT (ecma_date_days_in_year (0) == 366);
JERRY_ASSERT (ecma_date_days_in_year (1600) == 366);
JERRY_ASSERT (ecma_date_days_in_year (1603) == 365);
JERRY_ASSERT (ecma_date_days_in_year (1900) == 365);
JERRY_ASSERT (ecma_date_days_in_year (1970) == 365);
JERRY_ASSERT (ecma_date_days_in_year (2000) == 366);
JERRY_ASSERT (ecma_date_days_in_year (2000.45) == 366);
JERRY_ASSERT (ecma_date_days_in_year (2012) == 366);
JERRY_ASSERT (ecma_date_days_in_year (2015) == 365);
JERRY_ASSERT (ecma_date_days_in_year (285616 + 1970) == 365);
JERRY_ASSERT (ecma_date_days_in_year (-1970) == 365);
TEST_ASSERT (ecma_date_days_in_year (0) == 366);
TEST_ASSERT (ecma_date_days_in_year (1600) == 366);
TEST_ASSERT (ecma_date_days_in_year (1603) == 365);
TEST_ASSERT (ecma_date_days_in_year (1900) == 365);
TEST_ASSERT (ecma_date_days_in_year (1970) == 365);
TEST_ASSERT (ecma_date_days_in_year (2000) == 366);
TEST_ASSERT (ecma_date_days_in_year (2000.45) == 366);
TEST_ASSERT (ecma_date_days_in_year (2012) == 366);
TEST_ASSERT (ecma_date_days_in_year (2015) == 365);
TEST_ASSERT (ecma_date_days_in_year (285616 + 1970) == 365);
TEST_ASSERT (ecma_date_days_in_year (-1970) == 365);
/* int ecma_date_day_from_year (year) */
JERRY_ASSERT (ecma_date_day_from_year (1969) == -365);
JERRY_ASSERT (ecma_date_day_from_year (1970) == 0);
JERRY_ASSERT (ecma_date_day_from_year (1971) == 365);
JERRY_ASSERT (ecma_date_day_from_year (2000) == 10957);
TEST_ASSERT (ecma_date_day_from_year (1969) == -365);
TEST_ASSERT (ecma_date_day_from_year (1970) == 0);
TEST_ASSERT (ecma_date_day_from_year (1971) == 365);
TEST_ASSERT (ecma_date_day_from_year (2000) == 10957);
/* int ecma_date_year_from_time (time) */
JERRY_ASSERT (ecma_date_year_from_time (0) == 1970);
JERRY_ASSERT (ecma_date_year_from_time (0) == 1970);
JERRY_ASSERT (ecma_date_year_from_time (MS_PER_DAY) == 1970);
JERRY_ASSERT (ecma_date_year_from_time ((MS_PER_DAY) * (ecma_number_t) 365 - 1) == 1970);
JERRY_ASSERT (ecma_date_year_from_time (MS_PER_DAY * (ecma_number_t) 365) == 1971);
JERRY_ASSERT (ecma_date_year_from_time (MS_PER_DAY * (ecma_number_t) (365 * (2015 - 1970)))
TEST_ASSERT (ecma_date_year_from_time (0) == 1970);
TEST_ASSERT (ecma_date_year_from_time (0) == 1970);
TEST_ASSERT (ecma_date_year_from_time (MS_PER_DAY) == 1970);
TEST_ASSERT (ecma_date_year_from_time ((MS_PER_DAY) * (ecma_number_t) 365 - 1) == 1970);
TEST_ASSERT (ecma_date_year_from_time (MS_PER_DAY * (ecma_number_t) 365) == 1971);
TEST_ASSERT (ecma_date_year_from_time (MS_PER_DAY * (ecma_number_t) (365 * (2015 - 1970)))
== 2014);
JERRY_ASSERT (ecma_date_year_from_time (MS_PER_DAY * (ecma_number_t) (365.25 * (2015 - 1970)))
TEST_ASSERT (ecma_date_year_from_time (MS_PER_DAY * (ecma_number_t) (365.25 * (2015 - 1970)))
== 2015);
JERRY_ASSERT (ecma_date_year_from_time (-MS_PER_YEAR) == 1969);
JERRY_ASSERT (ecma_date_year_from_time (-1970 * MS_PER_YEAR) == 1);
JERRY_ASSERT (ecma_date_year_from_time (START_OF_GREGORIAN_CALENDAR) == 0);
JERRY_ASSERT (ecma_date_year_from_time (START_OF_GREGORIAN_CALENDAR - 1) == -1);
JERRY_ASSERT (ecma_date_year_from_time (START_OF_GREGORIAN_CALENDAR - 3 * MS_PER_YEAR) == -3);
TEST_ASSERT (ecma_date_year_from_time (-MS_PER_YEAR) == 1969);
TEST_ASSERT (ecma_date_year_from_time (-1970 * MS_PER_YEAR) == 1);
TEST_ASSERT (ecma_date_year_from_time (START_OF_GREGORIAN_CALENDAR) == 0);
TEST_ASSERT (ecma_date_year_from_time (START_OF_GREGORIAN_CALENDAR - 1) == -1);
TEST_ASSERT (ecma_date_year_from_time (START_OF_GREGORIAN_CALENDAR - 3 * MS_PER_YEAR) == -3);
/* int ecma_date_day_within_year (time) */
@@ -90,17 +90,17 @@ main ()
/* int ecma_date_month_from_time (time) */
JERRY_ASSERT (ecma_date_month_from_time (START_OF_GREGORIAN_CALENDAR) == 0);
JERRY_ASSERT (ecma_date_month_from_time (0) == 0);
JERRY_ASSERT (ecma_date_month_from_time (-MS_PER_DAY) == 11);
JERRY_ASSERT (ecma_date_month_from_time (31 * MS_PER_DAY) == 1);
TEST_ASSERT (ecma_date_month_from_time (START_OF_GREGORIAN_CALENDAR) == 0);
TEST_ASSERT (ecma_date_month_from_time (0) == 0);
TEST_ASSERT (ecma_date_month_from_time (-MS_PER_DAY) == 11);
TEST_ASSERT (ecma_date_month_from_time (31 * MS_PER_DAY) == 1);
/* int ecma_date_date_from_time (time) */
JERRY_ASSERT (ecma_date_date_from_time (START_OF_GREGORIAN_CALENDAR) == 1);
JERRY_ASSERT (ecma_date_date_from_time (0) == 1);
JERRY_ASSERT (ecma_date_date_from_time (-MS_PER_DAY) == 31);
JERRY_ASSERT (ecma_date_date_from_time (31 * MS_PER_DAY) == 1);
TEST_ASSERT (ecma_date_date_from_time (START_OF_GREGORIAN_CALENDAR) == 1);
TEST_ASSERT (ecma_date_date_from_time (0) == 1);
TEST_ASSERT (ecma_date_date_from_time (-MS_PER_DAY) == 31);
TEST_ASSERT (ecma_date_date_from_time (31 * MS_PER_DAY) == 1);
/* int ecma_date_week_day (ecma_number_t time) */
@@ -124,31 +124,31 @@ main ()
/* ecma_number_t ecma_date_hour_from_time (time) */
JERRY_ASSERT (ecma_date_hour_from_time (START_OF_GREGORIAN_CALENDAR) == 0);
JERRY_ASSERT (ecma_date_hour_from_time (0) == 0);
JERRY_ASSERT (ecma_date_hour_from_time (-MS_PER_DAY) == 0);
JERRY_ASSERT (ecma_date_hour_from_time (-1) == 23);
TEST_ASSERT (ecma_date_hour_from_time (START_OF_GREGORIAN_CALENDAR) == 0);
TEST_ASSERT (ecma_date_hour_from_time (0) == 0);
TEST_ASSERT (ecma_date_hour_from_time (-MS_PER_DAY) == 0);
TEST_ASSERT (ecma_date_hour_from_time (-1) == 23);
/* ecma_number_t ecma_date_min_from_time (time) */
JERRY_ASSERT (ecma_date_min_from_time (START_OF_GREGORIAN_CALENDAR) == 0);
JERRY_ASSERT (ecma_date_min_from_time (0) == 0);
JERRY_ASSERT (ecma_date_min_from_time (-MS_PER_DAY) == 0);
JERRY_ASSERT (ecma_date_min_from_time (-1) == 59);
TEST_ASSERT (ecma_date_min_from_time (START_OF_GREGORIAN_CALENDAR) == 0);
TEST_ASSERT (ecma_date_min_from_time (0) == 0);
TEST_ASSERT (ecma_date_min_from_time (-MS_PER_DAY) == 0);
TEST_ASSERT (ecma_date_min_from_time (-1) == 59);
/* ecma_number_t ecma_date_sec_from_time (time) */
JERRY_ASSERT (ecma_date_sec_from_time (START_OF_GREGORIAN_CALENDAR) == 0);
JERRY_ASSERT (ecma_date_sec_from_time (0) == 0);
JERRY_ASSERT (ecma_date_sec_from_time (-MS_PER_DAY) == 0);
JERRY_ASSERT (ecma_date_sec_from_time (-1) == 59);
TEST_ASSERT (ecma_date_sec_from_time (START_OF_GREGORIAN_CALENDAR) == 0);
TEST_ASSERT (ecma_date_sec_from_time (0) == 0);
TEST_ASSERT (ecma_date_sec_from_time (-MS_PER_DAY) == 0);
TEST_ASSERT (ecma_date_sec_from_time (-1) == 59);
/* ecma_number_t ecma_date_ms_from_time (time) */
JERRY_ASSERT (ecma_date_ms_from_time (START_OF_GREGORIAN_CALENDAR) == 0);
JERRY_ASSERT (ecma_date_ms_from_time (0) == 0);
JERRY_ASSERT (ecma_date_ms_from_time (-MS_PER_DAY) == 0);
JERRY_ASSERT (ecma_date_ms_from_time (-1) == 999);
TEST_ASSERT (ecma_date_ms_from_time (START_OF_GREGORIAN_CALENDAR) == 0);
TEST_ASSERT (ecma_date_ms_from_time (0) == 0);
TEST_ASSERT (ecma_date_ms_from_time (-MS_PER_DAY) == 0);
TEST_ASSERT (ecma_date_ms_from_time (-1) == 999);
/* ecma_number_t ecma_date_make_time (hour, min, sec, ms) */
@@ -156,12 +156,12 @@ main ()
/* ecma_number_t ecma_date_make_day (year, month, date) */
JERRY_ASSERT (ecma_date_make_day (1970, 0, 1) == 0);
JERRY_ASSERT (ecma_date_make_day (1970, -1, 1) == -31);
JERRY_ASSERT (ecma_date_make_day (1970, 0, 2.5) == 1);
JERRY_ASSERT (ecma_date_make_day (1970, 1, 35) == 65);
JERRY_ASSERT (ecma_date_make_day (1970, 13, 35) == 430);
JERRY_ASSERT (ecma_date_make_day (2016, 2, 1) == 16861);
TEST_ASSERT (ecma_date_make_day (1970, 0, 1) == 0);
TEST_ASSERT (ecma_date_make_day (1970, -1, 1) == -31);
TEST_ASSERT (ecma_date_make_day (1970, 0, 2.5) == 1);
TEST_ASSERT (ecma_date_make_day (1970, 1, 35) == 65);
TEST_ASSERT (ecma_date_make_day (1970, 13, 35) == 430);
TEST_ASSERT (ecma_date_make_day (2016, 2, 1) == 16861);
/* ecma_number_t ecma_date_make_date (day, time) */
tests/unit/test-heap.c
+4 -4
View File
@@ -45,7 +45,7 @@ test_heap_give_some_memory_back (jmem_free_unused_memory_severity_t severity)
}
else
{
JERRY_ASSERT (severity == JMEM_FREE_UNUSED_MEMORY_SEVERITY_HIGH);
TEST_ASSERT (severity == JMEM_FREE_UNUSED_MEMORY_SEVERITY_HIGH);
p = 1;
}
@@ -58,7 +58,7 @@ test_heap_give_some_memory_back (jmem_free_unused_memory_severity_t severity)
{
for (size_t k = 0; k < sizes[i]; k++)
{
JERRY_ASSERT (ptrs[i][k] == 0);
TEST_ASSERT (ptrs[i][k] == 0);
}
jmem_heap_free_block_size_stored (ptrs[i]);
@@ -89,7 +89,7 @@ main ()
ptrs[j] = (uint8_t *) jmem_heap_alloc_block_store_size (size);
sizes[j] = size;
JERRY_ASSERT (sizes[j] == 0 || ptrs[j] != NULL);
TEST_ASSERT (sizes[j] == 0 || ptrs[j] != NULL);
memset (ptrs[j], 0, sizes[j]);
}
@@ -101,7 +101,7 @@ main ()
{
for (size_t k = 0; k < sizes[j]; k++)
{
JERRY_ASSERT (ptrs[j][k] == 0);
TEST_ASSERT (ptrs[j][k] == 0);
}
jmem_heap_free_block_size_stored (ptrs[j]);
tests/unit/test-lit-char-helpers.c
+9 -9
View File
@@ -45,33 +45,33 @@ main ()
// 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);
TEST_ASSERT (length == 1);
length = lit_char_get_utf8_length (lexer_hex_to_character (0, _1_byte_long2 + 2, 4));
JERRY_ASSERT (length == 1);
TEST_ASSERT (length == 1);
length = lit_char_get_utf8_length (lexer_hex_to_character (0, _1_byte_long3 + 2, 4));
JERRY_ASSERT (length == 1);
TEST_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);
TEST_ASSERT (length == 2);
length = lit_char_get_utf8_length (lexer_hex_to_character (0, _2_byte_long2 + 2, 4));
JERRY_ASSERT (length == 2);
TEST_ASSERT (length == 2);
length = lit_char_get_utf8_length (lexer_hex_to_character (0, _2_byte_long3 + 2, 4));
JERRY_ASSERT (length == 2);
TEST_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);
TEST_ASSERT (length != 2);
length = lit_char_get_utf8_length (lexer_hex_to_character (0, _3_byte_long2 + 2, 4));
JERRY_ASSERT (length == 3);
TEST_ASSERT (length == 3);
length = lit_char_get_utf8_length (lexer_hex_to_character (0, _3_byte_long3 + 2, 4));
JERRY_ASSERT (length == 3);
TEST_ASSERT (length == 3);
ecma_finalize ();
jmem_finalize (true);
tests/unit/test-literal-storage.c
+8 -8
View File
@@ -83,13 +83,13 @@ main ()
ecma_find_or_create_literal_string (strings[j], lengths[j]);
strings[j][lengths[j]] = '\0';
ptrs[j] = strings[j];
JERRY_ASSERT (ptrs[j]);
TEST_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]);
TEST_ASSERT (ptrs[j]);
lengths[j] = (lit_utf8_size_t) lit_zt_utf8_string_size (ptrs[j]);
ecma_find_or_create_literal_string (ptrs[j], lengths[j]);
}
@@ -112,21 +112,21 @@ main ()
{
lit1 = ecma_find_or_create_literal_string (ptrs[j], lengths[j]);
lit2 = ecma_find_or_create_literal_string (ptrs[j], lengths[j]);
JERRY_ASSERT (lit1 == lit2);
TEST_ASSERT (lit1 == lit2);
}
else
{
lit1 = ecma_find_or_create_literal_number (numbers[j]);
lit2 = ecma_find_or_create_literal_number (numbers[j]);
JERRY_ASSERT (lit1 == lit2);
TEST_ASSERT (lit1 == lit2);
}
JERRY_ASSERT (lit1);
JERRY_ASSERT (lit2);
JERRY_ASSERT (lit1 == lit2);
TEST_ASSERT (lit1);
TEST_ASSERT (lit2);
TEST_ASSERT (lit1 == lit2);
}
// Check empty string exists
JERRY_ASSERT (ecma_find_or_create_literal_string (NULL, 0) != JMEM_CP_NULL);
TEST_ASSERT (ecma_find_or_create_literal_string (NULL, 0) != JMEM_CP_NULL);
}
ecma_finalize_lit_storage ();
tests/unit/test-longjmp.c
+6 -6
View File
@@ -46,22 +46,22 @@ test_setjmp_longjmp (volatile int depth)
}
else
{
JERRY_ASSERT (k == depth + 1);
TEST_ASSERT (k == depth + 1);
JERRY_ASSERT (a == 1);
JERRY_ASSERT (b == 2);
JERRY_ASSERT (c == 3);
TEST_ASSERT (a == 1);
TEST_ASSERT (b == 2);
TEST_ASSERT (c == 3);
for (int i = 0; i < 256; i++)
{
JERRY_ASSERT (array[i] == i);
TEST_ASSERT (array[i] == i);
}
}
}
else
{
int t = rand () % depth;
JERRY_ASSERT (t >= 0 && t < depth);
TEST_ASSERT (t >= 0 && t < depth);
longjmp (buffers[t], t + 1);
}
tests/unit/test-number-to-integer.c
+2 -2
View File
@@ -65,7 +65,7 @@ main ()
i < sizeof (test_cases_uint32) / sizeof (test_cases_uint32[0]);
i++)
{
JERRY_ASSERT (ecma_number_to_uint32 (test_cases_uint32[i].num) == test_cases_uint32[i].uint32_num);
TEST_ASSERT (ecma_number_to_uint32 (test_cases_uint32[i].num) == test_cases_uint32[i].uint32_num);
}
int32_test_case_t test_cases_int32[] =
@@ -101,7 +101,7 @@ main ()
i < sizeof (test_cases_int32) / sizeof (test_cases_int32[0]);
i++)
{
JERRY_ASSERT (ecma_number_to_int32 (test_cases_int32[i].num) == test_cases_int32[i].int32_num);
TEST_ASSERT (ecma_number_to_int32 (test_cases_int32[i].num) == test_cases_int32[i].int32_num);
}
return 0;
tests/unit/test-poolman.c
+1 -1
View File
@@ -71,7 +71,7 @@ main ()
if (ptrs[j] != NULL)
{
JERRY_ASSERT (!memcmp (data[j], ptrs[j], JMEM_POOL_CHUNK_SIZE));
TEST_ASSERT (!memcmp (data[j], ptrs[j], JMEM_POOL_CHUNK_SIZE));
jmem_pools_free (ptrs[j]);
}
tests/unit/test-strings.c
+28 -28
View File
@@ -42,7 +42,7 @@ static lit_utf8_size_t
generate_cesu8_char (utf8_char_size char_size,
lit_utf8_byte_t *buf)
{
JERRY_ASSERT (char_size >= 0 && char_size <= LIT_CESU8_MAX_BYTES_IN_CODE_UNIT);
TEST_ASSERT (char_size >= 0 && char_size <= LIT_CESU8_MAX_BYTES_IN_CODE_UNIT);
lit_code_point_t code_point = (lit_code_point_t) rand ();
if (char_size == 1)
@@ -88,14 +88,14 @@ generate_cesu8_string (lit_utf8_byte_t *buf_p,
lit_utf8_size_t bytes_generated = generate_cesu8_char (char_size, buf_p);
JERRY_ASSERT (lit_is_cesu8_string_valid (buf_p, bytes_generated));
TEST_ASSERT (lit_is_cesu8_string_valid (buf_p, bytes_generated));
size += bytes_generated;
buf_p += bytes_generated;
length++;
}
JERRY_ASSERT (size == buf_size);
TEST_ASSERT (size == buf_size);
return length;
} /* generate_cesu8_string */
@@ -119,10 +119,10 @@ main ()
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);
TEST_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);
TEST_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;
@@ -140,7 +140,7 @@ main ()
lit_utf8_incr (&curr_p);
}
JERRY_ASSERT (length == calculated_length);
TEST_ASSERT (length == calculated_length);
if (code_units_count > 0)
{
@@ -148,73 +148,73 @@ main ()
{
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]);
TEST_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);
TEST_ASSERT (code_units_count > 0);
calculated_length--;
JERRY_ASSERT (code_units[calculated_length] == lit_utf8_peek_prev (curr_p));
TEST_ASSERT (code_units[calculated_length] == lit_utf8_peek_prev (curr_p));
lit_utf8_decr (&curr_p);
}
JERRY_ASSERT (calculated_length == 0);
TEST_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]);
TEST_ASSERT (code_unit == code_units[calculated_length]);
calculated_length++;
}
JERRY_ASSERT (length == calculated_length);
TEST_ASSERT (length == calculated_length);
while (curr_p > cesu8_string)
{
JERRY_ASSERT (code_units_count > 0);
TEST_ASSERT (code_units_count > 0);
calculated_length--;
JERRY_ASSERT (code_units[calculated_length] == lit_utf8_read_prev (&curr_p));
TEST_ASSERT (code_units[calculated_length] == lit_utf8_read_prev (&curr_p));
}
JERRY_ASSERT (calculated_length == 0);
TEST_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)));
TEST_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)));
TEST_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)));
TEST_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)));
TEST_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);
TEST_ASSERT (res_size == 1);
TEST_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);
TEST_ASSERT (res_size == 2);
TEST_ASSERT (res_buf[0] == 0xD0);
TEST_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);
TEST_ASSERT (res_size == 3);
TEST_ASSERT (res_buf[0] == 0xED);
TEST_ASSERT (res_buf[1] == 0x9F);
TEST_ASSERT (res_buf[2] == 0xBF);
ecma_finalize ();
jmem_finalize (true);