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)
