def test_message_bad_binary_length(self): """ Test for message with missing binary data """ parser = FIXParser(self.receiver, header_fields=[8, 9], binary_fields=[1000], max_length=100) # length too short with self.assertRaises(FIXParserError): parser.on_data_received(to_fix('8=FIX.4.2', '9=32', '42=A', '1000=2', '1001=abababababab', '10=000')) # length too long # This will not raise an error parser.on_data_received(to_fix('8=FIX.4.2', '9=32', '42=A', '1000=20', '1001=ab', '10=000')) self.assertEquals(0, self.receiver.count) self.assertTrue(parser.is_parsing)
def test_bad_binary_fields(self): """ Test bad binary fields """ parser = FIXParser(self.receiver, binary_fields=[1000], header_fields=[8, 9]) # Missing binary value portion of binary field # BUGBUG: This can cause some problems, because the parser # does not attempt to validate until the entire # field has been read in. Which this will fail because # the length goes past the end of the message. # For now, live with this. with self.assertRaises(FIXParserError): parser.on_data_received(to_fix('8=FIX.4.2', '9=32', '1000=5', '999=11', '10=001')) # Missing binary length portion (the only time this # really impacts something is if the field has an # embedded \x01). with self.assertRaises(FIXParserError): parser.on_data_received(to_fix('8=FIX.4.2', '9=32', '1001=1010\x011010', '10=001')) parser.on_data_received(to_fix('8=FIX.4.2', '9=14', '1001=10101010', '10=127')) self.assertIsNone(self.receiver.last_error) self.assertEquals(1, self.receiver.count) self.assertIsNotNone(self.receiver.last_received_message)
def test_partial_binary_data(self): """ Receive a piece of binary data split into two parts """ parser = FIXParser(self.receiver, binary_fields=[99], header_fields=[8, 9]) text = to_fix('8=FIX.4.2', '9=38', '35=A') + '99=5\x01100=12' text2 = to_fix('345', '919=this', '955=that', '10=198') parser.on_data_received(text) self.assertTrue(parser.is_parsing) parser.on_data_received(text2) self.assertFalse(parser.is_parsing) self.assertEquals(1, self.receiver.count) message = self.receiver.last_received_message self.assertIsNotNone(message) self.assertEquals(8, len(message)) self.assertTrue(message.verify(fields=[(8, 'FIX.4.2'), (9, '38'), (35, 'A'), (99, '5'), (100, '12345'), (919, 'this'), (955, 'that'), (10, '198')]))
def test_nested_group_from_list(self): """ Call to_binary() on a nested grouped message from a list """ # As its difficult to test this, convert the (unordered) # dict into an OrderedDict() before inserting (sorting by tag). # This makes it easier to do the comparison. mess = FIXMessage(header_fields=[8, 9], source=to_ordered_dict([(8, 'FIX.4.2'), (100, [{ 101: 'abc', 102: 'def' }, { 101: 'ghi', 103: 'jkl' }, { 101: 'mno', 200: [{ 201: 'aaa', 202: 'bbb' }] }]), (99, 'X')])) self.assertEquals( to_fix('8=FIX.4.2', '9=73', '100=3', '101=abc', '102=def', '101=ghi', '103=jkl', '101=mno', '200=1', '201=aaa', '202=bbb', '99=X', '10=034'), mess.to_binary())
def test_simple_message(self): """ Basic function test. """ parser = FIXParser(self.receiver, header_fields=[8, 9]) self.assertFalse(parser.is_parsing) # message taken from wikipedia article parser.on_data_received(to_fix('8=FIX.4.2', '9=65', '35=A', '49=SERVER', '56=CLIENT', '34=177', '52=20090107-18:15:16', '98=0', '108=30', '10=062')) self.assertFalse(parser.is_parsing) self.assertEquals(1, self.receiver.count) message = self.receiver.last_received_message self.assertIsNotNone(message) self.assertEquals(10, len(message)) self.assertTrue(message.verify(fields=[(8, 'FIX.4.2'), (9, '65'), (35, 'A'), (10, '062')]))
def test_bad_protocol_version(self): """ Send a bad protocol_version through the protocol. """ with self.assertRaises(FIXDataError) as context: self.protocol.on_data_received( to_fix('8=FIX.X.X', '9=25', '35=A', '49=server', '56=client', '10=152')) self.assertEquals(8, context.exception.reference_id)
def test_bad_checksum(self): """ Send a message with an incorrect checksum field (10). """ with self.assertRaises(FIXDataError) as context: self.protocol.on_data_received( to_fix('8=FIX.4.2', '9=25', '35=A', '49=server', '56=client', '10=000')) self.assertEquals(10, context.exception.reference_id)
def test_to_binary(self): mess = FIXMessage() mess[8] = 'FIX.4.2' mess[9] = '---' mess[35] = 'A' mess[49] = 'SERVER' mess[56] = 'CLIENT' mess[34] = 177 mess[52] = '20090107-18:15:16' mess[98] = 0 mess[108] = 30 mess[10] = '---' data = mess.to_binary() # BodyLength(9) and Checksum(10) should be updated after # the to_binary() was called. self.assertEquals('65', mess[9]) self.assertEquals('062', mess[10]) self.assertEquals(to_fix('8=FIX.4.2', '9=65', '35=A', '49=SERVER', '56=CLIENT', '34=177', '52=20090107-18:15:16', '98=0', '108=30', '10=062'), data)
def test_multiple_message(self): """ Receive two messages in one data buffer """ parser = FIXParser(self.receiver, header_fields=[8, 9]) self.assertFalse(parser.is_parsing) parser.on_data_received(to_fix('8=FIX.4.2', '9=5', '35=A', '10=178', '8=FIX.4.2', '9=17', '35=E', '99=forsooth', '10=013')) self.assertFalse(parser.is_parsing) self.assertEquals(2, self.receiver.count) message = self.receiver.last_received_message self.assertIsNotNone(message) self.assertEquals(5, len(message)) self.assertTrue(message.verify(fields=[(8, 'FIX.4.2'), (9, '17'), (35, 'E'), (99, 'forsooth'), (10, '013')]))
def test_one_byte_at_a_time(self): """ Receive a message split up into single bytes """ parser = FIXParser(self.receiver, header_fields=[8, 9]) text = to_fix('8=FIX.4.2', '9=23', '35=A', '919=this', '955=that', '10=013') for c in text: parser.on_data_received(c) self.assertFalse(parser.is_parsing) self.assertEquals(1, self.receiver.count) message = self.receiver.last_received_message self.assertIsNotNone(message) self.assertEquals(6, len(message)) self.assertTrue(message.verify(fields=[(8, 'FIX.4.2'), (9, '23'), (35, 'A'), (919, 'this'), (955, 'that'), (10, '013')]))
def test_nested_group_from_list(self): """ Call to_binary() on a nested grouped message from a list """ # As its difficult to test this, convert the (unordered) # dict into an OrderedDict() before inserting (sorting by tag). # This makes it easier to do the comparison. mess = FIXMessage( header_fields=[8, 9], source=to_ordered_dict([(8, 'FIX.4.2'), (100, [{101: 'abc', 102: 'def'}, {101: 'ghi', 103: 'jkl'}, {101: 'mno', 200: [ {201: 'aaa', 202: 'bbb'}]}]), (99, 'X')])) self.assertEquals(to_fix('8=FIX.4.2', '9=73', '100=3', '101=abc', '102=def', '101=ghi', '103=jkl', '101=mno', '200=1', '201=aaa', '202=bbb', '99=X', '10=034'), mess.to_binary())
def test_multiple_nested_groups(self): """ Test the receiving of multiple nested groups """ parser = FIXParser(self.receiver, debug=True, group_fields={100: [101, 102, 200], 200: [201, 202], }, header_fields=[8, 9]) parser.on_data_received(to_fix('8=FIX.4.2', '9=60', '100=2', '101=a', '102=b', '200=2', '201=abc', '202=def', '201=zzz', '101=c', '102=d', '10=002')) self.assertEquals(1, self.receiver.count) message = self.receiver.last_received_message print message.store self.assertIsNotNone(message) self.assertEquals(4, len(message)) self.assertTrue(100 in message) self.assertEquals(2, len(message[100])) group = message[100] self.assertIsNotNone(group) self.assertEquals(2, len(group)) self.assertEquals(3, len(group[0])) self.assertTrue(101 in group[0]) self.assertTrue(102 in group[0]) self.assertTrue(200 in group[0]) self.assertEquals('a', group[0][101]) self.assertEquals('b', group[0][102]) self.assertEquals(2, len(group[1])) self.assertTrue(101 in group[1]) self.assertTrue(102 in group[1]) self.assertTrue(200 not in group[1]) self.assertEquals('c', group[1][101]) self.assertEquals('d', group[1][102]) subgroup = group[0] self.assertIsNotNone(subgroup) self.assertEquals(3, len(subgroup)) self.assertEquals(2, len(subgroup[200])) subgroup200 = subgroup[200] self.assertEquals(2, len(subgroup200[0])) self.assertTrue(201 in subgroup200[0]) self.assertTrue(202 in subgroup200[0]) self.assertEquals('abc', subgroup200[0][201]) self.assertEquals('def', subgroup200[0][202]) self.assertEquals(1, len(subgroup200[1])) self.assertTrue(201 in subgroup200[1]) self.assertTrue(202 not in subgroup200[1]) self.assertEquals('zzz', subgroup200[1][201])
def test_simple_group_fields(self): """ Simple group field testing. """ parser = FIXParser(self.receiver, group_fields={100: [101, 102, 200], 200: [201, 202], }, header_fields=[8, 9]) parser.on_data_received(to_fix('8=FIX.4.2', '9=18', '100=1', '101=a', '102=b', '10=099')) self.assertEquals(1, self.receiver.count) message = self.receiver.last_received_message self.assertIsNotNone(message) self.assertEquals(4, len(message)) self.assertTrue(100 in message) self.assertEquals(1, len(message[100])) group = message[100] self.assertIsNotNone(group) self.assertEquals(1, len(group)) self.assertEquals(2, len(group[0])) self.assertTrue(101 in group[0]) self.assertTrue(102 in group[0]) self.assertEquals('a', group[0][101]) self.assertEquals('b', group[0][102])
def test_group_from_list(self): """ Call to_binary() on a grouped message from a list """ mess = FIXMessage(header_fields=[8, 9], source=[(8, 'FIX.4.2'), (9, '25'), (49, 'SERVER'), (56, 'CLIENT'), (99, 'X')]) self.assertEquals( to_fix('8=FIX.4.2', '9=25', '49=SERVER', '56=CLIENT', '99=X', '10=239'), mess.to_binary())
def test_message_too_large(self): """ Test for too long message """ parser = FIXParser(self.receiver, header_fields=[8, 9], max_length=100) with self.assertRaises(FIXLengthTooLongError): parser.on_data_received(to_fix('8=FIX.4.2', '9=32', '42=A' + 'BB'*100))
def test_checksum(self): self.assertEquals(1, checksum('\x01')) self.assertEquals(2, checksum('\x01\x01')) self.assertEquals(2, checksum('\xFF\x03')) # example taken from wikipedia self.assertEquals( 62, checksum( to_fix('8=FIX.4.2', '9=65', '35=A', '49=SERVER', '56=CLIENT', '34=177', '52=20090107-18:15:16', '98=0', '108=30')))
def test_message_starts_incorrectly(self): """ Message must start with tag 8 """ parser = FIXParser(self.receiver, header_fields=[8, 9]) # message does not start with tag 8 with self.assertRaises(FIXParserError): parser.on_data_received(to_fix('18=FIX.4.2', '9=32', '8=FIX.4.2', '35=A', '10=100')) # unexpected tag 8 with self.assertRaises(FIXParserError): parser.on_data_received(to_fix('8=FIX.4.2', '9=32', '8=abcdef', '35=A', '10=100'))
def test_to_binary_binarydata(self): mess = FIXMessage(header_fields=[8, 9]) mess[8] = 'FIX.4.2' mess[9] = '---' mess[110] = 2 mess[111] = '\x01\x02a\xbbbcd' data = mess.to_binary() self.assertEquals( to_fix('8=FIX.4.2', '9=18', '110=2', '111=\x01\x02a\xbbbcd', '10=026'), data)
def test_receive_testrequest(self): """ Test receiving testrequest """ now = datetime.datetime.now() - datetime.timedelta(seconds=2) self.protocol._last_send_time = now self.protocol._last_received_time = now last_time = self.protocol._last_received_time self.protocol.filter_heartbeat = False self.protocol.on_data_received(to_fix("8=FIX.4.2", "9=13", "35=1", "112=tr1", "10=186")) self.assertEquals(1, self.transport.message_received_count) self.assertNotEquals(last_time, self.protocol._last_received_time)
def test_parser_reset(self): """ Test that the parser resets on an error """ parser = FIXParser(self.receiver, header_fields=[8, 9]) # Tag ID is not a number self.assertFalse(parser.is_parsing) with self.assertRaises(FIXParserError): parser.on_data_received(to_fix('8=FIX.4.2', '9=32', 'abcd=A')) self.assertFalse(parser.is_parsing)
def test_to_binary_include(self): mess = FIXMessage() mess[8] = 'FIX.4.2' mess[9] = '---' mess[35] = 'A' mess[49] = 'SERVER' mess[56] = 'CLIENT' mess[177] = 'hello' data = mess.to_binary(include=[8, 9, 35, 177]) self.assertEquals( to_fix('8=FIX.4.2', '9=15', '35=A', '177=hello', '10=212'), data)
def test_partial_message(self): """ Test for partial input. """ parser = FIXParser(self.receiver, header_fields=[8, 9]) self.assertFalse(parser.is_parsing) self.assertEquals(0, self.receiver.count) parser.on_data_received(to_fix('8=FIX.4.2', '9=32', '35=A')) self.assertEquals(0, self.receiver.count) self.assertTrue(parser.is_parsing)
def test_binary_fields(self): """ Binary field testing. """ parser = FIXParser(self.receiver, binary_fields=[1000, 1010], header_fields=[8, 9]) # Test with embedded binary \x01 parser.on_data_received(to_fix('8=FIX.4.2', '9=18', '1000=5', '1001=\x01\x02\x03\x04\x05', '10=066')) self.assertEquals(1, self.receiver.count) message = self.receiver.last_received_message self.assertIsNotNone(message) self.assertEquals(5, len(message)) self.assertTrue(message.verify(fields=[(8, 'FIX.4.2'), (9, '18'), (1000, '5'), (1001, '\x01\x02\x03\x04\x05'), (10, '066')])) # Test with embedded '=' signs parser.on_data_received(to_fix('8=FIX.4.2', '9=18', '1000=5', '1001=31=20', '10=054')) self.assertEquals(2, self.receiver.count) message = self.receiver.last_received_message self.assertIsNotNone(message) self.assertEquals(5, len(message)) self.assertTrue(message.verify(fields=[(8, 'FIX.4.2'), (9, '18'), (1000, '5'), (1001, '31=20'), (10, '054')]))
def test_bad_syntax(self): """ Test for various bad syntax cases """ parser = FIXParser(self.receiver, header_fields=[8, 9]) # Tag ID is not a number with self.assertRaises(FIXParserError): parser.on_data_received(to_fix('8=FIX.4.2', '9=32', 'abcd=A')) # Missing '=' and value portion with self.assertRaises(FIXParserError): parser.on_data_received(to_fix('8=FIX.4', '9=32', '35')) # Missing tag ID portion with self.assertRaises(FIXParserError): parser.on_data_received(to_fix('8=FIX.4', '9=32', '=A'))
def test_receive_testrequest(self): """ Test receiving testrequest """ now = datetime.datetime.now() - datetime.timedelta(seconds=2) self.protocol._last_send_time = now self.protocol._last_received_time = now last_time = self.protocol._last_received_time self.protocol.filter_heartbeat = False self.protocol.on_data_received( to_fix('8=FIX.4.2', '9=13', '35=1', '112=tr1', '10=186')) self.assertEquals(1, self.transport.message_received_count) self.assertNotEquals(last_time, self.protocol._last_received_time)
def test_to_binary_exclude(self): mess = FIXMessage() mess[8] = 'FIX.4.2' mess[9] = '---' mess[35] = 'A' mess[49] = 'SERVER' mess[56] = 'CLIENT' mess[99] = 'X' mess[177] = 'hello' data = mess.to_binary(exclude=[35, 177]) self.assertEquals( to_fix('8=FIX.4.2', '9=25', '49=SERVER', '56=CLIENT', '99=X', '10=239'), data)
def test_header_fields_in_order(self): """ Test for out-of-order header fields """ self.protocol.on_data_received(to_fix("8=FIX.4.2", "9=10", "49=s", "35=A", "10=252")) self.assertIsNotNone(self.transport.last_message_received) items = flatten(self.transport.last_message_received) # the order should be restored because the header fields will # have been pre-added. self.assertEquals(5, len(items)) self.assertEquals(8, items[0][0]) self.assertEquals(9, items[1][0]) self.assertEquals(35, items[2][0]) self.assertEquals(49, items[3][0]) self.assertEquals(10, items[4][0])
def test_header_fields_in_order(self): """ Test for out-of-order header fields """ self.protocol.on_data_received( to_fix('8=FIX.4.2', '9=10', '49=s', '35=A', '10=252')) self.assertIsNotNone(self.transport.last_message_received) items = flatten(self.transport.last_message_received) # the order should be restored because the header fields will # have been pre-added. self.assertEquals(5, len(items)) self.assertEquals(8, items[0][0]) self.assertEquals(9, items[1][0]) self.assertEquals(35, items[2][0]) self.assertEquals(49, items[3][0]) self.assertEquals(10, items[4][0])
def test_message_binary_too_long(self): """ Test for message with missing binary data """ parser = FIXParser(self.receiver, header_fields=[8, 9], binary_fields=[1000], max_length=100) # length too short with self.assertRaises(FIXLengthTooLongError): parser.on_data_received(to_fix('8=FIX.4.2', '9=32', '42=A', '1000=128', '1001=abababababab', '10=000'))
def test_to_binary_binarydata(self): mess = FIXMessage(header_fields=[8, 9]) mess[8] = 'FIX.4.2' mess[9] = '---' mess[110] = 2 mess[111] = '\x01\x02a\xbbbcd' data = mess.to_binary() self.assertEquals(to_fix('8=FIX.4.2', '9=18', '110=2', '111=\x01\x02a\xbbbcd', '10=026'), data)
def test_group_from_list(self): """ Call to_binary() on a grouped message from a list """ mess = FIXMessage(header_fields=[8, 9], source=[(8, 'FIX.4.2'), (9, '25'), (49, 'SERVER'), (56, 'CLIENT'), (99, 'X')]) self.assertEquals(to_fix('8=FIX.4.2', '9=25', '49=SERVER', '56=CLIENT', '99=X', '10=239'), mess.to_binary())
def test_filter_testrequest(self): """ Test testrequest filtering """ now = datetime.datetime.now() - datetime.timedelta(seconds=1) self.protocol._last_send_time = now - datetime.timedelta(minutes=1) self.protocol._last_received_time = now last_time = self.protocol._last_received_time # start heartbeat processing self.protocol.heartbeat = 5 # time in secs self.protocol.filter_heartbeat = True self.protocol.on_data_received(to_fix("8=FIX.4.2", "9=13", "35=1", "112=tr1", "10=186")) self.assertEquals(0, self.transport.message_received_count) self.assertNotEquals(last_time, self.protocol._last_received_time)
def test_filter_testrequest(self): """ Test testrequest filtering """ now = datetime.datetime.now() - datetime.timedelta(seconds=1) self.protocol._last_send_time = now - datetime.timedelta(minutes=1) self.protocol._last_received_time = now last_time = self.protocol._last_received_time # start heartbeat processing self.protocol.heartbeat = 5 # time in secs self.protocol.filter_heartbeat = True self.protocol.on_data_received( to_fix('8=FIX.4.2', '9=13', '35=1', '112=tr1', '10=186')) self.assertEquals(0, self.transport.message_received_count) self.assertNotEquals(last_time, self.protocol._last_received_time)
def test_checksum(self): self.assertEquals(1, checksum('\x01')) self.assertEquals(2, checksum('\x01\x01')) self.assertEquals(2, checksum('\xFF\x03')) # example taken from wikipedia self.assertEquals(62, checksum(to_fix('8=FIX.4.2', '9=65', '35=A', '49=SERVER', '56=CLIENT', '34=177', '52=20090107-18:15:16', '98=0', '108=30')))
def test_to_binary_include(self): mess = FIXMessage() mess[8] = 'FIX.4.2' mess[9] = '---' mess[35] = 'A' mess[49] = 'SERVER' mess[56] = 'CLIENT' mess[177] = 'hello' data = mess.to_binary(include=[8, 9, 35, 177]) self.assertEquals(to_fix('8=FIX.4.2', '9=15', '35=A', '177=hello', '10=212'), data)
def test_to_binary_group(self): """ Call to_binary() on a grouped message """ mess = FIXMessage(header_fields=[8, 9]) tags = collections.OrderedDict() mess[8] = 'FIX.4.2' mess[9] = '---' tags[110] = 2 tags[111] = 'abcd' mess[100] = [ tags, ] data = mess.to_binary() self.assertEquals( to_fix('8=FIX.4.2', '9=21', '100=1', '110=2', '111=abcd', '10=086'), data)
def test_to_binary_exclude(self): mess = FIXMessage() mess[8] = 'FIX.4.2' mess[9] = '---' mess[35] = 'A' mess[49] = 'SERVER' mess[56] = 'CLIENT' mess[99] = 'X' mess[177] = 'hello' data = mess.to_binary(exclude=[35, 177]) self.assertEquals(to_fix('8=FIX.4.2', '9=25', '49=SERVER', '56=CLIENT', '99=X', '10=239'), data)
def test_grouped_binary_fields(self): """ Test binary fields that are in a group. """ parser = FIXParser(self.receiver, debug=True, group_fields={200: [201, 202, 99, 100]}, binary_fields=[99], header_fields=[8, 9]) text = to_fix('8=FIX.4.2', '9=80', '35=A', '200=2', '201=aabc', '99=5', '100=abcde', '201=zzzaa', '202=myname', '99=5', '100=zztop', '955=that', '10=201') parser.on_data_received(text) self.assertFalse(parser.is_parsing) self.assertEquals(1, self.receiver.count) message = self.receiver.last_received_message self.assertIsNotNone(message) self.assertEquals(6, len(message)) self.assertEquals(2, len(message[200])) self.assertTrue(200 in message) self.assertTrue(955 in message) subgroup = message[200][0] self.assertEquals(3, len(subgroup)) self.assertTrue(201 in subgroup) self.assertTrue(99 in subgroup) self.assertTrue(100 in subgroup) subgroup = message[200][1] self.assertEquals(4, len(subgroup)) self.assertTrue(201 in subgroup) self.assertTrue(202 in subgroup) self.assertTrue(99 in subgroup) self.assertTrue(100 in subgroup)
def test_to_binary_group(self): """ Call to_binary() on a grouped message """ mess = FIXMessage(header_fields=[8, 9]) tags = collections.OrderedDict() mess[8] = 'FIX.4.2' mess[9] = '---' tags[110] = 2 tags[111] = 'abcd' mess[100] = [tags, ] data = mess.to_binary() self.assertEquals(to_fix('8=FIX.4.2', '9=21', '100=1', '110=2', '111=abcd', '10=086'), data)
def test_header_fields(self): """ Header field testing. """ parser = FIXParser(self.receiver, header_fields=[8, 9, 320]) parser.on_data_received(to_fix('8=FIX.4.2', '9=5', '35=A', '10=178')) self.assertEquals(1, self.receiver.count) message = self.receiver.last_received_message self.assertIsNotNone(message) message[320] = 'hello there' self.assertEquals(5, len(message)) # verify the order of the message items = [(k, v) for k, v in message.items()] self.assertEquals(8, items[0][0]) self.assertEquals(9, items[1][0]) self.assertEquals(320, items[2][0])
def test_multiple_groups(self): """ Test the receiving of multiple groups """ parser = FIXParser(self.receiver, group_fields={100: [101, 102, 200], 200: [201, 202], }, header_fields=[8, 9]) parser.on_data_received(to_fix('8=FIX.4.2', '9=32', '100=2', '101=a', '102=b', '101=aa', '102=bb', '10=135')) self.assertEquals(1, self.receiver.count) message = self.receiver.last_received_message self.assertIsNotNone(message) self.assertEquals(4, len(message)) self.assertTrue(100 in message) self.assertEquals(2, len(message[100])) group = message[100] self.assertIsNotNone(group) self.assertEquals(2, len(group)) self.assertEquals(2, len(group[0])) self.assertTrue(101 in group[0]) self.assertTrue(102 in group[0]) self.assertEquals('a', group[0][101]) self.assertEquals('b', group[0][102]) self.assertEquals(2, len(group[1])) self.assertTrue(101 in group[1]) self.assertTrue(102 in group[1]) self.assertEquals('aa', group[1][101]) self.assertEquals('bb', group[1][102])
def test_to_fix(self): data = to_fix('a', 'b', 'c') self.assertEquals('a\x01b\x01c\x01', data)