Final step of the java_cpp_template -> java_cpp_enum migration.

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.
 """
 
 import collections
+import optparse
+import os
+import sys
 import unittest
+
 from java_cpp_enum import EnumDefinition, GenerateOutput, HeaderParser
 
+sys.path.append(os.path.join(os.path.dirname(__file__), "gyp"))
+from util import build_utils
+
 class TestPreprocess(unittest.TestCase):
   def testOutput(self):
     definition = EnumDefinition(class_name='ClassName',
                                 class_package='some.package',
                                 entries=[('E1', 1), ('E2', '2 << 2')])
     output = GenerateOutput('path/to/file', definition)
     expected = """
 // 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.
@@ skipping 22 matching lines @@
     """.split('\n')
     definitions = HeaderParser(test_data).ParseDefinitions()
     self.assertEqual(1, len(definitions))
     definition = definitions[0]
     self.assertEqual('EnumName', definition.class_name)
     self.assertEqual('test.namespace', definition.class_package)
     self.assertEqual(collections.OrderedDict([('VALUE_ZERO', 0),
                                               ('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,
+      };
+    """.split('\n')
+    definitions = HeaderParser(test_data).ParseDefinitions()
+    self.assertEqual(1, len(definitions))
+    definition = definitions[0]
+    self.assertEqual('EnumName', definition.class_name)
+    self.assertEqual('test.namespace', definition.class_package)
+    self.assertEqual(collections.OrderedDict([('VALUE_ZERO', '1 << 0'),
+                                              ('VALUE_ONE', '1 << 1')]),
+                     definition.entries)
+
+  def testParseClassNameOverride(self):
+    test_data = """
+      // GENERATED_JAVA_ENUM_PACKAGE: test.namespace
+      // GENERATED_JAVA_CLASS_NAME_OVERRIDE: OverrideName
+      enum EnumName {
+        FOO
+      };
+    """.split('\n')
+    definitions = HeaderParser(test_data).ParseDefinitions()
+    self.assertEqual(1, len(definitions))
+    definition = definitions[0]
+    self.assertEqual('OverrideName', definition.class_name)
+
   def testParseTwoEnums(self):
     test_data = """
       // GENERATED_JAVA_ENUM_PACKAGE: test.namespace
       enum EnumOne {
         ENUM_ONE_A = 1,
         // Comment there
         ENUM_ONE_B = A,
       };
 
       enum EnumIgnore {
@@ skipping 51 matching lines @@
     definition.AppendEntry('B', 'A')
     definition.AppendEntry('C', None)
     definition.AppendEntry('D', 'C')
     definition.Finalize()
     self.assertEqual(collections.OrderedDict([('A', 0),
                                               ('B', 0),
                                               ('C', 1),
                                               ('D', 1)]),
                      definition.entries)
 
+  def testEnumValueAssignmentSet(self):
+    definition = EnumDefinition('c', 'p', [])
+    definition.AppendEntry('A', None)
+    definition.AppendEntry('B', '2')
+    definition.AppendEntry('C', None)
+    definition.Finalize()
+    self.assertEqual(collections.OrderedDict([('A', 0),
+                                              ('B', 2),
+                                              ('C', 3)]),
+                     definition.entries)
+
+  def testEnumValueAssignmentSetReferences(self):
+    definition = EnumDefinition('c', 'p', [])
+    definition.AppendEntry('A', None)
+    definition.AppendEntry('B', 'A')
+    definition.AppendEntry('C', 'B')
+    definition.AppendEntry('D', None)
+    definition.Finalize()
+    self.assertEqual(collections.OrderedDict([('A', 0),
+                                              ('B', 0),
+                                              ('C', 0),
+                                              ('D', 1)]),
+                     definition.entries)
+
   def testEnumValueAssignmentRaises(self):
     definition = EnumDefinition('c', 'p', [])
     definition.AppendEntry('A', None)
-    definition.AppendEntry('B', '1')
+    definition.AppendEntry('B', 'foo')
     definition.AppendEntry('C', None)
     with self.assertRaises(Exception):
       definition.Finalize()
 
   def testExplicitPrefixStripping(self):
     definition = EnumDefinition('c', 'p', [])
     definition.AppendEntry('P_A', None)
     definition.AppendEntry('B', None)
     definition.AppendEntry('P_C', None)
+    definition.AppendEntry('P_LAST', 'P_C')
     definition.prefix_to_strip = 'P_'
     definition.Finalize()
-    self.assertEqual(['A', 'B', 'C'], definition.entries.keys())
+    self.assertEqual(collections.OrderedDict([('A', 0),
+                                              ('B', 1),
+                                              ('C', 2),
+                                              ('LAST', 2)]),
+                     definition.entries)
 
   def testImplicitPrefixStripping(self):
     definition = EnumDefinition('ClassName', 'p', [])
     definition.AppendEntry('CLASS_NAME_A', None)
     definition.AppendEntry('CLASS_NAME_B', None)
     definition.AppendEntry('CLASS_NAME_C', None)
+    definition.AppendEntry('CLASS_NAME_LAST', 'CLASS_NAME_C')
     definition.Finalize()
-    self.assertEqual(['A', 'B', 'C'], definition.entries.keys())
+    self.assertEqual(collections.OrderedDict([('A', 0),
+                                              ('B', 1),
+                                              ('C', 2),
+                                              ('LAST', 2)]),
+                     definition.entries)
 
   def testImplicitPrefixStrippingRequiresAllConstantsToBePrefixed(self):
     definition = EnumDefinition('Name', 'p', [])
     definition.AppendEntry('A', None)
     definition.AppendEntry('B', None)
     definition.AppendEntry('NAME_LAST', None)
     definition.Finalize()
     self.assertEqual(['A', 'B', 'NAME_LAST'], definition.entries.keys())
 
+def main(argv):
+  parser = optparse.OptionParser()
+  parser.add_option("--stamp", help="File to touch on success.")
+  options, _ = parser.parse_args(argv)
+
+  suite = unittest.TestLoader().loadTestsFromTestCase(TestPreprocess)
+  unittest.TextTestRunner().run(suite)
+
+  if options.stamp:
+    build_utils.Touch(options.stamp)
 
 if __name__ == '__main__':
-  unittest.main()
+  main(sys.argv[1:])