def testSource(self): with open('lib/python/pack2/tests/test_param.p2', 'r') as f: source = f.read() p = parser.Parser() metadata = p.Parse(source) test_param = metadata.type_map['TestConfigParams'] p2 = parser.Parser() metadata2 = p2.Parse(test_param.Source()) test_param2 = metadata2.type_map['TestConfigParams'] self.assertEqual(str(test_param), str(test_param2))
def testRedefiendIncludeType(self): loader = _MockFileLoader() loader.AddFile( 'child.p2', textwrap.dedent("""\ enum8 ChildEnum { kValue0 = 0, kValue1 = 1, } """)) loader.AddFile( 'child2.p2', textwrap.dedent("""\ enum8 ChildEnum { kValue0 = 0, kValue1 = 1, } """)) text = textwrap.dedent("""\ include "child.p2"; include "child2.p2"; param ParentParam { ChildEnum child_enum; } """) p = parser.Parser(file_loader=loader) with self.assertRaises(parser.ParseError): p.Parse(text)
def testSpecialized(self): text = textwrap.dedent("""\ enum32 FooRevision { kFooRevisionA = 0, kFooRevisionB = 1, } param BaseConfigParams { string[32] name; int32 revision; } specialize(BaseConfigParams) FooConfigParams { FooRevision revision; } """) expected = textwrap.dedent("""\ param BaseConfigParams { string[32] name; // offset: 0 int32 revision; // offset: 32 } param FooConfigParams { string[32] name; // offset: 0 enum32 FooRevision { kFooRevisionA = 0, kFooRevisionB = 1, } revision; // offset: 32 } """) p = parser.Parser() metadata = p.Parse(text) self.assertEqual(str(metadata), expected)
def testDupicateIncludeOK(self): loader = _MockFileLoader() loader.AddFile( 'child.p2', textwrap.dedent("""\ enum8 ChildEnum { kValue0 = 0, kValue1 = 1, } """)) text = textwrap.dedent("""\ include "child.p2"; include "child.p2"; param ParentParam { ChildEnum child_enum; } """) expected = textwrap.dedent("""\ param ParentParam { enum8 ChildEnum { kValue0 = 0, kValue1 = 1, } child_enum; // offset: 0 } """) p = parser.Parser(file_loader=loader) metadata = p.Parse(text) self.assertEqual(str(metadata), expected)
def testStruct(self): text = textwrap.dedent("""\ struct test_struct { uint8 field0; int32 field1; } param test_param { uint8 thing_a; float32 thing_b; test_struct thing_c; test_struct thing_d; } """) expected = textwrap.dedent("""\ param test_param { uint8 thing_a; // offset: 0 float32 thing_b; // offset: 4 struct test_struct { uint8 field0; // offset: 0 int32 field1; // offset: 4 } thing_c; // offset: 8 struct test_struct { uint8 field0; // offset: 0 int32 field1; // offset: 4 } thing_d; // offset: 16 } """) p = parser.Parser() metadata = p.Parse(text) self.assertEqual(str(metadata), expected)
def testScaled(self): text = textwrap.dedent("""\ scaled8 test_scaled8 { offset = 0.0, scale = -1.0, } scaled16 test_scaled16 { offset = 1.2e1, scale = 0.1e-3, } scaled32 test_scaled32 { offset = -13, scale = -0.1e30, } scaled32 test_scaled32_2 { offset = -0, scale = -1, } param test_param { uint8 thing_a; float32 thing_b; test_scaled8 thing_c; test_scaled16 thing_d; test_scaled32 thing_e; test_scaled32_2 thing_f; } """) expected = textwrap.dedent("""\ param test_param { uint8 thing_a; // offset: 0 float32 thing_b; // offset: 4 scaled8 test_scaled8 { offset = 0, scale = -1, } thing_c; // offset: 8 scaled16 test_scaled16 { offset = 12, scale = 0.0001, } thing_d; // offset: 10 scaled32 test_scaled32 { offset = -13, scale = -1e+29, } thing_e; // offset: 12 scaled32 test_scaled32_2 { offset = 0, scale = -1, } thing_f; // offset: 16 } """) p = parser.Parser() metadata = p.Parse(text) self.assertEqual(str(metadata), expected)
def testFormatter(self): with open('lib/python/pack2/tests/test_param_pre_fmt.p2', 'r') as f: pre_format = f.read() with open('lib/python/pack2/tests/test_param_post_fmt.p2', 'r') as f: post_format = f.read() p = parser.Parser() p.Parse(pre_format) self.assertEqual(p.GetFormattedSource(), post_format)
def _TestEnumBadValue(self, width, value): text = textwrap.dedent("""\ enum{width} test_enum {{ VAL0 = {value}, }} """).format(width=width, value=value) p = parser.Parser() with self.assertRaises(parser.ParseError): p.Parse(text)
def testNoScaledScale(self): # Ensure a SyntaxError is raised when a scaled type has no scale property. text = textwrap.dedent("""\ scaled8 test_scaled8 { offset = -1, } """) p = parser.Parser() with self.assertRaises(parser.ParseError): p.Parse(text)
def testBadKeyword(self): # Ensure a ParseError is raised on an invalid keyword. text = textwrap.dedent("""\ garbage test_struct { uint8 thing_a; } """) p = parser.Parser() with self.assertRaises(parser.ParseError): p.Parse(text)
def testBitfield(self): text = textwrap.dedent("""\ bitfield8 test_bf8 { 0: FLAG0, 1: FLAG1, 7: FLAG_MAX, } bitfield16 test_bf16 { 0: FLAG0, 1: FLAG1, 15: FLAG_MAX, } bitfield32 test_bf32 { 0: FLAG0, 1: FLAG1, 31: FLAG_MAX, } param test_param { uint8 thing_a; float32 thing_b; test_bf8 thing_c; test_bf16 thing_d; test_bf32 thing_e; } """) expected = textwrap.dedent("""\ param test_param { uint8 thing_a; // offset: 0 float32 thing_b; // offset: 4 bitfield8 test_bf8 { 0: FLAG0, 1: FLAG1, 7: FLAG_MAX, } thing_c; // offset: 8 bitfield16 test_bf16 { 0: FLAG0, 1: FLAG1, 15: FLAG_MAX, } thing_d; // offset: 10 bitfield32 test_bf32 { 0: FLAG0, 1: FLAG1, 31: FLAG_MAX, } thing_e; // offset: 12 } """) p = parser.Parser() metadata = p.Parse(text) self.assertEqual(str(metadata), expected)
def testBitmapNegValue(self): # Ensure a SyntaxError is raised when a bitmap contains a negative value. text = textwrap.dedent("""\ bitfield8 test_bitfield8 { 0: FLAG0, -1: FLAG1, } """) p = parser.Parser() with self.assertRaises(parser.ParseError): p.Parse(text)
def testScaledNotFloat(self): # Ensure a SyntaxError is raised when a scaled property is not a float. text = textwrap.dedent("""\ scaled8 test_scaled8 { offset = -0, scale = abc, } """) p = parser.Parser() with self.assertRaises(parser.ParseError): p.Parse(text)
def testDupEnumValue(self): # Ensure a SyntaxError is raised when an enum contains duplicate values. text = textwrap.dedent("""\ enum8 test_enum8 { VAL0 = 0, VAL1 = 0, } """) p = parser.Parser() with self.assertRaises(parser.ParseError): p.Parse(text)
def testDupBitmapLabel(self): # Ensure a SyntaxError is raised when a bitmap contains duplicate labels. text = textwrap.dedent("""\ bitfield8 test_bitfield8 { 0: FLAG0, 1: FLAG0, } """) p = parser.Parser() with self.assertRaises(parser.ParseError): p.Parse(text)
def testDuplicateField(self): # Ensure that a ParseError is raised when two fields have the same name. text = textwrap.dedent("""\ param test_param { uint8 thing_a; float32 thing_a; } """) p = parser.Parser() with self.assertRaises(parser.ParseError): p.Parse(text)
def testArrayFieldNegativeExtent(self): # Ensure that a ParseError is raised on an array with a negative length. text = textwrap.dedent("""\ param test_param { uint8 thing_a[-7]; uint32 thing_b; } """) p = parser.Parser() with self.assertRaises(parser.ParseError): p.Parse(text)
def testBitmap32Overflow(self): # Ensure a SyntaxError is raised when a bitmap32 contains a value that is # out of range of its width. text = textwrap.dedent("""\ bitfield32 test_bitfield32 { 0: FLAG0, 32: FLAG8, } """) p = parser.Parser() with self.assertRaises(parser.ParseError): p.Parse(text)
def testUnnownScaledProperty(self): # Ensure a SyntaxError is raised when a scaled type has an unknown property. text = textwrap.dedent("""\ scaled8 test_scaled8 { offset = -0, scale = -1, abc = -1, } """) p = parser.Parser() with self.assertRaises(parser.ParseError): p.Parse(text)
def testDupScaledProperty(self): # Ensure a SyntaxError is raised when a scaled type has duplicate # properties. text = textwrap.dedent("""\ scaled8 test_scaled8 { offset = -0, scale = -1, scale = -1, } """) p = parser.Parser() with self.assertRaises(parser.ParseError): p.Parse(text)
def testDuplicateHeader(self): # Ensure a ParseError is raised when two headers have the same name. text = textwrap.dedent("""\ header test_header { uint8 thing_a; } header test_header { uint8 thing_a; } """) p = parser.Parser() with self.assertRaises(parser.ParseError): p.Parse(text)
def testDuplicateStruct(self): # Ensure a ParseError is raised when two structs have the same name. text = textwrap.dedent("""\ struct test_struct { uint8 thing_a; } struct test_struct { uint8 thing_a; } """) p = parser.Parser() with self.assertRaises(parser.ParseError): p.Parse(text)
def testEnumNotDefined(self): text = textwrap.dedent("""\ param BaseConfigParams { string[32] name; int32 revision; } specialize(BaseConfigParams) FooConfigParams { FooRevision revision; } """) p = parser.Parser() with self.assertRaises(parser.ParseError): p.Parse(text)
def testParentNotDefined(self): text = textwrap.dedent("""\ enum32 FooRevision { kFooRevisionA = 0, kFooRevisionB = 1, } specialize(BaseConfigParams) FooConfigParams { FooRevision revision; } """) p = parser.Parser() with self.assertRaises(parser.ParseError): p.Parse(text)
def testDupBitmapType(self): # Ensure a SyntaxError is raised when two bitfields have the same name. text = textwrap.dedent("""\ bitfield8 test_bitfield8 { 0: FLAG0, 1: FLAG1, } bitfield16 test_bitfield8 { 0: FLAG0, 1: FLAG1, } """) p = parser.Parser() with self.assertRaises(parser.ParseError): p.Parse(text)
def testDupEnumType(self): # Ensure a SyntaxError is raised when two enums have the same name. text = textwrap.dedent("""\ enum8 test_enum8 { VAL0 = 0, VAL1 = 1, } enum8 test_enum8 { VAL0 = 0, VAL1 = 1, } """) p = parser.Parser() with self.assertRaises(parser.ParseError): p.Parse(text)
def testDupScaledType(self): # Ensure a SyntaxError is raised when two scaled type have the same name. text = textwrap.dedent("""\ scaled8 test_scaled8 { offset = -0, scale = -1, } scaled8 test_scaled8 { offset = -0, scale = -1, } """) p = parser.Parser() with self.assertRaises(parser.ParseError): p.Parse(text)
def testArrayField(self): text = textwrap.dedent("""\ param test_param { uint8 thing_a[7]; uint32 thing_b; } """) expected = textwrap.dedent("""\ param test_param { uint8 thing_a[7]; // offset: 0 uint32 thing_b; // offset: 8 } """) p = parser.Parser() metadata = p.Parse(text) self.assertEqual(str(metadata), expected)
def testDateField(self): text = textwrap.dedent("""\ param test_param { date date; uint32 thing_b; } """) expected = textwrap.dedent("""\ param test_param { date date; // offset: 0 uint32 thing_b; // offset: 4 } """) p = parser.Parser() metadata = p.Parse(text) self.assertEqual(str(metadata), expected)
def testSimpleParam(self): text = textwrap.dedent("""\ param SerialParams { int32 serial_number; date date_of_manufacture; string[32] part_number; } """) expected = textwrap.dedent("""\ param SerialParams { int32 serial_number; // offset: 0 date date_of_manufacture; // offset: 4 string[32] part_number; // offset: 8 } """) p = parser.Parser() metadata = p.Parse(text) self.assertEqual(str(metadata), expected)