293 lines
12 KiB
Python
293 lines
12 KiB
Python
# vim: set fileencoding=utf-8
|
|
import unittest
|
|
|
|
from bemani.common import ValidatedDict, intish
|
|
|
|
|
|
class TestIntish(unittest.TestCase):
|
|
def test_none(self) -> None:
|
|
self.assertEqual(intish(None), None)
|
|
|
|
def test_int(self) -> None:
|
|
self.assertEqual(intish("3"), 3)
|
|
|
|
def test_str(self) -> None:
|
|
self.assertEqual(intish("str"), None)
|
|
|
|
|
|
class TestValidatedDict(unittest.TestCase):
|
|
def test_empty_dict(self) -> None:
|
|
# Empty dictionary gets
|
|
validict = ValidatedDict()
|
|
|
|
self.assertEqual(validict.get_int("int"), 0)
|
|
self.assertEqual(validict.get_int("int", 2), 2)
|
|
self.assertEqual(validict.get_float("float"), 0.0)
|
|
self.assertEqual(validict.get_float("float", 2.0), 2.0)
|
|
self.assertEqual(validict.get_bool("bool"), False)
|
|
self.assertEqual(validict.get_bool("bool", True), True)
|
|
self.assertEqual(validict.get_str("str"), "")
|
|
self.assertEqual(validict.get_str("str", "test"), "test")
|
|
self.assertEqual(validict.get_bytes("bytes"), b"")
|
|
self.assertEqual(validict.get_bytes("bytes", b"test"), b"test")
|
|
self.assertEqual(validict.get_int_array("int_array", 3), [0, 0, 0])
|
|
self.assertEqual(validict.get_int_array("int_array", 3, [1, 2, 3]), [1, 2, 3])
|
|
self.assertEqual(validict.get_bool_array("bool_array", 2), [False, False])
|
|
self.assertEqual(
|
|
validict.get_bool_array("bool_array", 2, [False, True]), [False, True]
|
|
)
|
|
self.assertEqual(validict.get_str_array("str_array", 3), ["", "", ""])
|
|
self.assertEqual(
|
|
validict.get_str_array("str_array", 3, ["1", "2", "3"]), ["1", "2", "3"]
|
|
)
|
|
self.assertEqual(validict.get_bytes_array("bytes_array", 3), [b"", b"", b""])
|
|
self.assertEqual(
|
|
validict.get_bytes_array("bytes_array", 3, [b"1", b"2", b"3"]),
|
|
[b"1", b"2", b"3"],
|
|
)
|
|
self.assertTrue(isinstance(validict.get_dict("dict"), dict))
|
|
self.assertEqual(validict.get_dict("dict").get_int("test"), 0)
|
|
|
|
def test_normal_dict(self) -> None:
|
|
# Existing info gets
|
|
validict = ValidatedDict(
|
|
{
|
|
"int": 5,
|
|
"float": 5.5,
|
|
"bool": True,
|
|
"str": "foobar",
|
|
"bytes": b"foobar",
|
|
"int_array": [3, 2, 1],
|
|
"bool_array": [True, False],
|
|
"str_array": ["3", "4", "5"],
|
|
"bytes_array": [b"3", b"5", b"7"],
|
|
"dict": {"test": 123},
|
|
}
|
|
)
|
|
self.assertEqual(validict.get_int("int"), 5)
|
|
self.assertEqual(validict.get_int("int", 2), 5)
|
|
self.assertEqual(validict.get_float("float"), 5.5)
|
|
self.assertEqual(validict.get_float("float", 2.0), 5.5)
|
|
self.assertEqual(validict.get_bool("bool"), True)
|
|
self.assertEqual(validict.get_bool("bool", False), True)
|
|
self.assertEqual(validict.get_str("str"), "foobar")
|
|
self.assertEqual(validict.get_str("str", "test"), "foobar")
|
|
self.assertEqual(validict.get_bytes("bytes"), b"foobar")
|
|
self.assertEqual(validict.get_bytes("bytes", b"test"), b"foobar")
|
|
self.assertEqual(validict.get_int_array("int_array", 3), [3, 2, 1])
|
|
self.assertEqual(validict.get_int_array("int_array", 3, [1, 2, 3]), [3, 2, 1])
|
|
self.assertEqual(validict.get_bool_array("bool_array", 2), [True, False])
|
|
self.assertEqual(
|
|
validict.get_bool_array("bool_array", 2, [False, True]), [True, False]
|
|
)
|
|
self.assertEqual(validict.get_str_array("str_array", 3), ["3", "4", "5"])
|
|
self.assertEqual(
|
|
validict.get_str_array("str_array", 3, ["1", "2", "3"]), ["3", "4", "5"]
|
|
)
|
|
self.assertEqual(validict.get_bytes_array("bytes_array", 3), [b"3", b"5", b"7"])
|
|
self.assertEqual(
|
|
validict.get_bytes_array("bytes_array", 3, [b"1", b"2", b"3"]),
|
|
[b"3", b"5", b"7"],
|
|
)
|
|
self.assertTrue(isinstance(validict.get_dict("dict"), dict))
|
|
self.assertEqual(validict.get_dict("dict").get_int("test"), 123)
|
|
|
|
def test_default_on_invalid(self) -> None:
|
|
# Default on invalid info stored
|
|
validict = ValidatedDict(
|
|
{
|
|
"int": "five",
|
|
"float": "five",
|
|
"bool": "true",
|
|
"str": 123,
|
|
"bytes": "str",
|
|
"int_array": [3, 2, 1, 0],
|
|
"bool_array": [True, False],
|
|
"str_array": ["3", "2", "1", "0"],
|
|
"bytes_array": [b"3", b"2", b"1", b"0"],
|
|
"dict": "not_a_dict",
|
|
}
|
|
)
|
|
self.assertEqual(validict.get_int("int"), 0)
|
|
self.assertEqual(validict.get_int("int", 2), 2)
|
|
self.assertEqual(validict.get_float("float"), 0.0)
|
|
self.assertEqual(validict.get_float("float", 2.0), 2.0)
|
|
self.assertEqual(validict.get_bool("bool"), False)
|
|
self.assertEqual(validict.get_bool("bool", True), True)
|
|
self.assertEqual(validict.get_str("str"), "")
|
|
self.assertEqual(validict.get_str("str", "test"), "test")
|
|
self.assertEqual(validict.get_bytes("bytes"), b"")
|
|
self.assertEqual(validict.get_bytes("bytes", b"test"), b"test")
|
|
self.assertEqual(validict.get_int_array("int_array", 3), [0, 0, 0])
|
|
self.assertEqual(validict.get_int_array("int_array", 3, [1, 2, 3]), [1, 2, 3])
|
|
self.assertEqual(
|
|
validict.get_bool_array("bool_array", 3), [False, False, False]
|
|
)
|
|
self.assertEqual(
|
|
validict.get_bool_array("bool_array", 3, [False, True, True]),
|
|
[False, True, True],
|
|
)
|
|
self.assertEqual(validict.get_str_array("str_array", 3), ["", "", ""])
|
|
self.assertEqual(
|
|
validict.get_str_array("str_array", 3, ["1", "2", "3"]), ["1", "2", "3"]
|
|
)
|
|
self.assertEqual(validict.get_bytes_array("bytes_array", 3), [b"", b"", b""])
|
|
self.assertEqual(
|
|
validict.get_bytes_array("bytes_array", 3, [b"1", b"2", b"3"]),
|
|
[b"1", b"2", b"3"],
|
|
)
|
|
self.assertTrue(isinstance(validict.get_dict("dict"), dict))
|
|
self.assertEqual(validict.get_dict("dict").get_int("test"), 0)
|
|
|
|
def test_replace_int(self) -> None:
|
|
# Verify replace int
|
|
validict = ValidatedDict(
|
|
{
|
|
"int": 5,
|
|
}
|
|
)
|
|
validict.replace_int("int", 3)
|
|
self.assertEqual(validict.get_int("int"), 3)
|
|
validict.replace_int("int", None)
|
|
self.assertEqual(validict.get_int("int"), 3)
|
|
validict.replace_int("int", "three")
|
|
self.assertEqual(validict.get_int("int"), 3)
|
|
|
|
def test_replace_float(self) -> None:
|
|
# Verify replace float
|
|
validict = ValidatedDict(
|
|
{
|
|
"float": 5.0,
|
|
}
|
|
)
|
|
validict.replace_float("float", 3.0)
|
|
self.assertEqual(validict.get_float("float"), 3.0)
|
|
validict.replace_float("float", None)
|
|
self.assertEqual(validict.get_float("float"), 3.0)
|
|
validict.replace_float("float", "three")
|
|
self.assertEqual(validict.get_float("float"), 3.0)
|
|
|
|
def test_replace_bool(self) -> None:
|
|
# Verify replace bool
|
|
validict = ValidatedDict(
|
|
{
|
|
"bool": False,
|
|
}
|
|
)
|
|
validict.replace_bool("bool", True)
|
|
self.assertEqual(validict.get_bool("bool"), True)
|
|
validict.replace_bool("bool", None)
|
|
self.assertEqual(validict.get_bool("bool"), True)
|
|
validict.replace_bool("bool", "three")
|
|
self.assertEqual(validict.get_bool("bool"), True)
|
|
|
|
def test_replace_str(self) -> None:
|
|
# Verify replace str
|
|
validict = ValidatedDict(
|
|
{
|
|
"str": "blah",
|
|
}
|
|
)
|
|
validict.replace_str("str", "foobar")
|
|
self.assertEqual(validict.get_str("str"), "foobar")
|
|
validict.replace_str("str", None)
|
|
self.assertEqual(validict.get_str("str"), "foobar")
|
|
validict.replace_str("str", 5)
|
|
self.assertEqual(validict.get_str("str"), "foobar")
|
|
|
|
def test_replace_bytes(self) -> None:
|
|
# Verify replace bytes
|
|
validict = ValidatedDict(
|
|
{
|
|
"bytes": "blah",
|
|
}
|
|
)
|
|
validict.replace_bytes("bytes", b"foobar")
|
|
self.assertEqual(validict.get_bytes("bytes"), b"foobar")
|
|
validict.replace_bytes("bytes", None)
|
|
self.assertEqual(validict.get_bytes("bytes"), b"foobar")
|
|
validict.replace_bytes("bytes", 5)
|
|
self.assertEqual(validict.get_bytes("bytes"), b"foobar")
|
|
|
|
def test_replace_int_array(self) -> None:
|
|
# Verify replace int_array
|
|
validict = ValidatedDict({"int_array": [1, 2, 3]})
|
|
validict.replace_int_array("int_array", 3, [3, 2, 1])
|
|
self.assertEqual(validict.get_int_array("int_array", 3), [3, 2, 1])
|
|
validict.replace_int_array("int_array", 3, None)
|
|
self.assertEqual(validict.get_int_array("int_array", 3), [3, 2, 1])
|
|
validict.replace_int_array("int_array", 3, "bla")
|
|
self.assertEqual(validict.get_int_array("int_array", 3), [3, 2, 1])
|
|
validict.replace_int_array("int_array", 3, [3, 2, 1, 0])
|
|
self.assertEqual(validict.get_int_array("int_array", 3), [3, 2, 1])
|
|
|
|
def test_replace_bool_array(self) -> None:
|
|
# Verify replace bool_array
|
|
validict = ValidatedDict(
|
|
{
|
|
"bool_array": [False, True],
|
|
}
|
|
)
|
|
validict.replace_bool_array("bool_array", 2, [True, False])
|
|
self.assertEqual(validict.get_bool_array("bool_array", 2), [True, False])
|
|
validict.replace_bool_array("bool_array", 2, None)
|
|
self.assertEqual(validict.get_bool_array("bool_array", 2), [True, False])
|
|
validict.replace_bool_array("bool_array", 2, "bla")
|
|
self.assertEqual(validict.get_bool_array("bool_array", 2), [True, False])
|
|
validict.replace_bool_array("bool_array", 2, [True, True, True])
|
|
self.assertEqual(validict.get_bool_array("bool_array", 2), [True, False])
|
|
|
|
def test_replace_str_array(self) -> None:
|
|
# Verify replace str_array
|
|
validict = ValidatedDict({"str_array": ["1", "2", "3"]})
|
|
validict.replace_str_array("str_array", 3, ["3", "2", "1"])
|
|
self.assertEqual(validict.get_str_array("str_array", 3), ["3", "2", "1"])
|
|
validict.replace_str_array("str_array", 3, None)
|
|
self.assertEqual(validict.get_str_array("str_array", 3), ["3", "2", "1"])
|
|
validict.replace_str_array("str_array", 3, "bla")
|
|
self.assertEqual(validict.get_str_array("str_array", 3), ["3", "2", "1"])
|
|
validict.replace_str_array("str_array", 3, ["3", "2", "1", "0"])
|
|
self.assertEqual(validict.get_str_array("str_array", 3), ["3", "2", "1"])
|
|
|
|
def test_replace_bytes_array(self) -> None:
|
|
# Verify replace bytes_array
|
|
validict = ValidatedDict({"bytes_array": [b"1", b"2", b"3"]})
|
|
validict.replace_bytes_array("bytes_array", 3, [b"3", b"2", b"1"])
|
|
self.assertEqual(validict.get_bytes_array("bytes_array", 3), [b"3", b"2", b"1"])
|
|
validict.replace_bytes_array("bytes_array", 3, None)
|
|
self.assertEqual(validict.get_bytes_array("bytes_array", 3), [b"3", b"2", b"1"])
|
|
validict.replace_bytes_array("bytes_array", 3, "bla")
|
|
self.assertEqual(validict.get_bytes_array("bytes_array", 3), [b"3", b"2", b"1"])
|
|
validict.replace_bytes_array("bytes_array", 3, [b"3", b"2", b"1", b"0"])
|
|
self.assertEqual(validict.get_bytes_array("bytes_array", 3), [b"3", b"2", b"1"])
|
|
|
|
def test_replace_dict(self) -> None:
|
|
# Verify replace dict
|
|
validict = ValidatedDict(
|
|
{
|
|
"dict": {},
|
|
}
|
|
)
|
|
validict.replace_dict("dict", {"yay": "bla"})
|
|
self.assertTrue(isinstance(validict.get_dict("dict"), dict))
|
|
self.assertEqual(validict.get_dict("dict").get_str("yay"), "bla")
|
|
validict.replace_dict("dict", None)
|
|
self.assertEqual(validict.get_dict("dict").get_str("yay"), "bla")
|
|
validict.replace_dict("dict", "three")
|
|
self.assertEqual(validict.get_dict("dict").get_str("yay"), "bla")
|
|
|
|
def test_increment_int(self) -> None:
|
|
# Verify increment_int
|
|
validict = ValidatedDict(
|
|
{
|
|
"int": 5,
|
|
"int2": "str",
|
|
}
|
|
)
|
|
validict.increment_int("int")
|
|
self.assertEqual(validict.get_int("int"), 6)
|
|
validict.increment_int("int2")
|
|
self.assertEqual(validict.get_int("int2"), 1)
|
|
validict.increment_int("int3")
|
|
self.assertEqual(validict.get_int("int3"), 1)
|