build/android/gyp/java_cpp_enum_tests.py

   1 #!/usr/bin/env python
   2 # Copyright 2014 The Chromium Authors. All rights reserved.
   3 # Use of this source code is governed by a BSD-style license that can be
   4 # found in the LICENSE file.
   5
   6 """Tests for enum_preprocess.py.
   7
   8 This test suite containss various tests for the C++ -> Java enum generator.
   9 """
  10
  11 import collections
  12 import optparse
  13 import os
  14 import sys
  15 import unittest
  16
  17 from java_cpp_enum import EnumDefinition, GenerateOutput, GetScriptName
  18 from java_cpp_enum import HeaderParser
  19
  20 sys.path.append(os.path.join(os.path.dirname(__file__), "gyp"))
  21 from util import build_utils
  22
  23 class TestPreprocess(unittest.TestCase):
  24   def testOutput(self):
  25     definition = EnumDefinition(original_enum_name='ClassName',
  26                                 enum_package='some.package',
  27                                 entries=[('E1', 1), ('E2', '2 << 2')])
  28     output = GenerateOutput('path/to/file', definition)
  29     expected = """
  30 // Copyright 2014 The Chromium Authors. All rights reserved.
  31 // Use of this source code is governed by a BSD-style license that can be
  32 // found in the LICENSE file.
  33
  34 // This file is autogenerated by
  35 //     %s
  36 // From
  37 //     path/to/file
  38
  39 package some.package;
  40
  41 public class ClassName {
  42   public static final int E1 = 1;
  43   public static final int E2 = 2 << 2;
  44 }
  45 """
  46     self.assertEqual(expected % GetScriptName(), output)
  47
  48   def testParseSimpleEnum(self):
  49     test_data = """
  50       // GENERATED_JAVA_ENUM_PACKAGE: test.namespace
  51       enum EnumName {
  52         VALUE_ZERO,
  53         VALUE_ONE,
  54       };
  55     """.split('\n')
  56     definitions = HeaderParser(test_data).ParseDefinitions()
  57     self.assertEqual(1, len(definitions))
  58     definition = definitions[0]
  59     self.assertEqual('EnumName', definition.class_name)
  60     self.assertEqual('test.namespace', definition.enum_package)
  61     self.assertEqual(collections.OrderedDict([('VALUE_ZERO', 0),
  62                                               ('VALUE_ONE', 1)]),
  63                      definition.entries)
  64
  65   def testParseBitShifts(self):
  66     test_data = """
  67       // GENERATED_JAVA_ENUM_PACKAGE: test.namespace
  68       enum EnumName {
  69         VALUE_ZERO = 1 << 0,
  70         VALUE_ONE = 1 << 1,
  71       };
  72     """.split('\n')
  73     definitions = HeaderParser(test_data).ParseDefinitions()
  74     self.assertEqual(1, len(definitions))
  75     definition = definitions[0]
  76     self.assertEqual('EnumName', definition.class_name)
  77     self.assertEqual('test.namespace', definition.enum_package)
  78     self.assertEqual(collections.OrderedDict([('VALUE_ZERO', '1 << 0'),
  79                                               ('VALUE_ONE', '1 << 1')]),
  80                      definition.entries)
  81
  82   def testParseClassNameOverride(self):
  83     test_data = """
  84       // GENERATED_JAVA_ENUM_PACKAGE: test.namespace
  85       // GENERATED_JAVA_CLASS_NAME_OVERRIDE: OverrideName
  86       enum EnumName {
  87         FOO
  88       };
  89
  90       // GENERATED_JAVA_ENUM_PACKAGE: test.namespace
  91       // GENERATED_JAVA_CLASS_NAME_OVERRIDE: OtherOverride
  92       enum PrefixTest {
  93         PREFIX_TEST_A,
  94         PREFIX_TEST_B,
  95       };
  96     """.split('\n')
  97     definitions = HeaderParser(test_data).ParseDefinitions()
  98     self.assertEqual(2, len(definitions))
  99     definition = definitions[0]
 100     self.assertEqual('OverrideName', definition.class_name)
 101
 102     definition = definitions[1]
 103     self.assertEqual('OtherOverride', definition.class_name)
 104     self.assertEqual(collections.OrderedDict([('A', 0),
 105                                               ('B', 1)]),
 106                      definition.entries)
 107
 108   def testParseTwoEnums(self):
 109     test_data = """
 110       // GENERATED_JAVA_ENUM_PACKAGE: test.namespace
 111       enum EnumOne {
 112         ENUM_ONE_A = 1,
 113         // Comment there
 114         ENUM_ONE_B = A,
 115       };
 116
 117       enum EnumIgnore {
 118         C, D, E
 119       };
 120
 121       // GENERATED_JAVA_ENUM_PACKAGE: other.package
 122       // GENERATED_JAVA_PREFIX_TO_STRIP: P_
 123       enum EnumTwo {
 124         P_A,
 125         P_B
 126       };
 127     """.split('\n')
 128     definitions = HeaderParser(test_data).ParseDefinitions()
 129     self.assertEqual(2, len(definitions))
 130     definition = definitions[0]
 131     self.assertEqual('EnumOne', definition.class_name)
 132     self.assertEqual('test.namespace', definition.enum_package)
 133     self.assertEqual(collections.OrderedDict([('A', '1'),
 134                                               ('B', 'A')]),
 135                      definition.entries)
 136
 137     definition = definitions[1]
 138     self.assertEqual('EnumTwo', definition.class_name)
 139     self.assertEqual('other.package', definition.enum_package)
 140     self.assertEqual(collections.OrderedDict([('A', 0),
 141                                               ('B', 1)]),
 142                      definition.entries)
 143
 144   def testParseThrowsOnUnknownDirective(self):
 145     test_data = """
 146       // GENERATED_JAVA_UNKNOWN: Value
 147       enum EnumName {
 148         VALUE_ONE,
 149       };
 150     """.split('\n')
 151     with self.assertRaises(Exception):
 152       HeaderParser(test_data).ParseDefinitions()
 153
 154   def testParseEnumClass(self):
 155     test_data = """
 156       // GENERATED_JAVA_ENUM_PACKAGE: test.namespace
 157       enum class Foo {
 158         FOO_A,
 159       };
 160     """.split('\n')
 161     definitions = HeaderParser(test_data).ParseDefinitions()
 162     self.assertEqual(1, len(definitions))
 163     definition = definitions[0]
 164     self.assertEqual('Foo', definition.class_name)
 165     self.assertEqual('test.namespace', definition.enum_package)
 166     self.assertEqual(collections.OrderedDict([('A', 0)]),
 167                      definition.entries)
 168
 169   def testParseEnumStruct(self):
 170     test_data = """
 171       // GENERATED_JAVA_ENUM_PACKAGE: test.namespace
 172       enum struct Foo {
 173         FOO_A,
 174       };
 175     """.split('\n')
 176     definitions = HeaderParser(test_data).ParseDefinitions()
 177     self.assertEqual(1, len(definitions))
 178     definition = definitions[0]
 179     self.assertEqual('Foo', definition.class_name)
 180     self.assertEqual('test.namespace', definition.enum_package)
 181     self.assertEqual(collections.OrderedDict([('A', 0)]),
 182                      definition.entries)
 183
 184   def testParseFixedTypeEnum(self):
 185     test_data = """
 186       // GENERATED_JAVA_ENUM_PACKAGE: test.namespace
 187       enum Foo : int {
 188         FOO_A,
 189       };
 190     """.split('\n')
 191     definitions = HeaderParser(test_data).ParseDefinitions()
 192     self.assertEqual(1, len(definitions))
 193     definition = definitions[0]
 194     self.assertEqual('Foo', definition.class_name)
 195     self.assertEqual('test.namespace', definition.enum_package)
 196     self.assertEqual('int', definition.fixed_type)
 197     self.assertEqual(collections.OrderedDict([('A', 0)]),
 198                      definition.entries)
 199
 200   def testParseFixedTypeEnumClass(self):
 201     test_data = """
 202       // GENERATED_JAVA_ENUM_PACKAGE: test.namespace
 203       enum class Foo: unsigned short {
 204         FOO_A,
 205       };
 206     """.split('\n')
 207     definitions = HeaderParser(test_data).ParseDefinitions()
 208     self.assertEqual(1, len(definitions))
 209     definition = definitions[0]
 210     self.assertEqual('Foo', definition.class_name)
 211     self.assertEqual('test.namespace', definition.enum_package)
 212     self.assertEqual('unsigned short', definition.fixed_type)
 213     self.assertEqual(collections.OrderedDict([('A', 0)]),
 214                      definition.entries)
 215
 216   def testParseUnknownFixedTypeRaises(self):
 217     test_data = """
 218       // GENERATED_JAVA_ENUM_PACKAGE: test.namespace
 219       enum class Foo: foo_type {
 220         FOO_A,
 221       };
 222     """.split('\n')
 223     with self.assertRaises(Exception):
 224       HeaderParser(test_data).ParseDefinitions()
 225
 226   def testParseSimpleMultiLineDirective(self):
 227     test_data = """
 228       // GENERATED_JAVA_ENUM_PACKAGE: (
 229       //   test.namespace)
 230       // GENERATED_JAVA_CLASS_NAME_OVERRIDE: Bar
 231       enum Foo {
 232         FOO_A,
 233       };
 234     """.split('\n')
 235     definitions = HeaderParser(test_data).ParseDefinitions()
 236     self.assertEqual('test.namespace', definitions[0].enum_package)
 237     self.assertEqual('Bar', definitions[0].class_name)
 238
 239   def testParseMultiLineDirective(self):
 240     test_data = """
 241       // GENERATED_JAVA_ENUM_PACKAGE: (te
 242       //   st.name
 243       //   space)
 244       enum Foo {
 245         FOO_A,
 246       };
 247     """.split('\n')
 248     definitions = HeaderParser(test_data).ParseDefinitions()
 249     self.assertEqual('test.namespace', definitions[0].enum_package)
 250
 251   def testParseMultiLineDirectiveWithOtherDirective(self):
 252     test_data = """
 253       // GENERATED_JAVA_ENUM_PACKAGE: (
 254       //   test.namespace)
 255       // GENERATED_JAVA_CLASS_NAME_OVERRIDE: (
 256       //   Ba
 257       //   r
 258       //   )
 259       enum Foo {
 260         FOO_A,
 261       };
 262     """.split('\n')
 263     definitions = HeaderParser(test_data).ParseDefinitions()
 264     self.assertEqual('test.namespace', definitions[0].enum_package)
 265     self.assertEqual('Bar', definitions[0].class_name)
 266
 267   def testParseMalformedMultiLineDirectiveWithOtherDirective(self):
 268     test_data = """
 269       // GENERATED_JAVA_ENUM_PACKAGE: (
 270       //   test.name
 271       //   space
 272       // GENERATED_JAVA_CLASS_NAME_OVERRIDE: Bar
 273       enum Foo {
 274         FOO_A,
 275       };
 276     """.split('\n')
 277     with self.assertRaises(Exception):
 278       HeaderParser(test_data).ParseDefinitions()
 279
 280   def testParseMalformedMultiLineDirective(self):
 281     test_data = """
 282       // GENERATED_JAVA_ENUM_PACKAGE: (
 283       //   test.name
 284       //   space
 285       enum Foo {
 286         FOO_A,
 287       };
 288     """.split('\n')
 289     with self.assertRaises(Exception):
 290       HeaderParser(test_data).ParseDefinitions()
 291
 292   def testParseMalformedMultiLineDirectiveShort(self):
 293     test_data = """
 294       // GENERATED_JAVA_ENUM_PACKAGE: (
 295       enum Foo {
 296         FOO_A,
 297       };
 298     """.split('\n')
 299     with self.assertRaises(Exception):
 300       HeaderParser(test_data).ParseDefinitions()
 301
 302   def testEnumValueAssignmentNoneDefined(self):
 303     definition = EnumDefinition(original_enum_name='c', enum_package='p')
 304     definition.AppendEntry('A', None)
 305     definition.AppendEntry('B', None)
 306     definition.AppendEntry('C', None)
 307     definition.Finalize()
 308     self.assertEqual(collections.OrderedDict([('A', 0),
 309                                               ('B', 1),
 310                                               ('C', 2)]),
 311                      definition.entries)
 312
 313   def testEnumValueAssignmentAllDefined(self):
 314     definition = EnumDefinition(original_enum_name='c', enum_package='p')
 315     definition.AppendEntry('A', '1')
 316     definition.AppendEntry('B', '2')
 317     definition.AppendEntry('C', '3')
 318     definition.Finalize()
 319     self.assertEqual(collections.OrderedDict([('A', '1'),
 320                                               ('B', '2'),
 321                                               ('C', '3')]),
 322                      definition.entries)
 323
 324   def testEnumValueAssignmentReferences(self):
 325     definition = EnumDefinition(original_enum_name='c', enum_package='p')
 326     definition.AppendEntry('A', None)
 327     definition.AppendEntry('B', 'A')
 328     definition.AppendEntry('C', None)
 329     definition.AppendEntry('D', 'C')
 330     definition.Finalize()
 331     self.assertEqual(collections.OrderedDict([('A', 0),
 332                                               ('B', 0),
 333                                               ('C', 1),
 334                                               ('D', 1)]),
 335                      definition.entries)
 336
 337   def testEnumValueAssignmentSet(self):
 338     definition = EnumDefinition(original_enum_name='c', enum_package='p')
 339     definition.AppendEntry('A', None)
 340     definition.AppendEntry('B', '2')
 341     definition.AppendEntry('C', None)
 342     definition.Finalize()
 343     self.assertEqual(collections.OrderedDict([('A', 0),
 344                                               ('B', 2),
 345                                               ('C', 3)]),
 346                      definition.entries)
 347
 348   def testEnumValueAssignmentSetReferences(self):
 349     definition = EnumDefinition(original_enum_name='c', enum_package='p')
 350     definition.AppendEntry('A', None)
 351     definition.AppendEntry('B', 'A')
 352     definition.AppendEntry('C', 'B')
 353     definition.AppendEntry('D', None)
 354     definition.Finalize()
 355     self.assertEqual(collections.OrderedDict([('A', 0),
 356                                               ('B', 0),
 357                                               ('C', 0),
 358                                               ('D', 1)]),
 359                      definition.entries)
 360
 361   def testEnumValueAssignmentRaises(self):
 362     definition = EnumDefinition(original_enum_name='c', enum_package='p')
 363     definition.AppendEntry('A', None)
 364     definition.AppendEntry('B', 'foo')
 365     definition.AppendEntry('C', None)
 366     with self.assertRaises(Exception):
 367       definition.Finalize()
 368
 369   def testExplicitPrefixStripping(self):
 370     definition = EnumDefinition(original_enum_name='c', enum_package='p')
 371     definition.AppendEntry('P_A', None)
 372     definition.AppendEntry('B', None)
 373     definition.AppendEntry('P_C', None)
 374     definition.AppendEntry('P_LAST', 'P_C')
 375     definition.prefix_to_strip = 'P_'
 376     definition.Finalize()
 377     self.assertEqual(collections.OrderedDict([('A', 0),
 378                                               ('B', 1),
 379                                               ('C', 2),
 380                                               ('LAST', 2)]),
 381                      definition.entries)
 382
 383   def testImplicitPrefixStripping(self):
 384     definition = EnumDefinition(original_enum_name='ClassName',
 385                                 enum_package='p')
 386     definition.AppendEntry('CLASS_NAME_A', None)
 387     definition.AppendEntry('CLASS_NAME_B', None)
 388     definition.AppendEntry('CLASS_NAME_C', None)
 389     definition.AppendEntry('CLASS_NAME_LAST', 'CLASS_NAME_C')
 390     definition.Finalize()
 391     self.assertEqual(collections.OrderedDict([('A', 0),
 392                                               ('B', 1),
 393                                               ('C', 2),
 394                                               ('LAST', 2)]),
 395                      definition.entries)
 396
 397   def testImplicitPrefixStrippingRequiresAllConstantsToBePrefixed(self):
 398     definition = EnumDefinition(original_enum_name='Name',
 399                                 enum_package='p')
 400     definition.AppendEntry('A', None)
 401     definition.AppendEntry('B', None)
 402     definition.AppendEntry('NAME_LAST', None)
 403     definition.Finalize()
 404     self.assertEqual(['A', 'B', 'NAME_LAST'], definition.entries.keys())
 405
 406 def main(argv):
 407   parser = optparse.OptionParser()
 408   parser.add_option("--stamp", help="File to touch on success.")
 409   options, _ = parser.parse_args(argv)
 410
 411   suite = unittest.TestLoader().loadTestsFromTestCase(TestPreprocess)
 412   unittest.TextTestRunner(verbosity=0).run(suite)
 413
 414   if options.stamp:
 415     build_utils.Touch(options.stamp)
 416
 417 if __name__ == '__main__':
 418   main(sys.argv[1:])