From ba010168cf8c71fefd01bda2783a8d1890a1c522 Mon Sep 17 00:00:00 2001 From: rdb Date: Sat, 25 Apr 2020 14:44:43 +0200 Subject: [PATCH] tests: more improvements to test suite coverage --- tests/putil/test_bitarray.py | 64 ++++++++++++++++++++++++++++- tests/putil/test_bitmask.py | 18 ++++++++ tests/putil/test_buttonhandle.py | 64 +++++++++++++++++++++++++++++ tests/putil/test_clockobject.py | 23 ++++++++--- tests/putil/test_datagram.py | 11 +++++ tests/putil/test_modifierbuttons.py | 50 ++++++++++++++++++++++ tests/putil/test_sparsearray.py | 4 ++ tests/putil/test_updateseq.py | 7 ++++ tests/showbase/test_ShowBase.py | 21 ++++++++++ 9 files changed, 255 insertions(+), 7 deletions(-) create mode 100644 tests/putil/test_buttonhandle.py create mode 100644 tests/showbase/test_ShowBase.py diff --git a/tests/putil/test_bitarray.py b/tests/putil/test_bitarray.py index 6c258dfd37..1e39600c32 100644 --- a/tests/putil/test_bitarray.py +++ b/tests/putil/test_bitarray.py @@ -1,8 +1,12 @@ -from panda3d.core import BitArray +from panda3d.core import BitArray, SparseArray import pickle import pytest +def test_bitarray_type(): + assert BitArray.get_class_type().name == "BitArray" + + def test_bitarray_constructor(): assert BitArray().is_zero() assert BitArray(0).is_zero() @@ -18,8 +22,31 @@ def test_bitarray_constructor(): assert BitArray(-10000000000000000000) +def test_bitarray_constructor_sparse(): + # Create a BitArray from a SparseArray. + ba = BitArray(SparseArray.all_on()) + assert ba.is_all_on() + + ba = BitArray(SparseArray()) + assert ba.is_zero() + + sa = SparseArray() + sa.set_range(3, 64) + sa.set_range(0, 1) + sa.clear_range(60, 2) + ba = BitArray(sa) + exp = 0b1111100111111111111111111111111111111111111111111111111111111111001 + assert ba.__getstate__() == exp + + sa.invert_in_place() + ba = BitArray(sa) + assert ba.__getstate__() == ~exp + + def test_bitarray_allon(): assert BitArray.all_on().is_all_on() + assert BitArray.all_on().get_highest_on_bit() == -1 + assert BitArray.all_on().get_highest_off_bit() == -1 def test_bitarray_nonzero(): @@ -36,6 +63,41 @@ def test_bitarray_invert(): assert ~~BitArray(123) == BitArray(123) +def test_bitarray_set_word(): + # Non-inverted + expected = 9876 | (123456 << (BitArray.num_bits_per_word * 3)) + ba = BitArray(0) + ba.set_word(0, 9876) + ba.set_word(3, 123456) + assert ba.__getstate__() == expected + assert not ba.is_all_on() + + # Inverted + ba = BitArray(0) + ba.invert_in_place() + ba.set_word(2, 1234) + full_word = (1 << BitArray.num_bits_per_word) - 1 + expected = ~((full_word & ~1234) << (BitArray.num_bits_per_word * 2)) + assert ba.__getstate__() == expected + assert not ba.is_all_on() + + +def test_bitarray_clear(): + ba = BitArray(1234) + ba.clear() + assert ba.is_zero() + assert not ba.is_all_on() + assert ba.get_highest_on_bit() == -1 + assert ba.get_highest_off_bit() == -1 + + ba = BitArray.all_on() + ba.clear() + assert ba.is_zero() + assert not ba.is_all_on() + assert ba.get_highest_on_bit() == -1 + assert ba.get_highest_off_bit() == -1 + + def test_bitarray_getstate(): assert BitArray().__getstate__() == 0 assert BitArray(0).__getstate__() == 0 diff --git a/tests/putil/test_bitmask.py b/tests/putil/test_bitmask.py index 47fb6dc7ca..9e80758d78 100644 --- a/tests/putil/test_bitmask.py +++ b/tests/putil/test_bitmask.py @@ -8,6 +8,10 @@ double_num_bits = DoubleBitMaskNative.get_max_num_bits() quad_num_bits = QuadBitMaskNative.get_max_num_bits() +def test_bitmask_type(): + assert BitMask16.get_class_type().name == "BitMask16" + + def test_bitmask_allon(): assert BitMask16.all_on().is_all_on() assert BitMask32.all_on().is_all_on() @@ -34,6 +38,13 @@ def test_bitmask_overflow(): with pytest.raises(OverflowError): QuadBitMaskNative(1 << quad_num_bits) + with pytest.raises(Exception): + DoubleBitMaskNative(-1) + + +def test_bitmask_repr(): + repr(BitMask16(0)) == ' 0000 0000 0000 0000' + def test_bitmask_int(): assert int(BitMask16()) == 0 @@ -68,3 +79,10 @@ def test_bitmask_pickle(): data = pickle.dumps(mask1, -1) mask2 = pickle.loads(data) assert mask1 == mask2 + + assert pickle.loads(pickle.dumps(DoubleBitMaskNative(0), -1)).is_zero() + + mask1 = DoubleBitMaskNative(0xffff0001) + data = pickle.dumps(mask1, -1) + mask2 = pickle.loads(data) + assert mask1 == mask2 diff --git a/tests/putil/test_buttonhandle.py b/tests/putil/test_buttonhandle.py new file mode 100644 index 0000000000..3242e06a7a --- /dev/null +++ b/tests/putil/test_buttonhandle.py @@ -0,0 +1,64 @@ +from panda3d.core import ButtonHandle +from panda3d.core import GamepadButton +from panda3d.core import KeyboardButton +from panda3d.core import MouseButton + + +def test_buttonhandle_type(): + assert ButtonHandle.get_class_type().name == "ButtonHandle" + + +def test_buttonhandle_none(): + none = ButtonHandle.none() + assert none.index == 0 + assert none.name == "none" + assert none == ButtonHandle.none() + assert none.alias == none + assert repr(none) == "none" + assert str(none) == "none" + + +def test_gamepadbutton_joystick(): + # The first one is called "trigger" + assert GamepadButton.trigger() == GamepadButton.joystick(0) + assert GamepadButton.joystick(0).name == "trigger" + + for i in range(1, 8): + btn = GamepadButton.joystick(i) + assert btn.name == "joystick" + str(i + 1) + + +def test_keyboardbutton_ascii(): + assert KeyboardButton.space() == KeyboardButton.ascii_key(' ') + assert KeyboardButton.backspace() == KeyboardButton.ascii_key('\x08') + assert KeyboardButton.tab() == KeyboardButton.ascii_key('\x09') + assert KeyboardButton.enter() == KeyboardButton.ascii_key('\x0d') + assert KeyboardButton.escape() == KeyboardButton.ascii_key('\x1b') + + assert KeyboardButton.ascii_key(' ').name == 'space' + assert KeyboardButton.ascii_key('\x08').name == 'backspace' + assert KeyboardButton.ascii_key('\x09').name == 'tab' + assert KeyboardButton.ascii_key('\x0d').name == 'enter' + assert KeyboardButton.ascii_key('\x1b').name == 'escape' + assert KeyboardButton.ascii_key('\x7f').name == 'delete' + + assert KeyboardButton.ascii_key('a').name == 'a' + + +def test_mousebutton(): + btns = [MouseButton.one(), + MouseButton.two(), + MouseButton.three(), + MouseButton.four(), + MouseButton.five()] + + for i, btn in enumerate(btns): + assert MouseButton.button(i) == btn + assert MouseButton.is_mouse_button(btn) + + assert MouseButton.button(5) == ButtonHandle.none() + + assert MouseButton.is_mouse_button(MouseButton.wheel_up()) + assert MouseButton.is_mouse_button(MouseButton.wheel_down()) + assert MouseButton.is_mouse_button(MouseButton.wheel_left()) + assert MouseButton.is_mouse_button(MouseButton.wheel_right()) diff --git a/tests/putil/test_clockobject.py b/tests/putil/test_clockobject.py index afff7f9b3e..14a2d30d7e 100644 --- a/tests/putil/test_clockobject.py +++ b/tests/putil/test_clockobject.py @@ -1,23 +1,34 @@ import time -def test_get_frame_time(clockobj): + +def test_clock_get_frame_time(clockobj): current_time = clockobj.get_frame_time() - time.sleep(2) + time.sleep(0.2) assert clockobj.get_frame_time() == current_time -def test_jump_frame_time(clockobj): + +def test_clock_jump_frame_time(clockobj): current_time = clockobj.get_frame_time() clockobj.tick() assert clockobj.get_frame_time() == current_time + clockobj.get_frame_time() -def test_get_real_time(clockobj): + +def test_clock_get_real_time(clockobj): current_time = clockobj.get_real_time() - time.sleep(2) + time.sleep(0.2) assert current_time != clockobj.get_real_time() -def test_get_dt(clockobj): + +def test_clock_get_dt(clockobj): clockobj.tick() first_tick = clockobj.get_frame_time() clockobj.tick() second_tick = clockobj.get_frame_time() assert clockobj.get_dt() == second_tick - first_tick + + +def test_clock_reset(clockobj): + clockobj.reset() + assert clockobj.get_dt() == 0 + assert clockobj.get_frame_time() == 0 + assert clockobj.get_real_time() < 0.01 diff --git a/tests/putil/test_datagram.py b/tests/putil/test_datagram.py index ad8ef9857c..01a1e5eada 100644 --- a/tests/putil/test_datagram.py +++ b/tests/putil/test_datagram.py @@ -111,6 +111,17 @@ def test_datagram_pickle(): assert pickle.loads(pickle.dumps(dg, -1)) == dg +def test_datagram_cow(): + dg1 = core.Datagram() + dg1.append_data(b'1234') + + dg2 = core.Datagram(dg1) + dg2.append_data(b'5678') + + assert dg1.get_message() == b'1234' + assert dg2.get_message() == b'12345678' + + def test_iterator(datagram_small): """This tests Datagram/DatagramIterator, and sort of serves as a self-check of the test fixtures too.""" diff --git a/tests/putil/test_modifierbuttons.py b/tests/putil/test_modifierbuttons.py index 289966d1df..b51a64d1ed 100644 --- a/tests/putil/test_modifierbuttons.py +++ b/tests/putil/test_modifierbuttons.py @@ -33,3 +33,53 @@ def test_modifierbuttons_cow(): btns3.add_button("escape") assert tuple(btns2.buttons) == ("space",) assert tuple(btns3.buttons) == ("space", "escape") + + +def test_modifierbuttons_assign(): + # Tests assignment operator. + btns1 = ModifierButtons() + btns1.add_button("space") + + btns2 = ModifierButtons() + btns2.assign(btns1) + + assert btns1 == btns2 + assert tuple(btns1.buttons) == tuple(btns2.buttons) + + +def test_modifierbuttons_state(): + btns = ModifierButtons() + btns.add_button("alt") + btns.add_button("shift") + btns.add_button("control") + assert not btns.is_any_down() + + # Not tracked + btns.button_down("enter") + assert not btns.is_any_down() + + # Tracked + btns.button_down("shift") + assert btns.is_any_down() + assert not btns.is_down(0) + assert btns.is_down(1) + assert not btns.is_down(2) + + btns.button_up("shift") + assert not btns.is_any_down() + assert not btns.is_down(0) + assert not btns.is_down(1) + assert not btns.is_down(2) + + btns.button_down("alt") + btns.button_down("shift") + assert btns.is_any_down() + assert btns.is_down(0) + assert btns.is_down(1) + assert not btns.is_down(2) + + btns.all_buttons_up() + assert not btns.is_any_down() + assert not btns.is_down(0) + assert not btns.is_down(1) + assert not btns.is_down(2) diff --git a/tests/putil/test_sparsearray.py b/tests/putil/test_sparsearray.py index e06a7adedb..9721ad495a 100644 --- a/tests/putil/test_sparsearray.py +++ b/tests/putil/test_sparsearray.py @@ -2,6 +2,10 @@ from panda3d import core import pickle +def test_sparse_array_type(): + assert core.SparseArray.get_class_type().name == "SparseArray" + + def test_sparse_array_set_bit_to(): """Tests SparseArray behavior for set_bit_to().""" diff --git a/tests/putil/test_updateseq.py b/tests/putil/test_updateseq.py index 5cd7312595..93617aaabe 100644 --- a/tests/putil/test_updateseq.py +++ b/tests/putil/test_updateseq.py @@ -103,3 +103,10 @@ def test_updateseq_old(): assert not (seq != old) assert not (seq > old) assert not (seq < old) + + +def test_updateseq_clear(): + seq = UpdateSeq(UpdateSeq.fresh()) + seq.clear() + assert seq == UpdateSeq.initial() + assert seq.is_initial() diff --git a/tests/showbase/test_ShowBase.py b/tests/showbase/test_ShowBase.py new file mode 100644 index 0000000000..1233ad0067 --- /dev/null +++ b/tests/showbase/test_ShowBase.py @@ -0,0 +1,21 @@ +from direct.showbase.ShowBase import ShowBase +import sys + +if sys.version_info >= (3, 0): + import builtins +else: + import __builtin__ as builtins + + +def test_showbase_create_destroy(): + sb = ShowBase(windowType='none') + try: + assert builtins.base == sb + finally: + sb.destroy() + sb = None + + assert not hasattr(builtins, 'base') + assert not hasattr(builtins, 'run') + assert not hasattr(builtins, 'loader') + assert not hasattr(builtins, 'taskMgr')