def test_decimal_largeexp_dec():
buf = SBytes("2f f9 be b7 b0 88 89 1c")
assert decode_decimal(buf,0,len(buf)) == Decimal('.123456789012345')
buf = SBytes("30 13 95 82 a6 ef c7 9e 84 91 11")
assert decode_decimal(buf,0,len(buf)) == Decimal('.1234567890123456789')
buf = SBytes("70 13 95 82 a6 ef c7 9e 84 91 11")
assert decode_decimal(buf,0,len(buf)) == Decimal('-.1234567890123456789')
def test_sched_gen_date_enc():
assert encode_sched_gen(TmDate("2020 01 16"), True,
False) == SBytes("80 c8 1f 01 10")
assert encode_sched_gen(TmDate("1984 01 16"), True,
False) == SBytes("80 80 1f 01 10")
assert encode_sched_gen(TmDate("-1984 01 16"), True,
False) == SBytes("80 ff 1e 01 10")
def test_enc_gen_tzname():
assert encode_sched_gen(
None, False, False,
tzname="Pacific/Auckland") == SBytes("10 b9 f8 32 9f")
assert encode_sched_gen(
None, False, False,
tzname="America/Argentina/Buenos_Aires") == SBytes("10 1e 59 9d e4")
def test_decimal_largeexp_enc():
x = Decimal('.123456789012345') # 0010 1111 & signif the rest
assert encode_decimal( x ) == SBytes("2f f9 be b7 b0 88 89 1c")
y = Decimal('.1234567890123456789') # 0011 0000 exp 13 & signif the rest
assert encode_decimal( y ) == SBytes("30 13 95 82 a6 ef c7 9e 84 91 11")
z = -y # 0111 0000 exp 13 & signif the rest
assert encode_decimal( z ) == SBytes("70 13 95 82 a6 ef c7 9e 84 91 11")
def test_enc_gen_offset_dst():
assert encode_sched_gen(TMX(0, 0, 0, 0, 0, 0, 0),
False,
False,
offset="+0200") == SBytes("20 02")
assert encode_sched_gen(TMX(0, 0, 0, 0, 0, 0, 1),
False,
False,
offset="+0200") == SBytes("20 42")
assert encode_sched_gen(TMX(0, 0, 0, 0, 0, 0, -1),
False,
False,
offset="+0200") == SBytes("20 02")
def test_schema_unpack_unwanted_incoming_field():
bool2_buf = SBytes(
"55 04 01 01") # a second B3_BOOL with key=4, len=1, value=True
unwantfield_buf = test1_buf + bool2_buf
out2_data = schema_unpack(TEST_SCHEMA, unwantfield_buf, 0,
len(unwantfield_buf))
assert out2_data == test1
def test_schema_unpack_missing_incoming_field():
missing_fields_buf = SBytes(
"97 01") # so only field 1 is present (and null)
null_data = dict(
bool1=None, number1=None,
string1=None) # missing incoming fields get created and null-valued.
assert schema_unpack(TEST_SCHEMA, missing_fields_buf, 0,
len(missing_fields_buf)) == null_data
def test_schema_unpack_bytes_yield():
BYTES_SCHEMA = ((B3_BYTES, 'bytes1', 1), (B3_COMPOSITE_LIST, 'list1', 2))
bytes1_hex = "53 01 03 66 6f 6f" # b"foo"
list1_hex = "52 02 03 66 6f 6f" # (actually just b"foo" as well, not an encoded list)
test_buf = SBytes(" ".join([bytes1_hex, list1_hex]))
test_data = dict(bytes1=b"foo", list1=b"foo")
assert schema_unpack(BYTES_SCHEMA, test_buf, 0, len(test_buf)) == test_data
def test_dec_gen_offset():
assert decode_offset(SBytes("02"), 0) == ("+0200", False, 1)
assert decode_offset(SBytes("82"), 0) == ("-0200", False, 1)
assert decode_offset(SBytes("12"), 0) == ("+0215", False, 1)
assert decode_offset(SBytes("a2"), 0) == ("-0230", False, 1)
assert decode_offset(SBytes("32"), 0) == ("+0245", False, 1)
assert decode_offset(SBytes("0b"), 0) == ("+1100", False, 1)
def test_schema_pack_nesting():
# Testing this buffer...
bytes1_hex = "53 01 0a 6f 75 74 65 72 62 79 74 65 73" # header + 'outerbytes'
signed1_hex = "58 02 02 a3 13" # header + encode_svarint(-1234)
inner_buf_hex = "51 03 06 17 01 14 02 15 03" # header + buffer output from the zeroval test
test_outer_buf = SBytes(" ".join([bytes1_hex, signed1_hex, inner_buf_hex]))
# ...against this data
inner_data = dict(bool1=False, number1=0, string1=u"")
inner1 = schema_pack(TEST_SCHEMA, inner_data)
outer_data = dict(bytes1=b"outerbytes", signed1=-1234, inner1=inner1)
outer_buf = schema_pack(OUTER_SCHEMA, outer_data)
assert outer_buf == test_outer_buf
def test_schema_pack_zeroval():
# Testing this buffer...
number1_zero_header = "17 01"
string1_zero_header = "14 02"
bool1_zero_header = "15 03"
buf_zv_hex = " ".join(
[number1_zero_header, string1_zero_header, bool1_zero_header])
buf_zv = SBytes(buf_zv_hex)
# ...against this data
test_zv_data = dict(bool1=False, number1=0, string1=u"")
buf = schema_pack(TEST_SCHEMA, test_zv_data)
assert buf_zv == buf
def test_header_keys_enc():
assert encode_header(0, key=None) == SBytes("00")
assert encode_header(0, key=4) == SBytes("10 04")
assert encode_header(0, key=7777777777) == SBytes("10 f1 f0 dd fc 1c")
assert encode_header(0, key=u"foo") == SBytes("20 03 66 6f 6f")
assert encode_header(
0,
key=u"Виагра") == SBytes("20 0c d0 92 d0 b8 d0 b0 d0 b3 d1 80 d0 b0")
assert encode_header(0, key=b"foo") == SBytes("30 03 66 6f 6f")
def test_schema_unpack_nesting():
# Testing this buffer...
bytes1_hex = "53 01 0a 6f 75 74 65 72 62 79 74 65 73" # header + 'outerbytes'
signed1_hex = "58 02 02 a3 13" # header + encode_svarint(-1234)
inner_buf_hex = "51 03 06 17 01 14 02 15 03" # header + buffer output from the zeroval test
test_outer_buf = SBytes(" ".join([bytes1_hex, signed1_hex, inner_buf_hex]))
# Note: It's up to the user to know - presumably using the defined schemas, that inner1 is a
# Note: B3_COMPOSITE_DICT type, as the returned dict (outer_data) just has the encoded bytes in that field.
outer_data = schema_unpack(OUTER_SCHEMA, test_outer_buf, 0,
len(test_outer_buf))
inner_len = len(outer_data['inner1'])
inner_data = schema_unpack(TEST_SCHEMA, outer_data['inner1'], 0, inner_len)
assert inner_data == dict(bool1=False, number1=0, string1=u"")
def test_schema_pack_field_missing():
# Testing this buffer...
bool1_header_null_value = u"95 03" # encode_header(B3_BOOL, key=3, is_null=True)
bool1_nulled_hex = " ".join([
number1_header, number1_data, string1_header, string1_data,
bool1_header_null_value
]) # note no data for bool1
bool1_nulled_buf = SBytes(bool1_nulled_hex)
# ...against this data
test2 = copy.copy(test1)
del test2[
'bool1'] # Missing field should be sent out as present but with a null value.
buf = schema_pack(TEST_SCHEMA, test2)
assert buf == bool1_nulled_buf
def test_header_keys_dec():
assert decode_header(SBytes("00"), 0) == (0, None, False, 0, 1)
assert decode_header(SBytes("10 04"), 0) == (0, 4, False, 0, 2)
assert decode_header(SBytes("10 f1 f0 dd fc 1c"),
0) == (0, 7777777777, False, 0, 6)
assert decode_header(SBytes("20 03 66 6f 6f"),
0) == (0, u"foo", False, 0, 5)
assert decode_header(SBytes("20 0c d0 92 d0 b8 d0 b0 d0 b3 d1 80 d0 b0"),
0) == (0, u"Виагра", False, 0, 14)
assert decode_header(SBytes("30 03 66 6f 6f"),
0) == (0, b"foo", False, 0, 5)
def test_enc_gen_offset():
assert encode_sched_gen(None, False, False,
offset="+0200") == SBytes("20 02")
assert encode_sched_gen(None, False, False,
offset="-0200") == SBytes("20 82")
assert encode_sched_gen(None, False, False,
offset="+0215") == SBytes("20 12")
assert encode_sched_gen(None, False, False,
offset="-0230") == SBytes("20 a2")
assert encode_sched_gen(None, False, False,
offset="+0245") == SBytes("20 32")
assert encode_sched_gen(None, False, False,
offset="+1100") == SBytes("20 0b")
def test_enc_gen_subsec():
assert encode_sched_gen(None, False, False, sub_exp=0,
sub=69) == SBytes("00") # no sub_exp
assert encode_sched_gen(None, False, False, sub_exp=3,
sub=0) == SBytes("00") # no sub
assert encode_sched_gen(None, False, False, sub_exp=3,
sub=69) == SBytes("01 45") # 69 ms
assert encode_sched_gen(None, False, False, sub_exp=-3, sub=69) == SBytes(
"01 45"
) # 69 ms (exponent always -ve so we dont actually need the sign)
assert encode_sched_gen(None, False, False, sub_exp=6,
sub=69) == SBytes("02 45") # 69 us
assert encode_sched_gen(None, False, False, sub_exp=9,
sub=69) == SBytes("03 45") # 69 ns
def test_base_stamp64_enc():
assert encode_stamp64(timFlo) == SBytes("00 22 46 6c ad d1 13 16")
assert encode_stamp64(timNano) == SBytes("00 22 46 6c ad d1 13 16")
assert encode_stamp64(timZero) == SBytes("")
def test_base_float64_dec():
for tflo, tbytes in TEST_FLOAT64S:
assert decode_float64(tbytes, 0, len(tbytes)) == tflo
assert decode_float64(SBytes("00 00 00 00 00 00 00 00"), 0,
8) == 0.0 # check non-compact zero value too
def test_base_int64_dec():
for tint, tbytes in TEST_INT64S:
assert decode_int64(tbytes, 0, len(tbytes)) == tint
assert decode_int64(SBytes("00 00 00 00 00 00 00 00"), 0,
8) == 0 # check non-compact zero value too
def test_base_bool_dec():
assert decode_bool(SBytes("01"), 0, 1) is True
assert decode_bool(SBytes("00"), 0, 1) is False # normal zero-value
assert decode_bool(SBytes(""), 0, 0) is False # compact zero-value mode
def test_base_complex_dec():
assert decode_complex(tcplx_bytes, 0, 16) == tcplx
assert decode_complex(SBytes(""), 0, 0) == 0j
assert decode_complex(
SBytes("00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00"), 0, 16) == 0j
def test_base_complex_enc():
assert encode_complex(tcplx) == tcplx_bytes
assert encode_complex(0j) == SBytes("")
def test_dyna_unpack_recurse_invalid_container():
with pytest.raises(TypeError):
unpack_into(None, SBytes("93 0e"), 0,
2) # passing None instead of a list or dict.
def test_dyna_unpack_header_only_invalid_type():
hdr_buf = SBytes("05") # no key, no data, bool type. (Error!)
with pytest.raises(TypeError):
assert unpack(hdr_buf, 0) == {}
def test_dyna_unpack_header_only_dict():
hdr_buf = SBytes("01") # no key, no data, dict type.
assert unpack(hdr_buf, 0) == {}
def test_dyna_unpack_header_only_list():
hdr_buf = SBytes("02") # no key, no data, list type.
assert unpack(hdr_buf, 0) == []
def test_base_bool_enc():
assert encode_bool(True) == SBytes("01")
assert encode_bool(False) == b"" # compact zero-value mode
def test_base_stamp64_dec():
assert decode_stamp64(SBytes("00 22 46 6c ad d1 13 16"), 0, 8) == timNano
assert decode_stamp64(SBytes(""), 0,
0) == timZero # compact zero-value mode
assert decode_stamp64(SBytes("00 00 00 00 00 00 00 00"), 0,
8) == timZero # non-compact zero value too
def test_base_bool_enc():
assert encode_bool(True) == SBytes("01")
assert encode_bool(False) == b"" # compact zero-value mode
def test_base_bool_dec():
assert decode_bool(SBytes("01"), 0, 1) is True
assert decode_bool(SBytes("00"), 0, 1) is False # normal zero-value
assert decode_bool(SBytes(""), 0, 0) is False # compact zero-value mode
# BMP 0000-FFFF, SMP 10000-1FFFF, SIP 20000-2FFFF, TIP 30000-3FFFF
# Went and got the utf8 bytes from the equivalent golang script
TEST_UNISTRS = (
(u"hello world", SBytes("68 65 6c 6c 6f 20 77 6f 72 6c 64")),
(u"Виагра",
SBytes("d0 92 d0 b8 d0 b0 d0 b3 d1 80 d0 b0")), # Viagra OWEN
(u"✈✉🚀🚸🚼🚽",
SBytes("e2 9c 88 e2 9c 89 f0 9f 9a 80 f0 9f 9a b8 f0 9f 9a bc f0 9f 9a bd"
)), # SMP
(u"", b"") # zero-length strings
)
def test_base_utf8_enc():
for tstr, tbytes in TEST_UNISTRS:
assert encode_utf8(tstr) == tbytes
def test_base_utf8_dec():