Wrote some explicit tests

bilby/gw/series.py

@@ -20,6 +20,12 @@ class CoupledTimeAndFrequencySeries(object):
         self.start_time = start_time
         self._frequency_array_updated = False
         self._time_array_updated = False
+        self._frequency_array = None
+        self._time_array = None
+
+    def __repr__(self):
+        return self.__class__.__name__ + '(duration={}, sampling_frequency={}, start_time={})'\
+            .format(self.duration, self.sampling_frequency, self.start_time)
 
     @property
     def frequency_array(self):
@@ -31,9 +37,11 @@ class CoupledTimeAndFrequencySeries(object):
         """
         if self._frequency_array_updated is False:
             if self.sampling_frequency and self.duration:
-                self.frequency_array = utils.create_frequency_series(
+                self._frequency_array = utils.create_frequency_series(
                     sampling_frequency=self.sampling_frequency,
                     duration=self.duration)
+                self._sampling_frequency, self._duration = \
+                    utils.get_sampling_frequency_and_duration_from_frequency_array(self._frequency_array)
             else:
                 raise ValueError('Can not calculate a frequency series without a '
                                  'legitimate sampling_frequency ({}) or duration ({})'
@@ -63,6 +71,8 @@ class CoupledTimeAndFrequencySeries(object):
                     sampling_frequency=self.sampling_frequency,
                     duration=self.duration,
                     starting_time=self.start_time)
+                self._sampling_frequency, self._duration = \
+                    utils.get_sampling_frequency_and_duration_from_time_array(self._time_array)
             else:
                 raise ValueError('Can not calculate a time series without a '
                                  'legitimate sampling_frequency ({}) or duration ({})'

test/series_test.py

+from __future__ import absolute_import
+import unittest
+import bilby
+import numpy as np
+
+
+class TestCoupledTimeAndFrequencySeries(unittest.TestCase):
+
+    def setUp(self):
+        self.duration = 2
+        self.sampling_frequency = 4096
+        self.start_time = -1
+        self.series = bilby.gw.series.CoupledTimeAndFrequencySeries(duration=self.duration,
+                                                                    sampling_frequency=self.sampling_frequency,
+                                                                    start_time=self.start_time)
+
+    def tearDown(self):
+        del self.duration
+        del self.sampling_frequency
+        del self.start_time
+        del self.series
+
+    def test_repr(self):
+        expected = 'CoupledTimeAndFrequencySeries(duration={}, sampling_frequency={}, start_time={})'\
+            .format(self.series.duration,
+                    self.series.sampling_frequency,
+                    self.series.start_time)
+        self.assertEqual(expected, repr(self.series))
+
+    def test_duration_from_init(self):
+        self.assertEqual(self.duration, self.series.duration)
+
+    def test_sampling_from_init(self):
+        self.assertEqual(self.sampling_frequency, self.series.sampling_frequency)
+
+    def test_start_time_from_init(self):
+        self.assertEqual(self.start_time, self.series.start_time)
+
+    def test_frequency_array_type(self):
+        self.assertIsInstance(self.series.frequency_array, np.ndarray)
+
+    def test_time_array_type(self):
+        self.assertIsInstance(self.series.time_array, np.ndarray)
+
+    def test_frequency_array_from_init(self):
+        expected = bilby.core.utils.create_frequency_series(sampling_frequency=self.sampling_frequency,
+                                                            duration=self.duration)
+        self.assertTrue(np.array_equal(expected, self.series.frequency_array))
+
+    def test_time_array_from_init(self):
+        expected = bilby.core.utils.create_time_series(sampling_frequency=self.sampling_frequency,
+                                                       duration=self.duration,
+                                                       starting_time=self.start_time)
+        self.assertTrue(np.array_equal(expected, self.series.time_array))
+
+    def test_frequency_array_setter(self):
+        new_sampling_frequency = 100
+        new_duration = 3
+        new_frequency_array = bilby.core.utils.create_frequency_series(sampling_frequency=new_sampling_frequency,
+                                                                       duration=new_duration)
+        self.series.frequency_array = new_frequency_array
+        self.assertTrue(np.array_equal(new_frequency_array, self.series.frequency_array))
+        self.assertLessEqual(np.abs(new_sampling_frequency - self.series.sampling_frequency), 1)
+        self.assertAlmostEqual(new_duration, self.series.duration)
+        self.assertAlmostEqual(self.start_time, self.series.start_time)
+
+    def test_time_array_setter(self):
+        new_sampling_frequency = 100
+        new_duration = 3
+        new_start_time = 4
+        new_time_array = bilby.core.utils.create_time_series(sampling_frequency=new_sampling_frequency,
+                                                             duration=new_duration,
+                                                             starting_time=new_start_time)
+        self.series.time_array = new_time_array
+        self.assertTrue(np.array_equal(new_time_array, self.series.time_array))
+        self.assertAlmostEqual(new_sampling_frequency, self.series.sampling_frequency, places=1)
+        self.assertAlmostEqual(new_duration, self.series.duration, places=1)
+        self.assertAlmostEqual(new_start_time, self.series.start_time, places=1)