def test_missingRequiredDateTimes(self):
"""
A warning should be raised if a blockette misses a required date.
"""
# blockette 10 - missing start time
b010 = b"0100034 2.408~2038,001~2009,001~~~"
# strict raises an exception
blockette = Blockette010(strict=True)
self.assertRaises(SEEDParserException, blockette.parse_SEED, b010)
# If strict is false, a warning is raised. This is tested in
# test_bug165.
with warnings.catch_warnings(record=True):
warnings.simplefilter("ignore", UserWarning)
blockette = Blockette010()
blockette.parse_SEED(b010)
self.assertEqual(b010, blockette.get_SEED())
# blockette 10 - missing volume time
b010 = b"0100034 2.4082008,001~2038,001~~~~"
# strict raises an exception
blockette = Blockette010(strict=True)
self.assertRaises(SEEDParserException, blockette.parse_SEED, b010)
# non-strict
blockette = Blockette010()
# The warning cannot be tested due to being issued only once.
# A similar case is tested in test_bug165.
blockette.parse_SEED(b010)
self.assertEqual(b010, blockette.get_SEED())
def test_compare_blockettes(self):
"""
Tests the comparison of two blockettes.
"""
p = Parser()
b010_1 = b"0100042 2.4082008,001~2038,001~2009,001~~~"
blockette1 = Blockette010(strict=True, compact=True,
xseed_version='1.0')
blockette1.parse_seed(b010_1)
blockette2 = Blockette010()
blockette2.parse_seed(b010_1)
b010_3 = b"0100042 2.4082009,001~2038,001~2009,001~~~"
blockette3 = Blockette010(strict=True, compact=True)
blockette3.parse_seed(b010_3)
blockette4 = Blockette010(xseed_version='1.0')
blockette4.parse_seed(b010_3)
self.assertTrue(p._compare_blockettes(blockette1, blockette2))
self.assertFalse(p._compare_blockettes(blockette1, blockette3))
self.assertFalse(p._compare_blockettes(blockette2, blockette3))
self.assertTrue(p._compare_blockettes(blockette3, blockette4))
def test_multipleContinuedStationControlHeader(self):
"""
"""
# create a valid blockette 010 with record length 256
b010 = b"0100042 2.4082008,001~2038,001~2009,001~~~"
blockette = Blockette010(strict=True, compact=True)
blockette.parse_SEED(b010)
self.assertEqual(b010, blockette.get_SEED())
# create a valid blockette 054
b054 = b"0540960A0400300300000039"
nr = b""
for i in range(0, 78):
# 960 chars
nr = nr + ("+1.000%02dE-03" % i).encode('ascii', 'strict')
blockette = Blockette054(strict=True, compact=True)
blockette.parse_SEED(b054 + nr)
self.assertEqual(b054 + nr, blockette.get_SEED())
# create a blockette 051
b051 = b'05100271999,123~~0001000000'
blockette = Blockette051(strict=False)
# ignore user warning
with warnings.catch_warnings(record=True):
warnings.simplefilter("ignore")
blockette.parse_SEED(b051)
# combine data (each line equals 256 chars)
data = b"000001V " + b010 + (b' ' * 206)
data += b"000002S " + b054 + nr[0:224] # 256-8-24 = 224
data += b"000003S*" + nr[224:472] # 256-8 = 248
data += b"000004S*" + nr[472:720]
data += b"000005S*" + nr[720:] + b051 + b' ' * 5 # 5 spaces left
self.assertEqual(len(data), 256 * 5)
data += b"000006S " + b054 + nr[0:224] # 256-8-24 = 224
data += b"000007S*" + nr[224:472] # 256-8 = 248
data += b"000008S*" + nr[472:720]
data += b"000009S*" + nr[720:] + b' ' * 32 # 32 spaces left
self.assertEqual(len(data), 256 * 9)
# read records
parser = Parser(strict=False)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
parser.read(data)
# check results
self.assertEqual(sorted(parser.blockettes.keys()), [10, 51, 54])
self.assertEqual(len(parser.blockettes[10]), 1)
self.assertEqual(len(parser.blockettes[51]), 1)
self.assertEqual(len(parser.blockettes[54]), 2)
def test_blocketteStartsAfterRecord(self):
"""
'... 058003504 1.00000E+00 0.00000E+0000 000006S*0543864 ... '
' 0543864' -> results in Blockette 005
"""
# create a valid blockette 010 with record length 256
b010 = b"0100042 2.4082008,001~2038,001~2009,001~~~"
blockette = Blockette010(strict=True, compact=True)
blockette.parse_SEED(b010)
self.assertEqual(b010, blockette.get_SEED())
# create a valid blockette 054
b054 = b"0540240A0400300300000009" + (b"+1.58748E-03" * 18)
blockette = Blockette054(strict=True, compact=True)
blockette.parse_SEED(b054)
self.assertEqual(b054, blockette.get_SEED())
# combine data
data = b"000001V " + b010 + (b' ' * 206)
data += b"000002S " + b054 + (b' ' * 8)
data += b"000003S*" + b054 + (b' ' * 8)
# read records
parser = Parser(strict=True)
parser.read(data)
