Testing instance representation.

1 files changed, 165 insertions, 0 deletions

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__':