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 testEnumValueAssignmentNoneDefined(self):
 227     definition = EnumDefinition(original_enum_name='c', enum_package='p')
 228     definition.AppendEntry('A', None)
 229     definition.AppendEntry('B', None)
 230     definition.AppendEntry('C', None)
 231     definition.Finalize()
 232     self.assertEqual(collections.OrderedDict([('A', 0),
 233                                               ('B', 1),
 234                                               ('C', 2)]),
 235                      definition.entries)
 236
 237   def testEnumValueAssignmentAllDefined(self):
 238     definition = EnumDefinition(original_enum_name='c', enum_package='p')
 239     definition.AppendEntry('A', '1')
 240     definition.AppendEntry('B', '2')
 241     definition.AppendEntry('C', '3')
 242     definition.Finalize()
 243     self.assertEqual(collections.OrderedDict([('A', '1'),
 244                                               ('B', '2'),
 245                                               ('C', '3')]),
 246                      definition.entries)
 247
 248   def testEnumValueAssignmentReferences(self):
 249     definition = EnumDefinition(original_enum_name='c', enum_package='p')
 250     definition.AppendEntry('A', None)
 251     definition.AppendEntry('B', 'A')
 252     definition.AppendEntry('C', None)
 253     definition.AppendEntry('D', 'C')
 254     definition.Finalize()
 255     self.assertEqual(collections.OrderedDict([('A', 0),
 256                                               ('B', 0),
 257                                               ('C', 1),
 258                                               ('D', 1)]),
 259                      definition.entries)
 260
 261   def testEnumValueAssignmentSet(self):
 262     definition = EnumDefinition(original_enum_name='c', enum_package='p')
 263     definition.AppendEntry('A', None)
 264     definition.AppendEntry('B', '2')
 265     definition.AppendEntry('C', None)
 266     definition.Finalize()
 267     self.assertEqual(collections.OrderedDict([('A', 0),
 268                                               ('B', 2),
 269                                               ('C', 3)]),
 270                      definition.entries)
 271
 272   def testEnumValueAssignmentSetReferences(self):
 273     definition = EnumDefinition(original_enum_name='c', enum_package='p')
 274     definition.AppendEntry('A', None)
 275     definition.AppendEntry('B', 'A')
 276     definition.AppendEntry('C', 'B')
 277     definition.AppendEntry('D', None)
 278     definition.Finalize()
 279     self.assertEqual(collections.OrderedDict([('A', 0),
 280                                               ('B', 0),
 281                                               ('C', 0),
 282                                               ('D', 1)]),
 283                      definition.entries)
 284
 285   def testEnumValueAssignmentRaises(self):
 286     definition = EnumDefinition(original_enum_name='c', enum_package='p')
 287     definition.AppendEntry('A', None)
 288     definition.AppendEntry('B', 'foo')
 289     definition.AppendEntry('C', None)
 290     with self.assertRaises(Exception):
 291       definition.Finalize()
 292
 293   def testExplicitPrefixStripping(self):
 294     definition = EnumDefinition(original_enum_name='c', enum_package='p')
 295     definition.AppendEntry('P_A', None)
 296     definition.AppendEntry('B', None)
 297     definition.AppendEntry('P_C', None)
 298     definition.AppendEntry('P_LAST', 'P_C')
 299     definition.prefix_to_strip = 'P_'
 300     definition.Finalize()
 301     self.assertEqual(collections.OrderedDict([('A', 0),
 302                                               ('B', 1),
 303                                               ('C', 2),
 304                                               ('LAST', 2)]),
 305                      definition.entries)
 306
 307   def testImplicitPrefixStripping(self):
 308     definition = EnumDefinition(original_enum_name='ClassName',
 309                                 enum_package='p')
 310     definition.AppendEntry('CLASS_NAME_A', None)
 311     definition.AppendEntry('CLASS_NAME_B', None)
 312     definition.AppendEntry('CLASS_NAME_C', None)
 313     definition.AppendEntry('CLASS_NAME_LAST', 'CLASS_NAME_C')
 314     definition.Finalize()
 315     self.assertEqual(collections.OrderedDict([('A', 0),
 316                                               ('B', 1),
 317                                               ('C', 2),
 318                                               ('LAST', 2)]),
 319                      definition.entries)
 320
 321   def testImplicitPrefixStrippingRequiresAllConstantsToBePrefixed(self):
 322     definition = EnumDefinition(original_enum_name='Name',
 323                                 enum_package='p')
 324     definition.AppendEntry('A', None)
 325     definition.AppendEntry('B', None)
 326     definition.AppendEntry('NAME_LAST', None)
 327     definition.Finalize()
 328     self.assertEqual(['A', 'B', 'NAME_LAST'], definition.entries.keys())
 329
 330 def main(argv):
 331   parser = optparse.OptionParser()
 332   parser.add_option("--stamp", help="File to touch on success.")
 333   options, _ = parser.parse_args(argv)
 334
 335   suite = unittest.TestLoader().loadTestsFromTestCase(TestPreprocess)
 336   unittest.TextTestRunner(verbosity=0).run(suite)
 337
 338   if options.stamp:
 339     build_utils.Touch(options.stamp)
 340
 341 if __name__ == '__main__':
 342   main(sys.argv[1:])