PRESUBMIT_test.py

   1 #!/usr/bin/env python
   2 # Copyright (c) 2012 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 import glob
   7 import json
   8 import os
   9 import re
  10 import subprocess
  11 import sys
  12 import unittest
  13
  14 import PRESUBMIT
  15
  16
  17 _TEST_DATA_DIR = 'base/test/data/presubmit'
  18
  19
  20 class MockInputApi(object):
  21   def __init__(self):
  22     self.json = json
  23     self.re = re
  24     self.os_path = os.path
  25     self.python_executable = sys.executable
  26     self.subprocess = subprocess
  27     self.files = []
  28     self.is_committing = False
  29
  30   def AffectedFiles(self):
  31     return self.files
  32
  33   def PresubmitLocalPath(self):
  34     return os.path.dirname(__file__)
  35
  36   def ReadFile(self, filename, mode='rU'):
  37     for file_ in self.files:
  38       if file_.LocalPath() == filename:
  39         return '\n'.join(file_.NewContents())
  40     # Otherwise, file is not in our mock API.
  41     raise IOError, "No such file or directory: '%s'" % filename
  42
  43
  44 class MockOutputApi(object):
  45   class PresubmitResult(object):
  46     def __init__(self, message, items=None, long_text=''):
  47       self.message = message
  48       self.items = items
  49       self.long_text = long_text
  50
  51   class PresubmitError(PresubmitResult):
  52     def __init__(self, message, items, long_text=''):
  53       MockOutputApi.PresubmitResult.__init__(self, message, items, long_text)
  54       self.type = 'error'
  55
  56   class PresubmitPromptWarning(PresubmitResult):
  57     def __init__(self, message, items, long_text=''):
  58       MockOutputApi.PresubmitResult.__init__(self, message, items, long_text)
  59       self.type = 'warning'
  60
  61   class PresubmitNotifyResult(PresubmitResult):
  62     def __init__(self, message, items, long_text=''):
  63       MockOutputApi.PresubmitResult.__init__(self, message, items, long_text)
  64       self.type = 'notify'
  65
  66   class PresubmitPromptOrNotify(PresubmitResult):
  67     def __init__(self, message, items, long_text=''):
  68       MockOutputApi.PresubmitResult.__init__(self, message, items, long_text)
  69       self.type = 'promptOrNotify'
  70
  71
  72 class MockFile(object):
  73   def __init__(self, local_path, new_contents):
  74     self._local_path = local_path
  75     self._new_contents = new_contents
  76     self._changed_contents = [(i + 1, l) for i, l in enumerate(new_contents)]
  77
  78   def ChangedContents(self):
  79     return self._changed_contents
  80
  81   def NewContents(self):
  82     return self._new_contents
  83
  84   def LocalPath(self):
  85     return self._local_path
  86
  87
  88 class MockChange(object):
  89   def __init__(self, changed_files):
  90     self._changed_files = changed_files
  91
  92   def LocalPaths(self):
  93     return self._changed_files
  94
  95
  96 class IncludeOrderTest(unittest.TestCase):
  97   def testSystemHeaderOrder(self):
  98     scope = [(1, '#include <csystem.h>'),
  99              (2, '#include <cppsystem>'),
 100              (3, '#include "acustom.h"')]
 101     all_linenums = [linenum for (linenum, _) in scope]
 102     mock_input_api = MockInputApi()
 103     warnings = PRESUBMIT._CheckIncludeOrderForScope(scope, mock_input_api,
 104                                                     '', all_linenums)
 105     self.assertEqual(0, len(warnings))
 106
 107   def testSystemHeaderOrderMismatch1(self):
 108     scope = [(10, '#include <cppsystem>'),
 109              (20, '#include <csystem.h>'),
 110              (30, '#include "acustom.h"')]
 111     all_linenums = [linenum for (linenum, _) in scope]
 112     mock_input_api = MockInputApi()
 113     warnings = PRESUBMIT._CheckIncludeOrderForScope(scope, mock_input_api,
 114                                                     '', all_linenums)
 115     self.assertEqual(1, len(warnings))
 116     self.assertTrue('20' in warnings[0])
 117
 118   def testSystemHeaderOrderMismatch2(self):
 119     scope = [(10, '#include <cppsystem>'),
 120              (20, '#include "acustom.h"'),
 121              (30, '#include <csystem.h>')]
 122     all_linenums = [linenum for (linenum, _) in scope]
 123     mock_input_api = MockInputApi()
 124     warnings = PRESUBMIT._CheckIncludeOrderForScope(scope, mock_input_api,
 125                                                     '', all_linenums)
 126     self.assertEqual(1, len(warnings))
 127     self.assertTrue('30' in warnings[0])
 128
 129   def testSystemHeaderOrderMismatch3(self):
 130     scope = [(10, '#include "acustom.h"'),
 131              (20, '#include <csystem.h>'),
 132              (30, '#include <cppsystem>')]
 133     all_linenums = [linenum for (linenum, _) in scope]
 134     mock_input_api = MockInputApi()
 135     warnings = PRESUBMIT._CheckIncludeOrderForScope(scope, mock_input_api,
 136                                                     '', all_linenums)
 137     self.assertEqual(2, len(warnings))
 138     self.assertTrue('20' in warnings[0])
 139     self.assertTrue('30' in warnings[1])
 140
 141   def testAlphabeticalOrderMismatch(self):
 142     scope = [(10, '#include <csystem.h>'),
 143              (15, '#include <bsystem.h>'),
 144              (20, '#include <cppsystem>'),
 145              (25, '#include <bppsystem>'),
 146              (30, '#include "bcustom.h"'),
 147              (35, '#include "acustom.h"')]
 148     all_linenums = [linenum for (linenum, _) in scope]
 149     mock_input_api = MockInputApi()
 150     warnings = PRESUBMIT._CheckIncludeOrderForScope(scope, mock_input_api,
 151                                                     '', all_linenums)
 152     self.assertEqual(3, len(warnings))
 153     self.assertTrue('15' in warnings[0])
 154     self.assertTrue('25' in warnings[1])
 155     self.assertTrue('35' in warnings[2])
 156
 157   def testSpecialFirstInclude1(self):
 158     mock_input_api = MockInputApi()
 159     contents = ['#include "some/path/foo.h"',
 160                 '#include "a/header.h"']
 161     mock_file = MockFile('some/path/foo.cc', contents)
 162     warnings = PRESUBMIT._CheckIncludeOrderInFile(
 163         mock_input_api, mock_file, range(1, len(contents) + 1))
 164     self.assertEqual(0, len(warnings))
 165
 166   def testSpecialFirstInclude2(self):
 167     mock_input_api = MockInputApi()
 168     contents = ['#include "some/other/path/foo.h"',
 169                 '#include "a/header.h"']
 170     mock_file = MockFile('some/path/foo.cc', contents)
 171     warnings = PRESUBMIT._CheckIncludeOrderInFile(
 172         mock_input_api, mock_file, range(1, len(contents) + 1))
 173     self.assertEqual(0, len(warnings))
 174
 175   def testSpecialFirstInclude3(self):
 176     mock_input_api = MockInputApi()
 177     contents = ['#include "some/path/foo.h"',
 178                 '#include "a/header.h"']
 179     mock_file = MockFile('some/path/foo_platform.cc', contents)
 180     warnings = PRESUBMIT._CheckIncludeOrderInFile(
 181         mock_input_api, mock_file, range(1, len(contents) + 1))
 182     self.assertEqual(0, len(warnings))
 183
 184   def testSpecialFirstInclude4(self):
 185     mock_input_api = MockInputApi()
 186     contents = ['#include "some/path/bar.h"',
 187                 '#include "a/header.h"']
 188     mock_file = MockFile('some/path/foo_platform.cc', contents)
 189     warnings = PRESUBMIT._CheckIncludeOrderInFile(
 190         mock_input_api, mock_file, range(1, len(contents) + 1))
 191     self.assertEqual(1, len(warnings))
 192     self.assertTrue('2' in warnings[0])
 193
 194   def testSpecialFirstInclude5(self):
 195     mock_input_api = MockInputApi()
 196     contents = ['#include "some/other/path/foo.h"',
 197                 '#include "a/header.h"']
 198     mock_file = MockFile('some/path/foo-suffix.h', contents)
 199     warnings = PRESUBMIT._CheckIncludeOrderInFile(
 200         mock_input_api, mock_file, range(1, len(contents) + 1))
 201     self.assertEqual(0, len(warnings))
 202
 203   def testSpecialFirstInclude6(self):
 204     mock_input_api = MockInputApi()
 205     contents = ['#include "some/other/path/foo_win.h"',
 206                 '#include <set>',
 207                 '#include "a/header.h"']
 208     mock_file = MockFile('some/path/foo_unittest_win.h', contents)
 209     warnings = PRESUBMIT._CheckIncludeOrderInFile(
 210         mock_input_api, mock_file, range(1, len(contents) + 1))
 211     self.assertEqual(0, len(warnings))
 212
 213   def testOrderAlreadyWrong(self):
 214     scope = [(1, '#include "b.h"'),
 215              (2, '#include "a.h"'),
 216              (3, '#include "c.h"')]
 217     mock_input_api = MockInputApi()
 218     warnings = PRESUBMIT._CheckIncludeOrderForScope(scope, mock_input_api,
 219                                                     '', [3])
 220     self.assertEqual(0, len(warnings))
 221
 222   def testConflictAdded1(self):
 223     scope = [(1, '#include "a.h"'),
 224              (2, '#include "c.h"'),
 225              (3, '#include "b.h"')]
 226     mock_input_api = MockInputApi()
 227     warnings = PRESUBMIT._CheckIncludeOrderForScope(scope, mock_input_api,
 228                                                     '', [2])
 229     self.assertEqual(1, len(warnings))
 230     self.assertTrue('3' in warnings[0])
 231
 232   def testConflictAdded2(self):
 233     scope = [(1, '#include "c.h"'),
 234              (2, '#include "b.h"'),
 235              (3, '#include "d.h"')]
 236     mock_input_api = MockInputApi()
 237     warnings = PRESUBMIT._CheckIncludeOrderForScope(scope, mock_input_api,
 238                                                     '', [2])
 239     self.assertEqual(1, len(warnings))
 240     self.assertTrue('2' in warnings[0])
 241
 242   def testIfElifElseEndif(self):
 243     mock_input_api = MockInputApi()
 244     contents = ['#include "e.h"',
 245                 '#define foo',
 246                 '#include "f.h"',
 247                 '#undef foo',
 248                 '#include "e.h"',
 249                 '#if foo',
 250                 '#include "d.h"',
 251                 '#elif bar',
 252                 '#include "c.h"',
 253                 '#else',
 254                 '#include "b.h"',
 255                 '#endif',
 256                 '#include "a.h"']
 257     mock_file = MockFile('', contents)
 258     warnings = PRESUBMIT._CheckIncludeOrderInFile(
 259         mock_input_api, mock_file, range(1, len(contents) + 1))
 260     self.assertEqual(0, len(warnings))
 261
 262   def testExcludedIncludes(self):
 263     # #include <sys/...>'s can appear in any order.
 264     mock_input_api = MockInputApi()
 265     contents = ['#include <sys/b.h>',
 266                 '#include <sys/a.h>']
 267     mock_file = MockFile('', contents)
 268     warnings = PRESUBMIT._CheckIncludeOrderInFile(
 269         mock_input_api, mock_file, range(1, len(contents) + 1))
 270     self.assertEqual(0, len(warnings))
 271
 272     contents = ['#include <atlbase.h>',
 273                 '#include <aaa.h>']
 274     mock_file = MockFile('', contents)
 275     warnings = PRESUBMIT._CheckIncludeOrderInFile(
 276         mock_input_api, mock_file, range(1, len(contents) + 1))
 277     self.assertEqual(0, len(warnings))
 278
 279     contents = ['#include "build/build_config.h"',
 280                 '#include "aaa.h"']
 281     mock_file = MockFile('', contents)
 282     warnings = PRESUBMIT._CheckIncludeOrderInFile(
 283         mock_input_api, mock_file, range(1, len(contents) + 1))
 284     self.assertEqual(0, len(warnings))
 285
 286   def testCheckOnlyCFiles(self):
 287     mock_input_api = MockInputApi()
 288     mock_output_api = MockOutputApi()
 289     contents = ['#include <b.h>',
 290                 '#include <a.h>']
 291     mock_file_cc = MockFile('something.cc', contents)
 292     mock_file_h = MockFile('something.h', contents)
 293     mock_file_other = MockFile('something.py', contents)
 294     mock_input_api.files = [mock_file_cc, mock_file_h, mock_file_other]
 295     warnings = PRESUBMIT._CheckIncludeOrder(mock_input_api, mock_output_api)
 296     self.assertEqual(1, len(warnings))
 297     self.assertEqual(2, len(warnings[0].items))
 298     self.assertEqual('promptOrNotify', warnings[0].type)
 299
 300   def testUncheckableIncludes(self):
 301     mock_input_api = MockInputApi()
 302     contents = ['#include <windows.h>',
 303                 '#include "b.h"',
 304                 '#include "a.h"']
 305     mock_file = MockFile('', contents)
 306     warnings = PRESUBMIT._CheckIncludeOrderInFile(
 307         mock_input_api, mock_file, range(1, len(contents) + 1))
 308     self.assertEqual(1, len(warnings))
 309
 310     contents = ['#include "gpu/command_buffer/gles_autogen.h"',
 311                 '#include "b.h"',
 312                 '#include "a.h"']
 313     mock_file = MockFile('', contents)
 314     warnings = PRESUBMIT._CheckIncludeOrderInFile(
 315         mock_input_api, mock_file, range(1, len(contents) + 1))
 316     self.assertEqual(1, len(warnings))
 317
 318     contents = ['#include "gl_mock_autogen.h"',
 319                 '#include "b.h"',
 320                 '#include "a.h"']
 321     mock_file = MockFile('', contents)
 322     warnings = PRESUBMIT._CheckIncludeOrderInFile(
 323         mock_input_api, mock_file, range(1, len(contents) + 1))
 324     self.assertEqual(1, len(warnings))
 325
 326     contents = ['#include "ipc/some_macros.h"',
 327                 '#include "b.h"',
 328                 '#include "a.h"']
 329     mock_file = MockFile('', contents)
 330     warnings = PRESUBMIT._CheckIncludeOrderInFile(
 331         mock_input_api, mock_file, range(1, len(contents) + 1))
 332     self.assertEqual(1, len(warnings))
 333
 334
 335 class VersionControlConflictsTest(unittest.TestCase):
 336   def testTypicalConflict(self):
 337     lines = ['<<<<<<< HEAD',
 338              '  base::ScopedTempDir temp_dir_;',
 339              '=======',
 340              '  ScopedTempDir temp_dir_;',
 341              '>>>>>>> master']
 342     errors = PRESUBMIT._CheckForVersionControlConflictsInFile(
 343         MockInputApi(), MockFile('some/path/foo_platform.cc', lines))
 344     self.assertEqual(3, len(errors))
 345     self.assertTrue('1' in errors[0])
 346     self.assertTrue('3' in errors[1])
 347     self.assertTrue('5' in errors[2])
 348
 349
 350 class BadExtensionsTest(unittest.TestCase):
 351   def testBadRejFile(self):
 352     mock_input_api = MockInputApi()
 353     mock_input_api.files = [
 354       MockFile('some/path/foo.cc', ''),
 355       MockFile('some/path/foo.cc.rej', ''),
 356       MockFile('some/path2/bar.h.rej', ''),
 357     ]
 358
 359     results = PRESUBMIT._CheckPatchFiles(mock_input_api, MockOutputApi())
 360     self.assertEqual(1, len(results))
 361     self.assertEqual(2, len(results[0].items))
 362     self.assertTrue('foo.cc.rej' in results[0].items[0])
 363     self.assertTrue('bar.h.rej' in results[0].items[1])
 364
 365   def testBadOrigFile(self):
 366     mock_input_api = MockInputApi()
 367     mock_input_api.files = [
 368       MockFile('other/path/qux.h.orig', ''),
 369       MockFile('other/path/qux.h', ''),
 370       MockFile('other/path/qux.cc', ''),
 371     ]
 372
 373     results = PRESUBMIT._CheckPatchFiles(mock_input_api, MockOutputApi())
 374     self.assertEqual(1, len(results))
 375     self.assertEqual(1, len(results[0].items))
 376     self.assertTrue('qux.h.orig' in results[0].items[0])
 377
 378   def testGoodFiles(self):
 379     mock_input_api = MockInputApi()
 380     mock_input_api.files = [
 381       MockFile('other/path/qux.h', ''),
 382       MockFile('other/path/qux.cc', ''),
 383     ]
 384     results = PRESUBMIT._CheckPatchFiles(mock_input_api, MockOutputApi())
 385     self.assertEqual(0, len(results))
 386
 387   def testOnlyOwnersFiles(self):
 388     mock_change = MockChange([
 389       'some/path/OWNERS',
 390       'A\Windows\Path\OWNERS',
 391     ])
 392     results = PRESUBMIT.GetPreferredTryMasters(None, mock_change)
 393     self.assertEqual({}, results)
 394
 395
 396 class InvalidOSMacroNamesTest(unittest.TestCase):
 397   def testInvalidOSMacroNames(self):
 398     lines = ['#if defined(OS_WINDOWS)',
 399              ' #elif defined(OS_WINDOW)',
 400              ' # if defined(OS_MACOSX) || defined(OS_CHROME)',
 401              '# else  // defined(OS_MAC)',
 402              '#endif  // defined(OS_MACOS)']
 403     errors = PRESUBMIT._CheckForInvalidOSMacrosInFile(
 404         MockInputApi(), MockFile('some/path/foo_platform.cc', lines))
 405     self.assertEqual(len(lines), len(errors))
 406     self.assertTrue(':1 OS_WINDOWS' in errors[0])
 407     self.assertTrue('(did you mean OS_WIN?)' in errors[0])
 408
 409   def testValidOSMacroNames(self):
 410     lines = ['#if defined(%s)' % m for m in PRESUBMIT._VALID_OS_MACROS]
 411     errors = PRESUBMIT._CheckForInvalidOSMacrosInFile(
 412         MockInputApi(), MockFile('some/path/foo_platform.cc', lines))
 413     self.assertEqual(0, len(errors))
 414
 415
 416 class CheckAddedDepsHaveTetsApprovalsTest(unittest.TestCase):
 417   def testFilesToCheckForIncomingDeps(self):
 418     changed_lines = [
 419       '"+breakpad",',
 420       '"+chrome/installer",',
 421       '"+chrome/plugin/chrome_content_plugin_client.h",',
 422       '"+chrome/utility/chrome_content_utility_client.h",',
 423       '"+chromeos/chromeos_paths.h",',
 424       '"+components/breakpad",',
 425       '"+components/nacl/common",',
 426       '"+content/public/browser/render_process_host.h",',
 427       '"+jni/fooblat.h",',
 428       '"+grit",  # For generated headers',
 429       '"+grit/generated_resources.h",',
 430       '"+grit/",',
 431       '"+policy",  # For generated headers and source',
 432       '"+sandbox",',
 433       '"+tools/memory_watcher",',
 434       '"+third_party/lss/linux_syscall_support.h",',
 435     ]
 436     files_to_check = PRESUBMIT._FilesToCheckForIncomingDeps(re, changed_lines)
 437     expected = set([
 438       'breakpad/DEPS',
 439       'chrome/installer/DEPS',
 440       'chrome/plugin/chrome_content_plugin_client.h',
 441       'chrome/utility/chrome_content_utility_client.h',
 442       'chromeos/chromeos_paths.h',
 443       'components/breakpad/DEPS',
 444       'components/nacl/common/DEPS',
 445       'content/public/browser/render_process_host.h',
 446       'policy/DEPS',
 447       'sandbox/DEPS',
 448       'tools/memory_watcher/DEPS',
 449       'third_party/lss/linux_syscall_support.h',
 450     ])
 451     self.assertEqual(expected, files_to_check);
 452
 453
 454 class JSONParsingTest(unittest.TestCase):
 455   def testSuccess(self):
 456     input_api = MockInputApi()
 457     filename = 'valid_json.json'
 458     contents = ['// This is a comment.',
 459                 '{',
 460                 '  "key1": ["value1", "value2"],',
 461                 '  "key2": 3  // This is an inline comment.',
 462                 '}'
 463                 ]
 464     input_api.files = [MockFile(filename, contents)]
 465     self.assertEqual(None,
 466                      PRESUBMIT._GetJSONParseError(input_api, filename))
 467
 468   def testFailure(self):
 469     input_api = MockInputApi()
 470     test_data = [
 471       ('invalid_json_1.json',
 472        ['{ x }'],
 473        'Expecting property name: line 1 column 2 (char 2)'),
 474       ('invalid_json_2.json',
 475        ['// Hello world!',
 476         '{ "hello": "world }'],
 477        'Unterminated string starting at: line 2 column 12 (char 12)'),
 478       ('invalid_json_3.json',
 479        ['{ "a": "b", "c": "d", }'],
 480        'Expecting property name: line 1 column 22 (char 22)'),
 481       ('invalid_json_4.json',
 482        ['{ "a": "b" "c": "d" }'],
 483        'Expecting , delimiter: line 1 column 11 (char 11)'),
 484       ]
 485
 486     input_api.files = [MockFile(filename, contents)
 487                        for (filename, contents, _) in test_data]
 488
 489     for (filename, _, expected_error) in test_data:
 490       actual_error = PRESUBMIT._GetJSONParseError(input_api, filename)
 491       self.assertEqual(expected_error, str(actual_error))
 492
 493   def testNoEatComments(self):
 494     input_api = MockInputApi()
 495     file_with_comments = 'file_with_comments.json'
 496     contents_with_comments = ['// This is a comment.',
 497                               '{',
 498                               '  "key1": ["value1", "value2"],',
 499                               '  "key2": 3  // This is an inline comment.',
 500                               '}'
 501                               ]
 502     file_without_comments = 'file_without_comments.json'
 503     contents_without_comments = ['{',
 504                                  '  "key1": ["value1", "value2"],',
 505                                  '  "key2": 3',
 506                                  '}'
 507                                  ]
 508     input_api.files = [MockFile(file_with_comments, contents_with_comments),
 509                        MockFile(file_without_comments,
 510                                 contents_without_comments)]
 511
 512     self.assertEqual('No JSON object could be decoded',
 513                      str(PRESUBMIT._GetJSONParseError(input_api,
 514                                                       file_with_comments,
 515                                                       eat_comments=False)))
 516     self.assertEqual(None,
 517                      PRESUBMIT._GetJSONParseError(input_api,
 518                                                   file_without_comments,
 519                                                   eat_comments=False))
 520
 521
 522 class IDLParsingTest(unittest.TestCase):
 523   def testSuccess(self):
 524     input_api = MockInputApi()
 525     filename = 'valid_idl_basics.idl'
 526     contents = ['// Tests a valid IDL file.',
 527                 'namespace idl_basics {',
 528                 '  enum EnumType {',
 529                 '    name1,',
 530                 '    name2',
 531                 '  };',
 532                 '',
 533                 '  dictionary MyType1 {',
 534                 '    DOMString a;',
 535                 '  };',
 536                 '',
 537                 '  callback Callback1 = void();',
 538                 '  callback Callback2 = void(long x);',
 539                 '  callback Callback3 = void(MyType1 arg);',
 540                 '  callback Callback4 = void(EnumType type);',
 541                 '',
 542                 '  interface Functions {',
 543                 '    static void function1();',
 544                 '    static void function2(long x);',
 545                 '    static void function3(MyType1 arg);',
 546                 '    static void function4(Callback1 cb);',
 547                 '    static void function5(Callback2 cb);',
 548                 '    static void function6(Callback3 cb);',
 549                 '    static void function7(Callback4 cb);',
 550                 '  };',
 551                 '',
 552                 '  interface Events {',
 553                 '    static void onFoo1();',
 554                 '    static void onFoo2(long x);',
 555                 '    static void onFoo2(MyType1 arg);',
 556                 '    static void onFoo3(EnumType type);',
 557                 '  };',
 558                 '};'
 559                 ]
 560     input_api.files = [MockFile(filename, contents)]
 561     self.assertEqual(None,
 562                      PRESUBMIT._GetIDLParseError(input_api, filename))
 563
 564   def testFailure(self):
 565     input_api = MockInputApi()
 566     test_data = [
 567       ('invalid_idl_1.idl',
 568        ['//',
 569         'namespace test {',
 570         '  dictionary {',
 571         '    DOMString s;',
 572         '  };',
 573         '};'],
 574        'Unexpected "{" after keyword "dictionary".\n'),
 575       # TODO(yoz): Disabled because it causes the IDL parser to hang.
 576       # See crbug.com/363830.
 577       # ('invalid_idl_2.idl',
 578       #  (['namespace test {',
 579       #    '  dictionary MissingSemicolon {',
 580       #    '    DOMString a',
 581       #    '    DOMString b;',
 582       #    '  };',
 583       #    '};'],
 584       #   'Unexpected symbol DOMString after symbol a.'),
 585       ('invalid_idl_3.idl',
 586        ['//',
 587         'namespace test {',
 588         '  enum MissingComma {',
 589         '    name1',
 590         '    name2',
 591         '  };',
 592         '};'],
 593        'Unexpected symbol name2 after symbol name1.'),
 594       ('invalid_idl_4.idl',
 595        ['//',
 596         'namespace test {',
 597         '  enum TrailingComma {',
 598         '    name1,',
 599         '    name2,',
 600         '  };',
 601         '};'],
 602        'Trailing comma in block.'),
 603       ('invalid_idl_5.idl',
 604        ['//',
 605         'namespace test {',
 606         '  callback Callback1 = void(;',
 607         '};'],
 608        'Unexpected ";" after "(".'),
 609       ('invalid_idl_6.idl',
 610        ['//',
 611         'namespace test {',
 612         '  callback Callback1 = void(long );',
 613         '};'],
 614        'Unexpected ")" after symbol long.'),
 615       ('invalid_idl_7.idl',
 616        ['//',
 617         'namespace test {',
 618         '  interace Events {',
 619         '    static void onFoo1();',
 620         '  };',
 621         '};'],
 622        'Unexpected symbol Events after symbol interace.'),
 623       ('invalid_idl_8.idl',
 624        ['//',
 625         'namespace test {',
 626         '  interface NotEvent {',
 627         '    static void onFoo1();',
 628         '  };',
 629         '};'],
 630        'Did not process Interface Interface(NotEvent)'),
 631       ('invalid_idl_9.idl',
 632        ['//',
 633         'namespace test {',
 634         '  interface {',
 635         '    static void function1();',
 636         '  };',
 637         '};'],
 638        'Interface missing name.'),
 639       ]
 640
 641     input_api.files = [MockFile(filename, contents)
 642                        for (filename, contents, _) in test_data]
 643
 644     for (filename, _, expected_error) in test_data:
 645       actual_error = PRESUBMIT._GetIDLParseError(input_api, filename)
 646       self.assertTrue(expected_error in str(actual_error),
 647                       "'%s' not found in '%s'" % (expected_error, actual_error))
 648
 649
 650 if __name__ == '__main__':
 651   unittest.main()