def test_float_upper(self):
block = {
"key": "float upper",
"type": "float",
"bits": 5,
"upper": 31,
}
t = 13
a = "0b01101"
self.assertEqual(spos.encode_block(t, block), a)
self.assertClose(spos.decode_block(a, block), t)
def test_integer_offset(self):
block = {
"key": "integer offset",
"type": "integer",
"bits": 6,
"offset": 100,
}
t = 120
a = "0b010100"
self.assertEqual(spos.encode_block(t, block), a)
self.assertEqual(spos.decode_block(a, block), t)
def test_float_lower(self):
block = {
"key": "float lower",
"type": "float",
"bits": 3,
"lower": -6,
}
t = -1
a = "0b101"
self.assertEqual(spos.encode_block(t, block), a)
self.assertClose(spos.decode_block(a, block), t)
def test_steps_lower_boundary(self):
block = {
"key": "steps",
"type": "steps",
"steps": [0, 5, 10],
"steps_names": ["critical", "low", "charged", "full"],
}
t = 5
a = "0b10"
t_dec = "charged"
self.assertEqual(spos.encode_block(t, block), a)
self.assertEqual(spos.decode_block(a, block), t_dec)
def test_steps_last_index(self):
block = {
"key": "steps",
"type": "steps",
"steps": [0, 5, 10],
"steps_names": ["critical", "low", "charged", "full"],
}
t = 11
a = "0b11"
t_dec = "full"
self.assertEqual(spos.encode_block(t, block), a)
self.assertEqual(spos.decode_block(a, block), t_dec)
def test_categories_key_error_existent(self):
block = {
"key": "categories",
"type": "categories",
"categories": ["critical", "low", "charged", "full"],
"error": "critical",
}
t = "invalid"
a = "0b00"
t_dec = "critical"
self.assertEqual(spos.encode_block(t, block), a)
self.assertEqual(spos.decode_block(a, block), t_dec)
def test_float_approximation_floor(self):
block = {
"key": "float approximation floor",
"type": "float",
"bits": 2,
"approximation": "floor",
}
t = 0.66
a = "0b01"
t_dec = 0.33
self.assertEqual(spos.encode_block(t, block), a)
self.assertClose(spos.decode_block(a, block), t_dec)
def test_float_approximation_ceil(self):
block = {
"key": "float approximation ceil",
"type": "float",
"bits": 2,
"approximation": "ceil",
}
t = 0.34
a = "0b10"
t_dec = 0.66
self.assertEqual(spos.encode_block(t, block), a)
self.assertClose(spos.decode_block(a, block), t_dec)
def test_categories_error_new(self):
block = {
"key": "categories",
"type": "categories",
"categories": ["critical", "low", "charged", "full"],
"error": "invalid_category",
}
t = "invalid_value"
a = "0b100"
t_dec = "invalid_category"
self.assertEqual(spos.encode_block(t, block), a)
self.assertEqual(spos.decode_block(a, block), t_dec)
def test_integer_remainder(self):
block = {
"key": "integer remainder",
"type": "integer",
"mode": "remainder",
"bits": 6,
}
t = 72
a = "0b001000"
t_dec = 8
self.assertEqual(spos.encode_block(t, block), a)
self.assertEqual(spos.decode_block(a, block), t_dec)
def test_integer_offset_remainder(self):
block = {
"key": "integer remainder offset",
"type": "integer",
"offset": 3,
"mode": "remainder",
"bits": 3,
}
t = 22
a = "0b011"
t_dec = 6
self.assertEqual(spos.encode_block(t, block), a)
self.assertEqual(spos.decode_block(a, block), t_dec)
def test_static_value_mismatch_warning(self):
static_value = "0b10101"
block = {
"key": "binary bin",
"type": "binary",
"value": static_value,
"bits": 5,
}
with warnings.catch_warnings(record=True) as w:
self.assertEqual(spos.decode_block("0b11111", block), static_value)
self.assertEqual(len(w), 1)
self.assertTrue(
issubclass(w[-1].category, spos.StaticValueMismatchWarning))
def test_string_custom_alphabeth(self):
block = {
"key": "string",
"type": "string",
"length": 6,
"custom_alphabeth": {
62: " "
},
}
t = "test"
a = "0b111110111110101101011110101100101101"
t_dec = " test"
self.assertEqual(spos.encode_block(t, block), a)
self.assertEqual(spos.decode_block(a, block), t_dec)
def test_array_block(self):
block = {
"key": "integer array",
"type": "array",
"length": 7,
"blocks": {
"key": "array val",
"type": "integer",
"bits": 3
},
}
t = [1, 2, 3, 4]
a = "0b100001010011100"
self.assertEqual(spos.encode_block(t, block), a)
self.assertEqual(spos.decode_block(a, block), t)
def test_array_empty(self):
block = {
"key": "empty array",
"type": "array",
"length": 127,
"blocks": {
"key": "array val",
"type": "integer",
"bits": 3
},
}
t = []
a = "0b0000000"
self.assertEqual(spos.encode_block(t, block), a)
self.assertEqual(spos.decode_block(a, block), [])
def test_array_truncate(self):
block = {
"key": "truncate array",
"type": "array",
"length": 3,
"blocks": {
"key": "array val",
"type": "integer",
"bits": 3
},
}
t = [1, 2, 3, 4, 5]
a = "0b11001010011"
t_dec = [1, 2, 3]
self.assertEqual(spos.encode_block(t, block), a)
self.assertEqual(spos.decode_block(a, block), t_dec)
def test_array_fixed(self):
block = {
"key": "fixed array",
"type": "array",
"length": 3,
"fixed": True,
"blocks": {
"key": "array val",
"type": "integer",
"bits": 3
},
}
t = [0, 1, 2]
a = "0b000001010"
self.assertEqual(spos.encode_block(t, block), a)
self.assertEqual(spos.decode_block(a, block), t)
def test_array_nested(self):
block = {
"key": "nested array",
"type": "array",
"length": 3,
"blocks": {
"key": "array val 1",
"type": "array",
"length": 7,
"blocks": {
"key": "array val 2",
"type": "integer",
"bits": 3
},
},
}
t = [[1, 2], [3, 4, 5]]
a = "0b10010001010011011100101"
self.assertEqual(spos.encode_block(t, block), a)
self.assertEqual(spos.decode_block(a, block), t)
def test_object_nested(self):
block = {
"key":
"object",
"type":
"object",
"blocklist": [
{
"key": "key1",
"type": "integer",
"bits": 3
},
{
"key":
"key2",
"type":
"object",
"blocklist": [
{
"key": "nKey",
"type": "boolean"
},
{
"key":
"nKey2",
"type":
"object",
"blocklist": [{
"key": "nKey3",
"type": "float",
"bits": 8
}],
},
],
},
],
}
t = {"key1": 6, "key2": {"nKey": False, "nKey2": {"nKey3": 0.8}}}
a = "0b110011001100"
self.assertEqual(spos.encode_block(t, block), a)
self.assertDict(spos.decode_block(a, block), t)
def test_object_block(self):
block = {
"key":
"object",
"type":
"object",
"blocklist": [
{
"key": "key1",
"type": "integer",
"bits": 3
},
{
"key": "key2",
"type": "float",
"bits": 5
},
],
}
t = {"key1": 6, "key2": 0.9}
a = "0b11011100"
self.assertEqual(spos.encode_block(t, block), a)
self.assertDict(spos.decode_block(a, block), t)
def test_boolean_false(self):
block = {"key": "boolean false", "type": "boolean"}
t = False
a = "0b0"
self.assertEqual(spos.encode_block(t, block), a)
self.assertEqual(spos.decode_block(a, block), t)
def test_boolean_true(self):
block = {"key": "boolean encode true", "type": "boolean"}
t = True
a = "0b1"
self.assertEqual(spos.encode_block(t, block), a)
self.assertEqual(spos.decode_block(a, block), t)
def test_float_block(self):
block = {"key": "float test", "type": "float", "bits": 2}
t = 0.66
a = "0b10"
self.assertEqual(spos.encode_block(t, block), a)
self.assertClose(spos.decode_block(a, block), t)
def test_pad_block_6(self):
block = {"key": "pad test", "type": "pad", "bits": 6}
t = None
a = "0b111111"
self.assertEqual(spos.encode_block(t, block), a)
self.assertEqual(spos.decode_block(a, block), t)
def test_object_dot_notation_1(self):
block = {
"key":
"object",
"type":
"object",
"blocklist": [
{
"key": "key1.nest1.a",
"type": "integer",
"bits": 3
},
{
"key": "key1.nest1.b",
"type": "string",
"length": 5
},
{
"key": "key1.nest1.c",
"type": "integer",
"bits": 3
},
{
"key":
"key1",
"type":
"object",
"blocklist": [
{
"key": "nest1.d",
"type": "integer",
"bits": 3
},
{
"key":
"nest1",
"type":
"object",
"blocklist": [
{
"key": "e",
"type": "integer",
"bits": 3
},
{
"key": "f",
"type": "integer",
"bits": 3
},
],
},
],
},
],
}
t = {
"key1": {
"nest1": {
"a": 1,
"b": "hello",
"c": 2,
"d": 3,
"e": 4,
"f": 5
}
},
}
a = "0b001100001011110100101100101101000010011100101"
self.assertEqual(spos.encode_block(t, block), a)
self.assertDict(spos.decode_block(a, block), t)