mirror of
https://github.com/Sei-Lisa/LSL-PyOptimizer
synced 2025-07-01 15:48:21 +00:00
9e7a5d1cdf
Rather than assert that the types are correct, use the force type functions on the parameters: ff, fk, fs, q2f, v2f, and the new fi, fl. These functions have also been modified to ensure that the input type supports an implicit typecast to the target type and perform it, or emit ELSLInvalidType otherwise, rather than an assertion failure. fl in particular returns the original list if it isn't changed, or a copy if it is. A couple bugs were found in testfuncs.py as a result, which have been fixed as well. A test has been added to ensure that the exception that caught these bugs remains in place. The isxxxx functions are no longer necessary, so they are removed. Same goes for the painful cast handling process in foldconst, which was basically performing this task, and not necessarily well. This approach is much more robust and should have been used since the beginning, but I didn't figure it out then.
1811 lines
96 KiB
Python
1811 lines
96 KiB
Python
# (C) Copyright 2015-2017 Sei Lisa. All rights reserved.
|
|
#
|
|
# This file is part of LSL PyOptimizer.
|
|
#
|
|
# LSL PyOptimizer is free software: you can redistribute it and/or
|
|
# modify it under the terms of the GNU General Public License as
|
|
# published by the Free Software Foundation, either version 3 of the
|
|
# License, or (at your option) any later version.
|
|
#
|
|
# LSL PyOptimizer is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with LSL PyOptimizer. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
# Unit Testing of lslfuncs, to ensure they match the output of LSL
|
|
|
|
from lslopt.lslcommon import *
|
|
from lslopt.lslfuncs import *
|
|
from lslopt import lslcommon
|
|
import sys
|
|
import math
|
|
from base64 import b64encode
|
|
|
|
StopAtFirstError = False
|
|
|
|
errors = 0
|
|
tests = 0
|
|
untested = 0
|
|
|
|
nan = NaN
|
|
inf = Infinity
|
|
|
|
F = float.fromhex
|
|
|
|
class ETestFailed(Exception):
|
|
def __init__(self):
|
|
super(self.__class__, self).__init__("Test failed")
|
|
pass
|
|
|
|
# Not failproof because we can't redefine float.__repr__
|
|
# so floats in vectors/rotations/lists aren't handled.
|
|
class newfloat(float):
|
|
def __repr__(n):
|
|
if not math.isnan(n):
|
|
return float.__repr__(n)
|
|
return '-nan' if math.copysign(1, n) < 0 else 'nan'
|
|
|
|
def reallyequal(actual, expected, tol):
|
|
if tol is None:
|
|
return repr(actual) == repr(expected)
|
|
|
|
if type(actual) != type(expected):
|
|
return False
|
|
|
|
# Deal with floats (edge cases, tolerance)
|
|
if isinstance(actual, float):
|
|
if actual == 0.0:
|
|
return repr(actual) == repr(expected)
|
|
if math.isnan(actual):
|
|
# This compares the sign of NaN as well
|
|
return math.isnan(expected) and math.copysign(1, actual) == math.copysign(1, expected)
|
|
if math.isinf(actual) and math.isinf(expected):
|
|
return actual == expected
|
|
return abs(actual - expected) <= tol
|
|
|
|
# Deal with tuples and lists (item-by-item, recursively)
|
|
if isinstance(actual, (tuple, list)):
|
|
return all(reallyequal(i1, i2, tol) for i1, i2 in zip(actual, expected))
|
|
|
|
# Fall back to 'classic' equality
|
|
return actual == expected
|
|
|
|
def test(fn, expected):
|
|
global tests
|
|
global errors
|
|
global untested
|
|
tol = 0.0 # compare to zero tolerance
|
|
tests += 1
|
|
if StopAtFirstError:
|
|
if errors:
|
|
untested += 1
|
|
return
|
|
|
|
actual = eval(fn)
|
|
if isinstance(actual, float):
|
|
actual = newfloat(actual)
|
|
if isinstance(expected, float):
|
|
expected = newfloat(expected)
|
|
werr = sys.stderr.write
|
|
if not reallyequal(actual, expected, tol):
|
|
werr("Test failed: " + fn + '\n')
|
|
werr("Actual: " + repr(actual) + '\n')
|
|
werr("Expect: " + repr(expected) + '\n')
|
|
errors += 1
|
|
#raise ETestFailed
|
|
else:
|
|
pass#sys.stdout.write("PASSED! %s == %s\n" % (fn, repr(expected)))
|
|
|
|
def shouldexcept(txt, exc):
|
|
global tests
|
|
global errors
|
|
global untested
|
|
|
|
tests += 1
|
|
if StopAtFirstError:
|
|
if errors:
|
|
untested += 1
|
|
return
|
|
|
|
try:
|
|
eval(txt)
|
|
except exc:
|
|
#sys.stdout.write("PASSED! %s on %s\n" % (exc.__name__, txt))
|
|
return
|
|
|
|
werr = sys.stderr.write
|
|
werr('Test failed: ' + txt + '\n')
|
|
werr('Actual: (no exception)\n')
|
|
werr('Expect: should raise ' + exc.__name__ + '\n')
|
|
errors += 1
|
|
|
|
def testXB64S(s1, s2, expect):
|
|
if type(s1) == str:
|
|
s1 = s1.decode('utf8')
|
|
if type(s2) == str:
|
|
s2 = s2.decode('utf8')
|
|
if type(expect) == str:
|
|
expect = expect.decode('utf8')
|
|
# llXorBase64Strings can only be executed in calculator mode
|
|
SaveIsCalc = lslcommon.IsCalc
|
|
lslcommon.IsCalc = True
|
|
test('llXorBase64Strings(' + repr(s1) + ',' + repr(s2) + ')', expect)
|
|
lslcommon.IsCalc = SaveIsCalc
|
|
|
|
def testXB64SC(s1, s2, expect):
|
|
if type(s1) == str:
|
|
s1 = s1.decode('utf8')
|
|
if type(s2) == str:
|
|
s2 = s2.decode('utf8')
|
|
if type(expect) == str:
|
|
expect = expect.decode('utf8')
|
|
test('llXorBase64StringsCorrect(' + repr(s1) + ',' + repr(s2) + ')', expect)
|
|
|
|
def testXB64(s1, s2, expect, Bug3763=False):
|
|
if type(s1) == str:
|
|
s1 = s1.decode('utf8')
|
|
if type(s2) == str:
|
|
s2 = s2.decode('utf8')
|
|
if type(expect) == str:
|
|
expect = expect.decode('utf8')
|
|
if Bug3763:
|
|
Bugs.add(3763)
|
|
test('llXorBase64(' + repr(s1) + ',' + repr(s2) + ')', expect)
|
|
Bugs.discard(3763)
|
|
|
|
def h2b64(h):
|
|
return unicode(b64encode(bytes(bytearray.fromhex(h))))
|
|
|
|
def testB642S(b, expected):
|
|
assert type(b) == str
|
|
assert type(expected) == str
|
|
test('llEscapeURL(llBase64ToString(h2b64(' + repr(b) + ')))', unicode(expected))
|
|
|
|
# Begin JSON tests from http://wiki.secondlife.com/wiki/Json_usage_in_LSL/TestScript
|
|
def verify(msg, result, expected):
|
|
global tests
|
|
tests += 1
|
|
werr = sys.stderr.write
|
|
if expected != result:
|
|
global errors
|
|
errors += 1
|
|
werr("Test failed: " + msg + '\n')
|
|
werr("Actual: " + repr(result) + '\n')
|
|
werr("Expect: " + repr(expected) + '\n')
|
|
#return 0
|
|
else:
|
|
pass#sys.stdout.write("PASSED! %s, expect=actual=%s\n" % (msg, repr(expected)))
|
|
#return 1
|
|
|
|
def verify_list(msg, result, expected):
|
|
verify(msg, repr(result), repr(expected))
|
|
|
|
def test_types():
|
|
verify("Type of string",llJsonValueType(u"\"test\"",[]),JSON_STRING);
|
|
verify("Type of string, unquoted",llJsonValueType(u"test",[]),JSON_INVALID);
|
|
verify("Type of invalid",llJsonValueType(u"test",[]),JSON_INVALID);
|
|
verify("Type of integer",llJsonValueType(u"12",[]),JSON_NUMBER);
|
|
verify("Type of float",llJsonValueType(u"12.300000",[]),JSON_NUMBER);
|
|
verify("Type of Inf (is unsupported by JSON standard)",llJsonValueType(u"Inf",[]),JSON_INVALID);
|
|
verify("Type of NaN (is unsupported by JSON standard)",llJsonValueType(u"NaN",[]),JSON_INVALID);
|
|
verify("Type of number",llJsonValueType(u"-123.4e-5",[]),JSON_NUMBER);
|
|
verify("Type of object",llJsonValueType(u"{\"a\":\"b\"}",[]),JSON_OBJECT);
|
|
# Expected to be OBJECT, since we don't do deep validation on input
|
|
#verify("Type of object, invalid/unquoted key",llJsonValueType(u"{a:\"b\"}",[]),JSON_INVALID);
|
|
\
|
|
verify("Type of object, invalid/unquoted key",llJsonValueType(u"{a:\"b\"}",[]),JSON_OBJECT) # check so
|
|
# Expected to be OBJECT, since we don't do deep validation on input
|
|
#verify("Type of object, invalid/unquoted value",llJsonValueType(u"{\"a\":b}",[]),JSON_INVALID);
|
|
\
|
|
verify("Type of object, invalid/unquoted value",llJsonValueType(u"{\"a\":b}",[]),JSON_OBJECT) # check so
|
|
verify("Type of array",llJsonValueType(u"[1,2,3]",[]),JSON_ARRAY);
|
|
verify("Type of array padded front",llJsonValueType(u" [1,2,3]",[]),JSON_ARRAY);
|
|
verify("Type of array padded back",llJsonValueType(u"[1,2,3] ",[]),JSON_ARRAY);
|
|
verify("Type of array padded",llJsonValueType(u" [1,2,3] ",[]),JSON_ARRAY);
|
|
verify("Type of true",llJsonValueType(u"true",[]),JSON_TRUE);
|
|
verify("Type of false",llJsonValueType(u"false",[]),JSON_FALSE);
|
|
verify("Type of null",llJsonValueType(u"null",[]),JSON_NULL);
|
|
|
|
# test traversal of llJsonValueType
|
|
json = u"[[1,2,3],{\"a\":3,\"b\":[true,\"test\",6],\"c\":\"true\",\"d\":false}]";
|
|
verify("Type of [0]",llJsonValueType(json,[0]),JSON_ARRAY);
|
|
verify("Type of [0,1]",llJsonValueType(json,[0,1]),JSON_NUMBER);
|
|
verify("Type of [1]",llJsonValueType(json,[1]),JSON_OBJECT);
|
|
verify("Type of [1,\"b\"]",llJsonValueType(json,[1,u"b"]),JSON_ARRAY);
|
|
verify("Type of [1,\"b\",0]",llJsonValueType(json,[1,u"b",0]),JSON_TRUE);
|
|
verify("Type of [1,\"b\",1]",llJsonValueType(json,[1,u"b",1]),JSON_STRING);
|
|
verify("Type of [1,\"b\",2]",llJsonValueType(json,[1,u"b",2]),JSON_NUMBER);
|
|
verify("Type of [1,\"c\"]",llJsonValueType(json,[1,u"c"]),JSON_STRING);
|
|
verify("Type of [1,\"d\"]",llJsonValueType(json,[1,u"d"]),JSON_FALSE);
|
|
verify("Type of [3] (invalid index at level 0)",llJsonValueType(json,[3]),JSON_INVALID);
|
|
verify("Type of [-1] (invalid index at level 0)",llJsonValueType(json,[-1]),JSON_INVALID);
|
|
verify("Type of [1,\"c\",3] (invalid index at level 1), MAINT-2670",llJsonValueType(json,[1,u"c",3]),JSON_INVALID);
|
|
\
|
|
verify("Type of [1,\"c\",0] (first element of non-nested object)",llJsonValueType(json,[1,u"c",0]),JSON_INVALID);
|
|
# added by us
|
|
verify("Type of [1,\"b\",3] (invalid index at level 2)",llJsonValueType(json,[1,u"b",3]),JSON_INVALID);
|
|
verify("Type of [1,\"b\",2,0,1] (invalid index at level 3) MAINT-2670",llJsonValueType(json,[1,u"b",2, 0, 1]),JSON_INVALID);
|
|
|
|
# some invalid cases where keys are uncoded
|
|
json = u"[[1,2,3],{a:3,b:[true,\"test\",6],c:\"true\",\"d\":false}]";
|
|
verify("Type of [1,\"a\"] where key is unquoted",llJsonValueType(json,[1,u"a"]),JSON_INVALID);
|
|
verify("Type of [1,\"b\"] where key is unquoted",llJsonValueType(json,[1,u"b"]),JSON_INVALID);
|
|
verify("Type of [1,\"c\"] where key is unquoted",llJsonValueType(json,[1,u"c"]),JSON_INVALID);
|
|
|
|
|
|
def test_get_value():
|
|
json = u"[[1,2,3,4.0],{\"a\":3,\"b\":[true,\"test\",6]}]";
|
|
verify("llJsonGetValue [0]",llJsonGetValue(json,[0]),u"[1,2,3,4.0]");
|
|
verify("llJsonGetValue [0,1]",llJsonGetValue(json,[0,1]),u"2");
|
|
verify("llJsonGetValue [1]",llJsonGetValue(json,[1]),u"{\"a\":3,\"b\":[true,\"test\",6]}");
|
|
verify("llJsonGetValue [1,\"b\"]",llJsonGetValue(json,[1,u"b"]),u"[true,\"test\",6]");
|
|
verify("llJsonGetValue [1,\"b\",0]",llJsonGetValue(json,[1,u"b",0]),JSON_TRUE);
|
|
verify("llJsonGetValue [1,\"b\",1]",llJsonGetValue(json,[1,u"b",1]),u"test");
|
|
verify("llJsonGetValue [1,\"b\",2]",llJsonGetValue(json,[1,u"b",2]),u"6");
|
|
verify("llJsonGetValue [0,3]",llJsonGetValue(json,[0,3]), u"4.0");
|
|
verify("llJsonGetValue [2] (invalid index at level 0)",llJsonGetValue(json,[2]),JSON_INVALID);
|
|
verify("llJsonGetValue [-1] (invalid index at level 0)",llJsonGetValue(json,[-1]),JSON_INVALID);
|
|
verify("llJsonGetValue [0,4] (invalid index within array)",llJsonGetValue(json,[0,4]),JSON_INVALID);
|
|
verify("llJsonGetValue [\"f\"] (look for missing object within array, depth=0) MAINT-2671",llJsonGetValue(json,[u"f"]),JSON_INVALID);
|
|
verify("llJsonGetValue [0,\"f\"] (look for missing object within array, depth=1) MAINT-2671",llJsonGetValue(json,[0,u"f"]),JSON_INVALID);
|
|
verify("llJsonGetValue [1,2] (specify index within object - disallowed)",llJsonGetValue(json,[1,2]),JSON_INVALID);
|
|
|
|
# invalid input json - missing quotes around 'a' and 'test'
|
|
json = u"[[1,2,3,4.0],{a:3,\"b\":[true,test,6]}]";
|
|
verify("llJsonGetValue [1,\"b\",1], unquoted/invalid string value",llJsonGetValue(json,[1,u"b",1]),JSON_INVALID);
|
|
verify("llJsonGetValue [1,\"a\"], unquoted/invalid string for key",llJsonGetValue(json,[1,u"a"]),JSON_INVALID);
|
|
|
|
def test_set_value():
|
|
# Test building from scratch
|
|
json = u""
|
|
json = llJsonSetValue(json,[0,0],u"1");
|
|
verify("llJsonSetValue build json",json,u"[[1]]");
|
|
json = llJsonSetValue(json,[0,1],u"2");
|
|
verify("llJsonSetValue build json",json,u"[[1,2]]");
|
|
json = llJsonSetValue(json,[0,2],u"3");
|
|
verify("llJsonSetValue build json",json,u"[[1,2,3]]");
|
|
json = llJsonSetValue(json,[1,u"a"],u"3");
|
|
verify("llJsonSetValue build json",json,u"[[1,2,3],{\"a\":3}]");
|
|
json = llJsonSetValue(json,[1,u"b",0],JSON_TRUE);
|
|
verify("llJsonSetValue build json",json,u"[[1,2,3],{\"a\":3,\"b\":[true]}]");
|
|
json = llJsonSetValue(json,[1,u"b",1],u"test");
|
|
verify("llJsonSetValue build json",json,u"[[1,2,3],{\"a\":3,\"b\":[true,\"test\"]}]");
|
|
json = llJsonSetValue(json,[1,u"b",2],u"6");
|
|
verify("llJsonSetValue completed json",json,u"[[1,2,3],{\"a\":3,\"b\":[true,\"test\",6]}]");
|
|
|
|
# Test replacing
|
|
json = llJsonSetValue(json,[1,u"b",1],u"foo");
|
|
verify("llJsonSetValue completed json",json,u"[[1,2,3],{\"a\":3,\"b\":[true,\"foo\",6]}]");
|
|
json = llJsonSetValue(json,[1,u"b"],JSON_TRUE);
|
|
verify("llJsonSetValue completed json, true",json,u"[[1,2,3],{\"a\":3,\"b\":true}]");
|
|
json = llJsonSetValue(json,[1,u"b"],u"true");
|
|
verify("llJsonSetValue completed json, alt true",json,u"[[1,2,3],{\"a\":3,\"b\":true}]");
|
|
json = llJsonSetValue(json,[1,0,0],JSON_FALSE);
|
|
verify("llJsonSetValue completed json",json,u"[[1,2,3],[[false]]]");
|
|
|
|
# Test appending
|
|
json = llJsonSetValue(u"[[1,2,3],{\"a\":3,\"b\":[true,\"test\",6]}]",[0,JSON_APPEND], u"4.0");
|
|
verify("llJsonSetValue append to first array",json,u"[[1,2,3,4.0],{\"a\":3,\"b\":[true,\"test\",6]}]");
|
|
json = llJsonSetValue(json,[1,u"b",JSON_APPEND], u"5.0");
|
|
verify("llJsonSetValue append to array withhin object",json,u"[[1,2,3,4.0],{\"a\":3,\"b\":[true,\"test\",6,5.0]}]");
|
|
json = llJsonSetValue(json,[JSON_APPEND], u"6.0");
|
|
verify("llJsonSetValue append to outer array",json,u"[[1,2,3,4.0],{\"a\":3,\"b\":[true,\"test\",6,5.0]},6.0]");
|
|
json = llJsonSetValue(u"[]",[JSON_APPEND], u"\"alone\"");
|
|
verify("llJsonSetValue append to empty array (MAINT-2684)",json,u"[\"alone\"]");
|
|
json = llJsonSetValue(u"[]",[1], u"\"alone\"");
|
|
verify("llJsonSetValue append to empty array at invalid index (MAINT-2684)",json,JSON_INVALID);
|
|
json = llJsonSetValue(u"[]",[0], u"\"alone\"");
|
|
verify("llJsonSetValue append to empty array at first index (MAINT-2684)",json,u"[\"alone\"]");
|
|
|
|
# Test deleting
|
|
json = u"[[1,2,3],{\"a\":3,\"b\":[true,\"test\",6,null]}]";
|
|
json = llJsonSetValue(json,[1,u"b",1],JSON_DELETE);
|
|
verify("llJsonSetValue deleting string in middle of array",json,u"[[1,2,3],{\"a\":3,\"b\":[true,6,null]}]");
|
|
json = llJsonSetValue(json,[1,u"b",2],JSON_DELETE);
|
|
verify("llJsonSetValue deleting null at end of array",json,u"[[1,2,3],{\"a\":3,\"b\":[true,6]}]");
|
|
json = llJsonSetValue(json,[1,u"b"],JSON_DELETE);
|
|
verify("llJsonSetValue deleting key-value",json,u"[[1,2,3],{\"a\":3}]");
|
|
json = llJsonSetValue(json,[1],JSON_DELETE);
|
|
verify("llJsonSetValue deleting object in array",json,u"[[1,2,3]]");
|
|
json = u"[[1,2,3],4]";
|
|
json = llJsonSetValue(json,[0],JSON_DELETE);
|
|
verify("llJsonSetValue deleting array (which is first index in array)",json,u"[4]");
|
|
json = llJsonSetValue(json,[0],JSON_DELETE);
|
|
verify("llJsonSetValue deleting last element in array",json,u"[]");
|
|
json = u"[[1]]";
|
|
json = llJsonSetValue(json,[0,0],JSON_DELETE);
|
|
verify("llJsonSetValue deleting last element in array",json,u"[[]]");
|
|
json = llJsonSetValue(json,[0],JSON_DELETE);
|
|
verify("llJsonSetValue deleting array within array",json,u"[]");
|
|
|
|
# Test failures in deleting
|
|
json = u"[[1,2,3],{\"a\":3,\"b\":[true,\"test\",6,null]}]";
|
|
verify("llJsonSetValue deleting undefined key-value in object",llJsonSetValue(json,[1,u"d"],JSON_DELETE),JSON_INVALID);
|
|
verify("llJsonSetValue deleting out-of-range index in array",llJsonSetValue(json,[2],JSON_DELETE),JSON_INVALID);
|
|
verify("llJsonSetValue deleting depth within object that doesn't exist",llJsonSetValue(json,[1,u"a",u"unicorn"],JSON_DELETE),JSON_INVALID);
|
|
verify("llJsonSetValue deleting depth within array that doesn't exist",llJsonSetValue(json,[0,1,1],JSON_DELETE),JSON_INVALID);
|
|
|
|
# this is the only failure mode that should exist.
|
|
json = u"[[1,2,3],{\"a\":3,\"b\":[true,\"foo\",6]}]";
|
|
json = llJsonSetValue(json,[3],JSON_FALSE);
|
|
verify("llJsonSetValue fail to insert data into invalid array index (MAINT-2675)",json,JSON_INVALID);
|
|
|
|
def test_json_to_list():
|
|
l = llJson2List(u"[[1,2,3],{\"a\":3,\"b\":[true,\"test\",6]}]");
|
|
verify_list("llJson2List first",l,[u"[1,2,3]",u"{\"a\":3,\"b\":[true,\"test\",6]}"]);
|
|
n = llJson2List(llList2String(l,0));
|
|
verify_list("llJson2List l,0",n,[1,2,3]);
|
|
n = llJson2List(llList2String(l,1));
|
|
verify_list("llJson2List l,1",n,[u"a",3,u"b",u"[true,\"test\",6]"]);
|
|
n = llJson2List(llList2String(n,3));
|
|
verify_list("llJson2List n,3",n,[JSON_TRUE, u"test", 6]);
|
|
n = llJson2List(llList2String(n,1));
|
|
verify_list("llJson2List n,1",n,[u"test"]);
|
|
n = llJson2List(u"");
|
|
verify_list("Empty JSON string becomes empty list",n,[]);
|
|
n = llJson2List(u"[]");
|
|
verify_list("Empty JSON array becomes empty list (MAINT-2678)",n,[]);
|
|
n = llJson2List(u"{}");
|
|
verify_list("Empty JSON object becomes empty list (MAINT-2678)",n,[]);
|
|
n = llJson2List(u"Non-JSON string, with comma");
|
|
verify_list("llJson2List for non-JSON string is stored as a single object",n,[u"Non-JSON string, with comma"]);
|
|
n = llJson2List(u"[malformed}");
|
|
verify_list("llJson2List, malformed input",n,[u"[malformed}"]);
|
|
|
|
def test_list_to_json():
|
|
TRUE=1
|
|
# test objects
|
|
json = llList2Json(JSON_OBJECT,[u"a",1,u"b",2.5,u"c",u"test",u"d",u"true",u"e",u"[1,2,3]"]);
|
|
verify("llList2Json, json object",json,u"{\"a\":1,\"b\":2.500000,\"c\":\"test\",\"d\":true,\"e\":[1,2,3]}");
|
|
|
|
# test arrays
|
|
json = llList2Json(JSON_ARRAY,[1,2.5,u"test",u"true",u"[1,2,3]"]);
|
|
verify("llList2Json, json array",json,u"[1,2.500000,\"test\",true,[1,2,3]]");
|
|
|
|
# test arrays
|
|
json = llList2Json(JSON_ARRAY,[1,2.5,u"test",JSON_TRUE,u"[1,2,3]"]);
|
|
verify("llList2Json, json array, alternative true representation",json,u"[1,2.500000,\"test\",true,[1,2,3]]");
|
|
|
|
# test objects, with empty input
|
|
json = llList2Json(JSON_OBJECT,[]);
|
|
verify("llList2Json, json object with empty input (MAINT-2681)",json,u"{}");
|
|
|
|
# test arrays, with empty input
|
|
json = llList2Json(JSON_ARRAY,[]);
|
|
verify("llList2Json, json array with empty input (MAINT-2681)",json,u"[]");
|
|
|
|
# test objects which are truncated
|
|
json = llList2Json(JSON_OBJECT,[u"a",1,u"b",2.5,u"c",u"test",u"d",u"true",u"e"]);
|
|
verify("llList2Json, json object, truncated",json,JSON_INVALID);
|
|
|
|
# test objects which has a non-string identifier somewhere
|
|
json = llList2Json(JSON_OBJECT,[u"a",1,TRUE,2.5,u"c",u"test",u"d",u"true",u"e"]);
|
|
verify("llList2Json, json object, non-string in one of the first stride values",json,JSON_INVALID);
|
|
|
|
# test invalid type
|
|
json = llList2Json(u"foo",[u"a",1,u"b",2.5,u"c",u"test",u"d",u"true",u"e",u"[1,2,3]"]);
|
|
verify("llList2Json, json invalid type",json,JSON_INVALID);
|
|
|
|
def test_strings_with_escaped_chars():
|
|
escaped_pairs = [
|
|
(u"funky\"string", u"funky\\\"string", "quote in middle"),
|
|
(u"funkystr\"ing", u"funkystr\\\"ing", "quote in middle, other position"),
|
|
# note that we have to double-up backslashes to assign them to strings..
|
|
(u"funky\\string", u"funky\\\\string", "backslashes in middle"),
|
|
(u"\\funkystring", u"\\\\funkystring", "backslashes at beginning"),
|
|
(u"funky\nstring", u"funky\\nstring", "newline in string"),
|
|
(u"funky/string", u"funky\\/string", "forward slash in string"),
|
|
# TAB (\t) fails, because it seems that LSL automatically converts any tab into 4 consecutive spaces.
|
|
(u"funky\tstring", u"funky\\tstring", "tab in string"), # we enable it, with some mods
|
|
# these cases fail; it seems that LSL doesn't support these characters, and strips the '\'
|
|
(u"funky\x08string", u"funky\\bstring", "backspace in middle"), # we enable it, with some mods
|
|
(u"funky\x0Cstring", u"funky\\fstring", "form feed in middle"), # we enable it, with some mods
|
|
(u"funky\rstring", "funky\\rstring", "carriage return in string"), # we enable it, with some mods
|
|
# note that the following case can't be supported, since strings starting with \" can't be escaped
|
|
(u"\"funkystring", u"\\\"funkystring", "quote in beginning"), # we enable it as it's supported
|
|
(u"vanilla string", u"vanilla string", "nothing that needs to be escaped..")
|
|
];
|
|
for funky_string, funky_string_escaped, escaped_desc1 in escaped_pairs:
|
|
escaped_desc = " '" + escaped_desc1 + "'"
|
|
|
|
verify("Type of string with escaped char (for MAINT-2698),"+escaped_desc,llJsonValueType(u"\""+funky_string_escaped+u"\"",[]),JSON_STRING);
|
|
|
|
json = u"[[1,2,3,4.0],{\""+funky_string_escaped+u"\":3,\"b\":\""+funky_string_escaped+u"value\"}]";
|
|
verify("llJsonGetValue [1,\""+str(funky_string_escaped)+"\"] (for MAINT-2698),"+escaped_desc,
|
|
llJsonGetValue(json,[1,funky_string]),"3");
|
|
verify("llJsonGetValue [1,\"b\"] (for MAINT-2698),"+escaped_desc,llJsonGetValue(json,[1,u"b"]),funky_string+u"value");
|
|
|
|
#llSay(0, "DEBU G: '" + llEscapeURL(json) + "' is input for test " + escaped_desc);
|
|
json = llJsonSetValue(json,[0],funky_string);
|
|
verify("llJsonSetValue with escaped string as value (for MAINT-2698),"+escaped_desc,json,
|
|
u"[\""+funky_string_escaped+u"\",{\""+funky_string_escaped+u"\":3,\"b\":\""+funky_string_escaped+u"value\"}]");
|
|
|
|
json = llJsonSetValue(json,[0],funky_string);
|
|
verify("llJsonSetValue with escaped string as value (for MAINT-2698),"+escaped_desc,json,
|
|
u"[\""+funky_string_escaped+u"\",{\""+funky_string_escaped+u"\":3,\"b\":\""+funky_string_escaped+u"value\"}]");
|
|
|
|
json = llJsonSetValue(json,[0,funky_string], funky_string+u"value");
|
|
verify("llJsonSetValue with escaped string as key's value (for MAINT-2698),"+escaped_desc,json,
|
|
u"[{\""+funky_string_escaped+u"\":\""+funky_string_escaped+u"value\"},{\""+funky_string_escaped+u"\":3,\"b\":\""+funky_string_escaped+u"value\"}]");
|
|
|
|
l = llJson2List(json);
|
|
verify_list("llJson2List extracting object containing escaped string (for MAINT-2698),"+escaped_desc, l,
|
|
[u"{\""+funky_string_escaped+u"\":\""+funky_string_escaped+u"value\"}",u"{\""+funky_string_escaped+u"\":3,\"b\":\""+funky_string_escaped+u"value\"}"]);
|
|
n = llJson2List(llList2String(l, 0));
|
|
verify_list("llJson2List extracting escaped strings (for MAINT-2698),"+escaped_desc, n,
|
|
[funky_string,funky_string+u"value"]);
|
|
|
|
json = llList2Json(JSON_ARRAY,n);
|
|
verify("llList2Json from escaped-containing string to array (for MAINT-2698),"+escaped_desc,json,
|
|
u"[\""+funky_string_escaped+u"\",\""+funky_string_escaped+u"value\"]");
|
|
|
|
json = llList2Json(JSON_OBJECT,n);
|
|
verify("llList2Json from escaped-containing string to object (for MAINT-2698),"+escaped_desc,json,
|
|
u"{\""+funky_string_escaped+u"\":\""+funky_string_escaped+u"value\"}");
|
|
|
|
def maint3070():
|
|
verify("Set value 'messa[g]e'", llJsonSetValue(u"",[u"toast"],u"messa[g]e"), u"{\"toast\":\"messa[g]e\"}");
|
|
verify("Set value 'messag[e]'", llJsonSetValue(u"",[u"toast"],u"messag[e]"), u"{\"toast\":\"messag[e]\"}");
|
|
#verify("Set value 'messag\[e\]'", llJsonSetValue(u"",[u"toast"],u"messag\[e\]"), u"{\"toast\":\"messag[e]\"}");
|
|
# ^^ BROKEN!!!!! LSL does not include the backslashes in the strings, so the above test is redundant.
|
|
# Python does, thus making that test would break it. We include our own test tho:
|
|
\
|
|
verify("Set value 'messag\\[e\\]'", llJsonSetValue(u"",[u"toast"],u"messag\\[e\\]"), u"{\"toast\":\"messag\\\\[e\\\\]\"}");
|
|
|
|
def maint4187():
|
|
verify("Valid json number with + before exponent", llJsonValueType(u"1.0e+1", []), JSON_NUMBER);
|
|
verify("Valid json number with - before exponent", llJsonValueType(u"1.0e-1", []), JSON_NUMBER);
|
|
verify("Valid json number with - before exponent and mantissa", llJsonValueType(u"-1.0e-1", []), JSON_NUMBER);
|
|
verify("Valid json number with unsigned exponent", llJsonValueType(u"1.0e1", []), JSON_NUMBER);
|
|
verify("Invalid json number due to + before mantissa", llJsonValueType(u"+1.0e1", []), JSON_INVALID);
|
|
|
|
verify("Invalid json number due to leading e", llJsonValueType(u"e1", []), JSON_INVALID);
|
|
verify("Invalid json number due to leading 0", llJsonValueType(u"01", []), JSON_INVALID);
|
|
verify("Invalid json number due to leading -0", llJsonValueType(u"-01", []), JSON_INVALID);
|
|
verify("Valid json number with 0 immediately before .", llJsonValueType(u"0.01", []), JSON_NUMBER);
|
|
verify("Valid json number with -0 immediately before .", llJsonValueType(u"-0.01", []), JSON_NUMBER);
|
|
|
|
def maint3053():
|
|
jT1 = u"[1, 2]"; # A JSON array
|
|
verify("llJsonSetValue(jT1,[2],\"t\")",llJsonSetValue(jT1,[2],u"t"),u"[1,2,\"t\"]");
|
|
verify("llJsonSetValue(jT1,[3],\"t\")",llJsonSetValue(jT1,[3],u"t"),JSON_INVALID);
|
|
verify("llJsonSetValue(jT1,[0, 0],\"t\")",llJsonSetValue(jT1,[0, 0],u"t"),u"[[\"t\"],2]");
|
|
verify("llJsonSetValue(jT1,[0, 0, 2, \"t\", 75],\"t\")",llJsonSetValue(jT1,[0, 0, 2, u"t", 75],u"t"),JSON_INVALID);
|
|
verify("llJsonSetValue(jT1,[0, 1],\"t\")",llJsonSetValue(jT1,[0, 1],u"t"),JSON_INVALID);
|
|
verify("llJsonSetValue(jT1,[0, 1, 2, \"t\", 75],\"t\")",llJsonSetValue(jT1,[0, 1, 2, u"t", 75],u"t"),JSON_INVALID);
|
|
|
|
jT2 = u"[ [\"A\", \"B\", \"C\"], 2]";
|
|
verify("llJsonSetValue(jT2,[0, 3],\"t\")",llJsonSetValue(jT2,[0, 3],u"t"),u"[[\"A\",\"B\",\"C\",\"t\"],2]");
|
|
verify("llJsonSetValue(jT2,[0, 4],\"t\")",llJsonSetValue(jT2,[0, 4],u"t"),JSON_INVALID);
|
|
verify("llJsonSetValue(jT2,[0, 1, 0],\"t\")",llJsonSetValue(jT2,[0, 1, 0],u"t"),u"[[\"A\",[\"t\"],\"C\"],2]");
|
|
verify("llJsonSetValue(jT2,[0, 1, 1],\"t\")",llJsonSetValue(jT2,[0, 1, 1],u"t"),JSON_INVALID);
|
|
|
|
jT3 = u"{\"1\":2}";
|
|
verify("llJsonSetValue(jT3,[\"1\"],\"t\")",llJsonSetValue(jT3,[u"1"],u"t"),u"{\"1\":\"t\"}");
|
|
verify("llJsonSetValue(jT3,[\"1\",0],\"t\")",llJsonSetValue(jT3,[u"1",0],u"t"),u"{\"1\":[\"t\"]}");
|
|
verify("llJsonSetValue(jT3,[\"1\",1],\"t\")",llJsonSetValue(jT3,[u"1",1],u"t"),JSON_INVALID);
|
|
|
|
jGood = u"[null, 2]";
|
|
verify("llJsonValueType(jGood, [0])",llJsonValueType(jGood, [0]),JSON_NULL);
|
|
verify("llJsonValueType(jGood, [0, 0])",llJsonValueType(jGood, [0, 0]),JSON_INVALID);
|
|
|
|
jBad = u"[, 2]";
|
|
verify("llJsonValueType(jBad,[0])",llJsonValueType(jBad,[0]),JSON_INVALID);
|
|
verify("llJsonValueType(jBad,[0, 0, 2, \"t\", 75])",llJsonValueType(jBad,[0, 0, 2, u"t", 75]),JSON_INVALID);
|
|
verify("llJsonGetValue(jBad,[1, 0, 2, \"t\", 75])",llJsonGetValue(jBad,[1, 0, 2, u"t", 75]),JSON_INVALID);
|
|
|
|
def maint3081():
|
|
verify("llJsonSetValue blank string",llJsonSetValue(u"",[u"test"],u""),u"{\"test\":\"\"}");
|
|
verify("llJsonSetValue JSON_NULL",llJsonSetValue(u"",[u"test"],JSON_NULL),u"{\"test\":null}");
|
|
verify("llJsonGetValue blank string",llJsonGetValue(u"{\"test\":\"\"}",[u"test"]),u"");
|
|
verify("llJsonGetValue JSON_NULL",llJsonGetValue(u"{\"test\":null}",[u"test"]),JSON_NULL);
|
|
verify("Identity (set->get) blank string",llJsonGetValue(llJsonSetValue(u"",[u"test"],u""),[u"test"]),u"");
|
|
verify("Identity (set->get) JSON_NULL",llJsonGetValue(llJsonSetValue(u"",[u"test"],JSON_NULL),[u"test"]),JSON_NULL);
|
|
|
|
def test_jira_fixes():
|
|
# FIXME: llJsonSetValue pending
|
|
#maint3070();
|
|
if 6466 not in Bugs:
|
|
maint4187();
|
|
# FIXME: llJsonSetValue pending
|
|
#maint3053();
|
|
# FIXME: llJsonSetValue pending
|
|
#maint3081();
|
|
|
|
# End JSON tests from wiki
|
|
|
|
def do_tests():
|
|
# Test our own test function for NaNs
|
|
test('reallyequal(NaN, Indet, 0.0)', False)
|
|
test('reallyequal(-NaN, Indet, 0.0)', True)
|
|
test('reallyequal(NaN, -Indet, 0.0)', True)
|
|
test('reallyequal(NaN, -(Infinity*0), 0.0)', True)
|
|
test('reallyequal(Infinity*0, Indet, 0.0)', True)
|
|
# Check that it properly distinguishes -0.0 and 0.0
|
|
test('reallyequal(-0.0, 0.0, 0.0)', False)
|
|
test('reallyequal(0.0, -0.0, 0.0)', False)
|
|
test('reallyequal(0.0, 0.0, 0.0)', True)
|
|
test('reallyequal(-0.0, -0.0, 0.0)', True)
|
|
|
|
shouldexcept('div(1.0, 0.0)', ELSLMathError)
|
|
shouldexcept('div(1, 0)', ELSLMathError)
|
|
shouldexcept('div(NaN, 1)', ELSLMathError)
|
|
shouldexcept('div(1, NaN)', ELSLMathError)
|
|
shouldexcept('div(F32(1e40), F32(1e40))', ELSLMathError)
|
|
shouldexcept('zstr(b"blah")', ELSLInvalidType)
|
|
test('div(1, 9)', 0)
|
|
test('div(8, 9)', 0)
|
|
test('div(9, 9)', 1)
|
|
test('div(-1,9)', 0)
|
|
test('div(-8,9)', 0)
|
|
test('div(-9,9)', -1)
|
|
test('div(1,-9)', 0)
|
|
test('div(8,-9)', 0)
|
|
test('div(9,-9)', -1)
|
|
test('less(Infinity, Infinity)', 0)
|
|
test('less(-Infinity, Infinity)', 1)
|
|
test(r'zstr(Key(u"xy\0zzy"))', Key(u'xy'))
|
|
test('typecast(Infinity, unicode)', u'Infinity')
|
|
test('typecast(NaN, unicode)', u'NaN')
|
|
test('typecast(Vector((NaN,-Infinity,-0.)), unicode)', u'<NaN, -Infinity, -0.00000>')
|
|
test('typecast(Vector((NaN,-Infinity,-0.)), unicode, True, True)', u'<NaN, -Infinity, -0.000000>')
|
|
test('typecast(Vector((NaN,2.,3.)), list)', [Vector((NaN,2.,3.))])
|
|
test('typecast([Vector((NaN,2.,-Infinity))], list)', [Vector((NaN,2.,-Infinity))])
|
|
|
|
shouldexcept('typecast(1.2, Vector)', ELSLTypeMismatch)
|
|
shouldexcept('typecast(1, Vector)', ELSLTypeMismatch)
|
|
shouldexcept('typecast(Vector((1.,2.,3.)), Key)', ELSLTypeMismatch)
|
|
shouldexcept('typecast(Quaternion((1.,2.,3.,0.)), Key)', ELSLTypeMismatch)
|
|
shouldexcept('typecast(Key(u""), Vector)', ELSLTypeMismatch)
|
|
test('typecast(Key(u"xyz"), unicode)', u'xyz')
|
|
test('typecast(u"xyz", Key)', Key(u'xyz'))
|
|
test('typecast(u"3.14e+0a", int)', 3)
|
|
test('typecast(u"a3.14e+0a", int)', 0)
|
|
test('typecast(u"0XA3.14e+0a", int)', 0xA3)
|
|
test('typecast(u"3333333333333", int)', -1)
|
|
test('typecast(u"4124567890", int)', -170399406)
|
|
test('typecast(u"-4124567890", int)', 170399406)
|
|
test('typecast(u"3.14e+0a", float)', F32(3.14))
|
|
test('typecast(u"++3.14e+0a", float)', F32(0.))
|
|
test('typecast(u"0x3.14p+0a", float)', F32(float.fromhex('0x3.14p0')))
|
|
test('typecast(u"<5.31,7.13,0x9.99", Vector)', F32(Vector((5.31,7.13,float.fromhex('0x9.99')))))
|
|
test('typecast(u"<5.31, 7.13, 0x9.99>", Vector)', F32(Vector((5.31,7.13,float.fromhex('0x9.99')))))
|
|
test('typecast(u"<5.31 , 7.13 , 0x9.99>", Vector)', ZERO_VECTOR)
|
|
test('typecast(u"5.31, 7.13, 0x9.99>", Vector)', ZERO_VECTOR)
|
|
test('typecast(u"<5.31, a7.13, 0x9.99>", Vector)', ZERO_VECTOR)
|
|
test('typecast(u"<1,1,2+", Vector)', Vector((1.,1.,2.)))
|
|
test('typecast(u"<1,1,2a", Vector)', Vector((1.,1.,2.)))
|
|
test('typecast(u"<1,1,inf", Vector)', Vector((1.,1.,Infinity)))
|
|
test('typecast(u"<1,1,infi", Vector)', ZERO_VECTOR)
|
|
test('typecast(u"<1,1,infix", Vector)', ZERO_VECTOR)
|
|
test('typecast(u"<1,1,infinity", Vector)', Vector((1.,1.,Infinity)))
|
|
test('neg(-2147483648)',-2147483648)
|
|
test('neg(2147483647)',-2147483647)
|
|
test('neg(Quaternion((-.5,.5,.4,-.4)))',Quaternion((.5,-.5,-.4,.4)))
|
|
shouldexcept('neg(u"3")', ELSLTypeMismatch)
|
|
test('add(-2147483648,-1)', 2147483647)
|
|
test('add(-2147483648.,-1.)', -2147483648.)
|
|
test('add(-2147483648.,-1)', -2147483648.)
|
|
test('add(-2147483648,-1.)', -2147483648.)
|
|
test('add(Vector((1.,2.,3.)),Vector((2.,4.,6.)))', Vector((3.,6.,9.)))
|
|
test('add(Quaternion((1.,2.,3.,4.)),Quaternion((2.,4.,6.,8.)))', Quaternion((3.,6.,9.,12.)))
|
|
test('add([u"1"],[u"2"])', [u'1',u'2'])
|
|
test('add(u"1",[u"2"])', [u'1',u'2'])
|
|
test('add([u"1"],u"2")', [u'1',u'2'])
|
|
test('add(u"1",u"2")', u'12')
|
|
test('sub(1,2)', -1)
|
|
test('sub(1.,2)', -1.)
|
|
test('sub(1,2.)', -1.)
|
|
test('sub(1.,2.)', -1.)
|
|
test('sub(-2147483647,2)', 2147483647)
|
|
test('sub(Vector((1.,2.,3.)),Vector((2.,4.,6.)))', Vector((-1.,-2.,-3.)))
|
|
test('sub(Quaternion((1.,2.,3.,4.)),Quaternion((2.,4.,6.,8.)))', Quaternion((-1.,-2.,-3.,-4.)))
|
|
test('mul(2.,Vector((1.,2.,3.)))', Vector((2.,4.,6.)))
|
|
test('mul(Quaternion((.5,.5,.5,.5)),Quaternion((1.,0.,0.,0.)))', Quaternion((.5,-.5,.5,-.5)))
|
|
test('mul(1,2)', 2)
|
|
test('mul(1.,2)', 2.)
|
|
test('mul(1,2.)', 2.)
|
|
test('mul(1.,2.)', 2.)
|
|
test('mul(Vector((3.,4.,5.)),Vector((3.,4.,5.)))', 50.)
|
|
test('mul(Vector((3.,4.,5.)),1.)', Vector((3.,4.,5.)))
|
|
test('mul(Vector((3.,4.,5.)),ZERO_ROTATION)', Vector((3.,4.,5.)))
|
|
test('mul(Vector((3.,4.,5.)),Quaternion((.5,.5,.5,.5)))', Vector((5.,3.,4.)))
|
|
shouldexcept('add(Key(u"1"),Key(u"2"))', ELSLTypeMismatch)
|
|
shouldexcept('sub(u"1",u"2")', ELSLTypeMismatch)
|
|
shouldexcept('mul(u"1",u"2")', ELSLTypeMismatch)
|
|
shouldexcept('mul(1.,Quaternion((1.,2.,3.,4.)))', ELSLTypeMismatch)
|
|
shouldexcept('mul(Quaternion((1.,2.,3.,4.)),1.)', ELSLTypeMismatch)
|
|
shouldexcept('mul(Quaternion((1.,2.,3.,4.)),Vector((1.,2.,3.)))', ELSLTypeMismatch)
|
|
shouldexcept('mul(b"a",3)', ELSLInvalidType)
|
|
shouldexcept('mul(Vector((3.,4.,5.)),b"a")', ELSLInvalidType)
|
|
shouldexcept('typecast([1,F32(3.14),Key(u"blah"),Quaternion((1.,0.,0.,0.))], Vector)',
|
|
ELSLTypeMismatch)
|
|
shouldexcept('typecast(b"", unicode)', ELSLInvalidType)
|
|
|
|
|
|
test('''llListSort(
|
|
[Quaternion((1.,2.,3.,4.)),Quaternion((2.,3.,4.,5.)),Quaternion((5.,4.,3.,2.)),
|
|
Quaternion((4.,3.,2.,1.)),Quaternion((3.,2.,1.,0.))]
|
|
,1,0)''',
|
|
[Quaternion((3.,2.,1.,0.)),Quaternion((4.,3.,2.,1.)),Quaternion((5.,4.,3.,2.)),
|
|
Quaternion((2.,3.,4.,5.)),Quaternion((1.,2.,3.,4.))]
|
|
)
|
|
|
|
test('''llListSort(
|
|
[Quaternion((1.,2.,3.,4.)),Quaternion((2.,3.,4.,5.)),Quaternion((5.,4.,3.,2.)),
|
|
Quaternion((4.,3.,2.,1.)),Quaternion((3.,2.,1.,0.))]
|
|
,1,1)''',
|
|
[Quaternion((1.,2.,3.,4.)),Quaternion((2.,3.,4.,5.)),Quaternion((5.,4.,3.,2.)),
|
|
Quaternion((4.,3.,2.,1.)),Quaternion((3.,2.,1.,0.))]
|
|
)
|
|
|
|
test('''llListSort(
|
|
[Vector((1.,0.,0.)),Vector((0.,3.,0.)),Vector((0.,0.,1.)),Vector((3.,0.,0.))]
|
|
,1,1)''',
|
|
[Vector((1.0, 0.0, 0.0)), Vector((0.0, 0.0, 1.0)), Vector((0.0, 3.0, 0.0)), Vector((3.0, 0.0, 0.0))]
|
|
)
|
|
|
|
test('''llListSort([2,0,1,1,2,2,2,3,2,4,1,5,2,6], 2, 1)''',
|
|
[1, 1, 1, 5, 2, 2, 2, 3, 2, 4, 2, 0, 2, 6])
|
|
test('''llListSort([2,0,1,1,2,2,2,3,2,4,1,5,2,6], 2, 0)''',
|
|
[2, 6, 2, 4, 2, 3, 2, 2, 2, 0, 1, 5, 1, 1])
|
|
test('''llListSort([2,0,1,1,2,2,2,3,2,4,1,5,2,6,3], 2, 1)''',
|
|
[2, 0, 1, 1, 2, 2, 2, 3, 2, 4, 1, 5, 2, 6, 3])
|
|
|
|
# NaN in sort behaves strangely. Also when inside vectors.
|
|
test('llListSort([-1., 9., 3., 2., NaN, 5., 1.], 1, 1)', [1., 5., NaN, -1., 2., 3., 9.])
|
|
test('llListSort([Vector((2.,0.,0.)),Vector((1.,NaN,0.))],1,1)', [Vector((1.,NaN,0.)),Vector((2.,0.,0.))])
|
|
test('llListSort([Vector((1.,NaN,0.)),Vector((2.,0.,0.))],1,1)', [Vector((2.,0.,0.)),Vector((1.,NaN,0.))])
|
|
test('llListSort([Vector((2.,0.,0.)),Vector((1.,NaN,0.))],1,0)', [Vector((2.,0.,0.)),Vector((1.,NaN,0.))])
|
|
test('llListSort([Vector((1.,NaN,0.)),Vector((2.,0.,0.))],1,0)', [Vector((1.,NaN,0.)),Vector((2.,0.,0.))])
|
|
# This proves that it does not sort by UTF-16 words, but by code points.
|
|
# Otherwise u"\U0001d41a" would be before u"\ufb01" (because the UTF-16
|
|
# of u"\U0001d41a" is 0xD835 0xDC1A)
|
|
test(r'llListSort([u"\ufb01",u"\xe1", u"\U0001d41a", u"a"], 1, 1)', [u'a',u'\xe1',u'\ufb01',u'\U0001d41a'])
|
|
|
|
test('llLog(NaN)', 0.)
|
|
test('llLog(-Infinity)', 0.)
|
|
test('llLog(Infinity)', Infinity)
|
|
test('llLog(-1.)', 0.)
|
|
test('llLog(-0.)', 0.)
|
|
test('llLog(1.)', 0.)
|
|
test('llLog(F32(math.e))', F('0x1.FFFFFEp-1'))
|
|
test('llLog10(NaN)', 0.)
|
|
test('llLog10(-Infinity)', 0.)
|
|
test('llLog10(Infinity)', Infinity)
|
|
test('llLog10(-1.)', 0.)
|
|
test('llLog10(-0.)', 0.)
|
|
test('llLog10(1.)', 0.)
|
|
test('llLog10(100.)', 2.)
|
|
test('llLog(Infinity)', Infinity)
|
|
|
|
test('F32(1e38)', 99999996802856924650656260769173209088.)
|
|
test('''llList2CSV([F32(1e0),F32(1e1),F32(1e2),F32(1e3),F32(1e4),F32(1e5),F32(1e6),
|
|
F32(1e7),F32(1e8),F32(1e9),F32(1e10),F32(1e11),F32(1e12),F32(1e13),
|
|
F32(1e14),F32(1e15),F32(1e16),F32(1e17),F32(1e18),F32(1e19),F32(1e20),
|
|
F32(1e21),F32(1e22),F32(1e23),F32(1e24),F32(1e25),F32(1e26),F32(1e27),
|
|
F32(1e28),F32(1e29),F32(1e30),F32(1e31),F32(1e32),F32(1e33),F32(1e34),
|
|
F32(1e35),F32(1e36),F32(1e37),F32(1e38)])''',
|
|
u"1.000000, 10.000000, 100.000000, 1000.000000, 10000.000000, 100000.000000, "
|
|
u"1000000.000000, 10000000.000000, 100000000.000000, 1000000000.000000, "
|
|
u"10000000000.000000, 99999997952.000000, 999999995904.000000, "
|
|
u"9999999827968.000000, 100000000376832.000000, 999999986991104.000000, "
|
|
u"10000000272564224.000000, 99999998430674944.000000, "
|
|
u"999999984306749440.000000, 9999999980506447872.000000, "
|
|
u"100000002004087734272.000000, 1000000020040877342720.000000, "
|
|
u"9999999778196308361216.000000, 99999997781963083612160.000000, "
|
|
u"1000000013848427855085568.000000, 9999999562023526247432192.000000, "
|
|
u"100000002537764290115403776.000000, 999999988484154753734934528.000000, "
|
|
u"9999999442119689768320106496.000000, "
|
|
u"100000001504746621987668885504.000000, "
|
|
u"1000000015047466219876688855040.000000, "
|
|
u"9999999848243207295109594873856.000000, "
|
|
u"100000003318135351409612647563264.000000, "
|
|
u"999999994495727286427992885035008.000000, "
|
|
u"9999999790214767953607394487959552.000000, "
|
|
u"100000004091847875962975319375216640.000000, "
|
|
u"999999961690316245365415600208216064.000000, "
|
|
u"9999999933815812510711506376257961984.000000, "
|
|
u"99999996802856924650656260769173209088.000000")
|
|
|
|
test('llDumpList2String([F32(1e11)], u"/")', u'100000000000.000000')
|
|
|
|
# Inputs
|
|
inp = [F32(i) for i in [1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14,
|
|
1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22, 1e23, 1e24, 1e25, 1e26, 1e27, 1e28, 1e29, 1e30,
|
|
1e31, 1e32, 1e33, 1e34, 1e35, 1e36, 1e37, 1e38]]
|
|
|
|
# Expected
|
|
exp = [
|
|
u'1.000000',u'10.000000',u'100.000000',u'1000.000000',u'10000.000000',u'100000.000000',
|
|
u'1000000.000000',u'10000000.000000',u'100000000.000000',u'1000000000.000000',u'10000000000.000000',
|
|
u'100000000000.000000',u'1000000000000.000000',u'10000000000000.000000',u'100000000000000.000000',
|
|
u'1000000000000000.000000',u'10000000000000000.000000',u'100000000000000000.000000',
|
|
u'1000000000000000000.000000',u'10000000000000000000.000000',u'100000000000000000000.000000',
|
|
u'1000000000000000000000.000000',u'10000000000000000000000.000000',
|
|
u'100000000000000000000000.000000',u'1000000000000000000000000.000000',
|
|
u'10000000000000000000000000.000000',u'100000000000000000000000000.000000',
|
|
u'1000000000000000000000000000.000000',u'9999999000000000000000000000.000000',
|
|
u'100000000000000000000000000000.000000',u'1000000000000000000000000000000.000000',
|
|
u'10000000000000000000000000000000.000000',u'100000000000000000000000000000000.000000',
|
|
u'1000000000000000000000000000000000.000000',u'10000000000000000000000000000000000.000000',
|
|
u'100000000000000000000000000000000000.000000',u'1000000000000000000000000000000000000.000000',
|
|
u'10000000000000000000000000000000000000.000000',u'100000000000000000000000000000000000000.000000'
|
|
]
|
|
|
|
for i in range(len(inp)):
|
|
test('typecast('+repr(inp[i])+',unicode)', exp[i])
|
|
|
|
# Mono mode
|
|
test('f2s(F32(-.5e-6), 6)', u'-0.000001')
|
|
test('f2s(F("-0x1.0C6F7Ap-21"), 6)', u'-0.000001') # = F32(-.5e-6) so this test is redundant
|
|
test('f2s(F("0x1.0C6F7Ap-21"), 6)', u'0.000001')
|
|
test('f2s(F("-0x1.0C6F78p-21"), 6)', u'0.000000')
|
|
test('f2s(F("0x1.0C6F78p-21"), 6)', u'0.000000')
|
|
test('f2s(F32(.5e-5), 5)', u'0.00001')
|
|
test('f2s(F("-0x1.4F8B58p-18"), 5)', u'-0.00001') # = F32(-.5e-5) so this test is redundant
|
|
test('f2s(F("0x1.4F8B58p-18"), 5)', u'0.00001')
|
|
test('f2s(F("-0x1.4F8B56p-18"), 5)', u'0.00000')
|
|
test('f2s(F("0x1.4F8B56p-18"), 5)', u'0.00000')
|
|
|
|
test('f2s(F32(-123456789.), 6)', u'-123456800.000000')
|
|
test('f2s(F32(-123456784.), 6)', u'-123456800.000000')
|
|
|
|
test('f2s(F32(-123456740.), 6)', u'-123456700.000000')
|
|
test('f2s(F32(-12345.674), 6)', u'-12345.670000')
|
|
test('f2s(F32(-1.2345674), 6)', u'-1.234567')
|
|
test('f2s(F32(-1.2345675), 6)', u'-1.234568')
|
|
test('f2s(F32(-123456740.), 5)', u'-123456700.00000')
|
|
test('f2s(F32(-12345.674), 5)', u'-12345.67000')
|
|
test('f2s(F32(-1.2345674), 5)', u'-1.23457')
|
|
test('f2s(F32(-1.234564), 5)', u'-1.23456')
|
|
|
|
test('f2s(F32(-123456750.), 6)', u'-123456800.000000')
|
|
test('f2s(F32(-12345.675), 6)', u'-12345.670000') # I kid you not - that's from LSL
|
|
test('f2s(F32(-12345.676), 6)', u'-12345.680000')
|
|
test('f2s(F32(-123456750.), 5)', u'-123456800.00000')
|
|
test('f2s(F32(-12345.675), 5)', u'-12345.67000') # I kid you not - that's from LSL
|
|
test('f2s(F32(-12345.676), 5)', u'-12345.68000')
|
|
test('f2s(F32(-12.345675), 5)', u'-12.34568')
|
|
test('f2s(F32(1234567.5), 5)', u'1234568.00000')
|
|
test('f2s(F32(1234567.5), 6)', u'1234568.000000')
|
|
test('f2s(F32(1234567.4), 5)', u'1234567.00000')
|
|
test('f2s(F32(1234567.4), 6)', u'1234567.000000')
|
|
test('f2s(F32(123456.75), 5)', u'123456.80000')
|
|
test('f2s(F32(123456.74), 5)', u'123456.70000')
|
|
test('f2s(F32(12345675.), 5)', u'12345680.00000')
|
|
test('f2s(F32(12345674.), 5)', u'12345670.00000')
|
|
test('f2s(F32(9.999999), 5)', u'10.00000')
|
|
|
|
# LSO mode
|
|
lslcommon.LSO = True
|
|
test('f2s(F32(-.5e-6), 6)', u'-0.000000')
|
|
test('f2s(F32(-.51e-6), 6)', u'-0.000001')
|
|
test('f2s(F("-0x1.0C6F7Ap-21"), 6)', u'-0.000000') # = F32(-.5e-6) so this test is redundant
|
|
test('f2s(F("0x1.0C6F7Ap-21"), 6)', u'0.000000')
|
|
test('f2s(F("-0x1.0C6F7Cp-21"), 6)', u'-0.000001')
|
|
test('f2s(F("0x1.0C6F7Cp-21"), 6)', u'0.000001')
|
|
test('f2s(F32(.5e-5), 5)', u'0.00000')
|
|
test('f2s(F("-0x1.4F8B58p-18"), 5)', u'-0.00000') # = F32(-.5e-5) so this test is redundant
|
|
test('f2s(F("0x1.4F8B58p-18"), 5)', u'0.00000')
|
|
test('f2s(F("-0x1.4F8B5Ap-18"), 5)', u'-0.00001')
|
|
test('f2s(F("0x1.4F8B5Ap-18"), 5)', u'0.00001')
|
|
|
|
test('f2s(F32(-123456789.), 6)', u'-123456792.000000')
|
|
test('f2s(F32(-123456784.), 6)', u'-123456784.000000')
|
|
|
|
test('f2s(F32(-123456740.), 6)', u'-123456736.000000')
|
|
test('f2s(F32(-12345.674), 6)', u'-12345.673828')
|
|
test('f2s(F32(-1.2345674), 6)', u'-1.234567')
|
|
test('f2s(F32(-1.2345675), 6)', u'-1.234568')
|
|
test('f2s(F32(-123456740.), 5)', u'-123456736.00000')
|
|
test('f2s(F32(-12345.674), 5)', u'-12345.67383')
|
|
test('f2s(F32(-1.2345674), 5)', u'-1.23457')
|
|
test('f2s(F32(-1.234564), 5)', u'-1.23456')
|
|
|
|
test('f2s(F32(-123456750.), 6)', u'-123456752.000000')
|
|
test('f2s(F32(-12345.675), 6)', u'-12345.674805')
|
|
test('f2s(F32(-12345.676), 6)', u'-12345.675781')
|
|
test('f2s(F32(-123456750.), 5)', u'-123456752.00000')
|
|
test('f2s(F32(-12345.675), 5)', u'-12345.67480')
|
|
test('f2s(F32(-12345.676), 5)', u'-12345.67578')
|
|
test('f2s(F32(-12.345675), 5)', u'-12.34568')
|
|
test('f2s(F32(1234567.5), 5)', u'1234567.50000')
|
|
test('f2s(F32(1234567.5), 6)', u'1234567.500000')
|
|
test('f2s(F32(1234567.4), 5)', u'1234567.37500')
|
|
test('f2s(F32(1234567.4), 6)', u'1234567.375000')
|
|
test('f2s(F32(123456.75), 5)', u'123456.75000')
|
|
test('f2s(F32(123456.74), 5)', u'123456.74219')
|
|
test('f2s(F32(123456.74), 6)', u'123456.742188')
|
|
test('f2s(F32(12345675.), 5)', u'12345675.00000')
|
|
test('f2s(F32(12345674.), 5)', u'12345674.00000')
|
|
|
|
lslcommon.LSO = False
|
|
|
|
# llPow() input matrix
|
|
in1 = in2 = [NaN,-Infinity,F32(-2.1),-2.,-1.,F32(-.1),-.0,.0,F32(.1),1.,2.,F32(2.1),Infinity,Indet]
|
|
|
|
# Expected results table
|
|
exp = [
|
|
NaN,NaN,NaN,NaN,NaN,NaN,NaN,NaN,NaN,NaN,NaN,NaN,NaN,NaN,
|
|
NaN,0.,0.,0.,0.,0.,1.,1.,Infinity,-Infinity,Infinity,Infinity,Infinity,NaN,
|
|
NaN,0.,Indet,F('0x1.D0662Ep-3'),F('-0x1.E79E7Cp-2'),Indet,1.,1.,Indet,F('-0x1.0CCCCCp+1'),F('0x1.1A3D6Ep+2'),Indet,Infinity,NaN,
|
|
NaN,0.,Indet,.25,-0.5,Indet,1.,1.,Indet,-2.,4.,Indet,Infinity,NaN,
|
|
NaN,NaN,Indet,1.,-1.,Indet,1.,1.,Indet,-1.,1.,Indet,NaN,NaN,
|
|
NaN,Infinity,Indet,100.,-10.,Indet,1.,1.,Indet,F('-0x1.99999Ap-4'),F('0x1.47AE16p-7'),Indet,0.,NaN,
|
|
NaN,Infinity,Infinity,Infinity,-Infinity,Infinity,1.,1.,0.,0.,0.,0.,0.,NaN,
|
|
NaN,Infinity,Infinity,Infinity,Infinity,Infinity,1.,1.,0.,0.,0.,0.,0.,NaN,
|
|
NaN,Infinity,F('0x1.F791EEp+6'),100.,10.,F('0x1.4248F0p0'),1.,1.,F('0x1.96B230p-1'),F('0x1.99999Ap-4'),F('0x1.47AE16p-7'),F('0x1.04491Ap-7'),0.,NaN,
|
|
NaN,NaN,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,NaN,NaN,
|
|
NaN,0.,F('0x1.DDB682p-3'),.25,.5,F('0x1.DDB680p-1'),1.,1.,F('0x1.125FBEp0'),2.,4.,F('0x1.125FBEp+2'),Infinity,NaN,
|
|
NaN,0.,F('0x1.AF30DAp-3'),F('0x1.D0662Ep-3'),F('0x1.E79E7Cp-2'),F('0x1.DB6346p-1'),1.,1.,F('0x1.13B748p0'),F('0x1.0CCCCCp+1'),F('0x1.1A3D6Ep+2'),F('0x1.2FFA0Ep+2'),Infinity,NaN,
|
|
NaN,0.,0.,0.,0.,0.,1.,1.,Infinity,Infinity,Infinity,Infinity,Infinity,NaN,
|
|
NaN,NaN,NaN,NaN,NaN,NaN,NaN,NaN,NaN,NaN,NaN,NaN,NaN,NaN,
|
|
]
|
|
|
|
idx = 0
|
|
for i in in1:
|
|
for j in in2:
|
|
test('llPow(' + repr(i) + ',' + repr(j) + ')', exp[idx])
|
|
idx += 1
|
|
|
|
test('llCos(NaN)', NaN)
|
|
test('llCos(Infinity)', Indet)
|
|
test('llCos(-Infinity)', Indet)
|
|
test('llCos(math.pi)', -1.)
|
|
test('llCos(1000.)', F('0x1.1FF026p-1'))
|
|
test('llCos(1000000.)', F('0x1.DF9DFAp-1'))
|
|
test('llCos(1000000000.)', F('0x1.ACFF8Cp-1'))
|
|
test('llCos(-1000000000.)', F('0x1.ACFF8Cp-1'))
|
|
test('llCos(F("0x1.FFFFFEp+62"))', F('-0x1.F4E122p-1'))
|
|
test('llCos(F("-0x1.FFFFFEp+62"))', F('-0x1.F4E122p-1'))
|
|
test('llCos(F("0x1p63"))', F('0x1p63'))
|
|
test('llCos(F("-0x1p63"))', F('-0x1p63'))
|
|
test('llSin(NaN)', NaN)
|
|
test('llSin(Infinity)', Indet)
|
|
test('llSin(-Infinity)', Indet)
|
|
test('llSin(F32(math.pi))', F('-0x1.777A5Cp-24'))
|
|
test('llSin(1000.)', F('0x1.A75CC2p-1'))
|
|
test('llSin(1000000.)', F('-0x1.6664B2p-2'))
|
|
test('llSin(1000000000.)', F('0x1.1778CAp-1'))
|
|
test('llSin(-1000000000.)', F('-0x1.1778CAp-1'))
|
|
test('llSin(F32(1e38))', F32(1e38))
|
|
test('llSin(F("0x1.FFFFFEp+62"))', F('0x1.A8862Cp-3'))
|
|
test('llSin(F("-0x1.FFFFFEp+62"))', F('-0x1.A8862Cp-3'))
|
|
test('llSin(F("0x1p63"))', F('0x1p63'))
|
|
test('llSin(F("-0x1p63"))', F('-0x1p63'))
|
|
test('llTan(F32(1e38))', F32(1e38))
|
|
test('llTan(F32(4e38))', Indet)
|
|
test('llTan(F32(math.pi))', F('0x1.777A5Cp-24'))
|
|
test('llTan(F32(math.pi*.5))', -22877332.)
|
|
test('llTan(F("0x1.921FB4p0"))', 13245402.)
|
|
test('llTan(F("0x1.FFFFFEp62"))', F('-0x1.B1F30Ep-3'))
|
|
test('llTan(F("-0x1.FFFFFEp62"))', F('0x1.B1F30Ep-3'))
|
|
test('llTan(F("0x1p63"))', F('0x1p63'))
|
|
test('llTan(F("-0x1p63"))', F('-0x1p63'))
|
|
test('llAsin(2.0)', NaN)
|
|
test('llAcos(2.0)', NaN)
|
|
test('llAtan2(0.0, 0.0)', 0.0)
|
|
test('llAtan2(-0.0, -1.0)', F32(-math.pi))
|
|
test('llAtan2(0.0, -1.0)', F32(math.pi))
|
|
test('llAtan2(-Infinity, -1.0)', F32(-math.pi/2))
|
|
test('llAtan2(Infinity, -1.0)', F32(math.pi/2))
|
|
test('llAtan2(NaN, -1.0)', NaN)
|
|
test('llAtan2(NaN, -0.0)', NaN)
|
|
test('llAtan2(NaN, 0.0)', NaN)
|
|
test('llAtan2(NaN, 1.0)', NaN)
|
|
test('llAtan2(-NaN, -1.0)', -NaN)
|
|
test('llAtan2(-NaN, -0.0)', -NaN)
|
|
test('llAtan2(-NaN, 0.0)', -NaN)
|
|
test('llAtan2(-NaN, 1.0)', -NaN)
|
|
test('llAtan2(-1.0, NaN)', NaN)
|
|
test('llAtan2(-0.0, NaN)', NaN)
|
|
test('llAtan2( 0.0, NaN)', NaN)
|
|
test('llAtan2( 1.0, NaN)', NaN)
|
|
test('llAtan2(-1.0, -NaN)', -NaN)
|
|
test('llAtan2(-0.0, -NaN)', -NaN)
|
|
test('llAtan2( 0.0, -NaN)', -NaN)
|
|
test('llAtan2( 1.0, -NaN)', -NaN)
|
|
test('llAtan2(-NaN, -NaN)', -NaN)
|
|
test('llAtan2(-NaN, NaN)', NaN)
|
|
test('llAtan2(NaN, -NaN)', NaN)
|
|
test('llAtan2(NaN, NaN)', NaN)
|
|
|
|
# nan and -nan in llList2CSV
|
|
test('llList2CSV([llSin(F32(4e38))])', u'-nan')
|
|
test('llList2CSV([llCos(F32(4e38))])', u'-nan')
|
|
test('llList2CSV([llTan(F32(4e38))])', u'-nan')
|
|
test('llList2CSV([llSqrt(F32(-1))])', u'-nan')
|
|
test('llList2CSV([llPow(-1.0,F32(1.3))])', u'-nan')
|
|
test('llList2CSV([llPow(nan,F32(1.3))])', u'nan')
|
|
test('llList2CSV([Vector((-nan,nan,-inf))])', u'<-nan, nan, -inf>')
|
|
|
|
test('llFrand(0.0)', 0.0)
|
|
test('llFrand(-0.0)', 0.0)
|
|
test('llFrand(Infinity)', 0.0)
|
|
test('llFrand(-Infinity)', 0.0)
|
|
test('llFrand(-NaN)', -NaN)
|
|
test('llFrand(NaN)', NaN)
|
|
test('llFrand(F32(1.4e-45))', 0.0)
|
|
test('llFrand(F32(1.1754942106924411e-38))', 0.0)
|
|
|
|
test('llRot2Fwd(Quaternion((1.,0.,0.,0.)))', Vector((1.,0.,0.)))
|
|
test('llRot2Fwd(Quaternion((0.,1.,0.,0.)))', Vector((-1.,0.,0.)))
|
|
test('llRot2Fwd(Quaternion((0.,0.,1.,0.)))', Vector((-1.,0.,0.)))
|
|
test('llRot2Fwd(Quaternion((0.,0.,0.,1.)))', Vector((1.,0.,0.)))
|
|
test('llRot2Fwd(Quaternion((0.,0.,0.,0.)))', Vector((1.,0.,0.)))
|
|
test('llRot2Left(Quaternion((1.,0.,0.,0.)))', Vector((0.,-1.,0.)))
|
|
test('llRot2Left(Quaternion((0.,1.,0.,0.)))', Vector((0.,1.,0.)))
|
|
test('llRot2Left(Quaternion((0.,0.,1.,0.)))', Vector((0.,-1.,0.)))
|
|
test('llRot2Left(Quaternion((0.,0.,0.,1.)))', Vector((0.,1.,0.)))
|
|
test('llRot2Left(Quaternion((0.,0.,0.,0.)))', Vector((0.,1.,0.)))
|
|
test('llRot2Up(Quaternion((1.,0.,0.,0.)))', Vector((0.,0.,-1.)))
|
|
test('llRot2Up(Quaternion((0.,1.,0.,0.)))', Vector((0.,0.,-1.)))
|
|
test('llRot2Up(Quaternion((0.,0.,1.,0.)))', Vector((0.,0.,1.)))
|
|
test('llRot2Up(Quaternion((0.,0.,0.,1.)))', Vector((0.,0.,1.)))
|
|
test('llRot2Up(Quaternion((0.,0.,0.,0.)))', Vector((0.,0.,1.)))
|
|
|
|
lslcommon.IsCalc = True # llGenerateKey() only works in calculator mode
|
|
test('cond(llGenerateKey())', True)
|
|
lslcommon.IsCalc = False
|
|
shouldexcept('llGenerateKey()', ELSLCantCompute)
|
|
|
|
testXB64S("", "", "")
|
|
testXB64S(u"Hello, World!", u"", u"Hello, World!")
|
|
testXB64S("AAAAA==AAAAA=", "_X", "/X/X/==X/X/X=")
|
|
testXB64S("AAAAAA......AAAAAAA", "BCDEFG=====", "BCDEFG======CDEFGBC")
|
|
testXB64S("AAAAA===AAAAAAAAAAA", "BCDEF", "BCDEF===EFBCDEFBCDE")
|
|
testXB64S("Hello, World!", "A", "Hello==World=")
|
|
testXB64S("Hello, World!", "A=", "Hello==World=")
|
|
testXB64S("Hello, World!", "A?", "Hello==World=")
|
|
testXB64S("Hello, World!", "A?A", "Hello==World=")
|
|
testXB64S("Hello, World!", "+", "5gbbW==oWVbj=")
|
|
testXB64S("Hello, World!", "++", "5gbbW==oWVbj=")
|
|
testXB64S("Hello, World!", "=", "5gbbW==oWVbj=")
|
|
testXB64S("Hello, World!", "+=", "5gbbW==oWVbj=")
|
|
testXB64S("Hello, World!", "+?", "5gbbW==oWVbj=")
|
|
testXB64S("Hello, World!", "+??", "5gbbW==oWVbj=")
|
|
testXB64S("Hello, World!", "+???", "5gbbW==oWVbj=")
|
|
testXB64S("Hello, World!", "+????", "5gbbW==oWVbj=")
|
|
testXB64S("Hello, World!", "+?????", "5gbbW==oWVbj=")
|
|
testXB64S("Hello, World!", "+???????", "5gbbW==oWVbj=")
|
|
testXB64S("Hello, World!", "/", "4haaX==pXUai=")
|
|
testXB64S("Hello, World!", "//", "4haaX==pXUai=")
|
|
testXB64S("Hello, World!", "^", "4haaX==pXUai=")
|
|
testXB64S("Hello, World!", ".", "4haaX==pXUai=")
|
|
testXB64S("Hello, World!", "_", "4haaX==pXUai=")
|
|
testXB64S("Hello, World!", "_XX", "4Jya/==B/UyK=")
|
|
testXB64S("Hello, World!", "XYZ", "QG8yw==Ox89E=")
|
|
testXB64S("Hello, World!", "XYZ?", "QG8yw==BwyyF=")
|
|
testXB64S("Hello, World!", "XYZXYZ", "QG8yw==Ox89E=")
|
|
testXB64S("Hello, World!", "XYZXYZ==", "QG8yw==BwyyF=")
|
|
testXB64S("AAAAA===AAAAAAAAAAA", "BCDEF", "BCDEF===EFBCDEFBCDE")
|
|
testXB64S("AAAAA===AAAAAAAAAAA", "BCDEF=", "BCDEF===DEFBCDEFBCD")
|
|
testXB64S("AAAAA===AAAAAAAAAAA", "BCDEF==", "BCDEF===CDEFBCDEFBC")
|
|
testXB64S("AAAAA===AAAAAAAAAAA", "BCDEF===", "BCDEF===BCDEFBCDEFB")
|
|
testXB64S("AA_AAA______AAAAAAAAAAAAA", "BC=EFG==",
|
|
"BC=EFG======FGBCBCBCBCBCB")
|
|
testXB64S("AA_AAA______AAAAAA=AAAAAA", "BC=EFG==",
|
|
"BC=EFG======FGBCBC=EFGBCB")
|
|
testXB64S("AAAAA==AAAAA", "_XXXXXXX", "/XXXX==X/XXX")
|
|
testXB64S("ABCDABCDABCDABCDABCDABCDABCD", "ABCD",
|
|
"AAAAAAAAAAAAAAAAAAAAAAAAAAAA")
|
|
testXB64S("BCDABCDABCDABCDABCDABCDABCDA", "BCDA",
|
|
"AAAAAAAAAAAAAAAAAAAAAAAAAAAA")
|
|
testXB64S("AA_AAA______AAAAAAAAAAAAA", "=5gbbW==oWVbj=", "+5=bbW======j+5gbbW+5gbbW")
|
|
|
|
testXB64SC(u"\U00012345", "", u"\U00012345")
|
|
testXB64SC("AABA", "1234", "1224")
|
|
testXB64SC("1234", "AABA", "1234")
|
|
testXB64SC("BAAA", "1234", "0234")
|
|
testXB64SC("1234", "BAAA", "02n8")
|
|
testXB64SC("AABA", "AABA", "AABA")
|
|
testXB64SC("AABA", "AABC", "AABA")
|
|
testXB64SC("AABC", "AABA", "AABC")
|
|
testXB64SC("Hello, World!", "XYZXYZ", "QG8y")
|
|
testXB64SC("QG8y", "XYZXYZ", "Hell")
|
|
testXB64SC("ABCDABCDABCDABCDABCDABCDABCD", "ABCD",
|
|
"AAAAAAAAAAAAAAAAAAAAAAAAAAAA")
|
|
testXB64SC("BCDABCDABCDABCDABCDABCDABCDA", "BCDA",
|
|
"AAAAAAAAAAAAAAAAAAAAAAAAAAAA")
|
|
testXB64SC("ABCD", "ABCD", "AAAA")
|
|
testXB64SC("ABCDABCDABCD", "ABCD", "AAAAAAAAAAAA")
|
|
testXB64SC("AACD", "AACD", "AACD")
|
|
testXB64SC("AQCD", "AQCD", "AAGC")
|
|
testXB64SC("AQCDAQCD", "AQC=", "AAGCAAGC")
|
|
testXB64SC("AQCDAQCD", "AQCD", "AAGCAAGC")
|
|
testXB64SC("ACCD", "AC==", "ACCD")
|
|
testXB64SC("ABCD", "AB==", "ABCD")
|
|
testXB64SC("ABCD", "ABC=", "AACD")
|
|
testXB64SC("APCD", "APC=", "AACD")
|
|
testXB64SC("AQCD", "AQC=", "AAGC")
|
|
testXB64SC("ACCD", "ABC=", "ADCD")
|
|
testXB64SC("ARCD", "ARC=", "AACC")
|
|
testXB64SC("ABCDABCDABCDABCDABCDABCDABCD", "AB==",
|
|
"ABCDABCDABCDABCDABCDABCDABCD")
|
|
testXB64SC("ABCDABCDABCDABCDABCDABCDABCD", "AQ==",
|
|
"ARGCARGCARGCARGCARGCARGCARGC")
|
|
testXB64SC("ABCDABCDABCDABCDABCDABCDABCD", "ABCDAP//",
|
|
"AAAAAAAAAAAAAAAAAAAAAAAAAAAA")
|
|
|
|
testXB64(u"\U00012345", "", u"\U00012345")
|
|
testXB64("AABA", "1234", "1224")
|
|
testXB64("1234", "AABA", "1224")
|
|
testXB64("BAAA", "1234", "0234")
|
|
testXB64("1234", "BAAA", "0234")
|
|
testXB64("AABA", "AABA", "AAAA")
|
|
testXB64("AABA", "AABC", "AAAC")
|
|
testXB64("AABC", "AABA", "AAAC")
|
|
testXB64("Hello, World!", "XYZXYZ", "QG8y")
|
|
testXB64("QG8y", "XYZXYZ", "Hell")
|
|
testXB64("ABCDABCDABCD", "ABCD", "AAAAAAAAABCT", True)
|
|
testXB64("ABCDABCDABCDABCDABCDABCDABCD", "ABCD",
|
|
"AAAAAAAAABCTgxCDEJODAAAAABCT", True)
|
|
testXB64("ABCDABCDABCD", "ABCD", "AAAAAAAAAAAA")
|
|
testXB64("ABCDABCDABCDABCDABCDABCDABCD", "ABCD",
|
|
"AAAAAAAAAAAAAAAAAAAAAAAAAAAA")
|
|
testXB64S ("ABCDABCDABCD", "ABC=", "AAADBDCCCBDB")
|
|
testXB64SC("ABCDABCDABCD", "ABC=", "AACDEBCTAACD")
|
|
testXB64 ("ABCDABCDABCD", "ABC=", "AACDEBCDEBCD", True)
|
|
testXB64 ("ABCDABCDABCD", "ABC=", "AACDEBCTAACD")
|
|
|
|
testXB64("Stuffs not b64 <^.^>!", "AA==", "Stuffg==")
|
|
|
|
# Four different results for the same input strings...
|
|
testXB64S ("AQCDAQCD", "AQC=", "AAADQSCT")
|
|
testXB64SC("AQCDAQCD", "AQC=", "AAGCAAGC")
|
|
testXB64 ("AQCDAQCD", "AQC=", "AACCAQCC", True)
|
|
testXB64 ("AQCDAQCD", "AQC=", "AACCAQGD") # the only correct one
|
|
|
|
|
|
lslcommon.IsCalc = True # llModPow can only be computed in calculator mode
|
|
test('llModPow(65535, 3, 0)', 0)
|
|
test('llModPow(65535, 3, 41)', 34)
|
|
test('llModPow(65535, 3, -2147483648)', 196607)
|
|
test('llModPow(65535, 3, -2147483647)', 131071)
|
|
test('llModPow(65533, 3, -2147483648)', 1769445)
|
|
test('llModPow(65533, 3, -2147483645)', 1572843)
|
|
test('llModPow(65533, 3, 2147483645)', 1966047)
|
|
test('llModPow(65533, 3, 555)', 142)
|
|
test('llModPow(65533, 3, 1073741823)', 1966045)
|
|
test('llModPow(65533, 3, 1073741824)', 1769445)
|
|
test('llModPow(65533, 3, 1073741825)', 1572845)
|
|
test('llModPow(32767, 3, 1073741825)', 98302)
|
|
test('llModPow(32767, 3, 107374182)', 216275)
|
|
test('llModPow(32767, 3, 10737418)', 876887)
|
|
test('llModPow(32767, 3, 1073741)', 230066)
|
|
test('llModPow(32767, 3, 107374)', 54345)
|
|
test('llModPow(32767, 3, 507374)', 161343)
|
|
test('llModPow(32767, 3, 907374)', 346875)
|
|
test('llModPow(32767, 3, 707374)', 690307)
|
|
test('llModPow(32767, 3, 607374)', 139309)
|
|
test('llModPow(32767, 3, 600374)', 146813)
|
|
test('llModPow(32767, 3, 550374)', 389875)
|
|
test('llModPow(32767, 3, 520374)', 301047)
|
|
test('llModPow(32767, 3, 510374)', 36839)
|
|
test('llModPow(32767, 3, 500374)', 115989)
|
|
test('llModPow(32767, 3, 300374)', 83681)
|
|
test('llModPow(32767, 3, 100374)', 23425)
|
|
test('llModPow(32767, 3, 130374)', 64819)
|
|
test('llModPow(32767, 3, 132374)', 66641)
|
|
test('llModPow(32767, 3, 142374)', 93049)
|
|
test('llModPow(32767, 3, 172374)', 59569)
|
|
test('llModPow(32767, 3, 192374)', 66591)
|
|
test('llModPow(32767, 3, 199374)', 112231)
|
|
test('llModPow(32767, 3, 209374)', 54343)
|
|
test('llModPow(32767, 3, 259374)', 84733)
|
|
test('llModPow(32767, 3, 269374)', 49913)
|
|
test('llModPow(32767, 3, 261374)', 85865)
|
|
test('llModPow(32767, 3, 260374)', 2379)
|
|
test('llModPow(32767, 3, 250374)', 78307)
|
|
test('llModPow(32767, 3, 259375)', 99163)
|
|
test('llModPow(32767, 3, 260000)', 254367)
|
|
test('llModPow(32767, 3, 259999)', 90487)
|
|
test('llModPow(32767, 3, 259500)', 19663)
|
|
test('llModPow(32767, 3, 259750)', 29663)
|
|
test('llModPow(32767, 3, 259850)', 49367)
|
|
test('llModPow(32767, 3, 259800)', 164967)
|
|
test('llModPow(32767, 3, 259790)', 137017)
|
|
test('llModPow(32767, 3, 259770)', 64183)
|
|
test('llModPow(32767, 3, 259780)', 237863)
|
|
test('llModPow(32767, 3, 259785)', 162132)
|
|
test('llModPow(32767, 3, 259782)', 85797)
|
|
test('llModPow(32767, 3, 259781)', 157054)
|
|
test('llModPow(32767, 2, 259781)', 1416)
|
|
test('llModPow(32767, 2, 259782)', 257065)
|
|
test('llModPow(32767, 3, 259782)', 85797)
|
|
test('llModPow(-1, 3, 259782)', 251271)
|
|
test('llModPow(-1, -3, 259782)', 251271)
|
|
test('llModPow(0, 0, 0)', 0)
|
|
test('llModPow(1, 0, 0)', 0)
|
|
test('llModPow(1, 0, 1)', 0)
|
|
test('llModPow(1, 0, 2)', 1)
|
|
test('llModPow(1, 0, 3)', 1)
|
|
test('llModPow(1, 0, 4)', 1)
|
|
test('llModPow(1, 1, 1)', 0)
|
|
test('llModPow(5, 1, 1)', 0)
|
|
test('llModPow(5, 25, 7)', 5)
|
|
test('llModPow(5, 25, 13)', 5)
|
|
test('llModPow(5, 25, 17)', 12)
|
|
test('llModPow(41, 1, 17)', 7)
|
|
lslcommon.IsCalc = False
|
|
|
|
lslcommon.LSO = True
|
|
test('llListFindList([],[])', -1)
|
|
test('llListFindList([3],[])', 0)
|
|
lslcommon.LSO = False
|
|
test('llListFindList([],[])', 0)
|
|
test('llListFindList([3],[])', 0)
|
|
test('llListFindList([3],[3,4,5])', -1)
|
|
test('llListFindList([NaN], [NaN])', 0) # I swear.
|
|
test('llListFindList([NaN, Indet], [Indet, NaN])', 0) # Indeed.
|
|
test('llListFindList([-0.], [0.])', 0) # Really.
|
|
test('llListFindList([0.], [-0.])', 0) # Yes.
|
|
test('llListFindList([1, NaN, 1., NaN], [1., NaN])', 2)
|
|
test('llListFindList([1, NaN, 1., NaN], [2.])', -1)
|
|
test('llListFindList([Vector((NaN,0.,0.))], [Vector((NaN,0.,0.))])', -1) # Yes, really
|
|
test('llListFindList([Vector((0.,0.,0.))], [Vector((0.,0.,0.))])', 0)
|
|
test('llListFindList([Quaternion((0.,0.,0.,NaN))], [Quaternion((0.,0.,0.,NaN))])', -1) # Python == fails here
|
|
test('llListFindList([Quaternion((0.,0.,0.,Indet))], [Quaternion((0.,0.,0.,Indet))])', -1)
|
|
test('''llListFindList([Key(u"12345678-ABCD-5678-1234-123456781234")],
|
|
[Key(u"12345678-abcd-5678-1234-123456781234")])''', -1)
|
|
test('''llListFindList([Key(u"12345678-abcd-5678-1234-123456781234")],
|
|
[Key(u"12345678-abcd-5678-1234-123456781234")])''', 0)
|
|
test('''llListFindList([u"12345678-abcd-5678-1234-123456781234",
|
|
Key(u"12345678-abcd-5678-1234-123456781234")],
|
|
[Key(u"12345678-abcd-5678-1234-123456781234")])''', 1)
|
|
|
|
test('llIntegerToBase64(-680658713)', u'12345w==')
|
|
test('llIntegerToBase64(-1)', u'/////w==')
|
|
test('llIntegerToBase64(0)', u'AAAAAA==')
|
|
test('llIntegerToBase64(1)', u'AAAAAQ==')
|
|
test('llIntegerToBase64(2)', u'AAAAAg==')
|
|
test('llIntegerToBase64(3)', u'AAAAAw==')
|
|
test('llIntegerToBase64(-2147483648)', u'gAAAAA==')
|
|
test('llIntegerToBase64(2147483647)', u'f////w==')
|
|
|
|
test('llBase64ToInteger(u"123456789")', 0)
|
|
test('llBase64ToInteger(u"12345A===")', 0)
|
|
test('llBase64ToInteger(u"12345678")', -680658713)
|
|
test('llBase64ToInteger(u"123456")', -680658713)
|
|
test('llBase64ToInteger(u"123456==")', -680658713)
|
|
test('llBase64ToInteger(u"12345w==")', -680658713)
|
|
test('llBase64ToInteger(u"12345.")', -680658944)
|
|
test('llBase64ToInteger(u"gAAAAA")', -2147483648)
|
|
test('llBase64ToInteger(u"/////w")', -1)
|
|
|
|
s = u''.join(unichr(i) for i in xrange(1,257))
|
|
test('llEscapeURL(' + repr(s) + ')',
|
|
u'%01%02%03%04%05%06%07%08%09%0A%0B%0C%0D%0E%0F%10%11%12%13%14%15%16%17%18%19%1A%1B%1C%1D%1E%1F'
|
|
u'%20%21%22%23%24%25%26%27%28%29%2A%2B%2C%2D%2E%2F0123456789%3A%3B%3C%3D%3E%3F%40ABCDEFGHIJKLMN'
|
|
u'OPQRSTUVWXYZ%5B%5C%5D%5E%5F%60abcdefghijklmnopqrstuvwxyz%7B%7C%7D%7E%7F%C2%80%C2%81%C2%82%C2%'
|
|
u'83%C2%84%C2%85%C2%86%C2%87%C2%88%C2%89%C2%8A%C2%8B%C2%8C%C2%8D%C2%8E%C2%8F%C2%90%C2%91%C2%92%'
|
|
u'C2%93%C2%94%C2%95%C2%96%C2%97%C2%98%C2%99%C2%9A%C2%9B%C2%9C%C2%9D%C2%9E%C2%9F%C2%A0%C2%A1%C2%'
|
|
u'A2%C2%A3%C2%A4%C2%A5%C2%A6%C2%A7%C2%A8%C2%A9%C2%AA%C2%AB%C2%AC%C2%AD%C2%AE%C2%AF%C2%B0%C2%B1%'
|
|
u'C2%B2%C2%B3%C2%B4%C2%B5%C2%B6%C2%B7%C2%B8%C2%B9%C2%BA%C2%BB%C2%BC%C2%BD%C2%BE%C2%BF%C3%80%C3%'
|
|
u'81%C3%82%C3%83%C3%84%C3%85%C3%86%C3%87%C3%88%C3%89%C3%8A%C3%8B%C3%8C%C3%8D%C3%8E%C3%8F%C3%90%'
|
|
u'C3%91%C3%92%C3%93%C3%94%C3%95%C3%96%C3%97%C3%98%C3%99%C3%9A%C3%9B%C3%9C%C3%9D%C3%9E%C3%9F%C3%'
|
|
u'A0%C3%A1%C3%A2%C3%A3%C3%A4%C3%A5%C3%A6%C3%A7%C3%A8%C3%A9%C3%AA%C3%AB%C3%AC%C3%AD%C3%AE%C3%AF%'
|
|
u'C3%B0%C3%B1%C3%B2%C3%B3%C3%B4%C3%B5%C3%B6%C3%B7%C3%B8%C3%B9%C3%BA%C3%BB%C3%BC%C3%BD%C3%BE%C3%'
|
|
u'BF%C4%80')
|
|
|
|
test(r'llStringToBase64(u"\U0001D11E\xC1a\xF1# +")', u'8J2EnsOBYcOxIyAr')
|
|
test('llBase64ToString(u"8J2EnsOBYcOxIyAr")', u'\U0001D11E\xC1a\xF1# +')
|
|
test('llBase64ToString(u"")', u'')
|
|
test('llBase64ToString(u"1")', u'')
|
|
test('llBase64ToString(u"12")', u'?')
|
|
test('llBase64ToString(u"14A")', u'\u05C0')
|
|
# llUnescapeURL and llBase64ToString behave differently. We need to test
|
|
# both thoroughly.
|
|
|
|
# Embedded and trailing NUL tests:
|
|
test('llBase64ToString(u"QUJDAERFRg")', u'ABC?DEF') # 'ABC\x00DEF'
|
|
test('llBase64ToString(u"AEEAQgBD")', u'?A?B?C') # '\x00A\x00B\x00C'
|
|
test('llBase64ToString(u"AEEAQgBDAA")', u'?A?B?C') # '\x00A\x00B\x00C\x00'
|
|
test('llBase64ToString(u"AEEAQgBDAAA=")', u'?A?B?C?') # '\x00A\x00B\x00C\x00'
|
|
|
|
# Some assorted tests:
|
|
test('llBase64ToString(u"gIAA")', u'??')
|
|
test('llBase64ToString(u"gAA")', u'?')
|
|
test('llBase64ToString(u"44AA")', u'?')
|
|
test('llBase64ToString(u"4IAh")', u'?!')
|
|
test('llBase64ToString(u"gICAgGE")', u'????a')
|
|
test('llBase64ToString(u"QQA")', u'A')
|
|
test('llBase64ToString(u"AEE=")', u'?A')
|
|
test('llBase64ToString(u"wKE")', u'?') # C080
|
|
test('llBase64ToString(u"9ICA")', u'?') # F48080
|
|
test('llBase64ToString(u"94CAgICA")', u'??????')
|
|
test('llBase64ToString(u"4ICA")', u'?') # E08080
|
|
test('llBase64ToString(u"4IA")', u'?') # E080
|
|
test('llUnescapeURL(u"%E0%80")', u'??') # Compare with the above
|
|
|
|
testB642S("C38180E381C380414243D3", "%C3%81%3F%3F%C3%80ABC%3F")
|
|
testB642S("C38180E381C38041424300D3", "%C3%81%3F%3F%C3%80ABC%3F%3F")
|
|
testB642S("E0808080808080E381C38041424300D3", "%3F%3F%3F%3F%3F%3F%C3%80ABC%3F%3F")
|
|
# test UTF-8 valid ranges
|
|
testB642S("7F78", "%7Fx") # range up to U+007F
|
|
testB642S("808078", "%3F%3Fx") # invalid range begin
|
|
testB642S("BFBF78", "%3F%3Fx") # invalid range end
|
|
testB642S("C08078", "%3Fx") # aliased range begin (U+0000)
|
|
testB642S("C1BF78", "%3Fx") # aliased range end (U+007F)
|
|
testB642S("C28078", "%C2%80x") # U+0080 (2-byte range start)
|
|
testB642S("DFBF78", "%DF%BFx") # U+07FF (2-byte range end)
|
|
testB642S("E0808078", "%3Fx") # aliased range begin (U+0000)
|
|
testB642S("E09FBF78", "%3Fx") # aliased range end (U+07FF)
|
|
testB642S("E0A08078", "%E0%A0%80x") # U+0800 (3-byte range start)
|
|
testB642S("ED9FBF78", "%ED%9F%BFx") # U+D7FF (right before first UTF-16 high surrogate)
|
|
testB642S("EE808078", "%EE%80%80x") # U+E000 (right after last UTF-16 low surrogate)
|
|
testB642S("EFBFBF78", "%EF%BF%BFx") # U+FFFF (3-byte range end)
|
|
testB642S("F080808078", "%3Fx") # aliased range begin (U+0000)
|
|
testB642S("F08FBFBF78", "%3Fx") # aliased range end (U+FFFF)
|
|
testB642S("F090808078", "%F0%90%80%80x") # U+10000 (4-byte range start)
|
|
testB642S("F48FBFBF78", "%F4%8F%BF%BFx") # U+10FFFF (valid 4-byte range end)
|
|
# excluded because they are used for UTF-16 surrogates, not valid characters
|
|
testB642S("EDA08078", "%3F%3F%3Fx") # D800 - first high surrogate
|
|
testB642S("EDAFBF78", "%3F%3F%3Fx") # DBFF - last high surrogate
|
|
testB642S("EDB08078", "%3F%3F%3Fx") # DC00 - first low surrogate
|
|
testB642S("EDBFBF78", "%3F%3F%3Fx") # DFFF - last low surrogate
|
|
# excluded because of truncation to U+10FFFF
|
|
testB642S("F490808078", "%3F%3F%3F%3Fx") # U+110000 (invalid 4-byte range start)
|
|
testB642S("F7BFBFBF78", "%3F%3F%3F%3Fx") # U+1FFFFF (invalid 4-byte range end)
|
|
testB642S("F88080808078", "%3Fx") # aliased range begin (U+0000)
|
|
testB642S("F887BFBFBF78", "%3Fx") # aliased range end (U+1FFFFF)
|
|
testB642S("F88880808078", "%3F%3F%3F%3F%3Fx") # U+200000 (invalid 5-byte range start)
|
|
testB642S("FBBFBFBFBF78", "%3F%3F%3F%3F%3Fx") # U+3FFFFFF (invalid 5-byte range end)
|
|
testB642S("FC808080808078", "%3Fx") # aliased range begin (U+0000)
|
|
testB642S("FC83BFBFBFBF78", "%3Fx") # aliased range end (U+3FFFFFF)
|
|
testB642S("FC848080808078", "%3F%3F%3F%3F%3F%3Fx") # U+4000000 (invalid 6-byte range start)
|
|
testB642S("FDBFBFBFBFBF78", "%3F%3F%3F%3F%3F%3Fx") # U+7FFFFFFF (invalid 6-byte range end)
|
|
# not actually valid either way (these are actually used to distinguish the
|
|
# input as UTF-16 BOM and are invalid in UTF-8)
|
|
testB642S("FEB080808080808078", "%3F%3F%3F%3F%3F%3F%3F%3Fx")
|
|
testB642S("FFBFBFBFBFBFBFBF78", "%3F%3F%3F%3F%3F%3F%3F%3Fx")
|
|
# short or invalid sequences
|
|
testB642S("80", "%3F")
|
|
testB642S("BF", "%3F")
|
|
testB642S("C2", "%3F")
|
|
testB642S("E1", "%3F")
|
|
testB642S("E180", "%3F")
|
|
testB642S("F1", "%3F")
|
|
testB642S("F180", "%3F")
|
|
testB642S("F18080", "%3F")
|
|
testB642S("F8808080", "%3F")
|
|
testB642S("F8888080", "%3F")
|
|
testB642S("FC80808080", "%3F")
|
|
testB642S("FC84808080", "%3F")
|
|
|
|
# Test that U+FFFD is preserved even with invalid characters
|
|
testB642S("EFBFBD90", "%EF%BF%BD%3F")
|
|
|
|
|
|
test('typecast([1,F32(3.14),Key(u"blah"),Quaternion((1.,0.,0.,0.))], unicode)',
|
|
u'13.140000blah<1.000000, 0.000000, 0.000000, 0.000000>')
|
|
|
|
test('''llDumpList2String(llCSV2List(u'a,<<1,2>,3,4,">5,6, "1,3",7<<>,8,9'), u"|")''',
|
|
u'a|<<1,2>,3,4,">5|6|"1|3"|7<<>,8,9')
|
|
|
|
test('llInsertString(u"", -3, u"abc")', u'abc')
|
|
test('llInsertString(u"", -1, u"abc")', u'abc')
|
|
test('llInsertString(u"", 0, u"abc")', u'abc')
|
|
test('llInsertString(u"", 1, u"abc")', u'abc')
|
|
test('llInsertString(u"", 3, u"abc")', u'abc')
|
|
|
|
test('llInsertString(u"xy", -3, u"abc")', u'abcxy')
|
|
test('llInsertString(u"xy", -1, u"abc")', u'abcxy')
|
|
test('llInsertString(u"xy", 0, u"abc")', u'abcxy')
|
|
test('llInsertString(u"xy", 1, u"abc")', u'xabcy')
|
|
test('llInsertString(u"xy", 2, u"abc")', u'xyabc')
|
|
test('llInsertString(u"xy", 3, u"abc")', u'xyabc')
|
|
|
|
test('llUnescapeURL(u"%")', u'')
|
|
test('llUnescapeURL(u"%%")', u'')
|
|
test('llUnescapeURL(u"%4%252Fabc")', u'\x40252Fabc')
|
|
test('llUnescapeURL(u"%%4%252Fabc")', u'\x04\x252Fabc')
|
|
test('llEscapeURL(llUnescapeURL(u"%.44%25%%2Fa\u2190c"))', u'%044%25%02Fa%E2%86%90c')
|
|
test('llEscapeURL(llUnescapeURL(u"%.44%25%%2Fa\u2190c%"))', u'%044%25%02Fa%E2%86%90c')
|
|
test('llEscapeURL(llUnescapeURL(u"%.44%25%%2Fa\u2190c%2"))', u'%044%25%02Fa%E2%86%90c')
|
|
test('llEscapeURL(llUnescapeURL(u"%.44%25%%2Fa\u2190c%%"))', u'%044%25%02Fa%E2%86%90c')
|
|
test('llEscapeURL(llUnescapeURL(u"%.44%25%%2Fa\u2190c%%2"))', u'%044%25%02Fa%E2%86%90c%02')
|
|
test('llEscapeURL(llUnescapeURL(u"%.44%25%%2Fa\u2190c%%%2346"))', u'%044%25%02Fa%E2%86%90c')
|
|
test('llEscapeURL(llUnescapeURL(u"%4.%25"))', u'%40%25')
|
|
|
|
# test UTF-8 validity
|
|
test('llEscapeURL(llUnescapeURL(u"%C3%81%80%E3%81%C3%80ABC%D3"))', u'%C3%81%3F%3F%3F%C3%80ABC%3F')
|
|
test('llEscapeURL(llUnescapeURL(u"%C3%81%80%E3%81%C3%80ABC%00%D3"))', u'%C3%81%3F%3F%3F%C3%80ABC')
|
|
test('llEscapeURL(llUnescapeURL(u"%E0%80%80%80%80%80%80%E3%81%C3%80ABC%00%D3"))', u'%3F%3F%3F%3F%3F%3F%3F%3F%3F%C3%80ABC')
|
|
# test UTF-8 valid ranges
|
|
test('llEscapeURL(llUnescapeURL(u"%7Fx"))', u'%7Fx') # range up to U+007F
|
|
test('llEscapeURL(llUnescapeURL(u"%80%80x"))', u'%3F%3Fx') # invalid range begin
|
|
test('llEscapeURL(llUnescapeURL(u"%BF%BFx"))', u'%3F%3Fx') # invalid range end
|
|
test('llEscapeURL(llUnescapeURL(u"%C0%80x"))', u'%3F%3Fx') # aliased range begin (U+0000)
|
|
test('llEscapeURL(llUnescapeURL(u"%C1%BFx"))', u'%3F%3Fx') # aliased range end (U+007F)
|
|
test('llEscapeURL(llUnescapeURL(u"%C2%80x"))', u'%C2%80x') # U+0080 (2-byte range start)
|
|
test('llEscapeURL(llUnescapeURL(u"%DF%BFx"))', u'%DF%BFx') # U+07FF (2-byte range end)
|
|
test('llEscapeURL(llUnescapeURL(u"%E0%80%80x"))', u'%3F%3F%3Fx') # aliased range begin (U+0000)
|
|
test('llEscapeURL(llUnescapeURL(u"%E0%9F%BFx"))', u'%3F%3F%3Fx') # aliased range end (U+07FF)
|
|
test('llEscapeURL(llUnescapeURL(u"%E0%A0%80x"))', u'%E0%A0%80x') # U+0800 (3-byte range start)
|
|
test('llEscapeURL(llUnescapeURL(u"%ED%9F%BFx"))', u'%ED%9F%BFx') # U+D7FF (right before first UTF-16 high surrogate)
|
|
# excluded because they are used for UTF-16 surrogates, not valid characters
|
|
test('llEscapeURL(llUnescapeURL(u"%ED%A0%80x"))', u'%3F%3F%3Fx') # D800 - first high surrogate
|
|
test('llEscapeURL(llUnescapeURL(u"%ED%AF%BFx"))', u'%3F%3F%3Fx') # DBFF - last high surrogate
|
|
test('llEscapeURL(llUnescapeURL(u"%ED%B0%80x"))', u'%3F%3F%3Fx') # DC00 - first low surrogate
|
|
test('llEscapeURL(llUnescapeURL(u"%ED%BF%BFx"))', u'%3F%3F%3Fx') # DFFF - last low surrogate
|
|
test('llEscapeURL(llUnescapeURL(u"%EE%80%80x"))', u'%EE%80%80x') # U+E000 (right after last UTF-16 low surrogate)
|
|
test('llEscapeURL(llUnescapeURL(u"%EF%BF%BFx"))', u'%EF%BF%BFx') # U+FFFF (3-byte range end)
|
|
test('llEscapeURL(llUnescapeURL(u"%F0%80%80%80x"))', u'%3F%3F%3F%3Fx') # aliased range begin (U+0000)
|
|
test('llEscapeURL(llUnescapeURL(u"%F0%8F%BF%BFx"))', u'%3F%3F%3F%3Fx') # aliased range end (U+FFFF)
|
|
test('llEscapeURL(llUnescapeURL(u"%F0%90%80%80x"))', u'%F0%90%80%80x') # U+10000 (4-byte range start)
|
|
test('llEscapeURL(llUnescapeURL(u"%F4%8F%BF%BFx"))', u'%F4%8F%BF%BFx') # U+10FFFF (valid 4-byte range end)
|
|
# excluded because of truncation to U+10FFFF
|
|
test('llEscapeURL(llUnescapeURL(u"%F4%90%80%80x"))', u'%3F%3F%3F%3Fx') # U+110000 (invalid 4-byte range start)
|
|
test('llEscapeURL(llUnescapeURL(u"%F7%BF%BF%BFx"))', u'%3F%3F%3F%3Fx') # U+1FFFFF (invalid 4-byte range end)
|
|
test('llEscapeURL(llUnescapeURL(u"%F8%80%80%80%80x"))', u'%3F%3F%3F%3F%3Fx') # aliased range begin (U+0000)
|
|
test('llEscapeURL(llUnescapeURL(u"%F8%87%BF%BF%BFx"))', u'%3F%3F%3F%3F%3Fx') # aliased range end (U+1FFFFF)
|
|
test('llEscapeURL(llUnescapeURL(u"%F8%88%80%80%80x"))', u'%3F%3F%3F%3F%3Fx') # U+200000 (5-byte range start)
|
|
test('llEscapeURL(llUnescapeURL(u"%FB%BF%BF%BF%BFx"))', u'%3F%3F%3F%3F%3Fx') # U+3FFFFFF (5-byte range end)
|
|
test('llEscapeURL(llUnescapeURL(u"%FC%80%80%80%80%80x"))', u'%3F%3F%3F%3F%3F%3Fx') # aliased range begin (U+0000)
|
|
test('llEscapeURL(llUnescapeURL(u"%FC%83%BF%BF%BF%BFx"))', u'%3F%3F%3F%3F%3F%3Fx') # aliased range end (U+3FFFFFF)
|
|
test('llEscapeURL(llUnescapeURL(u"%FC%84%80%80%80%80x"))', u'%3F%3F%3F%3F%3F%3Fx') # U+4000000 (6-byte range start)
|
|
test('llEscapeURL(llUnescapeURL(u"%FD%BF%BF%BF%BF%BFx"))', u'%3F%3F%3F%3F%3F%3Fx') # U+7FFFFFFF (6-byte range end)
|
|
# not actually valid either way (these are actually used to distinguish the input as UTF-16 BOM)
|
|
test('llEscapeURL(llUnescapeURL(u"%FE%B0%80%80%80%80%80%80x"))', u'%3F%3F%3F%3F%3F%3F%3F%3Fx')
|
|
test('llEscapeURL(llUnescapeURL(u"%FF%BF%BF%BF%BF%BF%BF%BFx"))', u'%3F%3F%3F%3F%3F%3F%3F%3Fx')
|
|
# short or invalid sequences
|
|
test('llEscapeURL(llUnescapeURL(u"%80"))', u'%3F')
|
|
test('llEscapeURL(llUnescapeURL(u"%BF"))', u'%3F')
|
|
test('llEscapeURL(llUnescapeURL(u"%C2"))', u'%3F')
|
|
test('llEscapeURL(llUnescapeURL(u"%E1"))', u'%3F')
|
|
test('llEscapeURL(llUnescapeURL(u"%E1%80"))', u'%3F%3F')
|
|
test('llEscapeURL(llUnescapeURL(u"%F1"))', u'%3F')
|
|
test('llEscapeURL(llUnescapeURL(u"%F1%80"))', u'%3F%3F')
|
|
test('llEscapeURL(llUnescapeURL(u"%F1%80%80"))', u'%3F%3F%3F')
|
|
|
|
# Test that U+FFFD is preserved even with invalid characters
|
|
test('llEscapeURL(llUnescapeURL(u"%EF%BF%BD%90"))', u'%EF%BF%BD%3F')
|
|
|
|
test('llParseString2List(u"[ 1 ]2|3|4|5", [u"|"], [u"[ ", u" ]"])',
|
|
[u"[ ", u"1", u" ]", u"2", u"3", u"4", u"5"])
|
|
test('llParseString2List(u"[ 1 ]2|3|4|5", [u"|"], [u"|", u"|"])',
|
|
[u"[ 1 ]2", u"3", u"4", u"5"])
|
|
test('llList2CSV(llParseString2List(u"1abc2ab3abc4",[u"ab",u"abc"],[]))',
|
|
u'1, c2, 3, c4')
|
|
test('llList2CSV(llParseString2List(u"1abc2ab3abc4",[u"abc",u"ab"],[]))',
|
|
u'1, 2, 3, 4')
|
|
test('llList2CSV(llParseStringKeepNulls(u"1abc2ab3abc4",[u"ab"],[u"abc"]))',
|
|
u'1, c2, 3, c4')
|
|
test('llList2CSV(llParseStringKeepNulls(u"1abc2ab3abc4",[u"ab"],[u"a"]))',
|
|
u'1, c2, 3, c4')
|
|
test('llList2CSV(llParseStringKeepNulls(u"1abc2ab3abc4",[u"ab"],[u"ab"]))',
|
|
u'1, c2, 3, c4')
|
|
test('llParseStringKeepNulls(u"",[],[])', [u""])
|
|
shouldexcept('llParseStringKeepNulls(u"",[],[""])', ELSLInvalidType)
|
|
test('llParseStringKeepNulls(u"",[],[u""])', [u""])
|
|
test('llParseStringKeepNulls(u"",[u""],[])', [u""])
|
|
test('llParseStringKeepNulls(u"",[u""],[u""])', [u""])
|
|
test('llParseString2List(u"",[],[])', [])
|
|
test('llParseString2List(u"",[],[u""])', [])
|
|
test('llParseString2List(u"",[u""],[])', [])
|
|
test('llParseString2List(u"",[u""],[u""])', [])
|
|
test('llParseStringKeepNulls(u"a",[u""],[])', [u"a"])
|
|
|
|
|
|
test(r'llToUpper(u"\u03c4\u03ac\u03c7\u03b9\u03c3\u03c4\u03b7 \u03b1\u03bb'
|
|
r'\u03ce\u03c0\u03b7\u03be \u03b2\u03b1\u03c6\u03ae\u03c2 \u03c8\u03b7'
|
|
r'\u03bc\u03ad\u03bd\u03b7 \u03b3\u03b7, \u03b4\u03c1\u03b1\u03c3'
|
|
r'\u03ba\u03b5\u03bb\u03af\u03b6\u03b5\u03b9 \u03c5\u03c0\u03ad\u03c1 '
|
|
r'\u03bd\u03c9\u03b8\u03c1\u03bf\u03cd \u03ba\u03c5\u03bd\u03cc\u03c2")',
|
|
u'\u03a4\u0386\u03a7\u0399\u03a3\u03a4\u0397 \u0391\u039b\u038f\u03a0'
|
|
u'\u0397\u039e \u0392\u0391\u03a6\u0389\u03a3 \u03a8\u0397\u039c\u0388'
|
|
u'\u039d\u0397 \u0393\u0397, \u0394\u03a1\u0391\u03a3\u039a\u0395'
|
|
u'\u039b\u038a\u0396\u0395\u0399 \u03a5\u03a0\u0388\u03a1 \u039d\u03a9'
|
|
u'\u0398\u03a1\u039f\u038e \u039a\u03a5\u039d\u038c\u03a3')
|
|
|
|
test(r'llToLower(u"\u03a4\u0386\u03a7\u0399\u03a3\u03a4\u0397 \u0391\u039b'
|
|
r'\u038f\u03a0\u0397\u039e \u0392\u0391\u03a6\u0389\u03a3 \u03a8\u0397'
|
|
r'\u039c\u0388\u039d\u0397 \u0393\u0397, \u0394\u03a1\u0391\u03a3'
|
|
r'\u039a\u0395\u039b\u038a\u0396\u0395\u0399 \u03a5\u03a0\u0388\u03a1 '
|
|
r'\u039d\u03a9\u0398\u03a1\u039f\u038e \u039a\u03a5\u039d\u038c\u03a3")',
|
|
u'\u03c4\u03ac\u03c7\u03b9\u03c3\u03c4\u03b7 \u03b1\u03bb\u03ce\u03c0'
|
|
u'\u03b7\u03be \u03b2\u03b1\u03c6\u03ae\u03c3 \u03c8\u03b7\u03bc\u03ad'
|
|
u'\u03bd\u03b7 \u03b3\u03b7, \u03b4\u03c1\u03b1\u03c3\u03ba\u03b5'
|
|
u'\u03bb\u03af\u03b6\u03b5\u03b9 \u03c5\u03c0\u03ad\u03c1 \u03bd\u03c9'
|
|
u'\u03b8\u03c1\u03bf\u03cd \u03ba\u03c5\u03bd\u03cc\u03c3')
|
|
|
|
test('llListStatistics(1, [])', 0.)
|
|
test('llListStatistics(0, [1.,5.,2,3,9,-1])', 10.)
|
|
test('llListStatistics(1, [1.,5.,-2,3,9,-1])', -2.)
|
|
test('llListStatistics(2, [1.,5.,2,3,9,-1])', 9.)
|
|
test('llListStatistics(3, [1.,5.,2,3,9,-1])', F('0x1.955556p+1'))
|
|
test('llListStatistics(4, [1.,5.,2,3,9,-1])', 2.5)
|
|
test('llListStatistics(4, [1.,5.,NaN,2,3,9,-1])', -1.)
|
|
test('llListStatistics(5, [1.,5.,2,3,9,-1])', F32(3.488075))
|
|
test('llListStatistics(6, [1.,5.,2,3,9,-1])', 19.)
|
|
test('llListStatistics(7, [1.,5.,2,3,9,-1])', 121.)
|
|
test('llListStatistics(8, [1.,5.,2,3,9,-1])', 6.)
|
|
test('llListStatistics(9, [1.,5.,2.,3.,NaN,9.])', NaN)
|
|
test('llListStatistics(9, [1.,5.,2.,3.,NaN,-9.])', 0.)
|
|
test('llListStatistics(9, [1.,5.,2.,3.,1.,9.])', F('0x1.456A2Ep+1'))
|
|
test('llListStatistics(10, [1.,5.,2,3,9,-1])', 0.)
|
|
test('llList2ListStrided([1,2,3,4,5],0,-1,2)', [1,3,5])
|
|
test('llList2ListStrided([1,2,3,4,5],1,-1,2)', [3,5])
|
|
test('llList2ListStrided([1,2,3,4,5],0,-2,2)', [1,3])
|
|
test('llList2ListStrided([1,2,3,4,5,6,7,8,9,10,11,12],0,-4,3)', [1, 4, 7])
|
|
test('llList2ListStrided([1,2,3,4,5,6,7,8,9,10,11,12],0,-3,3)', [1, 4, 7, 10])
|
|
test('llList2ListStrided([1,2,3,4,5,6,7,8,9,10,11,12],0,-1,3)', [1, 4, 7, 10])
|
|
test('llList2ListStrided([1,2,3,4,5,6,7,8,9,10,11,12],-3,3,3)', [1, 4, 7, 10])
|
|
test('llList2ListStrided([1,2,3,4,5,6,7,8,9,10,11,12],-2,-3,3)', [1, 4, 7, 10])
|
|
test('llList2ListStrided([1,2,3,4,5,6,7,8,9,10,11,12],-2,-2,3)', [])
|
|
test('llList2ListStrided([1,2,3,4,5,6,7,8,9,10,11,12],-2,-1,3)', [])
|
|
test('llList2ListStrided([1,2,3,4,5,6,7,8,9,10,11,12],4,3,3)', [1,4,7,10])
|
|
test('llList2ListStrided([1,2,3,4,5,6,7,8,9,10,11,12],4,4,3)', [])
|
|
test('llList2ListStrided([1,2,3,4,5,6,7,8,9,10,11,12],4,5,3)', [])
|
|
test('llList2ListStrided([1,2,3,4,5,6,7,8,9,10,11,12],5,5,3)', [])
|
|
test('llList2ListStrided([1,2,3,4,5,6,7,8,9,10,11,12],5,6,3)', [7])
|
|
test('llList2ListStrided([1,2,3,4,5,6,7,8,9,10,11,12],6,5,3)', [1,4,7,10])
|
|
test('llList2ListStrided([1,2,3,4,5,6,7,8,9,10,11,12],6,6,3)', [7])
|
|
test('llList2ListStrided([1,2,3,4,5,6,7,8,9,10,11,12],6,2,-3)', [1,4,7,10])
|
|
test('llList2ListStrided([1,2,3,4,5,6,7,8,9,10,11,12],6,2,-2)', [1,3,5,7,9,11])
|
|
test('llList2ListStrided([1,2,3,4,5,6,7,8,9,10,11,12],6,2,-1)', [1,2,3,4,5,6,7,8,9,10,11,12])
|
|
test('llList2ListStrided([1,2,3,4,5,6,7,8,9,10,11,12],6,2,0)', [1,2,3,4,5,6,7,8,9,10,11,12])
|
|
test('llList2ListStrided([1,2,3,4,5,6,7,8,9,10,11,12],6,2,1)', [1,2,3,4,5,6,7,8,9,10,11,12])
|
|
test('llList2ListStrided([1,2,3,4,5,6,7,8,9,10,11,12],6,20,3)', [7,10])
|
|
|
|
test('llListReplaceList([0,1,2,3,4,5],[6,7],2,3)', [0,1,6,7,4,5])
|
|
test('llListReplaceList([0,1,2,3,4,5],[],2,3)', [0,1,4,5])
|
|
test('llListReplaceList([0,1,2,3,4,5],[6,7],2,3)', [0,1,6,7,4,5])
|
|
test('llListReplaceList([0,1,2,3,4,5],[6,7],2,-1)', [0,1,6,7])
|
|
test('llListReplaceList([0,1,2,3,4,5],[],4,1)', [2,3])
|
|
test('llListReplaceList([0,1,2,3,4,5],[6,7,8],4,1)', [2,3,6,7,8])
|
|
test('llListReplaceList([0,1,2,3,4,5],[6,7,8],6,6)', [0,1,2,3,4,5,6,7,8])
|
|
test('llListReplaceList([0,1,2,3,4,5],[6,7,8],7,6)', [6,7,8])
|
|
test('llListReplaceList([0,1,2,3,4,5],[6,7,8],7,8)', [0,1,2,3,4,5,6,7,8])
|
|
|
|
test('llListInsertList([], [1], 0)', [1])
|
|
test('llListInsertList([], [1], 3)', [1])
|
|
test('llListInsertList([], [1], -1)', [1])
|
|
test('llListInsertList([1,2,3],[4,5],-1)', [1,2,4,5,3])
|
|
test('llListInsertList([1,2,3],[4,5],-5)', [4,5,1,2,3])
|
|
test('llListInsertList([1,2,3,4,5],[9],-3)', [1,2,9,3,4,5])
|
|
|
|
test('llMD5String(u"", 0)', u'1a9d5db22c73a993ff0b42f64b396873')
|
|
|
|
test('llGetEnv(u"")', u'')
|
|
test('llGetEnv(u"yadda")', u'')
|
|
shouldexcept('llGetEnv(u"agent_limit")', ELSLCantCompute)
|
|
|
|
|
|
|
|
|
|
# JSON tests - Here be dragons.
|
|
print "9 errors expected past here " + "-" * 50
|
|
test('''llEscapeURL(llList2Json(JSON_OBJECT, [llUnescapeURL(
|
|
u"%01%02%03%04%05%06%07%08%09%0A%0B%0C%0D%0E%0F"
|
|
u"%10%11%12%13%14%15%16%17%18%19%1A%1B%1C%1D%1E%1F"
|
|
u"%20%21%22%23%24%25%26%27%28%29%2A%2B%2C%2D%2E%2F"
|
|
u"%30%39%3A%3B%3C%3D%3E%3F%40%41%5A%5B%5C%5D%5E%5F"
|
|
u"%60%61%7A%7B%7C%7D%7E%7F%C2%80%C2%81"),Key(u"")]))''',
|
|
|
|
u'%7B%22%01%02%03%04%05%06%07%5Cb%5Ct%5Cn%0B%5Cf%5Cr%0E%0F'
|
|
u'%10%11%12%13%14%15%16%17%18%19%1A%1B%1C%1D%1E%1F'
|
|
u'%20%21%5C%22%23%24%25%26%27%28%29%2A%2B%2C%2D%2E%5C%2F'
|
|
u'09%3A%3B%3C%3D%3E%3F%40AZ%5B%5C%5C%5D%5E%5F%60az%7B%7C%7D%7E%7F'
|
|
u'%C2%80%C2%81%22%3A%22%22%7D')
|
|
|
|
test(r'llEscapeURL(llList2Json(JSON_OBJECT, [u"blah",F32(Quaternion((1000000000000.0,-Infinity,NaN,-0.))), u"x", u"{\"}}"]))',
|
|
u'%7B%22blah%22%3A%22%3C999999995904%2E000000%2C%20%2Dinf%2C%20nan%2C%20'
|
|
u'%2D0%2E000000%3E%22%2C%22x%22%3A%7B%22%7D%7D%7D')
|
|
|
|
test(r'llList2Json(JSON_OBJECT, [u"true",u"true"])', u'{"true":true}')
|
|
test(r'llList2Json(JSON_OBJECT, [u"true",u"tr\nue"])', ur'{"true":"tr\nue"}')
|
|
|
|
# ... yeah
|
|
test(r'llList2Json(JSON_ARRAY, [u" "+JSON_INVALID+u" ",u" "+JSON_DELETE+u" ",'
|
|
r'u" "+JSON_STRING+u" ",JSON_NUMBER,JSON_OBJECT,JSON_ARRAY])',
|
|
u'[,"\ufdd8","\ufdd4","\ufdd3","\ufdd1","\ufdd2"]')
|
|
|
|
|
|
Bugs.add(6466)
|
|
test(r'llJson2List(u" -e11111.193147483650 ")', [0.0])
|
|
test(r'llJson2List(u" 12345678901234 ")', [2147483647])
|
|
test(r'llJson2List(u" 12345678901234e ")', [12345679020032.])
|
|
test(r'llJson2List(u" 1.0e+1 ")', [u'1.0e+1'])
|
|
test(r'llJson2List(u" 5e-1.2 ")', [0.5])
|
|
test(r'llJson2List(u" 0e0 ")', [0.])
|
|
test(r'llJson2List(u" . ")', [0.])
|
|
test(r'llJson2List(u" .5 ")', [0.5])
|
|
test(r'llJson2List(u" .5e ")', [0.5])
|
|
test(r'llJson2List(u" .e1 ")', [0.])
|
|
test(r'llJson2List(u" 0.e1 ")', [0.])
|
|
Bugs.discard(6466)
|
|
test(r'llJson2List(u" -e11111.193147483650 ")', [u'-e11111.193147483650'])
|
|
test(r'llJson2List(u" 12345678901234 ")', [2147483647])
|
|
test(r'llJson2List(u" 12345678901234e ")', [12345679020032.])
|
|
test(r'llJson2List(u" 1.0e+1 ")', [10.0])
|
|
test(r'llJson2List(u" 5e-1.2 ")', [0.5])
|
|
test(r'llJson2List(u" 0e0 ")', [u'0e0'])
|
|
test(r'llJson2List(u" . ")', [0.])
|
|
test(r'llJson2List(u" .5 ")', [0.5])
|
|
test(r'llJson2List(u" .5e ")', [0.5])
|
|
test(r'llJson2List(u" .e1 ")', [u'.e1'])
|
|
test(r'llJson2List(u" 0.e1 ")', [0.])
|
|
test(r'llJson2List(u" -12345678901234 ")', [-2147483648])
|
|
test(r'llJson2List(u" -123456 ")', [-123456])
|
|
test(r'llJson2List(u" true ")', [JSON_TRUE])
|
|
test(r'llJson2List(u" \"blah\\\" ")', [u'blah\\'])
|
|
test(r'llJson2List(u" True ")', [u'True'])
|
|
test(r'llJson2List(u" \" ")', [u'"'])
|
|
|
|
# Here's where the fun begins. Solve this puzzle.
|
|
test(r'llJson2List(u" \"ab,c\"3{,\"de\\1234\" ")', [u'ab,c"3{,"de1234'])
|
|
# INCOMPAT: Too crazy to make it work compatibly. All these tests fail.
|
|
#test(r'llJson2List(u" { \"ab,c\"3{,\"de\\1234\" } ")', [u'', u'"ab,c"3'])
|
|
#test(r'llJson2List(u" { x: \"ab,c\"3{,\"de\\1234\" } ")', [JSON_INVALID])
|
|
#test(r'llJson2List(u" { \"x\": \"ab,c\"3{,\"de\\1234\" } ")', [u'x', u'"ab,c"3'])
|
|
#test(r'llJson2List(u" [ \"x\": \"ab,c\"3{,\"de\\1234\" ] ")', [u'x', u'"ab,c"3'])
|
|
#test(r'llJson2List(u" [ ab,c\"3{,\"de\\1234} ] ")', [u'ab', ur'"3,de\1234'])
|
|
#test(r'llJson2List(u" [ ab, tes{t3\"de\\1234\" ] ")', [u'ab', u'tes'])
|
|
#test(r'llJson2List(u" [ ab, tes{t3\"de\\1234}\" ] ")', [u'ab', u'"'])
|
|
#test(r'llJson2List(u" [ ab, tes{t3\"de\\1234}\"x\" ] ")', [u'ab', u'x'])
|
|
#test(r'llJson2List(u" [ ab, tes{t3\"de\\1234}x ] ")', [u'ab', ur'tes{t3"de\1234}x'])
|
|
#test(r'llJson2List(u" [ ab, test\"3{,\"de\\1234} ] ")', [u'ab', ur'"3{,"de\1234}'])
|
|
test(r'llJson2List(u"[,,3]")', [u'', u'', 3])
|
|
test(r'llJson2List(u"[:,2,3]")', [JSON_INVALID])
|
|
test(r'llJson2List(u"[;,,3]")', [u';', u'', 3])
|
|
test(r'llJson2List(u"[],,3]")', [u']', u'', 3]) # nice, huh?
|
|
# INCOMPAT:
|
|
#test(r'llJson2List(u"[[,,3]")', [u'']) # Even crazier. Not going to try to make that work.
|
|
test(r'llJson2List(u"[,],3]")', [u'', u']', 3])
|
|
test(r'llJson2List(u"{1}")', [u'', 1])
|
|
test(r'llJson2List(u"{\"a\"}")', [u'', u'a'])
|
|
test(r'llJson2List(u"{1,2}")', [JSON_INVALID])
|
|
test(r'llJson2List(u"{\"\":1,\"a\":2}")', [JSON_INVALID]) # Empty names are only allowed at the end.
|
|
test(r'llJson2List(u"{\"a\":1,\"\":2}")', [u'a',1,u'',2])
|
|
test(r'llJson2List(u"{\"a\":1,2}")', [u'a',1,u'',2])
|
|
test(r'llJson2List(u"{\"a\":1,}")', [u'a',1,u'',u''])
|
|
test(r'llJson2List(u"{\"a\":},}}")', [u'a', u'}', u'', u'}'])
|
|
|
|
test(r'llJsonGetValue(u" { ab, tes{t3\"de\\1234}x ", [])', JSON_INVALID)
|
|
Bugs.add(6466)
|
|
test(r'llJsonGetValue(u"x", [])', JSON_INVALID)
|
|
test(r'llJsonGetValue(u"e", [])', u'e')
|
|
Bugs.discard(6466)
|
|
test(r'llJsonGetValue(u"x", [])', JSON_INVALID)
|
|
test(r'llJsonGetValue(u"e", [])', JSON_INVALID)
|
|
test(r'llJsonGetValue(u"", [])', JSON_INVALID)
|
|
test(r'llJsonGetValue(u"}", [])', JSON_INVALID)
|
|
test(r'llJsonGetValue(u"{", [])', JSON_INVALID)
|
|
test(r'llJsonGetValue(u" ", [])', JSON_INVALID)
|
|
test(r'llJsonGetValue(u" , ", [])', JSON_INVALID)
|
|
test(r'llJsonGetValue(u" null ", [])', JSON_NULL)
|
|
test(r'llJsonGetValue(u" false ", [])', JSON_FALSE)
|
|
test(r'llJsonGetValue(u" true ", [])', JSON_TRUE)
|
|
test(r'llJsonGetValue(u"true,", [])', JSON_INVALID)
|
|
test(r'llJsonGetValue(u"true,false", [])', JSON_INVALID)
|
|
test(r'llJsonGetValue(u"{x}", [])', u'{x}')
|
|
test(r'llJsonGetValue(u"[x]", [])', u'[x]')
|
|
test(r'llJsonGetValue(u" \"blah\\\\\" ", [])', u'blah\\')
|
|
test(r'llJsonGetValue(u" \"blah\\\" ", [])', u'blah\\')
|
|
test(r'llJsonGetValue(u" [[[]]]]]]][] ", [])', u'[[[]]]]]]][]')
|
|
|
|
test(r'llJsonGetValue(u"{\"a\":[1],\"a\":[2],\"a\":[3]}", [u"a",0])', u'3')
|
|
test(r'llJsonGetValue(u"{\"a\":[2,3,[4]],\"a\":1}", [u"a", 2, 0])', JSON_INVALID)
|
|
|
|
test(r'llJsonGetValue(u"{\"a\":1,}",[u"a"])', JSON_INVALID)
|
|
|
|
|
|
test(r'llJsonGetValue(u"[3,4,5,[6,7,8],:9,10]", [1])', JSON_INVALID) # *ing crap! ALL entries are tested before the result is returned...
|
|
test(r'llJsonGetValue(u"[3,4,5,[6,7,:8]]", [1])', u'4') # ... But only at the current nesting level. Crazy.
|
|
test(r'llJsonGetValue(u"[3,4,5,{:6,7,8}]", [1])', u'4')
|
|
test(r'llJsonGetValue(u"[[[[1,2,[3],4],5],6],7]", [0,0,0,2])', u'[3]')
|
|
test(r'llJsonGetValue(u"[[[[1,2,[3],4],5],6],7]", [0,0,0,2,0])', u'3')
|
|
# This suggests recursivity is used, once per nesting level, and that deeper levels remain unchecked:
|
|
test(r'llJsonGetValue(u"[[[[1,2,[:3],4],5],6],7]", [0,0,0,2,0])', JSON_INVALID)
|
|
test(r'llJsonGetValue(u"[[[[1,2,[:3],4],5],6],7]", [0,0,0,2])', u'[:3]')
|
|
test(r'llJsonGetValue(u"[[[[1,2,[3],:4],5],6],7]", [0,0,0,2])', JSON_INVALID)
|
|
test(r'llJsonGetValue(u"[[[[1,2,[3],4],:5],6],7]", [0,0,0,2])', JSON_INVALID)
|
|
test(r'llJsonGetValue(u"[[[[1,2,[3],4],5],:6],7]", [0,0,0,2])', JSON_INVALID)
|
|
test(r'llJsonGetValue(u"[[[[1,2,[3],4],5],6],:7]", [0,0,0,2])', JSON_INVALID)
|
|
# same with value type
|
|
test(r'llJsonValueType(u"[[[[1,2,[3],4],5],6],7]", [0,0,0,2,0])', JSON_NUMBER)
|
|
test(r'llJsonValueType(u"[[[[1,2,[:3],4],5],6],7]", [0,0,0,2,0])', JSON_INVALID)
|
|
test(r'llJsonValueType(u"[[[[1,2,[:3],4],5],6],7]", [0,0,0,2])', JSON_ARRAY)
|
|
test(r'llJsonValueType(u"[[[[1,2,[3],:4],5],6],7]", [0,0,0,2])', JSON_INVALID)
|
|
test(r'llJsonValueType(u"[[[[1,2,[3],4],:5],6],7]", [0,0,0,2])', JSON_INVALID)
|
|
test(r'llJsonValueType(u"[[[[1,2,[3],4],5],:6],7]", [0,0,0,2])', JSON_INVALID)
|
|
test(r'llJsonValueType(u"[[[[1,2,[3],4],5],6],:7]", [0,0,0,2])', JSON_INVALID)
|
|
|
|
if 6495 in Bugs:
|
|
# OH-MY-FLYINGSPAGHETTIMONSTER!!!!!! A nested string can't contain "]"!!!!
|
|
# INCOMPAT: Too crazy. We're not emulating that.
|
|
#test(r'llJsonGetValue(u"[[[[1,2,[\"],4]\",5],6],7]]]", [0,0,0,2])', JSON_INVALID)
|
|
# Simpler test case:
|
|
# INCOMPAT
|
|
#test(r'llJsonGetValue(u"[[\"[\"]]", [0])', JSON_INVALID)
|
|
#test(r'llJsonGetValue(u"[[\"]\"]]", [0])', JSON_INVALID)
|
|
#test(r'llJsonGetValue(u"[{\"{\":0}]", [0])', JSON_INVALID)
|
|
#test(r'llJsonGetValue(u"[{\"}\":0}]", [0])', JSON_INVALID)
|
|
test(r'llJsonGetValue(u"[[\"{\"]]", [0])', u'["{"]')
|
|
test(r'llJsonGetValue(u"[[\"}\"]]", [0])', u'["}"]')
|
|
test(r'llJsonGetValue(u"[{\"[\":0}]", [0])', u'{"[":0}')
|
|
test(r'llJsonGetValue(u"[{\"]\":0}]", [0])', u'{"]":0}')
|
|
# And proper balance removes the problem.
|
|
test(r'llJsonGetValue(u"[[\"[]\"]]", [0])', u'["[]"]')
|
|
# Even if not too proper.
|
|
test(r'llJsonGetValue(u"[[\"][\"]]", [0])', u'["]["]')
|
|
test(r'llJsonGetValue(u"[[\"][\"]]", [0,0])', u'][')
|
|
#INCOMPAT
|
|
#test(r'llJsonGetValue(u"[[][]]", [0])', u'[][]')
|
|
#test(r'llJsonValueType(u"[[][]]", [0])', JSON_ARRAY)
|
|
test(r'llJsonGetValue(u"[[][]]", [0,0])', JSON_INVALID)
|
|
# Depth zero is special, no error there:
|
|
test(r'llJsonGetValue(u"[\"[\"]", [])', u'["["]')
|
|
test(r'llJsonGetValue(u"[\"[\"]", [0])', u'[')
|
|
|
|
# INCOMPAT
|
|
#test(r'llJsonGetValue(u"[\"[\\\"\\\\\"]", [0])', JSON_INVALID) # File this under WTF.
|
|
#test(r'llJsonGetValue(u"[\"[\\\"\\\\\"", [0])', u'"[\\') # Ditto.
|
|
#test(r'llJsonGetValue(u"[\"\\\\\"]", [0])', JSON_INVALID) # This seems to be the essence.
|
|
#test(r'llJsonGetValue(u"[\"\\\\\"", [0])', u'\\')
|
|
else:
|
|
test(r'llJsonGetValue(u"[[[[1,2,[\"],4]\",5],6],7]]]", [0,0,0,2])', u'["],4]",5]')
|
|
# INCOMPAT
|
|
#test(r'llJsonGetValue(u"[[\"[\"]]", [0])', u'["["]')
|
|
#test(r'llJsonGetValue(u"[[\"]\"]]", [0])', u'["]"]')
|
|
#test(r'llJsonGetValue(u"[{\"{\":0}]", [0])', u'{"{":0}')
|
|
#test(r'llJsonGetValue(u"[{\"}\":0}]", [0])', u'{"}":0}')
|
|
test(r'llJsonGetValue(u"[[\"{\"]]", [0])', u'["{"]')
|
|
test(r'llJsonGetValue(u"[[\"}\"]]", [0])', u'["}"]')
|
|
test(r'llJsonGetValue(u"[{\"[\":0}]", [0])', u'{"[":0}')
|
|
test(r'llJsonGetValue(u"[{\"]\":0}]", [0])', u'{"]":0}')
|
|
test(r'llJsonGetValue(u"[[\"[]\"]]", [0])', u'["[]"]')
|
|
test(r'llJsonGetValue(u"[[\"][\"]]", [0])', u'["]["]')
|
|
test(r'llJsonGetValue(u"[[\"][\"]]", [0,0])', u'][')
|
|
# INCOMPAT
|
|
#test(r'llJsonGetValue(u"[[][]]", [0])', u'[][]')
|
|
#test(r'llJsonValueType(u"[[][]]", [0])', JSON_ARRAY)
|
|
test(r'llJsonGetValue(u"[[][]]", [0,0])', JSON_INVALID)
|
|
test(r'llJsonGetValue(u"[\"[\"]", [])', u'["["]')
|
|
test(r'llJsonGetValue(u"[\"[\"]", [0])', u'[')
|
|
|
|
# INCOMPAT
|
|
#test(r'llJsonGetValue(u"[\"[\\\"\\\\\"]", [0])', u'["\\')
|
|
#test(r'llJsonGetValue(u"[\"[\\\"\\\\\"", [0])', JSON_INVALID)
|
|
#test(r'llJsonGetValue(u"[\"\\\\\"]", [0])', u'\\')
|
|
#test(r'llJsonGetValue(u"[\"\\\\\"", [0])', JSON_INVALID)
|
|
|
|
# This proves that it converts to integer when traversing an array.
|
|
# MAINT-2671 introduced a check for the first character, which is reflected
|
|
# in the tests. Apparently the test is just Firstchar in [0-9].
|
|
test(r'llJsonGetValue(u"[[1,2],{\"a\":0}]",[u"0.9999999999"])', u"[1,2]")
|
|
# This test mimicks the test for MAINT-2671 in the wiki tests.
|
|
test(r'llJsonGetValue(u"[[1,2],{\"a\":0}]",[u"f"])', JSON_INVALID)
|
|
# FIXME: llJsonSetValue pending
|
|
'''test(r'llJsonSetValue(u"", [u"0",1], u"1")', JSON_INVALID)
|
|
test(r'llJsonSetValue(u"", [u"0",0], u"1")', u'{"0":[1]}')
|
|
test(r'llJsonSetValue(u"", [u"0",0.0], u"1")', u'{"0":}')
|
|
test(r'llJsonSetValue(u"", [u"0",0.0], u"1")', u'{"0":}')
|
|
test(r'llJsonSetValue(u"", [u"0",u"0"], u"1")', u'{"0":{u"0":1}}')
|
|
test(r'llJsonSetValue(u"", [u"0",Key(u"0")], u"1")', u'{"0":{u"0":1}}')
|
|
test(r'llJsonSetValue(u"", [u"0",ZERO_VECTOR], u"1")', u'{"0":}')
|
|
test(r'llJsonSetValue(u"", [ZERO_VECTOR], u"1")', u'')
|
|
test(r'llJsonSetValue(u" [ 1 , 2 , [ 3 , 4 ] ] ", [0], u"1")', u'[1,2,[ 3 , 4 ]]')
|
|
|
|
test(r'llJsonSetValue(u" { \"a\" : [ 1 ] , \"a\" : 2 } ",[u"a"], u"3")', u'{"a":3}')
|
|
test(r'llJsonSetValue(u" { \"a\" : [ 1 ] , \"a\" : 2 } ",[u"a",0], u"3")', u'{"a":[3]}')
|
|
test(r'llJsonSetValue(u" { \"a\" : [ 1 ] , \"a\" : 2 } ",[u"a",0], u"3")', u'{"a":3}')
|
|
test(r'llJsonSetValue(u" { \"a\" : [ 1 , 2 ] , \"a\" : 3 } ",[u"a",0], u"4")', u'{"a":[4]}')
|
|
# This proves the path must be found in the *last* match of an object:
|
|
test(r'llJsonSetValue(u" { \"a\" : [ 1 , 2 ] , \"a\" : 3 } ",[u"a",1], u"4")', JSON_INVALID)
|
|
test(r'llJsonSetValue(u" { \"a\" : 3 , \"a\" : [ 1 , 2 ] } ",[u"a",0], u"4")', u'{"a":[4,2]}')
|
|
test(r'llJsonSetValue(u" { \"a\" : 3 , \"a\" : [ 1 , 2 ] } ",[u"a",1], u"4")', u'{"a":[1,4]}')
|
|
test(r'llJsonSetValue(u" { \"a\" : 3 , \"b\" : 6, \"a\" : [ 1 , 2 ] } ",[u"a",1], u"4")', u'{"a":[1,4],"b":6}')
|
|
test(r'llJsonSetValue(u" { \"b\" : 3 , \"a\" : 6, \"b\" : [ 1 , 2 ] } ",[u"b",1], u"4")', u'{"a":6,"b":[1,4]}')
|
|
# This proves llJsonSetValue sorts the items it recurses into and keeps
|
|
# just one copy of them.
|
|
# No "a13" in original but some dupes:
|
|
test(r'llJsonSetValue(u"{\"b\":{\"a9\":15,\"a0\":16,\"a7\":27,\"a20\":28,'
|
|
r'\"a7\":21,\"a21\":22,\"a8\":7,\"a24\":8,\"a9\":13,\"a0\":14,\"a26\":29,'
|
|
r'\"a20\":30,\"a0\":11,\"a26\":12,\"a14\":19,\"a10\":20,\"a11\":1,'
|
|
r'\"a12\":2,\"a9\":23,\"a4\":24,\"a20\":5,\"a17\":6,\"a21\":17,\"a3\":18,'
|
|
r'\"a4\":9,\"a1\":10,\"a10\":3,\"a26\":4,\"a21\":25,\"a17\":26},'
|
|
r'\"a\":{\"a9\":15,\"a0\":16,\"a7\":27,\"a20\":28,\"a7\":21,\"a21\":22,'
|
|
r'\"a8\":7,\"a24\":8,\"a9\":13,\"a0\":14,\"a26\":29,\"a20\":30,\"a0\":11,'
|
|
r'\"a26\":12,\"a14\":19,\"a10\":20,\"a11\":1,\"a12\":2,\"a9\":23,\"a4\":24'
|
|
r',\"a20\":5,\"a17\":6,\"a21\":17,\"a3\":18,\"a4\":9,\"a1\":10,\"a10\":3'
|
|
r',\"a26\":4,\"a21\":25,\"a17\":26}}", [u"b",u"a13"], u"\"*********\"")',
|
|
u'{"a":{"a9":15,"a0":16,"a7":27,"a20":28,"a7":21,"a21":22,"a8":7,'
|
|
u'"a24":8,"a9":13,"a0":14,"a26":29,"a20":30,"a0":11,"a26":12,"a14":19,'
|
|
u'"a10":20,"a11":1,"a12":2,"a9":23,"a4":24,"a20":5,"a17":6,"a21":17,'
|
|
u'"a3":18,"a4":9,"a1":10,"a10":3,"a26":4,"a21":25,"a17":26},'
|
|
u'"b":{"a0":11,"a1":10,"a10":3,"a11":1,"a12":2,"a13":"*********","a14":19,'
|
|
u'"a17":26,"a20":5,"a21":25,"a24":8,"a26":4,"a3":18,"a4":9,"a7":21,"a8":7,'
|
|
u'"a9":23}}')
|
|
# Two "a13" in original (and some other dups such as "a9" which appears three times):
|
|
test(r'llJsonSetValue(u"{\"b\":{\"a12\":19,\"a23\":20,\"a9\":7,\"a7\":8,'
|
|
r'\"a28\":21,\"a15\":22,\"a9\":17,\"a22\":18,\"a1\":13,\"a26\":14,'
|
|
r'\"a7\":23,\"a13\":24,' # <-- 1st instance of "a13"
|
|
r'\"a9\":3,\"a26\":4,\"a14\":9,\"a24\":10,\"a12\":29,'
|
|
r'\"a16\":30,\"a25\":5,\"a23\":6,\"a2\":11,\"a13\":12,' # <-- 2nd instance
|
|
r'\"a11\":1,\"a12\":2,'
|
|
r'\"a15\":25,\"a25\":26,\"a25\":27,\"a18\":28,\"a22\":15,\"a27\":16},'
|
|
r'\"a\":{\"a12\":19,\"a23\":20,\"a9\":7,\"a7\":8,\"a28\":21,\"a15\":22,'
|
|
r'\"a9\":17,\"a22\":18,\"a1\":13,\"a26\":14,\"a7\":23,\"a13\":24,\"a9\":3,'
|
|
r'\"a26\":4,\"a14\":9,\"a24\":10,\"a12\":29,\"a16\":30,\"a25\":5,'
|
|
r'\"a23\":6,\"a2\":11,\"a13\":12,\"a11\":1,\"a12\":2,\"a15\":25,'
|
|
r'\"a25\":26,\"a25\":27,\"a18\":28,\"a22\":15,\"a27\":16}}",'
|
|
r' [u"b",u"a13"],u"\"*********\"")',
|
|
# "a" is respected but put *before* "b".
|
|
u'{"a":{"a12":19,"a23":20,"a9":7,"a7":8,"a28":21,"a15":22,"a9":17,'
|
|
u'"a22":18,"a1":13,"a26":14,"a7":23,"a13":24,"a9":3,"a26":4,"a14":9,'
|
|
u'"a24":10,"a12":29,"a16":30,"a25":5,"a23":6,"a2":11,"a13":12,"a11":1,'
|
|
u'"a12":2,"a15":25,"a25":26,"a25":27,"a18":28,"a22":15,"a27":16},'
|
|
# "b" has only one of each including "a13", and has its elements sorted.
|
|
# Only the last element of each repetition is kept.
|
|
u'"b":{"a1":13,"a11":1,"a12":2,"a13":"*********","a14":9,"a15":25,'
|
|
u'"a16":30,"a18":28,"a2":11,"a22":15,"a23":6,"a24":10,"a25":27,"a26":4,'
|
|
u'"a27":16,"a28":21,"a7":23,"a9":3}}')
|
|
|
|
# Incoming facepalm series.
|
|
test(r'llJsonSetValue(u"{\"a\":3,\"b\":4}", [], u" "+JSON_DELETE+u" ")', JSON_DELETE)
|
|
test(r'llJsonSetValue(u"{\"a\":3,\"b\":4}", [], u" "+JSON_INVALID+u" ")', u'')
|
|
test(r'llJsonSetValue(u"{\"a\":3,\"b\":4}", [], u" "+JSON_STRING+u" ")', u'"' + JSON_STRING + u'"')
|
|
test(r'llJsonSetValue(u"{\"a\":3,\"b\":4}", [], JSON_NUMBER)', u'"' + JSON_NUMBER + u'"')
|
|
test(r'llJsonSetValue(u"{\"a\":3,\"b\":4}", [], JSON_OBJECT)', u'"' + JSON_OBJECT + u'"')
|
|
test(r'llJsonSetValue(u"{\"a\":3,\"b\":4}", [], JSON_ARRAY)', u'"' + JSON_ARRAY + u'"')
|
|
test(r'llJsonSetValue(u"[1,2,3]", [0,0,0], JSON_INVALID)', u'[[[]],2,3]')
|
|
test(r'llJsonSetValue(u"[1,2,3]", [0,0,0], JSON_DELETE)', JSON_INVALID)
|
|
|
|
# These are sane-ish or at least they make sense.
|
|
test(r'llJsonSetValue(u"[1,2,3]", [0,0,0], u"")', u'[[[""]],2,3]')
|
|
test(r'llJsonSetValue(u"{\"a\":3,\"b\":4}", [], u" "+JSON_TRUE+u" ")', u'true')
|
|
test(r'llJsonSetValue(u"{\"a\":3,\"b\":4}", [], JSON_FALSE)', u'false')
|
|
test(r'llJsonSetValue(u"{\"a\":3,\"b\":4}", [], JSON_NULL)', u'null')
|
|
|
|
# Elements are completely replaced if the type doesn't match.
|
|
# E.g. an object turns into a zero-length array if necessary.
|
|
# And there's no numeric evaluation of strings.
|
|
test(r'llJsonSetValue(u"{\"a\":3}", [u"a"], u"")', u'{"a":""}')
|
|
test(r'llJsonSetValue(u"{\"a\":3}", [u"0"], u"")', u'{"0":"","a":3}')
|
|
test(r'llJsonSetValue(u"[\"a\",3]", [u"0"], u"")', u'{"0":""}')
|
|
test(r'llJsonSetValue(u"[\"a\",3]", [1, u"0"], u"")', u'["a",{"0":""}]')
|
|
test(r'llJsonSetValue(u"{\"a\":3}", [1, u"0"], u"")', JSON_INVALID)
|
|
test(r'llJsonSetValue(u"{\"a\":3}", [0, u"0"], u"")', u'[{"0":""}]')
|
|
test(r'llJsonSetValue(u"{\"a\":3,\"b\":4}", ["a"], u" "+JSON_DELETE+u" ")', u'{"b":4}')
|
|
'''
|
|
# JSON tests from the wiki
|
|
test_types();
|
|
test_get_value();
|
|
# FIXME: llJsonSetValue pending
|
|
#test_set_value();
|
|
test_json_to_list();
|
|
test_list_to_json();
|
|
# FIXME: llJsonSetValue pending
|
|
#test_strings_with_escaped_chars();
|
|
test_jira_fixes();
|
|
|
|
do_tests()
|
|
|
|
print
|
|
print tests, "tests in suite"
|
|
print tests-untested, "tests run"
|
|
print errors, "errors found"
|
|
print tests-untested-errors, "tests passed"
|
|
|
|
# Disassemble
|
|
#import dis
|
|
#dis.disco(sub.__code__)
|
|
|
|
#from deadcode import finddeadcode
|
|
#
|
|
#dead = finddeadcode(InternalUTF8toString.__code__)
|
|
#
|
|
#if dead:
|
|
# for line in dead:
|
|
# print "Line %d is unreachable" % line
|
|
#elif dead == []:
|
|
# print "No unreachable lines found."
|
|
#else:
|
|
# print "No line info in code?!"
|