Android: convert kEnumName to ENUM_NAME in java_cpp_enum.py.

build/android/gyp/java_cpp_enum_tests.py

 #!/usr/bin/env python
 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Tests for enum_preprocess.py.
 
 This test suite containss various tests for the C++ -> Java enum generator.
 """
 
@@ skipping 79 matching lines @@
                                               ('VALUE_ONE', 1)]),
                      definition.entries)
 
   def testParseBitShifts(self):
     test_data = """
       // GENERATED_JAVA_ENUM_PACKAGE: test.namespace
       enum EnumName {
         VALUE_ZERO = 1 << 0,
         VALUE_ONE = 1 << 1,
       };
+
+      // GENERATED_JAVA_ENUM_PACKAGE: test.namespace
+      enum EnumName {
+        ENUM_NAME_ZERO = 1 << 0,
+        ENUM_NAME_ONE = 1 << 1,
+        ENUM_NAME_TWO = ENUM_NAME_ZERO | ENUM_NAME_ONE,
+      };
     """.split('\n')
     definitions = HeaderParser(test_data).ParseDefinitions()
-    self.assertEqual(1, len(definitions))
+    self.assertEqual(2, len(definitions))
     definition = definitions[0]
     self.assertEqual('EnumName', definition.class_name)
     self.assertEqual('test.namespace', definition.enum_package)
     self.assertEqual(collections.OrderedDict([('VALUE_ZERO', '1 << 0'),
                                               ('VALUE_ONE', '1 << 1')]),
                      definition.entries)
 
+    definition = definitions[1]
+    expected_entries = collections.OrderedDict([
+        ('ZERO', '1 << 0'),
+        ('ONE', '1 << 1'),
+        ('TWO', 'ZERO | ONE')])
+    self.assertEqual(expected_entries, definition.entries)
+
   def testParseMultilineEnumEntry(self):
     test_data = """
       // GENERATED_JAVA_ENUM_PACKAGE: bar.namespace
       enum Foo {
         VALUE_ZERO = 1 << 0,
         VALUE_ONE =
             SymbolKey | FnKey | AltGrKey | MetaKey | AltKey | ControlKey,
         VALUE_TWO = 1 << 18,
       };
     """.split('\n')
@@ skipping 162 matching lines @@
       enum EnumTwo { P_A, P_B };
     """.split('\n')
     definitions = HeaderParser(test_data).ParseDefinitions()
     definition = definitions[0]
     self.assertEqual('EnumTwo', definition.class_name)
     self.assertEqual('other.package', definition.enum_package)
     self.assertEqual(collections.OrderedDict([('A', 0),
                                               ('B', 1)]),
                      definition.entries)
 
+  def testParseWithStrippingAndRelativeReferences(self):
+    test_data = """
+      // GENERATED_JAVA_ENUM_PACKAGE: other.package
+      // GENERATED_JAVA_PREFIX_TO_STRIP: P_
+      enum EnumTwo {
+        P_A = 1,
+        // P_A is old-don't use P_A.
+        P_B = P_A,
+      };
+    """.split('\n')
+    definitions = HeaderParser(test_data).ParseDefinitions()
+    definition = definitions[0]
+    self.assertEqual('EnumTwo', definition.class_name)
+    self.assertEqual('other.package', definition.enum_package)
+    self.assertEqual(collections.OrderedDict([('A', '1'),
+                                              ('B', 'A')]),
+                     definition.entries)
+    self.assertEqual(collections.OrderedDict([('B', 'A is old-don\'t use A.')]),
+                     definition.comments)
+
   def testParseSingleLineAndRegularEnum(self):
     test_data = """
       // GENERATED_JAVA_ENUM_PACKAGE: test.namespace
       enum EnumOne {
         ENUM_ONE_A = 1,
         // Comment there
         ENUM_ONE_B = A,
       };
 
       // GENERATED_JAVA_ENUM_PACKAGE: other.package
       enum EnumTwo { P_A, P_B };
 
       // GENERATED_JAVA_ENUM_PACKAGE: test.namespace
       // GENERATED_JAVA_CLASS_NAME_OVERRIDE: OverrideName
       enum EnumName {
         ENUM_NAME_FOO
       };
     """.split('\n')
     definitions = HeaderParser(test_data).ParseDefinitions()
     definition = definitions[0]
     self.assertEqual(
         collections.OrderedDict([('A', '1'), ('B', 'A')]), definition.entries)
-    self.assertEqual(collections.OrderedDict([('ENUM_ONE_B', 'Comment there')]),
+    self.assertEqual(collections.OrderedDict([('B', 'Comment there')]),
                      definition.comments)
 
     self.assertEqual(3, len(definitions))
     definition = definitions[1]
     self.assertEqual(
         collections.OrderedDict([('P_A', 0), ('P_B', 1)]), definition.entries)
 
     definition = definitions[2]
     self.assertEqual(collections.OrderedDict([('FOO', 0)]), definition.entries)
 
+  def testParseWithCamelCaseNames(self):
+    test_data = """
+      // GENERATED_JAVA_ENUM_PACKAGE: test.namespace
+      enum EnumTest {
+        EnumTestA = 1,
+        // comment for EnumTestB.
+        EnumTestB = 2,
+      };
+
+      // GENERATED_JAVA_ENUM_PACKAGE: test.namespace
+      // GENERATED_JAVA_PREFIX_TO_STRIP: Test
+      enum AnEnum {
+        TestHTTPOption,
+        TestHTTPSOption,
+      };
+
+    """.split('\n')
+    definitions = HeaderParser(test_data).ParseDefinitions()
+    definition = definitions[0]
+    self.assertEqual(
+        collections.OrderedDict([('ENUM_TEST_A', '1'), ('ENUM_TEST_B', '2')]),
+        definition.entries)
+    self.assertEqual(
+        collections.OrderedDict([('ENUM_TEST_B', 'comment for ENUM_TEST_B.')]),
+        definition.comments)
+
+    definition = definitions[1]
+    self.assertEqual(
+        collections.OrderedDict([('HTTP_OPTION', 0), ('HTTPS_OPTION', 1)]),
+        definition.entries)
+
+  def testParseWithKCamelCaseNames(self):
+    test_data = """
+      // GENERATED_JAVA_ENUM_PACKAGE: test.namespace
+      enum EnumOne {
+        kEnumOne = 1,
+        // comment for kEnumTwo.
+        kEnumTwo = 2,
+      };
+
+      // GENERATED_JAVA_ENUM_PACKAGE: test.namespace
+      // GENERATED_JAVA_CLASS_NAME_OVERRIDE: OverrideName
+      // GENERATED_JAVA_PREFIX_TO_STRIP: kEnumName
+      enum EnumName {
+        kEnumNameFoo,
+        kEnumNameBar
+      };
+
+      // GENERATED_JAVA_ENUM_PACKAGE: test.namespace
+      enum EnumName {
+        kEnumNameFoo,
+        kEnumBar,
+      };
+
+      // GENERATED_JAVA_ENUM_PACKAGE: test.namespace
+      enum Keys {
+        kSymbolKey = 1 << 0,
+        kAltKey = 1 << 1,
+        kUpKey = 1 << 2,
+        kKeyModifiers = kSymbolKey | kAltKey | kUpKey | kKeyModifiers,
+      };
+
+      // GENERATED_JAVA_ENUM_PACKAGE: test.namespace
+      enum Mixed {
+        kTestVal,
+        kCodecMPEG2
+      };
+    """.split('\n')
+    definitions = HeaderParser(test_data).ParseDefinitions()
+    definition = definitions[0]
+    self.assertEqual(
+        collections.OrderedDict([('ENUM_ONE', '1'), ('ENUM_TWO', '2')]),
+        definition.entries)
+    self.assertEqual(
+        collections.OrderedDict([('ENUM_TWO', 'comment for ENUM_TWO.')]),
+        definition.comments)
+
+    definition = definitions[1]
+    self.assertEqual(
+        collections.OrderedDict([('FOO', 0), ('BAR', 1)]),
+        definition.entries)
+
+    definition = definitions[2]
+    self.assertEqual(
+        collections.OrderedDict([('ENUM_NAME_FOO', 0), ('ENUM_BAR', 1)]),
+        definition.entries)
+
+    definition = definitions[3]
+    expected_entries = collections.OrderedDict([
+        ('SYMBOL_KEY', '1 << 0'),
+        ('ALT_KEY', '1 << 1'),
+        ('UP_KEY', '1 << 2'),
+        ('KEY_MODIFIERS', 'SYMBOL_KEY | ALT_KEY | UP_KEY | KEY_MODIFIERS')])
+    self.assertEqual(expected_entries, definition.entries)
+
+    definition = definitions[4]
+    self.assertEqual(
+        collections.OrderedDict([('TEST_VAL', 0), ('CODEC_MPEG2', 1)]),
+        definition.entries)
+
   def testParseThrowsOnUnknownDirective(self):
     test_data = """
       // GENERATED_JAVA_UNKNOWN: Value
       enum EnumName {
         VALUE_ONE,
       };
     """.split('\n')
     with self.assertRaises(Exception):
       HeaderParser(test_data).ParseDefinitions()
 
@@ skipping 284 matching lines @@
   options, _ = parser.parse_args(argv)
 
   suite = unittest.TestLoader().loadTestsFromTestCase(TestPreprocess)
   unittest.TextTestRunner(verbosity=0).run(suite)
 
   if options.stamp:
     build_utils.Touch(options.stamp)
 
 if __name__ == '__main__':
   main(sys.argv[1:])