257 lines
12 KiB
Python
257 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)
|