mirror of
https://github.com/KevinMidboe/linguist.git
synced 2025-10-29 17:50:22 +00:00
1170 lines
51 KiB
Plaintext
1170 lines
51 KiB
Plaintext
// Originally from /jsonion_test.gml in JSOnion
|
|
// JSOnion v1.0.0d is licensed under the MIT licence. You may freely adapt and use this library in commercial and non-commercial projects.
|
|
|
|
#define assert_true
|
|
{
|
|
/**
|
|
assert_true(result, errormsg): Display error <errormsg> unless <result> is true.
|
|
*/
|
|
|
|
if (!argument0) {
|
|
_assert_error_popup(argument1 + string_repeat(_assert_newline(), 2) + "Expected true, got false.");
|
|
}
|
|
}
|
|
|
|
#define assert_false
|
|
{
|
|
/**
|
|
assert_false(result, errormsg): Display error <errormsg> unless <result> is false.
|
|
*/
|
|
|
|
if (argument0) {
|
|
_assert_error_popup(argument1 + string_repeat(_assert_newline(), 2) + "Expected false, got true.");
|
|
}
|
|
}
|
|
|
|
#define assert_equal
|
|
{
|
|
/**
|
|
assert_equal(expected, result, errormsg): Display error <errormsg> unless <expected> and <result> are equal.
|
|
*/
|
|
|
|
//Safe equality check; won't crash even if the two are different types
|
|
var match;
|
|
match = is_string(argument0) == is_string(argument1);
|
|
if (match) {
|
|
match = argument0 == argument1;
|
|
}
|
|
|
|
//No match?
|
|
if (!match) {
|
|
//Data types
|
|
var type;
|
|
type[0] = "(Real)";
|
|
type[1] = "(String)";
|
|
|
|
//Construct message
|
|
var msg;
|
|
msg = argument2;
|
|
//Add expected value
|
|
msg += string_repeat(_assert_newline(), 2);
|
|
msg += "Expected " + type[is_string(argument0)] + ":" + _assert_newline();
|
|
msg += _assert_debug_value(argument0);
|
|
//Add actual value
|
|
msg += string_repeat(_assert_newline(), 2);
|
|
msg += "Actual " + type[is_string(argument1)] + ":" + _assert_newline();
|
|
msg += _assert_debug_value(argument1);
|
|
|
|
//Display message
|
|
_assert_error_popup(msg);
|
|
}
|
|
}
|
|
|
|
#define _assert_error_popup
|
|
{
|
|
/**
|
|
_assert_error_popup(msg): Display an assertion error.
|
|
*/
|
|
|
|
//Display message
|
|
if (os_browser == browser_not_a_browser) {
|
|
show_error(argument0, false); //Full-fledged error message for non-browser environments
|
|
} else {
|
|
show_message(argument0); //Browsers don't support show_error(), use show_message() instead
|
|
}
|
|
}
|
|
|
|
#define _assert_debug_value
|
|
{
|
|
/**
|
|
_assert_debug_value(val): Returns a low-level debug value for the value <val>.
|
|
<val> can be a string or a real value.
|
|
*/
|
|
|
|
//String
|
|
if (is_string(argument0)) {
|
|
if (os_browser == browser_not_a_browser) {
|
|
return argument0;
|
|
} else {
|
|
return string_replace_all(argument0, "#", "\#");
|
|
}
|
|
}
|
|
|
|
//Numeric --- use GMTuple's algorithm
|
|
else {
|
|
|
|
//Integers
|
|
if (frac(argument0) == 0) {
|
|
return string(argument0);
|
|
}
|
|
|
|
//Decimal numbers; get exponent and mantissa
|
|
var mantissa, exponent;
|
|
exponent = floor(log10(abs(argument0)));
|
|
mantissa = string_format(argument0/power(10,exponent), 15, 14);
|
|
//Look for trailing zeros in the mantissa
|
|
var i, ca;
|
|
i = string_length(mantissa);
|
|
do {
|
|
ca = string_char_at(mantissa, i);
|
|
i -= 1;
|
|
} until (ca != "0")
|
|
//Remove the dot if only the first digit of the normalized mantissa is nonzero
|
|
if (ca != ".") {
|
|
mantissa = string_copy(mantissa, 1, i+1);
|
|
}
|
|
else {
|
|
mantissa = string_copy(mantissa, 1, i);
|
|
}
|
|
//Remove the exponent if it is 0
|
|
if (exponent != 0) {
|
|
return mantissa + "e" + string(exponent);
|
|
} else {
|
|
return mantissa;
|
|
}
|
|
|
|
//GMTuple algorithm done
|
|
}
|
|
}
|
|
|
|
#define _assert_newline
|
|
{
|
|
/**
|
|
_assert_newline(): Returns a system-appropriate newline character sequence.
|
|
*/
|
|
|
|
if (os_browser == browser_not_a_browser) {
|
|
return chr(13) + chr(10);
|
|
} else {
|
|
return "#";
|
|
}
|
|
}
|
|
|
|
#define jso_test_all
|
|
{
|
|
/**
|
|
jso_test_all(): Run the test suite for the JSOnion library.
|
|
JSOnion version: 1.0.0d
|
|
*/
|
|
var a, b;
|
|
a = current_time;
|
|
_test_jso_new();
|
|
_test_jso_map_add();
|
|
_test_jso_list_add();
|
|
_test_jso_encode();
|
|
_test_jso_compare();
|
|
_test_jso_decode();
|
|
_test_jso_lookup();
|
|
_test_jso_bugs();
|
|
__jso_gmt_test_all();
|
|
b = current_time;
|
|
show_debug_message("JSOnion: Tests completed in " + string(b-a) + "ms.");
|
|
}
|
|
|
|
#define _test_jso_new
|
|
{
|
|
/**
|
|
_test_jso_new(): Test jso_new_*() functions.
|
|
JSOnion version: 1.0.0d
|
|
*/
|
|
|
|
var expected, actual;
|
|
|
|
//jso_new_map()
|
|
actual = jso_new_map();
|
|
assert_true(actual >= 0, "jso_new_map() failed to create a new map.");
|
|
ds_map_destroy(actual);
|
|
|
|
//jso_new_list()
|
|
actual = jso_new_list();
|
|
assert_true(actual >= 0, "jso_new_list() failed to create a new list.");
|
|
ds_list_destroy(actual);
|
|
}
|
|
|
|
#define _test_jso_map_add
|
|
{
|
|
/**
|
|
_test_jso_map_add(): Test jso_map_add_*() functions.
|
|
JSOnion version: 1.0.0d
|
|
*/
|
|
|
|
var expected, actual, key, map;
|
|
map = jso_new_map();
|
|
|
|
//jso_map_add_real()
|
|
expected = pi;
|
|
key = "pi";
|
|
jso_map_add_real(map, key, expected);
|
|
actual = jso_map_get(map, key);
|
|
assert_true(ds_map_exists(map, key), "jso_map_add_real() failed to add the number.");
|
|
assert_equal(expected, actual, "jso_map_add_real() added the wrong number.");
|
|
ds_map_delete(map, key);
|
|
|
|
//jso_map_add_string()
|
|
expected = "waahoo";
|
|
key = "str";
|
|
jso_map_add_string(map, key, expected);
|
|
actual = jso_map_get(map, key);
|
|
assert_true(ds_map_exists(map, key), "jso_map_add_string() failed to add the string.");
|
|
assert_equal(expected, actual, "jso_map_add_string() added the wrong string.");
|
|
ds_map_delete(map, key);
|
|
|
|
//jso_map_add_sublist()
|
|
expected = jso_new_list();
|
|
key = "sublist";
|
|
jso_map_add_sublist(map, key, expected);
|
|
actual = jso_map_get(map, key);
|
|
assert_true(ds_map_exists(map, key), "jso_map_add_sublist() failed to add the new sublist.");
|
|
assert_equal(expected, actual, "jso_map_add_sublist() added the wrong sublist.");
|
|
ds_map_delete(map, key);
|
|
ds_list_destroy(expected);
|
|
|
|
//jso_map_add_submap()
|
|
expected = jso_new_map();
|
|
key = "sublist";
|
|
jso_map_add_sublist(map, key, expected);
|
|
actual = jso_map_get(map, key);
|
|
assert_true(ds_map_exists(map, key), "jso_map_add_submap() failed to add the new submap.");
|
|
assert_equal(expected, actual, "jso_map_add_submap() added the wrong submap.");
|
|
ds_map_delete(map, key);
|
|
ds_map_destroy(expected);
|
|
|
|
//jso_map_add_integer()
|
|
expected = 2345;
|
|
key = "integer";
|
|
jso_map_add_integer(map, key, expected);
|
|
actual = jso_map_get(map, key);
|
|
assert_true(ds_map_exists(map, key), "jso_map_add_integer() failed to add the new integer.");
|
|
assert_equal(expected, actual, "jso_map_add_integer() added the wrong integer.");
|
|
ds_map_delete(map, key);
|
|
|
|
//jso_map_add_boolean() --- true
|
|
expected = true;
|
|
key = "booleantrue";
|
|
jso_map_add_boolean(map, key, expected);
|
|
actual = jso_map_get(map, key);
|
|
assert_true(ds_map_exists(map, key), "jso_map_add_boolean() failed to add true.");
|
|
assert_true(actual, "jso_map_add_boolean() added the wrong true.");
|
|
ds_map_delete(map, key);
|
|
|
|
//jso_map_add_boolean() --- false
|
|
expected = false;
|
|
key = "booleanfalse";
|
|
jso_map_add_boolean(map, key, expected);
|
|
actual = jso_map_get(map, key)
|
|
assert_true(ds_map_exists(map, key), "jso_map_add_boolean() failed to add false.");
|
|
assert_false(actual, "jso_map_add_boolean() added the wrong false.");
|
|
ds_map_delete(map, key);
|
|
|
|
//Cleanup
|
|
ds_map_destroy(map);
|
|
}
|
|
|
|
#define _test_jso_list_add
|
|
{
|
|
/**
|
|
_test_jso_list_add(): Test jso_list_add_*() functions.
|
|
JSOnion version: 1.0.0d
|
|
*/
|
|
|
|
var expected, actual, list;
|
|
list = jso_new_list();
|
|
|
|
//jso_list_add_real()
|
|
expected = pi;
|
|
jso_list_add_real(list, expected);
|
|
actual = jso_list_get(list, 0);
|
|
assert_false(ds_list_empty(list), "jso_list_add_real() failed to add the number.");
|
|
assert_equal(expected, actual, "jso_list_add_real() added the wrong number.");
|
|
ds_list_clear(list);
|
|
|
|
//jso_list_add_string()
|
|
expected = "waahoo";
|
|
jso_list_add_string(list, expected);
|
|
actual = jso_list_get(list, 0);
|
|
assert_false(ds_list_empty(list), "jso_list_add_string() failed to add the string.");
|
|
assert_equal(expected, actual, "jso_list_add_string() added the wrong string.");
|
|
ds_list_clear(list);
|
|
|
|
//jso_list_add_sublist()
|
|
expected = jso_new_list();
|
|
jso_list_add_sublist(list, expected);
|
|
actual = jso_list_get(list, 0);
|
|
assert_false(ds_list_empty(list), "jso_list_add_sublist() failed to add the sublist.");
|
|
assert_equal(expected, actual, "jso_list_add_sublist() added the wrong sublist.");
|
|
ds_list_clear(list);
|
|
ds_list_destroy(expected);
|
|
|
|
//jso_list_add_submap()
|
|
expected = jso_new_map();
|
|
jso_list_add_submap(list, expected);
|
|
actual = jso_list_get(list, 0);
|
|
assert_false(ds_list_empty(list), "jso_list_add_submap() failed to add the submap.");
|
|
assert_equal(expected, actual, "jso_list_add_submap() added the wrong submap.");
|
|
ds_list_clear(list);
|
|
ds_map_destroy(expected);
|
|
|
|
//jso_list_add_integer()
|
|
expected = 2345;
|
|
jso_list_add_integer(list, expected);
|
|
actual = jso_list_get(list, 0);
|
|
assert_false(ds_list_empty(list), "jso_list_add_integer() failed to add integer.");
|
|
assert_equal(expected, actual, "jso_list_add_integer() added the wrong integer.");
|
|
ds_list_clear(list);
|
|
|
|
//jso_list_add_boolean() --- true
|
|
expected = true;
|
|
jso_list_add_boolean(list, expected);
|
|
actual = jso_list_get(list, 0);
|
|
assert_false(ds_list_empty(list), "jso_list_add_boolean() failed to add boolean true.");
|
|
assert_true(actual, "jso_list_add_boolean() added the wrong boolean true.");
|
|
ds_list_clear(list);
|
|
|
|
//jso_list_add_boolean() --- false
|
|
expected = false;
|
|
jso_list_add_boolean(list, expected);
|
|
actual = jso_list_get(list, 0);
|
|
assert_false(ds_list_empty(list), "jso_list_add_boolean() failed to add boolean false.");
|
|
assert_false(actual, "jso_list_add_boolean() added the wrong boolean false.");
|
|
ds_list_clear(list);
|
|
|
|
//Cleanup
|
|
ds_list_destroy(list);
|
|
}
|
|
|
|
#define _test_jso_encode
|
|
{
|
|
/**
|
|
_test_jso_encode(): Tests jso_encode_*() functions.
|
|
JSOnion version: 1.0.0d
|
|
*/
|
|
|
|
var original, expected, actual;
|
|
|
|
//jso_encode_real() --- Positive
|
|
expected = 3.1415;
|
|
actual = jso_encode_real(3.1415);
|
|
assert_equal(expected, real(actual), "jso_encode_real() failed to encode positive real!");
|
|
|
|
//jso_encode_real() --- Negative
|
|
expected = -2.71828;
|
|
actual = jso_encode_real(-2.71828);
|
|
assert_equal(expected, real(actual), "jso_encode_real() failed to encode negative real!");
|
|
|
|
//jso_encode_real() --- Zero
|
|
expected = 0;
|
|
actual = jso_encode_integer(0);
|
|
assert_equal(expected, real(actual), "jso_encode_real() failed to encode zero!");
|
|
|
|
//jso_encode_integer() --- Positive
|
|
expected = "2345";
|
|
actual = jso_encode_integer(2345);
|
|
assert_equal(expected, actual, "jso_encode_integer() failed to encode positive integer!");
|
|
|
|
//jso_encode_integer() --- Negative
|
|
expected = "-45";
|
|
actual = jso_encode_integer(-45);
|
|
assert_equal(expected, actual, "jso_encode_integer() failed to encode negative integer!");
|
|
|
|
//jso_encode_integer() --- Zero
|
|
expected = "0";
|
|
actual = jso_encode_integer(0);
|
|
assert_equal(expected, actual, "jso_encode_integer() failed to encode zero!");
|
|
|
|
//jso_encode_boolean() --- true
|
|
expected = "true";
|
|
actual = jso_encode_boolean(true);
|
|
assert_equal(expected, actual, "jso_encode_boolean() failed to encode true!");
|
|
|
|
//jso_encode_boolean() --- false
|
|
expected = "false";
|
|
actual = jso_encode_boolean(false);
|
|
assert_equal(expected, actual, "jso_encode_boolean() failed to encode false!");
|
|
|
|
//jso_encode_string() --- Simple string
|
|
expected = '"waahoo"';
|
|
actual = jso_encode_string("waahoo");
|
|
assert_equal(expected, actual, "jso_encode_string() failed to encode simple string!");
|
|
|
|
//jso_encode_string() --- Empty string
|
|
expected = '""';
|
|
actual = jso_encode_string("");
|
|
assert_equal(expected, actual, "jso_encode_string() failed to encode empty string!");
|
|
|
|
//jso_encode_string() --- Basic escape characters
|
|
expected = '"\\\"\b\f\n\r\t"';
|
|
actual = jso_encode_string('\"' + chr(8) + chr(12) + chr(10) + chr(13) + chr(9));
|
|
assert_equal(expected, actual, "jso_encode_string() failed to encode escape character string!");
|
|
|
|
//jso_encode_map() --- Empty map
|
|
var empty_map;
|
|
empty_map = jso_new_map();
|
|
expected = "{}";
|
|
actual = jso_encode_map(empty_map);
|
|
assert_equal(expected, actual, "jso_encode_map() failed to encode empty map!");
|
|
jso_cleanup_map(empty_map);
|
|
|
|
//jso_encode_map() --- One-element map
|
|
var one_map;
|
|
one_map = jso_new_map();
|
|
jso_map_add_string(one_map, "key", "value");
|
|
expected = '{"key":"value"}';
|
|
actual = jso_encode_map(one_map);
|
|
assert_equal(expected, actual, "jso_encode_map() failed to encode one-element map!");
|
|
jso_cleanup_map(one_map);
|
|
|
|
//jso_encode_map() --- Multi-element map
|
|
var multi_map, ok1, ok2;
|
|
multi_map = jso_new_map();
|
|
jso_map_add_string(multi_map, "key1", "value\1");
|
|
jso_map_add_integer(multi_map, "key2", 2);
|
|
ok1 = '{"key1":"value\\1","key2":2}';
|
|
ok2 = '{"key2":2,"key1":"value\\1"}';
|
|
actual = jso_encode_map(multi_map);
|
|
assert_true((actual == ok1) || (actual == ok2), "jso_encode_map() failed to encode multi-element map!");
|
|
jso_cleanup_map(multi_map);
|
|
|
|
//jso_encode_list() --- Empty list
|
|
var empty_list;
|
|
empty_list = jso_new_list();
|
|
expected = "[]";
|
|
actual = jso_encode_list(empty_list);
|
|
assert_equal(expected, actual, "jso_encode_list() failed to encode empty list!");
|
|
jso_cleanup_list(empty_list);
|
|
|
|
//jso_encode_list() --- One-element nested list
|
|
var one_list;
|
|
one_list = jso_new_list();
|
|
jso_list_add_submap(one_list, jso_new_map());
|
|
expected = "[{}]";
|
|
actual = jso_encode_list(one_list);
|
|
assert_equal(expected, actual, "jso_encode_list() failed to encode one-element nested list!");
|
|
jso_cleanup_list(one_list);
|
|
|
|
//jso_encode_list() --- Multi-element nested list
|
|
var multi_list, submap, sublist;
|
|
multi_list = jso_new_list();
|
|
submap = jso_new_map();
|
|
jso_map_add_string(submap, "1", "one");
|
|
jso_list_add_submap(multi_list, submap);
|
|
jso_list_add_integer(multi_list, 2);
|
|
sublist = jso_new_list();
|
|
jso_list_add_string(sublist, "three");
|
|
jso_list_add_boolean(sublist, true);
|
|
jso_list_add_sublist(multi_list, sublist);
|
|
expected = '[{"1":"one"},2,["three",true]]';
|
|
actual = jso_encode_list(multi_list);
|
|
assert_equal(expected, actual, "jso_encode_list() failed to encode one-element nested list!");
|
|
jso_cleanup_list(multi_list);
|
|
}
|
|
|
|
#define _test_jso_decode
|
|
{
|
|
/**
|
|
_test_jso_decode(): Test core _jso_decode_*() functions.
|
|
The formatting is intentionally erratic here to simulate actual formatting deviations.
|
|
JSOnion version: 1.0.0d
|
|
*/
|
|
var json, expected, actual, expected_structure, actual_structure;
|
|
|
|
////Primitives
|
|
|
|
//_jso_decode_string(): Empty string
|
|
json = '""';
|
|
expected = __jso_gmt_tuple("", 3);
|
|
actual = _jso_decode_string(json, 1);
|
|
assert_equal(expected, actual, "_jso_decode_string() failed to decode an empty string!");
|
|
|
|
//_jso_decode_string(): Small string
|
|
json = '"key" ';
|
|
expected = __jso_gmt_tuple("key", 6);
|
|
actual = _jso_decode_string(json, 1);
|
|
assert_equal(expected, actual, "_jso_decode_string() failed to decode a small string!");
|
|
|
|
//_jso_decode_string(): Simple string
|
|
json = ' "The quick brown fox jumps over the lazy dog." ';
|
|
expected = __jso_gmt_tuple("The quick brown fox jumps over the lazy dog.", 49);
|
|
actual = _jso_decode_string(json, 1);
|
|
assert_equal(expected, actual, "_jso_decode_string() failed to decode a simple string!");
|
|
|
|
//_jso_decode_string(): Escape characters
|
|
json = ' "\"\\\b\f\n\r\t\u003A"';
|
|
expected = __jso_gmt_tuple('"\' + chr(8) + chr(12) + chr(10) + chr(13) + chr(9) + chr($003a), 24);
|
|
actual = _jso_decode_string(json, 1);
|
|
assert_equal(expected, actual, "_jso_decode_string() failed to decode a string with escape characters!");
|
|
|
|
//_jso_decode_string(): Mixed characters
|
|
json = ' "\"\\\bWaahoo\f\n\r\tnegg\u003a"';
|
|
expected = __jso_gmt_tuple('"\' + chr(8) + "Waahoo" + chr(12) + chr(10) + chr(13) + chr(9) + "negg" + chr($003a), 34);
|
|
actual = _jso_decode_string(json, 1);
|
|
assert_equal(expected, actual, "_jso_decode_string() failed to decode a string with mixed characters!");
|
|
|
|
//_jso_decode_boolean(): True
|
|
json = 'true';
|
|
expected = __jso_gmt_tuple(true, 5);
|
|
actual = _jso_decode_boolean(json, 1);
|
|
assert_equal(expected, actual, "_jso_decode_boolean() failed to decode true!");
|
|
|
|
//_jso_decode_boolean(): False
|
|
json = ' false ';
|
|
expected = __jso_gmt_tuple(false, 8);
|
|
actual = _jso_decode_boolean(json, 1);
|
|
assert_equal(expected, actual, "_jso_decode_boolean() failed to decode false!");
|
|
|
|
//_jso_decode_real(): Zero
|
|
json = '0';
|
|
expected = __jso_gmt_tuple(0, 2);
|
|
actual = _jso_decode_real(json, 1);
|
|
assert_equal(expected, actual, "_jso_decode_real() failed to decode standard zero!");
|
|
|
|
//_jso_decode_real(): Signed zero
|
|
json = ' +0 ';
|
|
expected = __jso_gmt_tuple(0, 5);
|
|
actual = _jso_decode_real(json, 1);
|
|
assert_equal(expected, actual, "_jso_decode_real() failed to decode signed zero!");
|
|
|
|
//_jso_decode_real(): Signed zero with decimal digits
|
|
json = ' -0.000';
|
|
expected = __jso_gmt_tuple(0, 8);
|
|
actual = _jso_decode_real(json, 1);
|
|
assert_equal(expected, actual, "_jso_decode_real() failed to decode signed zero with decimal digits!");
|
|
|
|
//_jso_decode_real(): Positive real
|
|
json = '3.14159';
|
|
expected = __jso_gmt_tuple(3.14159, 8);
|
|
actual = _jso_decode_real(json, 1);
|
|
assert_equal(expected, actual, "_jso_decode_real() failed to decode positive real number!");
|
|
|
|
//_jso_decode_real(): Negative real
|
|
json = ' -2.71828';
|
|
expected = __jso_gmt_tuple(-2.71828, 10);
|
|
actual = _jso_decode_real(json, 1);
|
|
assert_equal(expected, actual, "_jso_decode_real() failed to decode negative real number!");
|
|
|
|
//_jso_decode_real(): Positive real with positive exponent
|
|
json = ' 3.14159e2';
|
|
expected = __jso_gmt_tuple(3.14159*100, 11);
|
|
actual = _jso_decode_real(json, 1);
|
|
assert_equal(expected, actual, "_jso_decode_real() failed to decode positive real number with positive exponent!");
|
|
|
|
//_jso_decode_real(): Negative real with positive exponent
|
|
json = ' -2.71828E2';
|
|
expected = __jso_gmt_tuple(-2.71828*100, 12);
|
|
actual = _jso_decode_real(json, 1);
|
|
assert_equal(expected, actual, "_jso_decode_real() failed to decode negative real number with positive exponent!");
|
|
|
|
//_jso_decode_real(): Positive real with negative exponent
|
|
json = ' 314.159e-2';
|
|
expected = __jso_gmt_tuple(3.14159, 12);
|
|
actual = _jso_decode_real(json, 1);
|
|
assert_equal(expected, actual, "_jso_decode_real() failed to decode positive real number with negative exponent!");
|
|
|
|
//_jso_decode_real(): Negative real with negative exponent
|
|
json = ' -271.828E-2';
|
|
expected = __jso_gmt_tuple(-2.71828, 13);
|
|
actual = _jso_decode_real(json, 1);
|
|
assert_equal(expected, actual, "_jso_decode_real() failed to decode negative real number with negative exponent!");
|
|
|
|
//_jso_decode_real(): Positive integer
|
|
json = ' +1729';
|
|
expected = __jso_gmt_tuple(1729, 7);
|
|
actual = _jso_decode_real(json, 1);
|
|
assert_equal(expected, actual, "_jso_decode_real() failed to decode positive integer!");
|
|
|
|
//_jso_decode_real(): Negative integer
|
|
json = '-583';
|
|
expected = __jso_gmt_tuple(-583, 5);
|
|
actual = _jso_decode_real(json, 1);
|
|
assert_equal(expected, actual, "_jso_decode_real() failed to decode negative integer!");
|
|
|
|
//_jso_decode_integer(): Zero
|
|
json = ' 0 ';
|
|
expected = __jso_gmt_tuple(0, 3);
|
|
actual = _jso_decode_integer(json, 1);
|
|
assert_equal(expected, actual, "_jso_decode_integer() failed to decode zero!");
|
|
|
|
//_jso_decode_integer(): Positive integer
|
|
json = ' 1729 ';
|
|
expected = __jso_gmt_tuple(1729, 6);
|
|
actual = _jso_decode_integer(json, 1);
|
|
assert_equal(expected, actual, "_jso_decode_integer() failed to decode positive integer!");
|
|
|
|
//_jso_decode_integer(): Negative integer
|
|
json = ' -583';
|
|
expected = __jso_gmt_tuple(-583, 8);
|
|
actual = _jso_decode_integer(json, 1);
|
|
assert_equal(expected, actual, "_jso_decode_integer() failed to decode negative integer!");
|
|
|
|
|
|
////Data structures
|
|
|
|
//_jso_decode_map(): Empty map #1
|
|
json = '{}';
|
|
expected_structure = jso_new_map();
|
|
expected = __jso_gmt_tuple(expected_structure, 3);
|
|
actual = _jso_decode_map(json, 1);
|
|
actual_structure = __jso_gmt_elem(actual, 0);
|
|
assert_equal(__jso_gmt_elem(expected, 1), __jso_gmt_elem(actual, 1), "_jso_decode_map() didn't stop at the right place! (#1)");
|
|
assert_equal(actual_structure, __jso_gmt_elem(actual, 0), "_jso_decode_map() didn't include the right prefix! (#1)");
|
|
assert_true(jso_compare_maps(expected_structure, actual_structure), "_jso_decode_map() failed to decode an empty map! (#1)");
|
|
jso_cleanup_map(expected_structure);
|
|
jso_cleanup_map(actual_structure);
|
|
|
|
//_jso_decode_map(): Empty map #2
|
|
json = ' { } ';
|
|
expected_structure = jso_new_map();
|
|
expected = __jso_gmt_tuple(expected_structure, 7);
|
|
actual = _jso_decode_map(json, 1);
|
|
actual_structure = __jso_gmt_elem(actual, 0);
|
|
assert_equal(__jso_gmt_elem(expected, 1), __jso_gmt_elem(actual, 1), "_jso_decode_map() didn't stop at the right place! (#2)");
|
|
assert_equal(actual_structure, __jso_gmt_elem(actual, 0), "_jso_decode_map() didn't include the right prefix! (#2)");
|
|
assert_true(jso_compare_maps(expected_structure, actual_structure), "_jso_decode_map() failed to decode an empty map! (#2)");
|
|
jso_cleanup_map(expected_structure);
|
|
jso_cleanup_map(actual_structure);
|
|
|
|
//_jso_decode_map(): One-entry map
|
|
json = ' {"key": "value"} ';
|
|
expected_structure = jso_new_map();
|
|
expected = __jso_gmt_tuple(expected_structure, 18);
|
|
jso_map_add_string(expected_structure, "key", "value");
|
|
actual = _jso_decode_map(json, 1);
|
|
actual_structure = __jso_gmt_elem(actual, 0);
|
|
assert_equal(__jso_gmt_elem(expected, 1), __jso_gmt_elem(actual, 1), "_jso_decode_map() didn't stop at the right place! (one-entry map)");
|
|
assert_equal(actual_structure, __jso_gmt_elem(actual, 0), "_jso_decode_map() didn't include the right prefix! (one-entry map)");
|
|
assert_true(jso_compare_maps(expected_structure, actual_structure), "_jso_decode_map() failed to decode a one-entry map!");
|
|
jso_cleanup_map(expected_structure);
|
|
jso_cleanup_map(actual_structure);
|
|
|
|
//_jso_decode_map(): Multi-entry map
|
|
json = ' {"key" : "value", "pi":3.14, "bool" : true} ';
|
|
expected_structure = jso_new_map();
|
|
expected = __jso_gmt_tuple(expected_structure, 48);
|
|
jso_map_add_string(expected_structure, "key", "value");
|
|
jso_map_add_real(expected_structure, "pi", 3.14);
|
|
jso_map_add_boolean(expected_structure, "bool", true);
|
|
actual = _jso_decode_map(json, 1);
|
|
actual_structure = __jso_gmt_elem(actual, 0);
|
|
assert_equal(__jso_gmt_elem(expected, 1), __jso_gmt_elem(actual, 1), "_jso_decode_map() didn't stop at the right place! (multi-entry map)");
|
|
assert_equal(actual_structure, __jso_gmt_elem(actual, 0), "_jso_decode_map() didn't include the right prefix! (multi-entry map)");
|
|
assert_true(jso_compare_maps(expected_structure, actual_structure), "_jso_decode_map() failed to decode a multi-entry map!");
|
|
jso_cleanup_map(expected_structure);
|
|
jso_cleanup_map(actual_structure);
|
|
|
|
//_jso_decode_map(): Nested maps
|
|
var submap;
|
|
json = '{ "waahoo" : { "woohah" : 3 } , "woohah" : 4 }';
|
|
expected_structure = jso_new_map();
|
|
expected = __jso_gmt_tuple(expected_structure, 47);
|
|
jso_map_add_integer(expected_structure, "woohah", 4);
|
|
submap = jso_new_map();
|
|
jso_map_add_integer(submap, "woohah", 3);
|
|
jso_map_add_submap(expected_structure, "waahoo", submap);
|
|
actual = _jso_decode_map(json, 1);
|
|
actual_structure = __jso_gmt_elem(actual, 0);
|
|
assert_equal(__jso_gmt_elem(expected, 1), __jso_gmt_elem(actual, 1), "_jso_decode_map() didn't stop at the right place! (nested map)");
|
|
assert_equal(actual_structure, __jso_gmt_elem(actual, 0), "_jso_decode_map() didn't include the right prefix! (nested map)");
|
|
assert_true(jso_compare_maps(expected_structure, actual_structure), "_jso_decode_map() failed to decode a nested map!");
|
|
jso_cleanup_map(expected_structure);
|
|
jso_cleanup_map(actual_structure);
|
|
|
|
//_jso_decode_map(): Map with nested lists
|
|
var sublist, subsublist;
|
|
json = '{ "waahoo" : [ "woohah", [true] ] , "woohah" : 4 }';
|
|
expected_structure = jso_new_map();
|
|
expected = __jso_gmt_tuple(expected_structure, 51);
|
|
jso_map_add_real(expected_structure, "woohah", 4);
|
|
sublist = jso_new_list();
|
|
jso_list_add_string(sublist, "woohah");
|
|
subsublist = jso_new_list();
|
|
jso_list_add_boolean(subsublist, true);
|
|
jso_list_add_sublist(sublist, subsublist);
|
|
jso_map_add_sublist(expected_structure, "waahoo", sublist);
|
|
actual = _jso_decode_map(json, 1);
|
|
actual_structure = __jso_gmt_elem(actual, 0);
|
|
assert_equal(__jso_gmt_elem(expected, 1), __jso_gmt_elem(actual, 1), "_jso_decode_map() didn't stop at the right place! (map with nested lists)");
|
|
assert_equal(actual_structure, __jso_gmt_elem(actual, 0), "_jso_decode_map() didn't include the right prefix! (map with nested lists)");
|
|
assert_true(jso_compare_maps(expected_structure, actual_structure), "_jso_decode_map() failed to decode a map with nested lists!");
|
|
jso_cleanup_map(expected_structure);
|
|
jso_cleanup_map(actual_structure);
|
|
|
|
//_jso_decode_map(): Mix-up nested map
|
|
var sublist;
|
|
json = ' { "waahoo" : [{}, "a", 1] }';
|
|
expected_structure = jso_new_map();
|
|
expected = __jso_gmt_tuple(expected_structure, 30);
|
|
sublist = jso_new_list();
|
|
jso_list_add_submap(sublist, jso_new_map());
|
|
jso_list_add_string(sublist, "a");
|
|
jso_list_add_real(sublist, 1);
|
|
jso_map_add_sublist(expected_structure, "waahoo", sublist);
|
|
actual = _jso_decode_map(json, 1);
|
|
actual_structure = __jso_gmt_elem(actual, 0);
|
|
assert_equal(__jso_gmt_elem(expected, 1), __jso_gmt_elem(actual, 1), "_jso_decode_map() didn't stop at the right place! (mix-up nested map)");
|
|
assert_equal(actual_structure, __jso_gmt_elem(actual, 0), "_jso_decode_map() didn't include the right prefix! (mix-up nested map)");
|
|
assert_true(jso_compare_maps(expected_structure, actual_structure), "_jso_decode_map() failed to decode a mix-up nested map!");
|
|
jso_cleanup_map(expected_structure);
|
|
jso_cleanup_map(actual_structure);
|
|
|
|
//_jso_decode_list(): Empty list #1
|
|
json = '[]';
|
|
expected_structure = jso_new_list();
|
|
expected = __jso_gmt_tuple(expected_structure, 3);
|
|
actual = _jso_decode_list(json, 1);
|
|
actual_structure = __jso_gmt_elem(actual, 0);
|
|
assert_equal(__jso_gmt_elem(expected, 1), __jso_gmt_elem(actual, 1), "_jso_decode_list() didn't stop at the right place! (#1)");
|
|
assert_equal(actual_structure, __jso_gmt_elem(actual, 0), "_jso_decode_list() didn't include the right prefix! (#1)");
|
|
assert_true(jso_compare_lists(expected_structure, actual_structure), "_jso_decode_list() failed to decode an empty list! (#1)");
|
|
jso_cleanup_list(expected_structure);
|
|
jso_cleanup_list(actual_structure)
|
|
|
|
//_jso_decode_list(): Empty list #2
|
|
json = ' [ ] ';
|
|
expected_structure = jso_new_list();
|
|
expected = __jso_gmt_tuple(expected_structure, 6);
|
|
actual = _jso_decode_list(json, 1);
|
|
actual_structure = __jso_gmt_elem(actual, 0);
|
|
assert_equal(__jso_gmt_elem(expected, 1), __jso_gmt_elem(actual, 1), "_jso_decode_list() didn't stop at the right place! (#2)");
|
|
assert_equal(actual_structure, __jso_gmt_elem(actual, 0), "_jso_decode_list() didn't include the right prefix! (#2)");
|
|
assert_true(jso_compare_lists(expected_structure, actual_structure), "_jso_decode_list() failed to decode an empty list! (#2)");
|
|
jso_cleanup_list(expected_structure);
|
|
jso_cleanup_list(actual_structure);
|
|
|
|
//_jso_decode_list(): One-entry list
|
|
json = '[3]';
|
|
expected_structure = jso_new_list();
|
|
expected = __jso_gmt_tuple(expected_structure, 4);
|
|
jso_list_add_integer(expected_structure, 3);
|
|
actual = _jso_decode_list(json, 1);
|
|
actual_structure = __jso_gmt_elem(actual, 0);
|
|
assert_equal(__jso_gmt_elem(expected, 1), __jso_gmt_elem(actual, 1), "_jso_decode_list() didn't stop at the right place! (one-entry list)");
|
|
assert_equal(actual_structure, __jso_gmt_elem(actual, 0), "_jso_decode_list() didn't include the right prefix! (one-entry list)");
|
|
assert_true(jso_compare_lists(expected_structure, actual_structure), "_jso_decode_list() failed to decode a one-entry list!");
|
|
jso_cleanup_list(expected_structure);
|
|
jso_cleanup_list(actual_structure);
|
|
|
|
//_jso_decode_list(): Multi-entry list
|
|
json = ' [4,"multi-entry",true]';
|
|
expected_structure = jso_new_list();
|
|
expected = __jso_gmt_tuple(expected_structure, 24);
|
|
jso_list_add_real(expected_structure, 4);
|
|
jso_list_add_string(expected_structure, "multi-entry");
|
|
jso_list_add_boolean(expected_structure, true);
|
|
actual = _jso_decode_list(json, 1);
|
|
actual_structure = __jso_gmt_elem(actual, 0);
|
|
assert_equal(__jso_gmt_elem(expected, 1), __jso_gmt_elem(actual, 1), "_jso_decode_list() didn't stop at the right place! (multi-entry list)");
|
|
assert_equal(actual_structure, __jso_gmt_elem(actual, 0), "_jso_decode_list() didn't include the right prefix! (multi-entry list)");
|
|
assert_true(jso_compare_lists(expected_structure, actual_structure), "_jso_decode_list() failed to decode a multi-entry list!");
|
|
jso_cleanup_list(expected_structure);
|
|
jso_cleanup_list(actual_structure);
|
|
|
|
//_jso_decode_list(): Nested list
|
|
var sublist;
|
|
json = ' [ [], 3, false, ["waahoo"]]';
|
|
expected_structure = jso_new_list();
|
|
expected = __jso_gmt_tuple(expected_structure, 29);
|
|
jso_list_add_sublist(expected_structure, jso_new_list());
|
|
jso_list_add_integer(expected_structure, 3);
|
|
jso_list_add_boolean(expected_structure, false);
|
|
sublist = jso_new_list();
|
|
jso_list_add_string(sublist, "waahoo");
|
|
jso_list_add_sublist(expected_structure, sublist);
|
|
actual = _jso_decode_list(json, 1);
|
|
actual_structure = __jso_gmt_elem(actual, 0);
|
|
assert_equal(__jso_gmt_elem(expected, 1), __jso_gmt_elem(actual, 1), "_jso_decode_list() didn't stop at the right place! (nested list)");
|
|
assert_equal(actual_structure, __jso_gmt_elem(actual, 0), "_jso_decode_list() didn't include the right prefix! (nested list)");
|
|
assert_true(jso_compare_lists(expected_structure, actual_structure), "_jso_decode_list() failed to decode a nested list!");
|
|
jso_cleanup_list(expected_structure);
|
|
jso_cleanup_list(actual_structure);
|
|
|
|
//_jso_decode_list(): List with nested maps
|
|
var submap;
|
|
json = ' [3, false, { "waahoo":"woo"}]';
|
|
expected_structure = jso_new_list();
|
|
expected = __jso_gmt_tuple(expected_structure, 31);
|
|
jso_list_add_integer(expected_structure, 3);
|
|
jso_list_add_boolean(expected_structure, false);
|
|
submap = jso_new_map();
|
|
jso_map_add_string(submap, "waahoo", "woo");
|
|
jso_list_add_submap(expected_structure, submap);
|
|
actual = _jso_decode_list(json, 1);
|
|
actual_structure = __jso_gmt_elem(actual, 0);
|
|
assert_equal(__jso_gmt_elem(expected, 1), __jso_gmt_elem(actual, 1), "_jso_decode_list() didn't stop at the right place! (list with nested maps)");
|
|
assert_equal(actual_structure, __jso_gmt_elem(actual, 0), "_jso_decode_list() didn't include the right prefix! (list with nested maps)");
|
|
assert_true(jso_compare_lists(expected_structure, actual_structure), "_jso_decode_list() failed to decode a list with nested maps!");
|
|
jso_cleanup_list(expected_structure);
|
|
jso_cleanup_list(actual_structure);
|
|
|
|
//_jso_decode_list(): Mix-up nested list
|
|
var submap;
|
|
json = '[{}, {"a":[]}]';
|
|
expected_structure = jso_new_list();
|
|
expected = __jso_gmt_tuple(expected_structure, 15);
|
|
jso_list_add_submap(expected_structure, jso_new_map());
|
|
submap = jso_new_map();
|
|
jso_map_add_sublist(submap, "a", jso_new_list());
|
|
jso_list_add_submap(expected_structure, submap);
|
|
actual = _jso_decode_list(json, 1);
|
|
actual_structure = __jso_gmt_elem(actual, 0);
|
|
assert_equal(__jso_gmt_elem(expected, 1), __jso_gmt_elem(actual, 1), "_jso_decode_list() didn't stop at the right place! (mix-up nested list)");
|
|
assert_equal(actual_structure, __jso_gmt_elem(actual, 0), "_jso_decode_list() didn't include the right prefix! (mix-up nested list)");
|
|
assert_true(jso_compare_lists(expected_structure, actual_structure), "_jso_decode_list() failed to decode a mix-up nested list!");
|
|
jso_cleanup_list(expected_structure);
|
|
jso_cleanup_list(actual_structure);
|
|
}
|
|
|
|
#define _test_jso_compare
|
|
{
|
|
/**
|
|
_test_jso_compare(): Test basic jso_compare_*() functions.
|
|
JSOnion version: 1.0.0d
|
|
*/
|
|
var a, b;
|
|
|
|
//jso_compare_maps(): Empty maps should equal each other
|
|
a = jso_new_map();
|
|
b = jso_new_map();
|
|
assert_true(jso_compare_maps(a, b), "Empty maps should equal each other. (#1)");
|
|
assert_true(jso_compare_maps(b, a), "Empty maps should equal each other. (#2)");
|
|
jso_cleanup_map(a);
|
|
jso_cleanup_map(b);
|
|
|
|
//jso_compare_maps(): An empty map should not equal a filled map
|
|
a = jso_new_map();
|
|
b = jso_new_map();
|
|
jso_map_add_string(b, "junk", "info");
|
|
jso_map_add_integer(b, "taxi", 1729);
|
|
assert_false(jso_compare_maps(a, b), "An empty map should not equal a filled map. (#1)");
|
|
assert_false(jso_compare_maps(b, a), "An empty map should not equal a filled map. (#2)");
|
|
jso_cleanup_map(a);
|
|
jso_cleanup_map(b);
|
|
|
|
//jso_compare_maps(): Maps with same content entered in different orders should equal each other
|
|
a = jso_new_map();
|
|
b = jso_new_map();
|
|
jso_map_add_real(a, "A", 1);
|
|
jso_map_add_real(a, "B", 2);
|
|
jso_map_add_real(a, "C", 3);
|
|
jso_map_add_real(b, "C", 3);
|
|
jso_map_add_real(b, "A", 1);
|
|
jso_map_add_real(b, "B", 2);
|
|
assert_true(jso_compare_maps(a, b), "Maps with same content entered in different orders should equal each other. (#1)");
|
|
assert_true(jso_compare_maps(b, a), "Maps with same content entered in different orders should equal each other. (#2)");
|
|
jso_cleanup_map(a);
|
|
jso_cleanup_map(b);
|
|
|
|
//jso_compare_maps(): Maps with different keys should not equal each other
|
|
a = jso_new_map();
|
|
b = jso_new_map();
|
|
jso_map_add_real(a, "A", 1);
|
|
jso_map_add_real(a, "B", 2);
|
|
jso_map_add_real(a, "C", 3);
|
|
jso_map_add_real(b, "D", 3);
|
|
jso_map_add_real(b, "A", 1);
|
|
jso_map_add_real(b, "B", 2);
|
|
assert_false(jso_compare_maps(a, b), "Maps with different keys should not equal each other. (#1)");
|
|
assert_false(jso_compare_maps(b, a), "Maps with different keys should not equal each other. (#2)");
|
|
jso_cleanup_map(a);
|
|
jso_cleanup_map(b);
|
|
|
|
//jso_compare_maps(): Maps with different values should not equal each other
|
|
a = jso_new_map();
|
|
b = jso_new_map();
|
|
jso_map_add_real(a, "A", 5);
|
|
jso_map_add_real(a, "B", 6);
|
|
jso_map_add_real(a, "C", 9);
|
|
jso_map_add_real(b, "A", 5);
|
|
jso_map_add_real(b, "B", 6);
|
|
jso_map_add_real(b, "C", 8);
|
|
assert_false(jso_compare_maps(a, b), "Maps with different values should not equal each other. (#1)");
|
|
assert_false(jso_compare_maps(b, a), "Maps with different values should not equal each other. (#2)");
|
|
jso_cleanup_map(a);
|
|
jso_cleanup_map(b);
|
|
|
|
//jso_compare_maps(): Maps with corresponding values of different types should not equal each other, and should not crash.
|
|
a = jso_new_map();
|
|
b = jso_new_map();
|
|
jso_map_add_real(a, "A", 5);
|
|
jso_map_add_real(a, "B", 6);
|
|
jso_map_add_real(a, "C", 8);
|
|
jso_map_add_real(b, "A", 5);
|
|
jso_map_add_string(b, "B", "six");
|
|
jso_map_add_real(b, "C", 8);
|
|
assert_false(jso_compare_maps(a, b), "Maps with corresponding values of different types should not equal each other, and should not crash. (#1)");
|
|
assert_false(jso_compare_maps(b, a), "Maps with corresponding values of different types should not equal each other, and should not crash. (#2)");
|
|
jso_cleanup_map(a);
|
|
jso_cleanup_map(b);
|
|
|
|
//jso_compare_lists(): Empty lists should equal each other
|
|
a = jso_new_list();
|
|
b = jso_new_list();
|
|
assert_true(jso_compare_lists(a, b), "Empty lists should equal each other. (#1)");
|
|
assert_true(jso_compare_lists(b, a), "Empty lists should equal each other. (#2)");
|
|
jso_cleanup_list(a);
|
|
jso_cleanup_list(b);
|
|
|
|
//jso_compare_lists(): An empty list should not equal a filled list
|
|
a = jso_new_list();
|
|
b = jso_new_list();
|
|
jso_list_add_string(b, "junk");
|
|
jso_list_add_integer(b, 1729);
|
|
assert_false(jso_compare_lists(a, b), "An empty list should not equal a filled list. (#1)");
|
|
assert_false(jso_compare_lists(b, a), "An empty list should not equal a filled list. (#2)");
|
|
jso_cleanup_list(a);
|
|
jso_cleanup_list(b);
|
|
|
|
//jso_compare_lists(): Lists with same content entered in different orders should not equal each other
|
|
a = jso_new_list();
|
|
b = jso_new_list();
|
|
jso_list_add_real(a, 1);
|
|
jso_list_add_real(a, 2);
|
|
jso_list_add_real(a, 3);
|
|
jso_list_add_real(b, 3);
|
|
jso_list_add_real(b, 1);
|
|
jso_list_add_real(b, 2);
|
|
assert_false(jso_compare_lists(a, b), "Lists with same content entered in different orders should not equal each other. (#1)");
|
|
assert_false(jso_compare_lists(b, a), "Lists with same content entered in different orders should not equal each other. (#2)");
|
|
jso_cleanup_list(a);
|
|
jso_cleanup_list(b);
|
|
|
|
//jso_compare_lists(): Lists with corresponding entries of different types should not equal each other, should also not crash.
|
|
a = jso_new_list();
|
|
b = jso_new_list();
|
|
jso_list_add_real(a, 1);
|
|
jso_list_add_real(a, 2);
|
|
jso_list_add_real(a, 3);
|
|
jso_list_add_real(b, 1);
|
|
jso_list_add_string(b, "two");
|
|
jso_list_add_real(b, 3);
|
|
assert_false(jso_compare_lists(a, b), "Lists with corresponding entries of different types should not equal each other, should also not crash. (#1)");
|
|
assert_false(jso_compare_lists(b, a), "Lists with corresponding entries of different types should not equal each other, should also not crash. (#2)");
|
|
jso_cleanup_list(a);
|
|
jso_cleanup_list(b);
|
|
}
|
|
|
|
#define _test_jso_lookup
|
|
{
|
|
/**
|
|
_test_jso_lookup(): Test core jso_*_lookup() and jso_*_check() functions for nested structures.
|
|
JSOnion version: 1.0.0d
|
|
*/
|
|
var json, structure, expected, actual;
|
|
|
|
//jso_map_check(): Single argument --- exists
|
|
json = '{ "one" : 1, "two" : 2, "three" : 3 }';
|
|
structure = jso_decode_map(json);
|
|
assert_true(jso_map_check(structure, "one"), "jso_map_check() failed to find existing entry! (single argument)");
|
|
jso_cleanup_map(structure);
|
|
|
|
//jso_map_lookup(): Single argument --- exists
|
|
json = '{ "one" : 1, "two" : 2, "three" : 3 }';
|
|
structure = jso_decode_map(json);
|
|
expected = 1;
|
|
actual = jso_map_lookup(structure, "one")
|
|
assert_equal(expected, actual, "jso_map_lookup() found the wrong entry! (single argument)");
|
|
jso_cleanup_map(structure);
|
|
|
|
//jso_map_lookup_type(): Single argument --- exists
|
|
json = '{ "one" : -1, "two" : true, "three" : "trap" }';
|
|
structure = jso_decode_map(json);
|
|
expected = jso_type_real;
|
|
actual = jso_map_lookup_type(structure, "one")
|
|
assert_equal(expected, actual, "jso_map_lookup_type() found the wrong type! (single argument)");
|
|
jso_cleanup_map(structure);
|
|
|
|
//jso_map_check(): Single argument --- doesn't exist
|
|
json = '{ "one" : 1, "two" : 2, "three" : 3 }';
|
|
structure = jso_decode_map(json);
|
|
assert_false(jso_map_check(structure, "four"), "jso_map_check() found an inexistent entry! (single argument)");
|
|
jso_cleanup_map(structure);
|
|
|
|
//jso_map_check(): Single argument --- doesn't exist
|
|
json = '{ "one" : 1, "two" : 2, "three" : 3, "four" : { "A":true, "B":false } }';
|
|
structure = jso_decode_map(json);
|
|
assert_false(jso_map_check(structure, "A"), "jso_map_check() found an inexistent entry! (single argument, nested)");
|
|
jso_cleanup_map(structure);
|
|
|
|
//jso_map_check(): Multiple arguments (recurse) --- exists
|
|
json = '{ "one" : 1, "two" : 2, "three" : 3, "four" : { "A":true, "B":false } }';
|
|
structure = jso_decode_map(json);
|
|
assert_true(jso_map_check(structure, "four", "A"), "jso_map_check() failed to find existing entry! (multiple arguments)");
|
|
jso_cleanup_map(structure);
|
|
|
|
//jso_map_lookup(): Multiple arguments (recurse) --- exists
|
|
json = '{ "one" : 1, "two" : 2, "three" : 3, "four" : { "A":true, "B":false } }';
|
|
structure = jso_decode_map(json);
|
|
expected = true;
|
|
actual = jso_map_lookup(structure, "four", "A");
|
|
assert_equal(expected, actual, "jso_map_lookup() found the wrong entry! (multiple arguments)");
|
|
jso_cleanup_map(structure);
|
|
|
|
//jso_map_lookup_type(): Multiple arguments (recurse) --- exists
|
|
json = '{ "one" : 1, "two" : 2, "three" : 3, "four" : { "A":true, "B":"trap" } }';
|
|
structure = jso_decode_map(json);
|
|
expected = jso_type_boolean;
|
|
actual = jso_map_lookup_type(structure, "four", "A");
|
|
assert_equal(expected, actual, "jso_map_lookup_type() found the wrong type! (multiple arguments)");
|
|
jso_cleanup_map(structure);
|
|
|
|
//jso_map_check(): Multiple arguments (recurse) --- doesn't exist
|
|
json = '{ "one" : 1, "two" : 2, "three" : 3, "four" : { "A":true, "B":false } }';
|
|
structure = jso_decode_map(json);
|
|
assert_false(jso_map_check(structure, "four", "C"), "jso_map_check() found an inexistent entry! (multiple arguments, 1)");
|
|
jso_cleanup_map(structure);
|
|
|
|
//jso_map_check(): Multiple arguments (recurse) --- doesn't exist
|
|
json = '{ "one" : 1, "two" : 2, "three" : 3, "four" : { "A":true, "B":false } }';
|
|
structure = jso_decode_map(json);
|
|
assert_false(jso_map_check(structure, "three", ""), "jso_map_check() found an inexistent entry! (multiple arguments, 2)");
|
|
jso_cleanup_map(structure);
|
|
|
|
//jso_map_check(): Multiple arguments with nested list --- exists
|
|
json = '{ "one" : 1, "two" : 2, "three" : 3, "four" : [ "A", true, ["B", false] ] }';
|
|
structure = jso_decode_map(json);
|
|
assert_true(jso_map_check(structure, "four", 2, 1), "jso_map_check() failed to find an existing entry! (multiple arguments, nested)");
|
|
jso_cleanup_map(structure);
|
|
|
|
//jso_map_lookup(): Multiple arguments with nested list --- exists
|
|
json = '{ "one" : 1, "two" : 2, "three" : 3, "four" : [ "A", true, ["B", false] ] }';
|
|
structure = jso_decode_map(json);
|
|
expected = false;
|
|
actual = jso_map_lookup(structure, "four", 2, 1);
|
|
assert_equal(expected, actual, "jso_map_lookup() failed to find an existing entry! (multiple arguments, nested)");
|
|
jso_cleanup_map(structure);
|
|
|
|
//jso_map_lookup_type(): Multiple arguments with nested list --- exists
|
|
json = '{ "one" : 1, "two" : 2, "three" : 3, "four" : [ "A", true, [false, "false"] ] }';
|
|
structure = jso_decode_map(json);
|
|
expected = jso_type_string;
|
|
actual = jso_map_lookup_type(structure, "four", 2, 1);
|
|
assert_equal(expected, actual, "jso_map_lookup_type() found the wrong type! (multiple arguments, nested)");
|
|
jso_cleanup_map(structure);
|
|
|
|
//jso_map_check(): Multiple arguments with nested list --- wrong type
|
|
json = '{ "one" : 1, "two" : 2, "three" : 3, "four" : [ "A", true, ["B", false] ] }';
|
|
structure = jso_decode_map(json);
|
|
assert_false(jso_map_check(structure, "four", "A", 1), "jso_map_check() found an inexistent entry! (multiple arguments, nested, wrong type)");
|
|
jso_cleanup_map(structure);
|
|
|
|
//jso_map_check(): Multiple arguments with nested list --- index overflow
|
|
json = '{ "one" : 1, "two" : 2, "three" : 3, "four" : [ "A", true, ["B", false] ] }';
|
|
structure = jso_decode_map(json);
|
|
assert_false(jso_map_check(structure, "four", 2, 3), "jso_map_check() found an inexistent entry! (multiple arguments, nested, index overflow)");
|
|
jso_cleanup_map(structure);
|
|
|
|
//jso_list_check(): Single argument --- exists
|
|
json = '["one", 2, "three", true, 5]';
|
|
structure = jso_decode_list(json);
|
|
assert_true(jso_list_check(structure, 2), "jso_list_check() failed to find an existing index! (single argument)");
|
|
jso_cleanup_list(structure);
|
|
|
|
//jso_list_lookup(): Single argument --- exists
|
|
json = '["one", 2, "three", true, 5]';
|
|
structure = jso_decode_list(json);
|
|
expected = "three";
|
|
actual = jso_list_lookup(structure, 2);
|
|
assert_equal(expected, actual, "jso_list_lookup() found the wrong index! (single argument)");
|
|
jso_cleanup_list(structure);
|
|
|
|
//jso_list_lookup_type(): Single argument --- exists
|
|
json = '["one", 2, "three", true, 5]';
|
|
structure = jso_decode_list(json);
|
|
expected = jso_type_string;
|
|
actual = jso_list_lookup_type(structure, 2);
|
|
assert_equal(expected, actual, "jso_list_lookup_type() found the wrong type! (single argument)");
|
|
jso_cleanup_list(structure);
|
|
|
|
//jso_list_check(): Single argument --- doesn't exist
|
|
json = '["one", 2, "three", true, 5]';
|
|
structure = jso_decode_list(json);
|
|
assert_false(jso_list_check(structure, 5), "jso_list_check() found an inexistent index! (single argument)");
|
|
jso_cleanup_list(structure);
|
|
|
|
//jso_list_check(): Multiple arguments (recurse) --- exists
|
|
json = '["one", 2, ["three", 3], true, 5]';
|
|
structure = jso_decode_list(json);
|
|
assert_true(jso_list_check(structure, 2, 1), "jso_list_check() failed to find an existing index! (multiple arguments)");
|
|
jso_cleanup_list(structure);
|
|
|
|
//jso_list_lookup(): Multiple arguments (recurse) --- exists
|
|
json = '["one", 2, ["three", 3], true, 5]';
|
|
structure = jso_decode_list(json);
|
|
expected = 3;
|
|
actual = jso_list_lookup(structure, 2, 1);
|
|
assert_equal(expected, actual, "jso_list_lookup() failed to find an existing index! (multiple arguments)");
|
|
jso_cleanup_list(structure);
|
|
|
|
//jso_list_lookup_type(): Multiple arguments (recurse) --- exists
|
|
json = '["one", 2, ["three", 3], true, 5]';
|
|
structure = jso_decode_list(json);
|
|
expected = jso_type_real;
|
|
actual = jso_list_lookup_type(structure, 2, 1);
|
|
assert_equal(expected, actual, "jso_list_lookup_type() found the wrong type! (multiple arguments)");
|
|
jso_cleanup_list(structure);
|
|
|
|
//jso_list_check(): Multiple arguments (recurse) --- doesn't exist, inner index overflow
|
|
json = '["one", 2, ["three", 3], true, 5]';
|
|
structure = jso_decode_list(json);
|
|
assert_false(jso_list_check(structure, 2, 2), "jso_list_check() found an inexistent index! (multiple arguments, inner index overflow)");
|
|
jso_cleanup_list(structure);
|
|
|
|
//jso_list_check(): Multiple arguments (recurse) --- doesn't exist, trying to index single entry
|
|
json = '["one", 2, ["three", 3], true, 5]';
|
|
structure = jso_decode_list(json);
|
|
assert_false(jso_list_check(structure, 1, 0), "jso_list_check() found an inexistent index! (multiple arguments, indexing single entry)");
|
|
jso_cleanup_list(structure);
|
|
|
|
//jso_list_check(): Multiple arguments with nested map --- exists
|
|
json = '["one", 2, {"three":3}, true, 5]';
|
|
structure = jso_decode_list(json);
|
|
assert_true(jso_list_check(structure, 2, "three"), "jso_list_check() failed to find an existing entry! (multiple arguments, nested map)");
|
|
jso_cleanup_list(structure);
|
|
|
|
//jso_list_lookup(): Multiple arguments with nested map --- exists
|
|
json = '["one", 2, {"three":3}, true, 5]';
|
|
structure = jso_decode_list(json);
|
|
expected = 3;
|
|
actual = jso_list_lookup(structure, 2, "three");
|
|
assert_equal(expected, actual, "jso_list_lookup() failed to find an existing entry! (multiple arguments, nested map)");
|
|
jso_cleanup_list(structure);
|
|
|
|
//jso_list_lookup_type(): Multiple arguments with nested map --- exists
|
|
json = '["one", 2, {"three":false}, true, 5]';
|
|
structure = jso_decode_list(json);
|
|
expected = jso_type_boolean;
|
|
actual = jso_list_lookup_type(structure, 2, "three");
|
|
assert_equal(expected, actual, "jso_list_lookup_type() found the wrong type! (multiple arguments, nested map)");
|
|
jso_cleanup_list(structure);
|
|
|
|
//jso_list_exists(): Multiple arguments with nested map --- doesn't exist, key on single entry
|
|
json = '["one", 2, {"three":3}, true, 5]';
|
|
structure = jso_decode_list(json);
|
|
assert_false(jso_list_check(structure, 1, ""), "jso_list_check() found an inexistent entry! (multiple arguments, nested map, key on single entry)");
|
|
jso_cleanup_list(structure);
|
|
|
|
//jso_list_exists(): Multiple arguments with nested map --- doesn't exist, bad key
|
|
json = '["one", 2, {"three":3}, true, 5]';
|
|
structure = jso_decode_list(json);
|
|
assert_false(jso_list_check(structure, 2, ""), "jso_list_check() found an inexistent entry! (multiple arguments, nested map, bad key)");
|
|
jso_cleanup_list(structure);
|
|
}
|
|
|
|
#define _test_jso_bugs
|
|
{
|
|
/**
|
|
_test_jso_bugs(): Test reported bugs.
|
|
JSOnion version: 1.0.0d
|
|
*/
|
|
var expected, actual;
|
|
|
|
//jso_encode_map() --- One-element map
|
|
//Bug 1: Crash when encoding boolean-valued entries in maps, unknown variable jso_type_integer
|
|
var one_map;
|
|
one_map = jso_new_map();
|
|
jso_map_add_boolean(one_map, "true", true);
|
|
expected = '{"true":true}';
|
|
actual = jso_encode_map(one_map);
|
|
assert_equal(expected, actual, "jso_encode_map() failed to encode one-element map with boolean entry!");
|
|
jso_cleanup_map(one_map);
|
|
}
|
|
|