Example #1
0
print "seconds ", another.toSeconds()
if not timeStamp == another:
    print "timeStamp==another failed"
print "seconds ", another.toSeconds()
another.add(1.1)
print " after += 1.1 seconds ", another.toSeconds()
if timeStamp == another:
    print "timeStamp==another failed"
if not timeStamp < another:
    print "timeStamp==another failed"
if not timeStamp <= another:
    print "timeStamp<=another failed"
if timeStamp > another:
    print "timeStamp>another failed"
if timeStamp >= another:
    print "timeStamp>=another failed"
diff = another.toSeconds() - timeStamp.toSeconds()
print "diff", diff
another.sub(0.1)
diff = another.toSeconds() - timeStamp.toSeconds()
print "diff", diff
milli = timeStamp.getMilliseconds()
print "timeStamp milli ", milli
another.putMilliseconds(milli)
print "another milli ", another.getMilliseconds()
diff = another.toSeconds() - timeStamp.toSeconds()
print "diff", diff


print "all done"
Example #2
0
                    timeStamp.getNanoseconds())
print "seconds ", another.toSeconds()
if not timeStamp == another:
    print "timeStamp==another failed"
print "seconds ", another.toSeconds()
another.add(1.1)
print " after += 1.1 seconds ", another.toSeconds()
if timeStamp == another:
    print "timeStamp==another failed"
if not timeStamp < another:
    print "timeStamp==another failed"
if not timeStamp <= another:
    print "timeStamp<=another failed"
if timeStamp > another:
    print "timeStamp>another failed"
if timeStamp >= another:
    print "timeStamp>=another failed"
diff = another.toSeconds() - timeStamp.toSeconds()
print "diff", diff
another.sub(.1)
diff = another.toSeconds() - timeStamp.toSeconds()
print "diff", diff
milli = timeStamp.getMilliseconds()
print "timeStamp milli ", milli
another.putMilliseconds(milli)
print "another milli ", another.getMilliseconds()
diff = another.toSeconds() - timeStamp.toSeconds()
print "diff", diff

print "all done"
Example #3
0
class TestTimeStamp(unittest.TestCase):
    '''
    Sets up test variable for each test.
    '''
    def setUp(self):
        self.test_time_stamp = TimeStamp()
        #self.test_time_stamp.getCurrent()

    '''
    Tests getter for time at the point of request
    '''

    def testGetCurrent(self):
        self.test_time_stamp.getCurrent()
        self.assertGreater(self.test_time_stamp.toSeconds(), 0.0)
        test_stamp_two = TimeStamp()
        test_stamp_two.getCurrent()
        self.assertGreaterEqual(test_stamp_two, self.test_time_stamp)

    '''
    This test can not confirm time frame, so it will just ensure the function doesn't crash
    '''

    def testGetSecondsPastEpoch(self):
        self.test_time_stamp.getCurrent()
        self.assertGreater(self.test_time_stamp.getSecondsPastEpoch(), 0.0)

    '''
    This test can not confirm time frame, so it will just ensure the function doesn't crash
    '''

    def testGetEpicsSecondsPastEpoch(self):
        self.test_time_stamp.getCurrent()
        self.assertGreater(self.test_time_stamp.getEpicsSecondsPastEpoch(),
                           0.0)

    '''
    Test confirms operation of timeStamp.getNanoseconds() and performs logical test to ensure a reasonable result.
    Impossible to confirm actual time in nanoseconds.
    '''

    def testGetNanoseconds(self):
        test_stamp_nanoseconds = self.test_time_stamp.getNanoseconds()
        self.test_time_stamp.getCurrent()
        self.assertGreater(self.test_time_stamp.getNanoseconds(),
                           test_stamp_nanoseconds)

    '''
    Test confirms operation of timeStamp.toSeconds() and performs logical test to ensure a reasonable result.
    '''

    def testToSeconds(self):
        test_stamp_seconds = self.test_time_stamp.toSeconds()
        self.test_time_stamp.getCurrent()
        self.assertGreaterEqual(self.test_time_stamp.toSeconds(),
                                test_stamp_seconds)

    '''
    Ensures toString does not fail and properly returns a string
    '''

    def testToString(self):
        self.assertEqual(type(self.test_time_stamp.__str__()), StringType)

    '''
    This may be a bad test. This could result could be unintended.
    '''

    def testUserTag(self):
        self.assertEqual(type(self.test_time_stamp.getUserTag()), int)

    '''
    Tests method to set current time. Test could be expanded but would cause delays in run time.
    '''

    def testPut(self):
        for test_value_seconds in range(0, 100):
            for test_value_nanoseconds in range(0, 100):
                self.test_time_stamp.put(test_value_seconds,
                                         test_value_nanoseconds)
                self.assertEqual(self.test_time_stamp.getNanoseconds(),
                                 test_value_nanoseconds)
                # Some variance is applied to the following test
                # it appears this variance does not typically exceed +/- .00000001
                self.assertTrue(
                    self.test_time_stamp.toSeconds() + .1 >= test_value_seconds
                    >= self.test_time_stamp.toSeconds() - .1)

    '''
    Tests method to set current time in milliseconds, test range was chosen arbitrarily
    '''

    def testPutMilliseconds(self):
        for test_value_milliseconds in range(0, 1000):
            self.test_time_stamp.putMilliseconds(test_value_milliseconds)
            self.assertEqual(test_value_milliseconds,
                             self.test_time_stamp.getMilliseconds())

    '''
    Tests non-default constructor. Test ranges chosen arbitrarily, increasing scale slows test significantly
    '''

    def testNonDefaultConstructor(self):
        for test_value_seconds in range(0, 100):
            for test_value_nanoseconds in range(0, 100):
                self.test_time_stamp = TimeStamp(test_value_seconds,
                                                 test_value_nanoseconds)
                self.assertEqual(self.test_time_stamp.getNanoseconds(),
                                 test_value_nanoseconds)
                self.assertGreaterEqual(self.test_time_stamp.toSeconds() + .1,
                                        test_value_seconds)
                self.assertGreaterEqual(test_value_seconds,
                                        self.test_time_stamp.toSeconds() - .1)

    def testNormalize(self):
        time_stamp = TimeStamp(1, 1000000000)
        self.assertEqual(time_stamp.getNanoseconds(), 0)
        self.assertEqual(time_stamp.getSecondsPastEpoch(), 2)
        time_stamp = TimeStamp(1, 999999999)
        self.assertEqual(time_stamp.getNanoseconds(), 999999999)
        self.assertEqual(time_stamp.getSecondsPastEpoch(), 1)
        time_stamp = TimeStamp(1, -1000000000)
        self.assertEqual(time_stamp.getSecondsPastEpoch(), 0)
        self.assertEqual(time_stamp.getNanoseconds(), 0)
        time_stamp = TimeStamp(1, -999999999)
        self.assertEqual(time_stamp.getSecondsPastEpoch(), 0)
        self.assertEqual(time_stamp.getNanoseconds(), 1)

    def testOperators(self):
        self.assertTrue(TimeStamp(1, 0) == TimeStamp(0, 1000000000))
        self.assertFalse(TimeStamp(1, 0) == TimeStamp(1, -1000000000))
        self.assertFalse(TimeStamp(2, 0) == TimeStamp(3, -999999999))

        self.assertTrue(TimeStamp(1, 0) != TimeStamp(1, -1000000000))
        self.assertFalse(TimeStamp(1, 1) != TimeStamp(0, 1000000001))
        self.assertFalse(TimeStamp(1, 0) != TimeStamp(2, -1000000000))

        self.assertTrue(TimeStamp(1, 0) > TimeStamp(1, -1))
        self.assertFalse(TimeStamp(0, 999999999) > TimeStamp(1, -1))
        self.assertFalse(TimeStamp(1, -1) > TimeStamp(0, 1000000000))

        self.assertTrue(TimeStamp(1, 1) < TimeStamp(2, -999999998))
        self.assertFalse(TimeStamp(0, 999999999) < TimeStamp(1, -2))
        self.assertFalse(TimeStamp(0, 999999999) < TimeStamp(1, -1))

        self.assertTrue(TimeStamp(1, 0) >= TimeStamp(2, -1000000001))
        self.assertTrue(TimeStamp(1, 0) >= TimeStamp(2, -1000000000))
        self.assertFalse(TimeStamp(2, 0) >= TimeStamp(1, 1000000001))

        self.assertTrue(TimeStamp(1, 1000000000) <= TimeStamp(1, 1000000001))
        self.assertTrue(TimeStamp(1, -1) <= TimeStamp(2, -1000000001))
        self.assertFalse(TimeStamp(1, 1000000001) <= TimeStamp(2, 0))

    if __name__ == '__main__':
        unittest.main()
class TestTimeStamp(unittest.TestCase):

    '''
    Sets up test variable for each test.
    '''
    def setUp(self):
        self.test_time_stamp = TimeStamp()
        #self.test_time_stamp.getCurrent()

    '''
    Tests getter for time at the point of request
    '''
    def testGetCurrent(self):
        self.test_time_stamp.getCurrent()
        self.assertGreater(self.test_time_stamp.toSeconds(), 0.0)
        test_stamp_two = TimeStamp()
        test_stamp_two.getCurrent()
        self.assertGreaterEqual(test_stamp_two, self.test_time_stamp)

    '''
    This test can not confirm time frame, so it will just ensure the function doesn't crash
    '''
    def testGetSecondsPastEpoch(self):
        self.test_time_stamp.getCurrent()
        self.assertGreater(self.test_time_stamp.getSecondsPastEpoch(), 0.0)

    '''
    This test can not confirm time frame, so it will just ensure the function doesn't crash
    '''
    def testGetEpicsSecondsPastEpoch(self):
        self.test_time_stamp.getCurrent()
        self.assertGreater(self.test_time_stamp.getEpicsSecondsPastEpoch(), 0.0)

    '''
    Test confirms operation of timeStamp.getNanoseconds() and performs logical test to ensure a reasonable result.
    Impossible to confirm actual time in nanoseconds.
    '''
    def testGetNanoseconds(self):
        test_stamp_nanoseconds = self.test_time_stamp.getNanoseconds()
        self.test_time_stamp.getCurrent()
        self.assertGreater(self.test_time_stamp.getNanoseconds(), test_stamp_nanoseconds)

    '''
    Test confirms operation of timeStamp.toSeconds() and performs logical test to ensure a reasonable result.
    '''
    def testToSeconds(self):
        test_stamp_seconds = self.test_time_stamp.toSeconds()
        self.test_time_stamp.getCurrent()
        self.assertGreaterEqual(self.test_time_stamp.toSeconds(), test_stamp_seconds)

    '''
    Ensures toString does not fail and properly returns a string
    '''
    def testToString(self):
        self.assertEqual(type(self.test_time_stamp.__str__()), StringType)

    '''
    This may be a bad test. This could result could be unintended.
    '''
    def testUserTag(self):
        self.assertEqual(type(self.test_time_stamp.getUserTag()), int)

    '''
    Tests method to set current time. Test could be expanded but would cause delays in run time.
    '''
    def testPut(self):
        for test_value_seconds in range(0, 100):
            for test_value_nanoseconds in range(0, 100):
                self.test_time_stamp.put(test_value_seconds, test_value_nanoseconds)
                self.assertEqual(self.test_time_stamp.getNanoseconds(), test_value_nanoseconds)
                # Some variance is applied to the following test
                # it appears this variance does not typically exceed +/- .00000001
                self.assertTrue(self.test_time_stamp.toSeconds()+.1 >= test_value_seconds >= self.test_time_stamp.toSeconds()-.1)

    '''
    Tests method to set current time in milliseconds, test range was chosen arbitrarily
    '''
    def testPutMilliseconds(self):
        for test_value_milliseconds in range(0, 1000):
            self.test_time_stamp.putMilliseconds(test_value_milliseconds)
            self.assertEqual(test_value_milliseconds, self.test_time_stamp.getMilliseconds())

    '''
    Tests non-default constructor. Test ranges chosen arbitrarily, increasing scale slows test significantly
    '''
    def testNonDefaultConstructor(self):
        for test_value_seconds in range(0, 100):
            for test_value_nanoseconds in range(0, 100):
                self.test_time_stamp = TimeStamp(test_value_seconds, test_value_nanoseconds)
                self.assertEqual(self.test_time_stamp.getNanoseconds(), test_value_nanoseconds)
                self.assertGreaterEqual(self.test_time_stamp.toSeconds()+.1, test_value_seconds)
                self.assertGreaterEqual(test_value_seconds, self.test_time_stamp.toSeconds()-.1)

    def testNormalize(self):
        time_stamp = TimeStamp(1, 1000000000)
        self.assertEqual(time_stamp.getNanoseconds(), 0)
        self.assertEqual(time_stamp.getSecondsPastEpoch(), 2)
        time_stamp = TimeStamp(1, 999999999)
        self.assertEqual(time_stamp.getNanoseconds(), 999999999)
        self.assertEqual(time_stamp.getSecondsPastEpoch(), 1)
        time_stamp = TimeStamp(1, -1000000000)
        self.assertEqual(time_stamp.getSecondsPastEpoch(), 0)
        self.assertEqual(time_stamp.getNanoseconds(), 0)
        time_stamp = TimeStamp(1, -999999999)
        self.assertEqual(time_stamp.getSecondsPastEpoch(), 0)
        self.assertEqual(time_stamp.getNanoseconds(), 1)

    def testOperators(self):
        self.assertTrue(TimeStamp(1, 0) == TimeStamp(0, 1000000000))
        self.assertFalse(TimeStamp(1, 0) == TimeStamp(1, -1000000000))
        self.assertFalse(TimeStamp(2, 0) == TimeStamp(3, -999999999))

        self.assertTrue(TimeStamp(1, 0) != TimeStamp(1, -1000000000))
        self.assertFalse(TimeStamp(1, 1) != TimeStamp(0, 1000000001))
        self.assertFalse(TimeStamp(1, 0) != TimeStamp(2, -1000000000))

        self.assertTrue(TimeStamp(1, 0) > TimeStamp(1, -1))
        self.assertFalse(TimeStamp(0, 999999999) > TimeStamp(1, -1))
        self.assertFalse(TimeStamp(1, -1) > TimeStamp(0, 1000000000))

        self.assertTrue(TimeStamp(1, 1) < TimeStamp(2, -999999998))
        self.assertFalse(TimeStamp(0, 999999999) < TimeStamp(1, -2))
        self.assertFalse(TimeStamp(0, 999999999) < TimeStamp(1, -1))

        self.assertTrue(TimeStamp(1, 0) >= TimeStamp(2, -1000000001))
        self.assertTrue(TimeStamp(1, 0) >= TimeStamp(2, -1000000000))
        self.assertFalse(TimeStamp(2, 0) >= TimeStamp(1, 1000000001))

        self.assertTrue(TimeStamp(1, 1000000000) <= TimeStamp(1, 1000000001))
        self.assertTrue(TimeStamp(1, -1) <= TimeStamp(2, -1000000001))
        self.assertFalse(TimeStamp(1, 1000000001) <= TimeStamp(2, 0))

    if __name__ == '__main__':
        unittest.main()