def test_01(self): """A saturday morning.""" # A saturday morning t = datetime.datetime(*(2011, 10, 8, 10, 31, 39, 719783)) myRc = RepCode.DTIMEInternal(t) sOut = BaseTestClasses.MockStreamWrite() RepCode.writeDTIME(myRc, sOut)
def test_01(self): """Tests IULONG values write/read.""" for v, b in self.CASES: sOut = BaseTestClasses.MockStreamWrite() RepCode.writeIULONG(v, sOut) self.assertEqual(sOut.bytes, b) sIn = BaseTestClasses.MockStreamRead(sOut.bytes) vR = RepCode.readIULONG(sIn) self.assertEqual(v, vR)
def test_01(self): """Tests IUNORM values write/read.""" for v, b in self.CASES: sOut = TestBase.MockStreamWrite() RepCode.writeIUNORM(v, sOut) self.assertEqual(sOut.bytes, b) sIn = TestBase.MockStreamRead(sOut.bytes) vR = RepCode.readIUNORM(sIn) self.assertEqual(v, vR)
def _indirectTest(self): """Tests edge values write/read - indirect.""" for v, b in self.CASES: sOut = BaseTestClasses.MockStreamWrite() RepCode.writeIndirectRepCode(self.NUM, v, sOut) self.assertEqual(sOut.bytes, b) sIn = BaseTestClasses.MockStreamRead(sOut.bytes) vR = RepCode.readIndirectRepCode(self.NUM, sIn) self.assertEqual(v, vR)
def test_01(self): """Tests STATUS values write/read.""" for v, b in self.CASES: # print('TRACE: v, b:', v, b) sOut = BaseTestClasses.MockStreamWrite() RepCode.writeSTATUS(v, sOut) self.assertEqual(sOut.bytes, b) sIn = BaseTestClasses.MockStreamRead(sOut.bytes) vR = RepCode.readSTATUS(sIn) self.assertEqual(v, vR)
def test_01(self): """Tests USHORT values write/read.""" for v, b in self.CASES: # print('TRACE: v, b:', v, b) sOut = TestBase.MockStreamWrite() RepCode.writeUSHORT(v, sOut) self.assertEqual(sOut.bytes, b) sIn = TestBase.MockStreamRead(sOut.bytes) vR = RepCode.readUSHORT(sIn) self.assertEqual(v, vR)
def test_02(self): """Tests DTIME edge values write/read.""" for v, b in self.CASES: myRc = RepCode.DTIMEInternal(datetime.datetime(*v)) sOut = BaseTestClasses.MockStreamWrite() RepCode.writeDTIME(myRc, sOut) self.assertEqual(b, sOut.bytes) # Read from bytes sIn = BaseTestClasses.MockStreamRead(sOut.bytes) myRc = RepCode.readDTIME(sIn) self.assertEqual(self._datetimeTupleToSeconds(v), myRc.mktime())
def test_01(self): """Tests ASCII edge values write/read.""" for v, b in self.CASES: assert (0) print('TRACE: test_01', v, b) sOut = TestBase.MockStreamWrite() RepCode.writeASCII(v, sOut) self.assertEqual(sOut.bytes, b) sIn = TestBase.MockStreamRead(sOut.bytes) vR = RepCode.readASCII(sIn) self.assertEqual(v, vR)
def __init__(self, theS): super().__init__() self.length = RepCode.readUNORM(theS) # print('TRACE: EncryptionPacketRead.__init__(): length={:d}'.format(self.length)) self.prodCode = RepCode.readULONG(theS) self.transTag = RepCode.readOBNAME(theS) payLen = self.length - RepCode.lenFixedName( 'UNORM') - RepCode.lenFixedName('ULONG') - len(self.transTag) if payLen < 0: raise ExceptionEncryption( 'Negative encryption payload of {:d}'.format(payLen)) self.payload = theS.read(payLen)
def test_12(self): """Tests DTIME edge values write/read - indirect.""" # Can not use generic method as CASES does not contain DTIME objects. for v, b in self.CASES: # Fix up the microseconds to truncate to milleseconds myV = v[:-1] + (1000 * (v[-1] // 1000), ) rc = RepCode.DTIMEInternal(datetime.datetime(*myV)) sOut = BaseTestClasses.MockStreamWrite() RepCode.writeIndirectRepCode(self.NUM, rc, sOut) self.assertEqual(sOut.bytes, b) sIn = BaseTestClasses.MockStreamRead(sOut.bytes) vR = RepCode.readIndirectRepCode(self.NUM, sIn) self.assertEqual(rc._time, vR._time)
def test_01(self): """Tests ASCII edge values write/read.""" for v, b in self.CASES: # assert(0) # print('TRACE: test_01', v, b) sOut = BaseTestClasses.MockStreamWrite() RepCode.writeASCII(v, sOut) self.assertEqual(sOut.bytes, b) sIn = BaseTestClasses.MockStreamRead(sOut.bytes) vR = RepCode.readASCII(sIn) # print() # print(vR.ASCII_CHARS) self.assertEqual(v.payload, vR.payload)
def _readTrailer(self): if self.hasTrailer: if self.hasPadding: self.padCount = RepCode.readULONG(self._stream) else: self.padCount = None if self.hasChecksum: self.checksum = RepCode.readUNORM(self._stream) else: self.checksum = None if self.hasTrailingLength: self.segLenTrail = RepCode.readULONG(self._stream) else: self.segLenTrail = None
def test_01(self): """TestAttrCompBasic.test_01(): Simple creation of a single template object.""" sOut = BaseTestClasses.MockStreamWrite() RepCode.writeIDENT(RepCode.IDENTString(b'WEIGHT'), sOut) # FSINGL is code 2 RepCode.writeUSHORT(2, sOut) RepCode.writeUNITS(RepCode.UNITSString('KG'), sOut) sIn = BaseTestClasses.MockStreamRead(sOut.bytes) myTemplate = AttrComp.AttrCompStream(int('10110', 2), sIn) # print(myTemplate) self.assertEqual(RepCode.IDENTString(b'WEIGHT'), myTemplate.lable) self.assertEqual(b'WEIGHT', myTemplate.lable.payload) self.assertEqual(2, myTemplate.repCode) self.assertEqual(RepCode.UNITSString(b'KG'), myTemplate.units) self.assertEqual(b'KG', myTemplate.units.payload)
def _readHeader(self): myFilePos = self._stream.tell() if self.version == 1: self.segLen = RepCode.readUNORM(self._stream) myAttr = RepCode.readUSHORT(self._stream) self.lrType = RepCode.readUSHORT(self._stream) # Magic number 4 is length of UNORM + USHORT + USHORT self.dataLen = self.segLen - 4 else: self.segLen = RepCode.readULONG(self._stream) myAttr = RepCode.readUNORM(self._stream) self.lrType = None # Magic number 6 is length of ULONG + UNORM self.dataLen = self.segLen - 6 # Attribute error checking, consistency checking self._checkAndSetAttrs(myAttr) self.dataLen -= self.lenTrailer self.segPos = 0 if self.version == 1: print( 'TRACE: LogiData._readHeader(): tell=0x{0:08x} length={1:6d} [0x{1:04x}] attr=0x{2:2x} [{2:8b}] type={3:d}' .format( myFilePos, self.segLen, self.segAttr, self.lrType, )) else: print( 'TRACE: LogiData._readHeader(): tell=0x{0:08x} length={1:6d} [0x{1:04x}] attr=0x{2:2x} [{2:8b}]' .format( myFilePos, self.segLen, self.segAttr, )) if not self.hasPredecessor: # First segment self.filePos = myFilePos # Handle encryption if self.isEncrypted: self.encryptPkt = Encryption.EncryptionPacketRead(self._stream) self.dataLen -= len(self.encryptPkt) else: self.encryptPkt = None if self.dataLen < 0: raise ExceptionLogiData( 'Illegal negative data length of {:d}'.format(self.dataLen)) return True
def _readTrailer(self): """Reads the Visible Record Trailer - not in version 1.""" assert (self.length is not None) if self.version != 1: myLength = RepCode.readULONG(self._stream) if self.length != myLength: raise ExceptionVisRec( 'VisibleRecord.readTrailer(): expected length of {:d}, got {:d}' .format(self.length, myLength))
def __str__(self): return 'lable={:s} count={:s} rc={:s} ({:s}) units={:s} value={:s}'.format( str(self.lable), str(self.count), str(self.repCode), RepCode.codeToName(self.repCode), str(self.units), str(self.value), )
class TestASCII(TestRepCodeBase): """Tests the ASCII Representation Code number 20.""" NUM = 20 CASES = ( (RepCode.ASCIIString(''), b'\x00'), (RepCode.ASCIIString('$ / X'), b'$ / X'), ) def setUp(self): pass def tearDown(self): pass def test_00(self): """Tests ASCII properties in RC_TABLE.""" rte = RepCode.RC_TABLE[self.NUM] self.assertEquals(self.NUM, rte.Code) self.assertEquals('ASCII', rte.SymbolicName) self.assertEquals('Variable-length ASCII character string', rte.Description) self.assertEquals('STRING', rte.Class) self.assertEquals('S', rte.Type) self.assertEquals(-1, rte.Size) @pytest.mark.xfail(reason="RP66 is not fully supported.") def test_01(self): """Tests ASCII edge values write/read.""" for v, b in self.CASES: # assert(0) # print('TRACE: test_01', v, b) sOut = BaseTestClasses.MockStreamWrite() RepCode.writeASCII(v, sOut) self.assertEqual(sOut.bytes, b) sIn = BaseTestClasses.MockStreamRead(sOut.bytes) vR = RepCode.readASCII(sIn) # print() # print(vR.ASCII_CHARS) self.assertEqual(v.payload, vR.payload) @pytest.mark.xfail(reason="RP66 is not fully supported.") def test_02(self): """Tests ASCII edge values write/read - indirect.""" self._indirectTest()
class TestFDOUB2(TestRepCodeBase): """Tests the FDOUB2 Representation Code number 9.""" NUM = 9 CASES = ( (RepCode.FDOUB2Internal(0.0, 0.0, 0.0), b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' ), (RepCode.FDOUB2Internal(153.0, 153.0, 153.0), b'\x40\x63\x20\x00\x00\x00\x00\x00\x40\x63\x20\x00\x00\x00\x00\x00\x40\x63\x20\x00\x00\x00\x00\x00' ), (RepCode.FDOUB2Internal(-153.0, -153.0, -153.0), b'\xc0\x63\x20\x00\x00\x00\x00\x00\xc0\x63\x20\x00\x00\x00\x00\x00\xc0\x63\x20\x00\x00\x00\x00\x00' ), (RepCode.FDOUB2Internal(153.0, -153.0, 153.0), b'\x40\x63\x20\x00\x00\x00\x00\x00\xc0\x63\x20\x00\x00\x00\x00\x00\x40\x63\x20\x00\x00\x00\x00\x00' ), ) def test_00(self): """Tests FDOUB2 properties in RC_TABLE.""" rte = RepCode.RC_TABLE[self.NUM] self.assertEquals(self.NUM, rte.Code) self.assertEquals('FDOUB2', rte.SymbolicName) self.assertEquals('Two-way validated double precision floating point', rte.Description) self.assertEquals('UNBALANCED-INTERVAL', rte.Class) self.assertEquals('C', rte.Type) self.assertEquals(24, rte.Size) def test_01(self): """Tests FDOUB2 values write/read.""" for v, b in self.CASES: sOut = BaseTestClasses.MockStreamWrite() RepCode.writeFDOUB2(v, sOut) self.assertEqual(sOut.bytes, b) sIn = BaseTestClasses.MockStreamRead(sOut.bytes) vR = RepCode.readFDOUB2(sIn) self.assertEqual(v, vR) def test_02(self): """Tests FDOUBL1 edge values write/read - indirect.""" self._indirectTest()
class TestIDENT(TestRepCodeBase): """Tests the IDENT Representation Code number 19.""" NUM = 19 CASES = ( (RepCode.IDENTString(b''), b'\x00'), (RepCode.IDENTString(b'TYPE1'), b'\x05TYPE1'), ) def setUp(self): pass def tearDown(self): pass def test_00(self): """Tests IDENT properties in RC_TABLE.""" rte = RepCode.RC_TABLE[self.NUM] self.assertEquals(self.NUM, rte.Code) self.assertEquals('IDENT', rte.SymbolicName) self.assertEquals('Variable-length identifier', rte.Description) self.assertEquals('STRING', rte.Class) self.assertEquals('S', rte.Type) self.assertEquals(-1, rte.Size) def test_01(self): """Tests IDENT edge values write/read.""" for v, b in self.CASES: sOut = BaseTestClasses.MockStreamWrite() RepCode.writeIDENT(v, sOut) self.assertEqual(sOut.bytes, b) sIn = BaseTestClasses.MockStreamRead(sOut.bytes) vR = RepCode.readIDENT(sIn) self.assertEqual(v, vR) def test_02(self): """Tests IDENT edge values write/read - indirect.""" self._indirectTest()
class TestFSING1(TestRepCodeBase): """Tests the FSING1 Representation Code number 3.""" NUM = 3 CASES = ( (RepCode.FSING1Internal(0.0, 0.0), b'\x00\x00\x00\x00\x00\x00\x00\x00'), (RepCode.FSING1Internal(153.0, 153.0), b'\x43\x19\x00\x00\x43\x19\x00\x00'), (RepCode.FSING1Internal(-153.0, -153.0), b'\xc3\x19\x00\x00\xc3\x19\x00\x00'), ) def test_00(self): """Tests FSING1 properties in RC_TABLE.""" rte = RepCode.RC_TABLE[self.NUM] self.assertEquals(self.NUM, rte.Code) self.assertEquals('FSING1', rte.SymbolicName) self.assertEquals('Validated single precision floating point', rte.Description) self.assertEquals('BALANCED-INTERVAL', rte.Class) self.assertEquals('C', rte.Type) self.assertEquals(8, rte.Size) def test_01(self): """Tests FSING1 values write/read.""" for v, b in self.CASES: sOut = BaseTestClasses.MockStreamWrite() RepCode.writeFSING1(v, sOut) self.assertEqual(sOut.bytes, b) sIn = BaseTestClasses.MockStreamRead(sOut.bytes) vR = RepCode.readFSING1(sIn) self.assertEqual(v, vR) def test_02(self): """Tests FSINGL1 edge values write/read - indirect.""" self._indirectTest()
def read(self, formatBits, theStream): if formatBits & 0x10: self.lable = RepCode.IDENTStream(theStream) if formatBits & 0x8: self.count = RepCode.readUVARI(theStream) # else: # self.count = self.DEFAULT_COUNT if formatBits & 0x4: self.repCode = RepCode.readUSHORT(theStream) # else: # self.repCode = self.DEFAULT_REP_CODE # print('TRACE: self.repCode', self.repCode) if formatBits & 0x2: self.units = RepCode.UNITSStream(theStream) if formatBits & 0x1: if self.count > 1: self.value = [RepCode.readIndirectRepCode(self.repCode, theStream) for i in range(self.count)] else: self.value = RepCode.readIndirectRepCode(self.repCode, theStream)
def _readHeader(self): """Reads the Visible Record header.""" # # If something has been read and not thing more to read # if self.length is not None and self.remaining == 0: # self._readTrailer() self.filePos = self._stream.tell() try: # Version dependent, this is UNORM in version 1 if self.version == 1: self.length = RepCode.readUNORM(self._stream) else: self.length = RepCode.readULONG(self._stream) except File.ExceptionFileReadEOF: return False self.valueFF = RepCode.readUSHORT(self._stream) if self.FIXED_VALUE != self.valueFF: raise ExceptionVisRec( 'VisibleRecord.readHeader(): tell=0x{:x} expected fixed value of 0x{:x}, got 0x{:x}' .format( self._stream.tell(), self.FIXED_VALUE, self.valueFF, )) myV = RepCode.readUSHORT(self._stream) if self.version != myV: raise ExceptionVisRec( 'VisibleRecord.readHeader(): tell=0x{:x} expected version {:d}, got {:d}' .format( self._stream.tell(), self.version, myV, )) # Version dependent, these do not exist in version 1 if self.version != 1: self.fileSeq = RepCode.readULONG(self._stream) self.fileSect = RepCode.readUNORM(self._stream) self.buffPos = self._stream.tell() - self.filePos return True
def test_02(self): """TestAttrCompBasic.test_02(): Creation of a template object and a partial object.""" sOut = BaseTestClasses.MockStreamWrite() RepCode.writeIDENT(RepCode.IDENTString(b'WEIGHT'), sOut) # FSINGL is code 2 RepCode.writeUSHORT(2, sOut) RepCode.writeUNITS(RepCode.UNITSString('KG'), sOut) # print('TRACE: sOut.bytes', sOut.bytes) sIn = BaseTestClasses.MockStreamRead(sOut.bytes) myTemplate = AttrComp.AttrCompStream(int('10110', 2), sIn) # print(myTemplate) self.assertEqual(RepCode.IDENTString(b'WEIGHT'), myTemplate.lable) self.assertEqual(b'WEIGHT', myTemplate.lable.payload) # Now create object sOut = BaseTestClasses.MockStreamWrite() RepCode.writeFSINGL(356.2, sOut) sIn = BaseTestClasses.MockStreamRead(sOut.bytes) myObject = myTemplate.readAsTemplate(int('00001', 2), sIn) # print(myObject) self.assertEqual(RepCode.IDENTString(b'WEIGHT'), myObject.lable) self.assertEqual(b'WEIGHT', myObject.lable.payload) self.assertEqual(1, myObject.count) self.assertEqual(2, myObject.repCode) self.assertEqual(RepCode.UNITSString(b'KG'), myObject.units) self.assertEqual(b'KG', myObject.units.payload) # self.assertEqual(356.2, myObject.value) self.assertAlmostEqual(356.2, myObject.value, 2)