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