diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/argaze.test/DataStructures.py | 35 | ||||
| -rw-r--r-- | src/argaze.test/GazeFeatures.py | 165 |
2 files changed, 196 insertions, 4 deletions
diff --git a/src/argaze.test/DataStructures.py b/src/argaze.test/DataStructures.py index 5f0a4ac..c1b78d5 100644 --- a/src/argaze.test/DataStructures.py +++ b/src/argaze.test/DataStructures.py @@ -1,6 +1,7 @@ #!/usr/bin/env python import unittest +from dataclasses import dataclass, field from argaze import DataStructures @@ -27,6 +28,12 @@ def random_data_buffer(size, data_keys): return ts_buffer +@dataclass() +class BasicDataClass(): + """Define a basic dataclass for testing purpose.""" + + value: tuple + class TestTimeStampedBufferClass(unittest.TestCase): """Test TimeStampedBuffer class.""" @@ -56,12 +63,17 @@ class TestTimeStampedBufferClass(unittest.TestCase): DataStructures.TimeStampedBuffer({"first": ""}) - def test_str(self): + def test___repr__(self): """Test TimeStampedBuffer string representation.""" - self.assertEqual(str(DataStructures.TimeStampedBuffer()), "{}") - self.assertEqual(str(DataStructures.TimeStampedBuffer({0: ""})), "{\"0\": \"\"}") - self.assertEqual(str(DataStructures.TimeStampedBuffer({0.1: ""})), "{\"0.1\": \"\"}") + self.assertEqual(repr(DataStructures.TimeStampedBuffer()), "{}") + self.assertEqual(repr(DataStructures.TimeStampedBuffer({0: ""})), "{\"0\": \"\"}") + self.assertEqual(repr(DataStructures.TimeStampedBuffer({0.1: ""})), "{\"0.1\": \"\"}") + + data = BasicDataClass((123, 456)) + ts_buffer = DataStructures.TimeStampedBuffer({0: data}) + + self.assertEqual(repr(ts_buffer), "{\"0\": {\"value\": [123, 456]}}") def test_append(self): """Test TimeStampedBuffer append method.""" @@ -170,6 +182,11 @@ class TestTimeStampedBufferClass(unittest.TestCase): self.assertEqual(ts_buffer_dataframe.columns[1], "data_B") self.assertEqual(ts_buffer_dataframe.columns[2], "data_C") + self.assertEqual(ts_buffer_dataframe.index.dtype, 'float64') + self.assertEqual(ts_buffer_dataframe["data_A"].dtype, 'object') + self.assertEqual(ts_buffer_dataframe["data_B"].dtype, 'object') + self.assertEqual(ts_buffer_dataframe["data_C"].dtype, 'object') + # Check data exclusion option ts_buffer_dataframe = ts_buffer.as_dataframe(exclude=["data_B"]) @@ -192,6 +209,16 @@ class TestTimeStampedBufferClass(unittest.TestCase): self.assertEqual(ts_buffer_dataframe.columns[2], "data_B1") self.assertEqual(ts_buffer_dataframe.columns[3], "data_C") + # Check dataframe conversion with dataclass + data = BasicDataClass((123, 456)) + ts_buffer_dataframe = DataStructures.TimeStampedBuffer({0: data}).as_dataframe() + + self.assertEqual(ts_buffer_dataframe.index.name, "timestamp") + self.assertEqual(ts_buffer_dataframe.index.size, 1) + + self.assertEqual(ts_buffer_dataframe.columns.size, 1) + self.assertEqual(ts_buffer_dataframe.columns[0], "value") + if __name__ == '__main__': unittest.main()
\ No newline at end of file diff --git a/src/argaze.test/GazeFeatures.py b/src/argaze.test/GazeFeatures.py index 692b6cf..5a3c2d9 100644 --- a/src/argaze.test/GazeFeatures.py +++ b/src/argaze.test/GazeFeatures.py @@ -4,6 +4,29 @@ import unittest from argaze import GazeFeatures +import numpy + +def random_gaze_positions(size): + """ Generate random TimeStampedGazePsoitions for testing purpose. + Timestamps are current time. + GazePositions are random values. + """ + + import random + import time + + ts_gaze_positions = GazeFeatures.TimeStampedGazePositions() + + for i in range(0, size): + + # Edit gaze position + random_gaze_position = GazeFeatures.GazePosition((random.random(), random.random())) + + # Store gaze position + ts_gaze_positions[time.time()] = random_gaze_position + + return ts_gaze_positions + class TestGazePositionClass(unittest.TestCase): """Test GazePosition class.""" @@ -12,8 +35,150 @@ class TestGazePositionClass(unittest.TestCase): # Check empty GazePosition empty_gaze_position = GazeFeatures.GazePosition() + self.assertEqual(empty_gaze_position.value, (0, 0)) + self.assertEqual(empty_gaze_position[0], 0) + self.assertEqual(empty_gaze_position[1], 0) + + for v in empty_gaze_position: + self.assertEqual(v, 0) + self.assertEqual(empty_gaze_position.accuracy, 0.) + self.assertEqual(len(empty_gaze_position), 2) + self.assertEqual(empty_gaze_position.valid, True) + self.assertEqual(numpy.array(empty_gaze_position).shape, (2,)) + + # Check integer GazePosition + int_gaze_position = GazeFeatures.GazePosition((123, 456), accuracy=55) + + self.assertEqual(int_gaze_position.value, (123, 456)) + self.assertEqual(int_gaze_position[0], 123) + self.assertEqual(int_gaze_position[1], 456) + self.assertEqual(int_gaze_position.accuracy, 55) + self.assertEqual(len(int_gaze_position), 2) + self.assertEqual(int_gaze_position.valid, True) + self.assertEqual(numpy.array(empty_gaze_position).shape, (2,)) + + # Check float GazePosition + float_gaze_position = GazeFeatures.GazePosition((1.23, 4.56), accuracy=5.5) + + self.assertEqual(float_gaze_position.value, (1.23, 4.56)) + self.assertEqual(float_gaze_position[0], 1.23) + self.assertEqual(float_gaze_position[1], 4.56) + self.assertEqual(float_gaze_position.accuracy, 5.5) + self.assertEqual(len(float_gaze_position), 2) + self.assertEqual(float_gaze_position.valid, True) + self.assertEqual(numpy.array(empty_gaze_position).shape, (2,)) + + def test_properties(self): + """Test GazePosition properties cannot be modified after creation.""" + + gaze_position = GazeFeatures.GazePosition() + + # Check that gaze position value setting fails + with self.assertRaises(AttributeError): + + gaze_position.value = (123, 456) + + self.assertNotEqual(gaze_position.value, (123, 456)) + self.assertEqual(gaze_position.value, (0, 0)) + + def test___repr__(self): + """Test GazePosition string representation.""" + + # Check empty GazePosition representation + self.assertEqual(repr(GazeFeatures.GazePosition()), "{\"value\": [0, 0], \"accuracy\": 0.0}") + +class TestUnvalidGazePositionClass(unittest.TestCase): + """Test UnvalidGazePosition class.""" + + def test_new(self): + """Test UnvalidGazePosition creation.""" + + import math + + unvalid_gaze_position = GazeFeatures.UnvalidGazePosition() + + self.assertEqual(unvalid_gaze_position.value, (None, None)) + self.assertEqual(unvalid_gaze_position.accuracy, None) + self.assertEqual(unvalid_gaze_position.valid, False) + + def test___repr__(self): + """Test UnvalidGazePosition string representation.""" + + self.assertEqual(repr(GazeFeatures.UnvalidGazePosition()), "{\"value\": [null, null], \"accuracy\": null}") + +class TestTimeStampedGazePositionsClass(unittest.TestCase): + """Test TimeStampedGazePositions class.""" + + def test___setitem__(self): + """Test __setitem__ method.""" + + ts_gaze_positions = GazeFeatures.TimeStampedGazePositions() + ts_gaze_positions[0] = GazeFeatures.GazePosition() + ts_gaze_positions[1] = GazeFeatures.UnvalidGazePosition() + + # Check GazePosition is correctly stored and accessible as a GazePosition + self.assertIsInstance(ts_gaze_positions[0], GazeFeatures.GazePosition) + self.assertEqual(ts_gaze_positions[0].valid, True) + + # Check UnvalidGazePosition is correctly stored and accessible as a UnvalidGazePosition + self.assertIsInstance(ts_gaze_positions[1], GazeFeatures.UnvalidGazePosition) + self.assertEqual(ts_gaze_positions[1].valid, False) + + # Check that bad data type insertion fails + with self.assertRaises(AssertionError): + + ts_gaze_positions[2] = "This string is not a gaze position value." + + # Check final lenght + self.assertEqual(len(ts_gaze_positions), 2) + + def test___repr__(self): + """Test inherited string representation.""" + + ts_gaze_positions = GazeFeatures.TimeStampedGazePositions() + + self.assertEqual(repr(GazeFeatures.TimeStampedGazePositions()), "{}") + + ts_gaze_positions[0] = GazeFeatures.GazePosition() + + self.assertEqual(repr(ts_gaze_positions), "{\"0\": {\"value\": [0, 0], \"accuracy\": 0.0}}") + + ts_gaze_positions[0] = GazeFeatures.UnvalidGazePosition() + + self.assertEqual(repr(ts_gaze_positions), "{\"0\": {\"value\": [null, null], \"accuracy\": null}}") + + def test_as_dataframe(self): + """Test inherited as_dataframe method.""" + + ts_gaze_positions_dataframe = random_gaze_positions(10).as_dataframe() + + # Check dataframe conversion + self.assertEqual(ts_gaze_positions_dataframe.index.name, "timestamp") + self.assertEqual(ts_gaze_positions_dataframe.index.size, 10) + + self.assertEqual(ts_gaze_positions_dataframe.columns.size, 2) + self.assertEqual(ts_gaze_positions_dataframe.columns[0], "value") + self.assertEqual(ts_gaze_positions_dataframe.columns[1], "accuracy") + + self.assertEqual(ts_gaze_positions_dataframe["value"].dtype, 'object') + self.assertEqual(ts_gaze_positions_dataframe["accuracy"].dtype, 'float64') + + # Check unvalid position conversion + ts_gaze_positions = GazeFeatures.TimeStampedGazePositions() + ts_gaze_positions[0] = GazeFeatures.UnvalidGazePosition() + ts_gaze_positions_dataframe = ts_gaze_positions.as_dataframe() + + self.assertEqual(ts_gaze_positions_dataframe.index.name, "timestamp") + self.assertEqual(ts_gaze_positions_dataframe.index.size, 1) + + self.assertEqual(ts_gaze_positions_dataframe.columns.size, 2) + self.assertEqual(ts_gaze_positions_dataframe.columns[0], "value") + self.assertEqual(ts_gaze_positions_dataframe.columns[1], "accuracy") + + self.assertEqual(ts_gaze_positions_dataframe["value"].dtype, 'object') + self.assertEqual(ts_gaze_positions_dataframe["accuracy"].dtype, 'O') # Python object type if __name__ == '__main__': |