| #!/usr/bin/env python3 |
| # 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 contains various tests for the C++ -> Java enum generator. |
| """ |
| |
| import collections |
| from datetime import date |
| import unittest |
| |
| import java_cpp_enum |
| from java_cpp_enum import EnumDefinition, GenerateOutput |
| from java_cpp_enum import HeaderParser |
| from util import java_cpp_utils |
| |
| |
| class TestPreprocess(unittest.TestCase): |
| def testOutput(self): |
| definition = EnumDefinition(original_enum_name='ClassName', |
| enum_package='some.package', |
| entries=[('E1', 1), ('E2', '2 << 2')], |
| comments=[('E2', 'This is a comment.'), |
| ('E1', 'This is a multiple line ' |
| 'comment that is really long. ' |
| 'This is a multiple line ' |
| 'comment that is really ' |
| 'really long.')]) |
| output = GenerateOutput('path/to/file', definition) |
| expected = """ |
| // Copyright %d 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. |
| |
| // This file is autogenerated by |
| // %s |
| // From |
| // path/to/file |
| |
| package some.package; |
| |
| import androidx.annotation.IntDef; |
| |
| import java.lang.annotation.Retention; |
| import java.lang.annotation.RetentionPolicy; |
| |
| @IntDef({ |
| ClassName.E1, ClassName.E2 |
| }) |
| @Retention(RetentionPolicy.SOURCE) |
| public @interface ClassName { |
| /** |
| * %s |
| * really really long. |
| */ |
| int E1 = 1; |
| /** |
| * This is a comment. |
| */ |
| int E2 = 2 << 2; |
| } |
| """ |
| long_comment = ('This is a multiple line comment that is really long. ' |
| 'This is a multiple line comment that is') |
| self.assertEqual( |
| expected % (date.today().year, java_cpp_utils.GetScriptName(), |
| long_comment), output) |
| |
| def testParseSimpleEnum(self): |
| test_data = """ |
| // GENERATED_JAVA_ENUM_PACKAGE: test.namespace |
| enum EnumName { |
| VALUE_ZERO, |
| VALUE_ONE, |
| }; |
| """.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.enum_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, |
| }; |
| |
| // 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(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') |
| expected_entries = collections.OrderedDict([ |
| ('VALUE_ZERO', '1 << 0'), |
| ('VALUE_ONE', 'SymbolKey | FnKey | AltGrKey | MetaKey | AltKey | ' |
| 'ControlKey'), |
| ('VALUE_TWO', '1 << 18')]) |
| definitions = HeaderParser(test_data).ParseDefinitions() |
| self.assertEqual(1, len(definitions)) |
| definition = definitions[0] |
| self.assertEqual('Foo', definition.class_name) |
| self.assertEqual('bar.namespace', definition.enum_package) |
| self.assertEqual(expected_entries, definition.entries) |
| |
| def testParseEnumEntryWithTrailingMultilineEntry(self): |
| test_data = """ |
| // GENERATED_JAVA_ENUM_PACKAGE: bar.namespace |
| enum Foo { |
| VALUE_ZERO = 1, |
| VALUE_ONE = |
| SymbolKey | FnKey | AltGrKey | MetaKey | |
| AltKey | ControlKey | ShiftKey, |
| }; |
| """.split('\n') |
| expected_entries = collections.OrderedDict([ |
| ('VALUE_ZERO', '1'), |
| ('VALUE_ONE', 'SymbolKey | FnKey | AltGrKey | MetaKey | AltKey | ' |
| 'ControlKey | ShiftKey')]) |
| definitions = HeaderParser(test_data).ParseDefinitions() |
| self.assertEqual(1, len(definitions)) |
| definition = definitions[0] |
| self.assertEqual('Foo', definition.class_name) |
| self.assertEqual('bar.namespace', definition.enum_package) |
| self.assertEqual(expected_entries, definition.entries) |
| |
| def testParseNoCommaAfterLastEntry(self): |
| test_data = """ |
| // GENERATED_JAVA_ENUM_PACKAGE: bar.namespace |
| enum Foo { |
| VALUE_ZERO = 1, |
| |
| // This is a multiline |
| // |
| // comment with an empty line. |
| VALUE_ONE = 2 |
| }; |
| """.split('\n') |
| expected_entries = collections.OrderedDict([ |
| ('VALUE_ZERO', '1'), |
| ('VALUE_ONE', '2')]) |
| expected_comments = collections.OrderedDict([ |
| ('VALUE_ONE', 'This is a multiline comment with an empty line.')]) |
| definitions = HeaderParser(test_data).ParseDefinitions() |
| self.assertEqual(1, len(definitions)) |
| definition = definitions[0] |
| self.assertEqual('Foo', definition.class_name) |
| self.assertEqual('bar.namespace', definition.enum_package) |
| self.assertEqual(expected_entries, definition.entries) |
| self.assertEqual(expected_comments, definition.comments) |
| |
| def testParseClassNameOverride(self): |
| test_data = """ |
| // GENERATED_JAVA_ENUM_PACKAGE: test.namespace |
| // GENERATED_JAVA_CLASS_NAME_OVERRIDE: OverrideName |
| enum EnumName { |
| FOO |
| }; |
| |
| // GENERATED_JAVA_ENUM_PACKAGE: test.namespace |
| // GENERATED_JAVA_CLASS_NAME_OVERRIDE: OtherOverride |
| enum PrefixTest { |
| PREFIX_TEST_A, |
| PREFIX_TEST_B, |
| }; |
| """.split('\n') |
| definitions = HeaderParser(test_data).ParseDefinitions() |
| self.assertEqual(2, len(definitions)) |
| definition = definitions[0] |
| self.assertEqual('OverrideName', definition.class_name) |
| |
| definition = definitions[1] |
| self.assertEqual('OtherOverride', definition.class_name) |
| self.assertEqual(collections.OrderedDict([('A', 0), |
| ('B', 1)]), |
| definition.entries) |
| |
| def testParsePreservesCommentsWhenPrefixStripping(self): |
| test_data = """ |
| // GENERATED_JAVA_ENUM_PACKAGE: test.namespace |
| enum EnumOne { |
| ENUM_ONE_A = 1, |
| // Comment there |
| ENUM_ONE_B = A, |
| }; |
| |
| enum EnumIgnore { |
| C, D, E |
| }; |
| |
| // GENERATED_JAVA_ENUM_PACKAGE: other.package |
| // GENERATED_JAVA_PREFIX_TO_STRIP: P_ |
| enum EnumTwo { |
| P_A, |
| // This comment spans |
| // two lines. |
| P_B |
| }; |
| """.split('\n') |
| definitions = HeaderParser(test_data).ParseDefinitions() |
| self.assertEqual(2, len(definitions)) |
| definition = definitions[0] |
| self.assertEqual('EnumOne', definition.class_name) |
| self.assertEqual('test.namespace', definition.enum_package) |
| self.assertEqual(collections.OrderedDict([('A', '1'), |
| ('B', 'A')]), |
| definition.entries) |
| self.assertEqual(collections.OrderedDict([('B', 'Comment there')]), |
| definition.comments) |
| definition = definitions[1] |
| self.assertEqual('EnumTwo', definition.class_name) |
| self.assertEqual('other.package', definition.enum_package) |
| self.assertEqual(collections.OrderedDict( |
| [('B', 'This comment spans two lines.')]), definition.comments) |
| self.assertEqual(collections.OrderedDict([('A', 0), |
| ('B', 1)]), |
| definition.entries) |
| |
| def testParseTwoEnums(self): |
| test_data = """ |
| // GENERATED_JAVA_ENUM_PACKAGE: test.namespace |
| enum AnEnum { |
| ENUM_ONE_A = 1, |
| ENUM_ONE_B = A, |
| }; |
| |
| enum EnumIgnore { |
| C, D, E |
| }; |
| |
| // GENERATED_JAVA_ENUM_PACKAGE: other.package |
| enum EnumTwo { |
| P_A, |
| P_B |
| }; |
| """.split('\n') |
| definitions = HeaderParser(test_data).ParseDefinitions() |
| self.assertEqual(2, len(definitions)) |
| definition = definitions[0] |
| self.assertEqual('AnEnum', definition.class_name) |
| self.assertEqual('test.namespace', definition.enum_package) |
| self.assertEqual(collections.OrderedDict([('ENUM_ONE_A', '1'), |
| ('ENUM_ONE_B', 'A')]), |
| definition.entries) |
| definition = definitions[1] |
| self.assertEqual('EnumTwo', definition.class_name) |
| self.assertEqual('other.package', definition.enum_package) |
| self.assertEqual(collections.OrderedDict([('P_A', 0), |
| ('P_B', 1)]), |
| definition.entries) |
| |
| def testParseSingleLineEnum(self): |
| test_data = """ |
| // GENERATED_JAVA_ENUM_PACKAGE: other.package |
| // GENERATED_JAVA_PREFIX_TO_STRIP: P_ |
| 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([('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([('A', '1'), ('B', '2')]), |
| definition.entries) |
| self.assertEqual( |
| collections.OrderedDict([('B', 'comment for 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 |
| 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() |
| |
| def testParseReturnsEmptyListWithoutDirectives(self): |
| test_data = """ |
| enum EnumName { |
| VALUE_ONE, |
| }; |
| """.split('\n') |
| self.assertEqual([], HeaderParser(test_data).ParseDefinitions()) |
| |
| def testParseEnumClass(self): |
| test_data = """ |
| // GENERATED_JAVA_ENUM_PACKAGE: test.namespace |
| enum class Foo { |
| FOO_A, |
| }; |
| """.split('\n') |
| definitions = HeaderParser(test_data).ParseDefinitions() |
| self.assertEqual(1, len(definitions)) |
| definition = definitions[0] |
| self.assertEqual('Foo', definition.class_name) |
| self.assertEqual('test.namespace', definition.enum_package) |
| self.assertEqual(collections.OrderedDict([('A', 0)]), |
| definition.entries) |
| |
| def testParseEnumClassOneValueSubstringOfAnother(self): |
| test_data = """ |
| // GENERATED_JAVA_ENUM_PACKAGE: test.namespace |
| enum class SafeBrowsingStatus { |
| kChecking = 0, |
| kEnabled = 1, |
| kDisabled = 2, |
| kDisabledByAdmin = 3, |
| kDisabledByExtension = 4, |
| kEnabledStandard = 5, |
| kEnabledEnhanced = 6, |
| // New enum values must go above here. |
| kMaxValue = kEnabledEnhanced, |
| }; |
| """.split('\n') |
| definitions = HeaderParser(test_data).ParseDefinitions() |
| self.assertEqual(1, len(definitions)) |
| definition = definitions[0] |
| self.assertEqual('SafeBrowsingStatus', definition.class_name) |
| self.assertEqual('test.namespace', definition.enum_package) |
| self.assertEqual( |
| collections.OrderedDict([ |
| ('CHECKING', '0'), |
| ('ENABLED', '1'), |
| ('DISABLED', '2'), |
| ('DISABLED_BY_ADMIN', '3'), |
| ('DISABLED_BY_EXTENSION', '4'), |
| ('ENABLED_STANDARD', '5'), |
| ('ENABLED_ENHANCED', '6'), |
| ('MAX_VALUE', 'ENABLED_ENHANCED'), |
| ]), definition.entries) |
| self.assertEqual( |
| collections.OrderedDict([ |
| ('MAX_VALUE', 'New enum values must go above here.') |
| ]), definition.comments) |
| |
| def testParseEnumStruct(self): |
| test_data = """ |
| // GENERATED_JAVA_ENUM_PACKAGE: test.namespace |
| enum struct Foo { |
| FOO_A, |
| }; |
| """.split('\n') |
| definitions = HeaderParser(test_data).ParseDefinitions() |
| self.assertEqual(1, len(definitions)) |
| definition = definitions[0] |
| self.assertEqual('Foo', definition.class_name) |
| self.assertEqual('test.namespace', definition.enum_package) |
| self.assertEqual(collections.OrderedDict([('A', 0)]), |
| definition.entries) |
| |
| def testParseFixedTypeEnum(self): |
| test_data = """ |
| // GENERATED_JAVA_ENUM_PACKAGE: test.namespace |
| enum Foo : int { |
| FOO_A, |
| }; |
| """.split('\n') |
| definitions = HeaderParser(test_data).ParseDefinitions() |
| self.assertEqual(1, len(definitions)) |
| definition = definitions[0] |
| self.assertEqual('Foo', definition.class_name) |
| self.assertEqual('test.namespace', definition.enum_package) |
| self.assertEqual('int', definition.fixed_type) |
| self.assertEqual(collections.OrderedDict([('A', 0)]), |
| definition.entries) |
| |
| def testParseFixedTypeEnumClass(self): |
| test_data = """ |
| // GENERATED_JAVA_ENUM_PACKAGE: test.namespace |
| enum class Foo: unsigned short { |
| FOO_A, |
| }; |
| """.split('\n') |
| definitions = HeaderParser(test_data).ParseDefinitions() |
| self.assertEqual(1, len(definitions)) |
| definition = definitions[0] |
| self.assertEqual('Foo', definition.class_name) |
| self.assertEqual('test.namespace', definition.enum_package) |
| self.assertEqual('unsigned short', definition.fixed_type) |
| self.assertEqual(collections.OrderedDict([('A', 0)]), |
| definition.entries) |
| |
| def testParseUnknownFixedTypeRaises(self): |
| test_data = """ |
| // GENERATED_JAVA_ENUM_PACKAGE: test.namespace |
| enum class Foo: foo_type { |
| FOO_A, |
| }; |
| """.split('\n') |
| with self.assertRaises(Exception): |
| HeaderParser(test_data).ParseDefinitions() |
| |
| def testParseSimpleMultiLineDirective(self): |
| test_data = """ |
| // GENERATED_JAVA_ENUM_PACKAGE: ( |
| // test.namespace) |
| // GENERATED_JAVA_CLASS_NAME_OVERRIDE: Bar |
| enum Foo { |
| FOO_A, |
| }; |
| """.split('\n') |
| definitions = HeaderParser(test_data).ParseDefinitions() |
| self.assertEqual('test.namespace', definitions[0].enum_package) |
| self.assertEqual('Bar', definitions[0].class_name) |
| |
| def testParseMultiLineDirective(self): |
| test_data = """ |
| // GENERATED_JAVA_ENUM_PACKAGE: (te |
| // st.name |
| // space) |
| enum Foo { |
| FOO_A, |
| }; |
| """.split('\n') |
| definitions = HeaderParser(test_data).ParseDefinitions() |
| self.assertEqual('test.namespace', definitions[0].enum_package) |
| |
| def testParseMultiLineDirectiveWithOtherDirective(self): |
| test_data = """ |
| // GENERATED_JAVA_ENUM_PACKAGE: ( |
| // test.namespace) |
| // GENERATED_JAVA_CLASS_NAME_OVERRIDE: ( |
| // Ba |
| // r |
| // ) |
| enum Foo { |
| FOO_A, |
| }; |
| """.split('\n') |
| definitions = HeaderParser(test_data).ParseDefinitions() |
| self.assertEqual('test.namespace', definitions[0].enum_package) |
| self.assertEqual('Bar', definitions[0].class_name) |
| |
| def testParseMalformedMultiLineDirectiveWithOtherDirective(self): |
| test_data = """ |
| // GENERATED_JAVA_ENUM_PACKAGE: ( |
| // test.name |
| // space |
| // GENERATED_JAVA_CLASS_NAME_OVERRIDE: Bar |
| enum Foo { |
| FOO_A, |
| }; |
| """.split('\n') |
| with self.assertRaises(Exception): |
| HeaderParser(test_data).ParseDefinitions() |
| |
| def testParseMalformedMultiLineDirective(self): |
| test_data = """ |
| // GENERATED_JAVA_ENUM_PACKAGE: ( |
| // test.name |
| // space |
| enum Foo { |
| FOO_A, |
| }; |
| """.split('\n') |
| with self.assertRaises(Exception): |
| HeaderParser(test_data).ParseDefinitions() |
| |
| def testParseMalformedMultiLineDirectiveShort(self): |
| test_data = """ |
| // GENERATED_JAVA_ENUM_PACKAGE: ( |
| enum Foo { |
| FOO_A, |
| }; |
| """.split('\n') |
| with self.assertRaises(Exception): |
| HeaderParser(test_data).ParseDefinitions() |
| |
| def testParseMalformedMultiLineDirectiveMissingBrackets(self): |
| test_data = """ |
| // GENERATED_JAVA_ENUM_PACKAGE: |
| // test.namespace |
| enum Foo { |
| FOO_A, |
| }; |
| """.split('\n') |
| with self.assertRaises(Exception): |
| HeaderParser(test_data).ParseDefinitions() |
| |
| def testEnumValueAssignmentNoneDefined(self): |
| definition = EnumDefinition(original_enum_name='c', enum_package='p') |
| definition.AppendEntry('A', None) |
| definition.AppendEntry('B', None) |
| definition.AppendEntry('C', None) |
| definition.Finalize() |
| self.assertEqual(collections.OrderedDict([('A', 0), |
| ('B', 1), |
| ('C', 2)]), |
| definition.entries) |
| |
| def testEnumValueAssignmentAllDefined(self): |
| definition = EnumDefinition(original_enum_name='c', enum_package='p') |
| definition.AppendEntry('A', '1') |
| definition.AppendEntry('B', '2') |
| definition.AppendEntry('C', '3') |
| definition.Finalize() |
| self.assertEqual(collections.OrderedDict([('A', '1'), |
| ('B', '2'), |
| ('C', '3')]), |
| definition.entries) |
| |
| def testEnumValueAssignmentReferences(self): |
| definition = EnumDefinition(original_enum_name='c', enum_package='p') |
| definition.AppendEntry('A', None) |
| 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(original_enum_name='c', enum_package='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(original_enum_name='c', enum_package='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(original_enum_name='c', enum_package='p') |
| definition.AppendEntry('A', None) |
| definition.AppendEntry('B', 'foo') |
| definition.AppendEntry('C', None) |
| with self.assertRaises(Exception): |
| definition.Finalize() |
| |
| def testExplicitPrefixStripping(self): |
| definition = EnumDefinition(original_enum_name='c', enum_package='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(collections.OrderedDict([('A', 0), |
| ('B', 1), |
| ('C', 2), |
| ('LAST', 2)]), |
| definition.entries) |
| |
| def testImplicitPrefixStripping(self): |
| definition = EnumDefinition(original_enum_name='ClassName', |
| enum_package='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(collections.OrderedDict([('A', 0), |
| ('B', 1), |
| ('C', 2), |
| ('LAST', 2)]), |
| definition.entries) |
| |
| def testImplicitPrefixStrippingRequiresAllConstantsToBePrefixed(self): |
| definition = EnumDefinition(original_enum_name='Name', |
| enum_package='p') |
| definition.AppendEntry('A', None) |
| definition.AppendEntry('B', None) |
| definition.AppendEntry('NAME_LAST', None) |
| definition.Finalize() |
| self.assertEqual(['A', 'B', 'NAME_LAST'], list(definition.entries.keys())) |
| |
| def testGenerateThrowsOnEmptyInput(self): |
| with self.assertRaises(Exception): |
| original_do_parse = java_cpp_enum.DoParseHeaderFile |
| try: |
| java_cpp_enum.DoParseHeaderFile = lambda _: [] |
| for _ in java_cpp_enum.DoGenerate(['file']): |
| pass |
| finally: |
| java_cpp_enum.DoParseHeaderFile = original_do_parse |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |
