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

Add core unicode functionality.

Browse Source 
Add utf-8 processing routines.
Change ecma_char_t from char/uint16_t to uint16_t.
Apply all utf-8 processing routines.
Change char to jerry_api_char in API functions' declarations.

JerryScript-DCO-1.0-Signed-off-by: Andrey Shitov a.shitov@samsung.com
This commit is contained in:
Andrey Shitov
2015-06-29 19:17:17 +03:00
parent c4b0cd2196
commit fd9ff8e3bd
56 changed files with 2468 additions and 1480 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/unit/test-api.cpp
+28 -27
View File
@@ -88,7 +88,7 @@ test_api_init_api_value_string (jerry_api_value_t *out_value_p, /**< out: API va
const char* v) /**< string value to initialize with */
{
out_value_p->type = JERRY_API_DATA_TYPE_STRING;
out_value_p->v_string = jerry_api_create_string (v);
out_value_p->v_string = jerry_api_create_string ((jerry_api_char_t *) v);
} /* test_api_init_api_value_string */
/**
@@ -121,7 +121,7 @@ handler (const jerry_api_object_t *function_obj_p,
JERRY_ASSERT (args_p[0].type == JERRY_API_DATA_TYPE_STRING);
sz = jerry_api_string_to_char_buffer (args_p[0].v_string, NULL, 0);
JERRY_ASSERT (sz == -2);
sz = jerry_api_string_to_char_buffer (args_p[0].v_string, buffer, -sz);
sz = jerry_api_string_to_char_buffer (args_p[0].v_string, (jerry_api_char_t *) buffer, -sz);
JERRY_ASSERT (sz == 2);
JERRY_ASSERT (!strcmp (buffer, "1"));
@@ -142,7 +142,8 @@ handler_throw_test (const jerry_api_object_t *function_obj_p,
{
printf ("ok %p %p %p %d %p\n", function_obj_p, this_p, args_p, args_cnt, ret_val_p);
jerry_api_object_t* error_p = jerry_api_create_error (JERRY_API_ERROR_TYPE, "error");
jerry_api_object_t* error_p = jerry_api_create_error (JERRY_API_ERROR_TYPE,
(jerry_api_char_t *) "error");
test_api_init_api_value_object (ret_val_p, error_p);
@@ -176,7 +177,7 @@ handler_construct (const jerry_api_object_t *function_obj_p,
JERRY_ASSERT (args_p[0].type == JERRY_API_DATA_TYPE_BOOLEAN);
JERRY_ASSERT (args_p[0].v_bool == true);
jerry_api_set_object_field_value (this_p->v_object, "value_field", &args_p[0]);
jerry_api_set_object_field_value (this_p->v_object, (jerry_api_char_t *) "value_field", &args_p[0]);
jerry_api_set_object_native_handle (this_p->v_object,
(uintptr_t) 0x0012345678abcdefull,
@@ -240,7 +241,7 @@ main (void)
jerry_api_value_t res, args[2];
char buffer[32];
is_ok = jerry_parse (test_source, strlen (test_source));
is_ok = jerry_parse ((jerry_api_char_t *)test_source, strlen (test_source));
JERRY_ASSERT (is_ok);
is_ok = (jerry_run () == JERRY_COMPLETION_CODE_OK);
@@ -249,14 +250,14 @@ main (void)
global_obj_p = jerry_api_get_global ();
// Get global.t
is_ok = jerry_api_get_object_field_value (global_obj_p, "t", &val_t);
is_ok = jerry_api_get_object_field_value (global_obj_p, (jerry_api_char_t *)"t", &val_t);
JERRY_ASSERT (is_ok
&& val_t.type == JERRY_API_DATA_TYPE_FLOAT64
&& val_t.v_float64 == 1.0);
jerry_api_release_value (&val_t);
// Get global.foo
is_ok = jerry_api_get_object_field_value (global_obj_p, "foo", &val_foo);
is_ok = jerry_api_get_object_field_value (global_obj_p, (jerry_api_char_t *)"foo", &val_foo);
JERRY_ASSERT (is_ok
&& val_foo.type == JERRY_API_DATA_TYPE_OBJECT);
@@ -270,7 +271,7 @@ main (void)
jerry_api_release_value (&res);
// Get global.bar
is_ok = jerry_api_get_object_field_value (global_obj_p, "bar", &val_bar);
is_ok = jerry_api_get_object_field_value (global_obj_p, (jerry_api_char_t *)"bar", &val_bar);
JERRY_ASSERT (is_ok
&& val_bar.type == JERRY_API_DATA_TYPE_OBJECT);
@@ -285,7 +286,7 @@ main (void)
// Set global.t = "abcd"
test_api_init_api_value_string (&args[0], "abcd");
is_ok = jerry_api_set_object_field_value (global_obj_p,
"t",
(jerry_api_char_t *)"t",
&args[0]);
JERRY_ASSERT (is_ok);
jerry_api_release_value (&args[0]);
@@ -296,13 +297,13 @@ main (void)
&& res.type == JERRY_API_DATA_TYPE_STRING);
sz = jerry_api_string_to_char_buffer (res.v_string, NULL, 0);
JERRY_ASSERT (sz == -5);
sz = jerry_api_string_to_char_buffer (res.v_string, buffer, -sz);
sz = jerry_api_string_to_char_buffer (res.v_string, (jerry_api_char_t *) buffer, -sz);
JERRY_ASSERT (sz == 5);
jerry_api_release_value (&res);
JERRY_ASSERT (!strcmp (buffer, "abcd"));
// Get global.A
is_ok = jerry_api_get_object_field_value (global_obj_p, "A", &val_A);
is_ok = jerry_api_get_object_field_value (global_obj_p, (jerry_api_char_t *)"A", &val_A);
JERRY_ASSERT (is_ok
&& val_A.type == JERRY_API_DATA_TYPE_OBJECT);
@@ -310,7 +311,7 @@ main (void)
is_ok = jerry_api_is_constructor (val_A.v_object);
JERRY_ASSERT (is_ok);
is_ok = jerry_api_get_object_field_value (val_A.v_object,
"prototype",
(jerry_api_char_t *) "prototype",
&val_A_prototype);
JERRY_ASSERT (is_ok
&& val_A_prototype.type == JERRY_API_DATA_TYPE_OBJECT);
@@ -318,26 +319,26 @@ main (void)
// Set A.prototype.foo = global.foo
is_ok = jerry_api_set_object_field_value (val_A_prototype.v_object,
"foo",
(jerry_api_char_t *) "foo",
&val_foo);
JERRY_ASSERT (is_ok);
jerry_api_release_value (&val_A_prototype);
jerry_api_release_value (&val_foo);
// Get global.a
is_ok = jerry_api_get_object_field_value (global_obj_p, "a", &val_a);
is_ok = jerry_api_get_object_field_value (global_obj_p, (jerry_api_char_t *) "a", &val_a);
JERRY_ASSERT (is_ok
&& val_a.type == JERRY_API_DATA_TYPE_OBJECT);
// Get a.t
is_ok = jerry_api_get_object_field_value (val_a.v_object, "t", &res);
is_ok = jerry_api_get_object_field_value (val_a.v_object, (jerry_api_char_t *) "t", &res);
JERRY_ASSERT (is_ok
&& res.type == JERRY_API_DATA_TYPE_FLOAT64
&& res.v_float64 == 12.0);
jerry_api_release_value (&res);
// Get a.foo
is_ok = jerry_api_get_object_field_value (val_a.v_object, "foo", &val_a_foo);
is_ok = jerry_api_get_object_field_value (val_a.v_object, (jerry_api_char_t *) "foo", &val_a_foo);
JERRY_ASSERT (is_ok
&& val_a_foo.type == JERRY_API_DATA_TYPE_OBJECT);
@@ -359,14 +360,14 @@ main (void)
test_api_init_api_value_object (&val_external, external_func_p);
is_ok = jerry_api_set_object_field_value (global_obj_p,
"external",
(jerry_api_char_t *) "external",
&val_external);
JERRY_ASSERT (is_ok);
jerry_api_release_value (&val_external);
jerry_api_release_object (external_func_p);
// Call 'call_external' function that should call external function created above
is_ok = jerry_api_get_object_field_value (global_obj_p, "call_external", &val_call_external);
is_ok = jerry_api_get_object_field_value (global_obj_p, (jerry_api_char_t *) "call_external", &val_call_external);
JERRY_ASSERT (is_ok
&& val_call_external.type == JERRY_API_DATA_TYPE_OBJECT);
is_ok = jerry_api_call_function (val_call_external.v_object,
@@ -378,7 +379,7 @@ main (void)
&& res.type == JERRY_API_DATA_TYPE_STRING);
sz = jerry_api_string_to_char_buffer (res.v_string, NULL, 0);
JERRY_ASSERT (sz == -20);
sz = jerry_api_string_to_char_buffer (res.v_string, buffer, -sz);
sz = jerry_api_string_to_char_buffer (res.v_string, (jerry_api_char_t *) buffer, -sz);
JERRY_ASSERT (sz == 20);
jerry_api_release_value (&res);
JERRY_ASSERT (!strcmp (buffer, "string from handler"));
@@ -391,7 +392,7 @@ main (void)
test_api_init_api_value_object (&val_external_construct, external_construct_p);
is_ok = jerry_api_set_object_field_value (global_obj_p,
"external_construct",
(jerry_api_char_t *) "external_construct",
&val_external_construct);
JERRY_ASSERT (is_ok);
jerry_api_release_value (&val_external_construct);
@@ -403,7 +404,7 @@ main (void)
JERRY_ASSERT (is_ok
&& res.type == JERRY_API_DATA_TYPE_OBJECT);
is_ok = jerry_api_get_object_field_value (res.v_object,
"value_field",
(jerry_api_char_t *)"value_field",
&val_value_field);
// Get 'value_field' of constructed object
@@ -427,13 +428,13 @@ main (void)
test_api_init_api_value_object (&val_t, throw_test_handler_p);
is_ok = jerry_api_set_object_field_value (global_obj_p,
"throw_test",
(jerry_api_char_t *) "throw_test",
&val_t);
JERRY_ASSERT (is_ok);
jerry_api_release_value (&val_t);
jerry_api_release_object (throw_test_handler_p);
is_ok = jerry_api_get_object_field_value (global_obj_p, "call_throw_test", &val_t);
is_ok = jerry_api_get_object_field_value (global_obj_p, (jerry_api_char_t *) "call_throw_test", &val_t);
JERRY_ASSERT (is_ok
&& val_t.type == JERRY_API_DATA_TYPE_OBJECT);
@@ -446,7 +447,7 @@ main (void)
jerry_api_release_value (&res);
// Test: Unhandled exception in called function
is_ok = jerry_api_get_object_field_value (global_obj_p, "throw_reference_error", &val_t);
is_ok = jerry_api_get_object_field_value (global_obj_p, (jerry_api_char_t *) "throw_reference_error", &val_t);
JERRY_ASSERT (is_ok
&& val_t.type == JERRY_API_DATA_TYPE_OBJECT);
@@ -479,7 +480,7 @@ main (void)
jerry_api_release_object (obj_p);
// Test: Unhandled exception in function called, as constructor
is_ok = jerry_api_get_object_field_value (global_obj_p, "throw_reference_error", &val_t);
is_ok = jerry_api_get_object_field_value (global_obj_p, (jerry_api_char_t *) "throw_reference_error", &val_t);
JERRY_ASSERT (is_ok
&& val_t.type == JERRY_API_DATA_TYPE_OBJECT);
@@ -511,7 +512,7 @@ main (void)
// Test: eval
const char *eval_code_src_p = "(function () { return 123; })";
jerry_completion_code_t status = jerry_api_eval (eval_code_src_p,
jerry_completion_code_t status = jerry_api_eval ((jerry_api_char_t *) eval_code_src_p,
strlen (eval_code_src_p),
false,
true,
@@ -547,7 +548,7 @@ main (void)
magic_string_lengths);
const char *ms_code_src_p = "var global = {}; var console = [1]; var process = 1;";
is_ok = jerry_parse (ms_code_src_p, strlen (ms_code_src_p));
is_ok = jerry_parse ((jerry_api_char_t *) ms_code_src_p, strlen (ms_code_src_p));
JERRY_ASSERT (is_ok);
is_ok = (jerry_run () == JERRY_COMPLETION_CODE_OK);
tests/unit/test-literal-storage.cpp
+23 -23
View File
@@ -15,7 +15,7 @@
#include "ecma-helpers.h"
#include "lit-literal.h"
#include "lit-magic-strings.h"
#include "test-common.h"
// Iterations count
@@ -28,13 +28,13 @@
#define max_characters_in_string 256
static void
generate_string (ecma_char_t *str, ecma_length_t len)
generate_string (lit_utf8_byte_t *str, lit_utf8_size_t len)
{
static const ecma_char_t characters[] = "!@#$%^&*()_+abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ123456789";
static const ecma_length_t length = (ecma_length_t) (sizeof (characters) / sizeof (ecma_char_t) - 1);
for (ecma_length_t i = 0; i < len; ++i)
static const lit_utf8_byte_t bytes[] = "!@#$%^&*()_+abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ123456789";
static const lit_utf8_size_t length = (lit_utf8_size_t) (sizeof (bytes) - 1);
for (lit_utf8_size_t i = 0; i < len; ++i)
{
str[i] = characters[(unsigned long) rand () % length];
str[i] = bytes[(unsigned long) rand () % length];
}
}
@@ -60,10 +60,10 @@ main (int __attr_unused___ argc,
{
TEST_INIT ();
const ecma_char_t *ptrs[test_sub_iters];
const lit_utf8_byte_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];
lit_utf8_byte_t strings[test_sub_iters][max_characters_in_string + 1];
lit_utf8_size_t lengths[test_sub_iters];
mem_init ();
lit_init ();
@@ -72,17 +72,17 @@ main (int __attr_unused___ argc,
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);
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] = (ecma_length_t) (rand () % max_characters_in_string + 1);
lengths[j] = (lit_utf8_size_t) (rand () % max_characters_in_string + 1);
generate_string (strings[j], lengths[j]);
lit_create_literal_from_charset (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]);
@@ -90,21 +90,21 @@ main (int __attr_unused___ argc,
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_zt (msi);
ptrs[j] = lit_get_magic_string_utf8 (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]);
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_zt_string (num, strings[j], max_characters_in_string);
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_charset (NULL, 0);
lit_create_literal_from_utf8_string (NULL, 0);
for (uint32_t j = 0; j < test_sub_iters; j++)
{
@@ -112,10 +112,10 @@ main (int __attr_unused___ argc,
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]));
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 (lit_literal_equal_utf8 (lit1, ptrs[j], lengths[j]));
JERRY_ASSERT (lit_literal_equal_type_utf8 (lit2, ptrs[j], lengths[j]));
}
else
{
@@ -131,7 +131,7 @@ main (int __attr_unused___ argc,
}
// Check empty string exists
JERRY_ASSERT (lit_find_literal_by_charset (NULL, 0));
JERRY_ASSERT (lit_find_literal_by_utf8_string (NULL, 0));
lit_storage.cleanup ();
JERRY_ASSERT (lit_storage.get_first () == NULL);
tests/unit/test-number-to-string.cpp
+15 -15
View File
@@ -27,19 +27,19 @@ main (int __attr_unused___ argc,
{
TEST_INIT ();
const ecma_char_t* zt_strings[] =
const lit_utf8_byte_t *strings[] =
{
(const ecma_char_t*) "1",
(const ecma_char_t*) "0.5",
(const ecma_char_t*) "12345",
(const ecma_char_t*) "12345.123",
(const ecma_char_t*) "1e-45",
(const ecma_char_t*) "-2.5e+38",
(const ecma_char_t*) "NaN",
(const ecma_char_t*) "Infinity",
(const ecma_char_t*) "-Infinity",
(const ecma_char_t*) "0",
(const ecma_char_t*) "0",
(const lit_utf8_byte_t *) "1",
(const lit_utf8_byte_t *) "0.5",
(const lit_utf8_byte_t *) "12345",
(const lit_utf8_byte_t *) "12345.123",
(const lit_utf8_byte_t *) "1e-45",
(const lit_utf8_byte_t *) "-2.5e+38",
(const lit_utf8_byte_t *) "NaN",
(const lit_utf8_byte_t *) "Infinity",
(const lit_utf8_byte_t *) "-Infinity",
(const lit_utf8_byte_t *) "0",
(const lit_utf8_byte_t *) "0",
};
const ecma_number_t nums[] =
@@ -61,11 +61,11 @@ main (int __attr_unused___ argc,
i < sizeof (nums) / sizeof (nums[0]);
i++)
{
ecma_char_t zt_str[64];
lit_utf8_byte_t str[64];
ecma_number_to_zt_string (nums[i], zt_str, sizeof (zt_str));
lit_utf8_size_t str_size = ecma_number_to_utf8_string (nums[i], str, sizeof (str));
if (strcmp ((char*)zt_str, (char*)zt_strings[i]) != 0)
if (strncmp ((char *) str, (char *) strings[i], str_size) != 0)
{
return 1;
}
tests/unit/test-parser.cpp
+2 -2
View File
@@ -81,7 +81,7 @@ main (int __attr_unused___ argc,
serializer_init ();
parser_set_show_opcodes (true);
is_syntax_correct = parser_parse_script (program1, strlen (program1), &opcodes_p);
is_syntax_correct = parser_parse_script ((jerry_api_char_t *) program1, strlen (program1), &opcodes_p);
JERRY_ASSERT (is_syntax_correct && opcodes_p != NULL);
@@ -107,7 +107,7 @@ main (int __attr_unused___ argc,
serializer_init ();
parser_set_show_opcodes (true);
is_syntax_correct = parser_parse_script (program2, strlen (program2), &opcodes_p);
is_syntax_correct = parser_parse_script ((jerry_api_char_t *) program2, strlen (program2), &opcodes_p);
JERRY_ASSERT (!is_syntax_correct && opcodes_p == NULL);
tests/unit/test-string-to-number.cpp
+20 -20
View File
@@ -27,26 +27,26 @@ main (int __attr_unused___ argc,
{
TEST_INIT ();
const ecma_char_t* zt_strings[] =
const jerry_api_char_t *strings[] =
{
(const ecma_char_t*) "1",
(const ecma_char_t*) "0.5",
(const ecma_char_t*) "12345",
(const ecma_char_t*) "1e-45",
(const ecma_char_t*) "-2.5e+38",
(const ecma_char_t*) "-2.5e38",
(const ecma_char_t*) "- 2.5e+38",
(const ecma_char_t*) "-2 .5e+38",
(const ecma_char_t*) "-2. 5e+38",
(const ecma_char_t*) "-2.5e+ 38",
(const ecma_char_t*) "-2.5 e+38",
(const ecma_char_t*) "-2.5e +38",
(const ecma_char_t*) "NaN",
(const ecma_char_t*) "abc",
(const ecma_char_t*) " Infinity ",
(const ecma_char_t*) "-Infinity",
(const ecma_char_t*) "0",
(const ecma_char_t*) "0",
(const jerry_api_char_t *) "1",
(const jerry_api_char_t *) "0.5",
(const jerry_api_char_t *) "12345",
(const jerry_api_char_t *) "1e-45",
(const jerry_api_char_t *) "-2.5e+38",
(const jerry_api_char_t *) "-2.5e38",
(const jerry_api_char_t *) "- 2.5e+38",
(const jerry_api_char_t *) "-2 .5e+38",
(const jerry_api_char_t *) "-2. 5e+38",
(const jerry_api_char_t *) "-2.5e+ 38",
(const jerry_api_char_t *) "-2.5 e+38",
(const jerry_api_char_t *) "-2.5e +38",
(const jerry_api_char_t *) "NaN",
(const jerry_api_char_t *) "abc",
(const jerry_api_char_t *) " Infinity ",
(const jerry_api_char_t *) "-Infinity",
(const jerry_api_char_t *) "0",
(const jerry_api_char_t *) "0",
};
const ecma_number_t nums[] =
@@ -75,7 +75,7 @@ main (int __attr_unused___ argc,
i < sizeof (nums) / sizeof (nums[0]);
i++)
{
ecma_number_t num = ecma_zt_string_to_number (zt_strings[i]);
ecma_number_t num = ecma_utf8_string_to_number (strings[i], lit_zt_utf8_string_size (strings[i]));
if (num != nums[i]
&& (!ecma_number_is_nan (num)
tests/unit/test-strings.cpp
+94
View File
@@ -0,0 +1,94 @@
/* Copyright 2015 Samsung Electronics Co., Ltd.
*
* 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.
*/
#include "ecma-helpers.h"
#include "lit-strings.h"
#include "test-common.h"
// Iterations count
#define test_iters 64
// Subiterations count
#define test_sub_iters 64
int
main (int __attr_unused___ argc,
char __attr_unused___ **argv)
{
TEST_INIT ();
mem_init ();
/* test lit_is_utf8_string_valid */
/* Overlong-encoded code point */
lit_utf8_byte_t invalid_utf8_string_1[] = {0xC0, 0x82};
JERRY_ASSERT (!lit_is_utf8_string_valid (invalid_utf8_string_1, sizeof (invalid_utf8_string_1)));
/* Overlong-encoded code point */
lit_utf8_byte_t invalid_utf8_string_2[] = {0xE0, 0x80, 0x81};
JERRY_ASSERT (!lit_is_utf8_string_valid (invalid_utf8_string_2, sizeof (invalid_utf8_string_2)));
/* Pair of surrogates: 0xD901 0xDFF0 which encode Unicode character 0x507F0 */
lit_utf8_byte_t invalid_utf8_string_3[] = {0xED, 0xA4, 0x81, 0xED, 0xBF, 0xB0};
JERRY_ASSERT (!lit_is_utf8_string_valid (invalid_utf8_string_3, sizeof (invalid_utf8_string_3)));
/* Isolated high surrogate 0xD901 */
lit_utf8_byte_t valid_utf8_string_1[] = {0xED, 0xA4, 0x81};
JERRY_ASSERT (lit_is_utf8_string_valid (valid_utf8_string_1, sizeof (valid_utf8_string_1)));
/* 4-byte long utf-8 character - Unicode character 0x507F0 */
lit_utf8_byte_t valid_utf8_string_2[] = {0xF1, 0x90, 0x9F, 0xB0};
JERRY_ASSERT (lit_is_utf8_string_valid (valid_utf8_string_2, sizeof (valid_utf8_string_2)));
/* test lit_read_code_point_from_utf8 */
lit_utf8_byte_t buf[] = {0xF0, 0x90, 0x8D, 0x88};
lit_code_point_t code_point;
lit_utf8_size_t bytes_count = lit_read_code_point_from_utf8 (buf, sizeof (buf), &code_point);
JERRY_ASSERT (bytes_count == 4);
JERRY_ASSERT (code_point == 0x10348);
/* test lit_code_unit_to_utf8 */
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);
/* test lit_utf8_iterator */
lit_utf8_byte_t bytes[] = {0xF0, 0x90, 0x8D, 0x88};
lit_utf8_iterator_t iter = lit_utf8_iterator_create (bytes, sizeof (bytes));
ecma_char_t code_unit = lit_utf8_iterator_read_code_unit_and_increment (&iter);
JERRY_ASSERT (!lit_utf8_iterator_reached_buffer_end (&iter));
JERRY_ASSERT (code_unit == 0xD800);
code_unit = lit_utf8_iterator_read_code_unit_and_increment (&iter);
JERRY_ASSERT (lit_utf8_iterator_reached_buffer_end (&iter));
JERRY_ASSERT (code_unit == 0xDF48);
mem_finalize (true);
return 0;
}