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