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)