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 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 testGetTimeStamp(self):
test_timestamp = TimeStamp()
self.test_nttable.getTimeStamp(test_timestamp)
test_stamp = TimeStamp()
self.assertGreaterEqual(test_timestamp._diffInt(test_stamp), 0, "Unexpected time stamp value, "
"given time stamp is earlier than default time")
test_stamp.getCurrent()
self.assertLess(test_timestamp._diffInt(test_stamp), 0, "Unexpected time stamp value, "
"given time stamp is in the future")
def __clientRPC(function, params):
alarm = Alarm()
timeStamp = TimeStamp()
ntnv = NTNameValue(function, params)
# now do issue + wait
channelRPC = ChannelRPC("masarService")
channelRPC.issueConnect()
if not channelRPC.waitConnect(1.0):
print "error when waiting connection.", channelRPC.getMessage()
exit(1)
channelRPC.issueRequest(ntnv.getNTNameValue(), False)
result = channelRPC.waitResponse()
if result is None:
print channelRPC.getMessage()
exit(1)
# print "problem to get nttable using getNTTable()"
if function in ["retrieveSnapshot", "getLiveMachine", "saveSnapshot"]:
result = NTMultiChannel(result)
elif function in [
"retrieveServiceEvents", "retrieveServiceConfigs",
"retrieveServiceConfigProps"
]:
result = NTTable(result)
label = result.getLabels()
print "label", label
print result.getPVStructure()
elif function == "updateSnapshotEvent":
result = NTScalar(result)
# print "Problem above"
# print result
result.getAlarm(alarm)
# print alarm
result.getTimeStamp(timeStamp)
# print timeStamp
# numberValues = result.getNumberValues()
# print "numberValues", numberValues
#
# i = 0
# while i < numberValues :
# value = nttable.getValue(i)
# print "value",label[i],value
# i += 1
return result
def __clientRPC(function, params):
alarm = Alarm()
timeStamp = TimeStamp()
ntnv = NTNameValue(function,params)
# now do issue + wait
channelRPC = ChannelRPC("masarService","record[process=true]field()")
channelRPC.issueConnect()
if not channelRPC.waitConnect(1.0) :
print channelRPC.getMessage()
exit(1)
channelRPC.issueRequest(ntnv.getNTNameValue(),False)
result = channelRPC.waitRequest()
if(result==None) :
print channelRPC.getMessage()
exit(1)
nttable = NTTable(result)
print nttable
nttable.getAlarm(alarm.getAlarmPy())
# print alarm;
nttable.getTimeStamp(timeStamp.getTimeStampPy())
# print timeStamp;
# numberValues = nttable.getNumberValues()
# print "numberValues",numberValues
#
# label = nttable.getLabel()
# print "label",label
#
# i = 0
# while i < numberValues :
# value = nttable.getValue(i)
# print "value",label[i],value
# i += 1
return nttable
def ntnv_asserts(self, function, params):
alarm = Alarm()
time_stamp = TimeStamp()
ntnv = NTNameValue(function, params)
self.channelRPC.issueRequest(ntnv.getNTNameValue(), False)
response = self.channelRPC.waitResponse()
self.assertNotEqual(response, None, "ChannelRPC connection failure.")
result = NTMultiChannel(response)
result.getAlarm(alarm)
result.getTimeStamp(time_stamp)
self.assertEqual(3, len(
str(time_stamp).split(":"))) # Timestamp string format test
self.assertIn(alarm.getStatus(), alarm.getStatusChoices())
self.assertIn(alarm.getSeverity(), alarm.getSeverityChoices())
def testNTMultiChannel(self):
result = self.gatherv3data.get()
self.assertTrue(
result, "Connection failed with message: " +
self.gatherv3data.getMessage())
pvstructure = self.gatherv3data.getPVStructure()
ntmultichannel = NTMultiChannel(pvstructure)
alarm = Alarm()
ntmultichannel.getAlarm(alarm)
self.assertIn(alarm.getStatus(), alarm.getStatusChoices())
self.assertIn(alarm.getSeverity(), alarm.getSeverityChoices())
time_stamp = TimeStamp()
ntmultichannel.getTimeStamp(time_stamp)
self.assertEqual(3, len(
str(time_stamp).split(':'))) # Time stamp format test
channel_count = ntmultichannel.getNumberChannel()
self.assertEqual(channel_count, len(self.names))
test_val_list = (0, 1, 'zero', 'one', 10, 'string value', 1.9, (), (),
(), (), (), ())
self.assertEqual(ntmultichannel.getValue(), test_val_list)
self.assertEqual(ntmultichannel.getChannelName(), self.names)
test_connected_list = (1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1)
self.assertEqual(ntmultichannel.getIsConnected(), test_connected_list)
test_severity_list = (3, 0, 3, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3)
self.assertEqual(ntmultichannel.getSeverity(), test_severity_list)
test_status_list = (3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3)
self.assertEqual(ntmultichannel.getStatus(), test_status_list)
test_message_list = ('UDF_ALARM', 'UDF_ALARM', 'UDF_ALARM',
'UDF_ALARM', 'UDF_ALARM', 'UDF_ALARM',
'UDF_ALARM', 'UDF_ALARM', 'UDF_ALARM',
'UDF_ALARM', 'UDF_ALARM', 'UDF_ALARM',
'UDF_ALARM')
self.assertEqual(ntmultichannel.getMessage(), test_message_list)
test_dbrtype_list = (0, 5, 0, 0, 5, 0, 6, 4, 0, 1, 5, 2, 6)
self.assertEqual(ntmultichannel.getDbrType(), test_dbrtype_list)
test_secondspastepoch_list = (631152000, 631152000, 631152000,
631152000, 631152000, 631152000,
631152000, 631152000, 631152000,
631152000, 631152000, 631152000,
631152000)
self.assertEqual(ntmultichannel.getSecondsPastEpoch(),
test_secondspastepoch_list)
test_nanoseconds_list = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
self.assertEqual(ntmultichannel.getNanoseconds(),
test_nanoseconds_list)
test_usertag_list = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
self.assertEqual(ntmultichannel.getUserTag(), test_usertag_list)
self.assertEqual(type(ntmultichannel.getDescriptor()), StringType)
def setUp(self):
self.test_time_stamp = TimeStamp()
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)
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()
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))
# testnameValue.py
#
import time
from masarclient.ntscalar import NTScalar as NTScalar
from masarclient.alarm import Alarm as Alarm
from masarclient.timeStamp import TimeStamp as TimeStamp
from masarclient.control import Control as Control
from masarclient.display import Display as Display
timeStamp = TimeStamp()
alarm = Alarm()
control = Control()
display = Display()
scalar = NTScalar("double")
print scalar
newscalar = scalar.getNTScalar()
print newscalar
print "getTimeStamp"
scalar.getTimeStamp(timeStamp)
print timeStamp
print "getAlarm"
scalar.getAlarm(alarm)
print alarm
print "getControl"
scalar.getControl(control)
print control
print "getDisplay"
def testGetTimeStamp(self):
test_timestamp = TimeStamp()
test_ntscalar = NTScalar("double")
test_ntscalar.getTimeStamp(test_timestamp)
self.assertEqual(3, len(
str(test_timestamp).split(":"))) # Timestamp string format test
# testTimeStamp.py
#
# Copyright - See the COPYRIGHT that is included with this distribution.
# EPICS pvService is distributed subject to a Software License Agreement
# found in file LICENSE that is included with this distribution.
# Author Marty Kraimer 2011.07
import time
from masarclient.timeStamp import TimeStamp as TimeStamp
timeStamp = TimeStamp()
timeStamp.getCurrent()
print "secondsPastEpoch ", timeStamp.getSecondsPastEpoch()
print "epicsSecondsPastEpoch ", timeStamp.getEpicsSecondsPastEpoch()
print "nanoseconds ", timeStamp.getNanoseconds()
print "seconds ", timeStamp.toSeconds()
print "toString", timeStamp
tm = timeStamp.toSeconds()
tupletime = time.localtime(tm)
string = time.strftime("%Y %b %d %H:%M:%S", tupletime)
print string
string = time.strftime("%x", tupletime)
print string
string = time.strftime("%X", tupletime)
print string
string = time.strftime("%c %Z", tupletime)
print string
another = TimeStamp(timeStamp.getSecondsPastEpoch(),
timeStamp.getNanoseconds())
print "seconds ", another.toSeconds()
if not timeStamp == another:
print "timeStamp==another failed"
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 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)
def setUp(self):
self.test_time_stamp = TimeStamp()
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()
# testTimeStamp.py
#
# Copyright - See the COPYRIGHT that is included with this distribution.
# EPICS pvService is distributed subject to a Software License Agreement
# found in file LICENSE that is included with this distribution.
# Author Marty Kraimer 2011.07
import time
from masarclient.timeStamp import TimeStamp as TimeStamp
timeStamp = TimeStamp()
timeStamp.getCurrent()
print "secondsPastEpoch ", timeStamp.getSecondsPastEpoch()
print "epicsSecondsPastEpoch ", timeStamp.getEpicsSecondsPastEpoch()
print "nanoseconds ", timeStamp.getNanoseconds()
print "seconds ", timeStamp.toSeconds()
print "toString", timeStamp
tm = timeStamp.toSeconds()
tupletime = time.localtime(tm)
string = time.strftime("%Y %b %d %H:%M:%S", tupletime)
print string
string = time.strftime("%x", tupletime)
print string
string = time.strftime("%X", tupletime)
print string
string = time.strftime("%c %Z", tupletime)
print string
another = TimeStamp(timeStamp.getSecondsPastEpoch(), timeStamp.getNanoseconds())
print "seconds ", another.toSeconds()
if not timeStamp == another:
print "timeStamp==another failed"
print "seconds ", another.toSeconds()
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)
