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 class UmaHistogramChangeMatchedOrNotTest(unittest.TestCase):
 274   def testTypicalCorrectlyMatchedChange(self):
 275     diff_cc = ['UMA_HISTOGRAM_BOOL("Bla.Foo.Dummy", true)']
 276     diff_xml = ['<histogram name="Bla.Foo.Dummy"> </histogram>']
 277     mock_input_api = MockInputApi()
 278     mock_input_api.files = [
 279       MockFile('some/path/foo.cc', diff_cc),
 280       MockFile('tools/metrics/histograms/histograms.xml', diff_xml),
 281     ]
 282     warnings = PRESUBMIT._CheckUmaHistogramChanges(mock_input_api,
 283                                                    MockOutputApi())
 284     self.assertEqual(0, len(warnings))
 285
 286   def testTypicalNotMatchedChange(self):
 287     diff_cc = ['UMA_HISTOGRAM_BOOL("Bla.Foo.Dummy", true)']
 288     mock_input_api = MockInputApi()
 289     mock_input_api.files = [MockFile('some/path/foo.cc', diff_cc)]
 290     warnings = PRESUBMIT._CheckUmaHistogramChanges(mock_input_api,
 291                                                    MockOutputApi())
 292     self.assertEqual(1, len(warnings))
 293     self.assertEqual('warning', warnings[0].type)
 294
 295   def testTypicalNotMatchedChangeViaSuffixes(self):
 296     diff_cc = ['UMA_HISTOGRAM_BOOL("Bla.Foo.Dummy", true)']
 297     diff_xml = ['<histogram_suffixes name="SuperHistogram">',
 298                 '  <suffix name="Dummy"/>',
 299                 '  <affected-histogram name="Snafu.Dummy"/>',
 300                 '</histogram>']
 301     mock_input_api = MockInputApi()
 302     mock_input_api.files = [
 303       MockFile('some/path/foo.cc', diff_cc),
 304       MockFile('tools/metrics/histograms/histograms.xml', diff_xml),
 305     ]
 306     warnings = PRESUBMIT._CheckUmaHistogramChanges(mock_input_api,
 307                                                    MockOutputApi())
 308     self.assertEqual(1, len(warnings))
 309     self.assertEqual('warning', warnings[0].type)
 310
 311   def testTypicalCorrectlyMatchedChangeViaSuffixes(self):
 312     diff_cc = ['UMA_HISTOGRAM_BOOL("Bla.Foo.Dummy", true)']
 313     diff_xml = ['<histogram_suffixes name="SuperHistogram">',
 314                 '  <suffix name="Dummy"/>',
 315                 '  <affected-histogram name="Bla.Foo"/>',
 316                 '</histogram>']
 317     mock_input_api = MockInputApi()
 318     mock_input_api.files = [
 319       MockFile('some/path/foo.cc', diff_cc),
 320       MockFile('tools/metrics/histograms/histograms.xml', diff_xml),
 321     ]
 322     warnings = PRESUBMIT._CheckUmaHistogramChanges(mock_input_api,
 323                                                    MockOutputApi())
 324     self.assertEqual(0, len(warnings))
 325
 326   def testTypicalCorrectlyMatchedChangeViaSuffixesWithSeparator(self):
 327     diff_cc = ['UMA_HISTOGRAM_BOOL("Snafu_Dummy", true)']
 328     diff_xml = ['<histogram_suffixes name="SuperHistogram" separator="_">',
 329                 '  <suffix name="Dummy"/>',
 330                 '  <affected-histogram name="Snafu"/>',
 331                 '</histogram>']
 332     mock_input_api = MockInputApi()
 333     mock_input_api.files = [
 334       MockFile('some/path/foo.cc', diff_cc),
 335       MockFile('tools/metrics/histograms/histograms.xml', diff_xml),
 336     ]
 337     warnings = PRESUBMIT._CheckUmaHistogramChanges(mock_input_api,
 338                                                    MockOutputApi())
 339     self.assertEqual(0, len(warnings))
 340
 341 class BadExtensionsTest(unittest.TestCase):
 342   def testBadRejFile(self):
 343     mock_input_api = MockInputApi()
 344     mock_input_api.files = [
 345       MockFile('some/path/foo.cc', ''),
 346       MockFile('some/path/foo.cc.rej', ''),
 347       MockFile('some/path2/bar.h.rej', ''),
 348     ]
 349
 350     results = PRESUBMIT._CheckPatchFiles(mock_input_api, MockOutputApi())
 351     self.assertEqual(1, len(results))
 352     self.assertEqual(2, len(results[0].items))
 353     self.assertTrue('foo.cc.rej' in results[0].items[0])
 354     self.assertTrue('bar.h.rej' in results[0].items[1])
 355
 356   def testBadOrigFile(self):
 357     mock_input_api = MockInputApi()
 358     mock_input_api.files = [
 359       MockFile('other/path/qux.h.orig', ''),
 360       MockFile('other/path/qux.h', ''),
 361       MockFile('other/path/qux.cc', ''),
 362     ]
 363
 364     results = PRESUBMIT._CheckPatchFiles(mock_input_api, MockOutputApi())
 365     self.assertEqual(1, len(results))
 366     self.assertEqual(1, len(results[0].items))
 367     self.assertTrue('qux.h.orig' in results[0].items[0])
 368
 369   def testGoodFiles(self):
 370     mock_input_api = MockInputApi()
 371     mock_input_api.files = [
 372       MockFile('other/path/qux.h', ''),
 373       MockFile('other/path/qux.cc', ''),
 374     ]
 375     results = PRESUBMIT._CheckPatchFiles(mock_input_api, MockOutputApi())
 376     self.assertEqual(0, len(results))
 377
 378   def testOnlyOwnersFiles(self):
 379     mock_change = MockChange([
 380       'some/path/OWNERS',
 381       'A\Windows\Path\OWNERS',
 382     ])
 383     results = PRESUBMIT.GetPreferredTryMasters(None, mock_change)
 384     self.assertEqual({}, results)
 385
 386
 387 class InvalidOSMacroNamesTest(unittest.TestCase):
 388   def testInvalidOSMacroNames(self):
 389     lines = ['#if defined(OS_WINDOWS)',
 390              ' #elif defined(OS_WINDOW)',
 391              ' # if defined(OS_MACOSX) || defined(OS_CHROME)',
 392              '# else  // defined(OS_MAC)',
 393              '#endif  // defined(OS_MACOS)']
 394     errors = PRESUBMIT._CheckForInvalidOSMacrosInFile(
 395         MockInputApi(), MockFile('some/path/foo_platform.cc', lines))
 396     self.assertEqual(len(lines), len(errors))
 397     self.assertTrue(':1 OS_WINDOWS' in errors[0])
 398     self.assertTrue('(did you mean OS_WIN?)' in errors[0])
 399
 400   def testValidOSMacroNames(self):
 401     lines = ['#if defined(%s)' % m for m in PRESUBMIT._VALID_OS_MACROS]
 402     errors = PRESUBMIT._CheckForInvalidOSMacrosInFile(
 403         MockInputApi(), MockFile('some/path/foo_platform.cc', lines))
 404     self.assertEqual(0, len(errors))
 405
 406
 407 class InvalidIfDefinedMacroNamesTest(unittest.TestCase):
 408   def testInvalidIfDefinedMacroNames(self):
 409     lines = ['#if defined(TARGET_IPHONE_SIMULATOR)',
 410              '#if !defined(TARGET_IPHONE_SIMULATOR)',
 411              '#elif defined(TARGET_IPHONE_SIMULATOR)',
 412              '#ifdef TARGET_IPHONE_SIMULATOR',
 413              ' # ifdef TARGET_IPHONE_SIMULATOR',
 414              '# if defined(VALID) || defined(TARGET_IPHONE_SIMULATOR)',
 415              '# else  // defined(TARGET_IPHONE_SIMULATOR)',
 416              '#endif  // defined(TARGET_IPHONE_SIMULATOR)',]
 417     errors = PRESUBMIT._CheckForInvalidIfDefinedMacrosInFile(
 418         MockInputApi(), MockFile('some/path/source.mm', lines))
 419     self.assertEqual(len(lines), len(errors))
 420
 421   def testValidIfDefinedMacroNames(self):
 422     lines = ['#if defined(FOO)',
 423              '#ifdef BAR',]
 424     errors = PRESUBMIT._CheckForInvalidIfDefinedMacrosInFile(
 425         MockInputApi(), MockFile('some/path/source.cc', lines))
 426     self.assertEqual(0, len(errors))
 427
 428
 429 class CheckAddedDepsHaveTetsApprovalsTest(unittest.TestCase):
 430   def testFilesToCheckForIncomingDeps(self):
 431     changed_lines = [
 432       '"+breakpad",',
 433       '"+chrome/installer",',
 434       '"+chrome/plugin/chrome_content_plugin_client.h",',
 435       '"+chrome/utility/chrome_content_utility_client.h",',
 436       '"+chromeos/chromeos_paths.h",',
 437       '"+components/crash",',
 438       '"+components/nacl/common",',
 439       '"+content/public/browser/render_process_host.h",',
 440       '"+jni/fooblat.h",',
 441       '"+grit",  # For generated headers',
 442       '"+grit/generated_resources.h",',
 443       '"+grit/",',
 444       '"+policy",  # For generated headers and source',
 445       '"+sandbox",',
 446       '"+tools/memory_watcher",',
 447       '"+third_party/lss/linux_syscall_support.h",',
 448     ]
 449     files_to_check = PRESUBMIT._FilesToCheckForIncomingDeps(re, changed_lines)
 450     expected = set([
 451       'breakpad/DEPS',
 452       'chrome/installer/DEPS',
 453       'chrome/plugin/chrome_content_plugin_client.h',
 454       'chrome/utility/chrome_content_utility_client.h',
 455       'chromeos/chromeos_paths.h',
 456       'components/crash/DEPS',
 457       'components/nacl/common/DEPS',
 458       'content/public/browser/render_process_host.h',
 459       'policy/DEPS',
 460       'sandbox/DEPS',
 461       'tools/memory_watcher/DEPS',
 462       'third_party/lss/linux_syscall_support.h',
 463     ])
 464     self.assertEqual(expected, files_to_check);
 465
 466
 467 class JSONParsingTest(unittest.TestCase):
 468   def testSuccess(self):
 469     input_api = MockInputApi()
 470     filename = 'valid_json.json'
 471     contents = ['// This is a comment.',
 472                 '{',
 473                 '  "key1": ["value1", "value2"],',
 474                 '  "key2": 3  // This is an inline comment.',
 475                 '}'
 476                 ]
 477     input_api.files = [MockFile(filename, contents)]
 478     self.assertEqual(None,
 479                      PRESUBMIT._GetJSONParseError(input_api, filename))
 480
 481   def testFailure(self):
 482     input_api = MockInputApi()
 483     test_data = [
 484       ('invalid_json_1.json',
 485        ['{ x }'],
 486        'Expecting property name:'),
 487       ('invalid_json_2.json',
 488        ['// Hello world!',
 489         '{ "hello": "world }'],
 490        'Unterminated string starting at:'),
 491       ('invalid_json_3.json',
 492        ['{ "a": "b", "c": "d", }'],
 493        'Expecting property name:'),
 494       ('invalid_json_4.json',
 495        ['{ "a": "b" "c": "d" }'],
 496        'Expecting , delimiter:'),
 497       ]
 498
 499     input_api.files = [MockFile(filename, contents)
 500                        for (filename, contents, _) in test_data]
 501
 502     for (filename, _, expected_error) in test_data:
 503       actual_error = PRESUBMIT._GetJSONParseError(input_api, filename)
 504       self.assertTrue(expected_error in str(actual_error),
 505                       "'%s' not found in '%s'" % (expected_error, actual_error))
 506
 507   def testNoEatComments(self):
 508     input_api = MockInputApi()
 509     file_with_comments = 'file_with_comments.json'
 510     contents_with_comments = ['// This is a comment.',
 511                               '{',
 512                               '  "key1": ["value1", "value2"],',
 513                               '  "key2": 3  // This is an inline comment.',
 514                               '}'
 515                               ]
 516     file_without_comments = 'file_without_comments.json'
 517     contents_without_comments = ['{',
 518                                  '  "key1": ["value1", "value2"],',
 519                                  '  "key2": 3',
 520                                  '}'
 521                                  ]
 522     input_api.files = [MockFile(file_with_comments, contents_with_comments),
 523                        MockFile(file_without_comments,
 524                                 contents_without_comments)]
 525
 526     self.assertEqual('No JSON object could be decoded',
 527                      str(PRESUBMIT._GetJSONParseError(input_api,
 528                                                       file_with_comments,
 529                                                       eat_comments=False)))
 530     self.assertEqual(None,
 531                      PRESUBMIT._GetJSONParseError(input_api,
 532                                                   file_without_comments,
 533                                                   eat_comments=False))
 534
 535
 536 class IDLParsingTest(unittest.TestCase):
 537   def testSuccess(self):
 538     input_api = MockInputApi()
 539     filename = 'valid_idl_basics.idl'
 540     contents = ['// Tests a valid IDL file.',
 541                 'namespace idl_basics {',
 542                 '  enum EnumType {',
 543                 '    name1,',
 544                 '    name2',
 545                 '  };',
 546                 '',
 547                 '  dictionary MyType1 {',
 548                 '    DOMString a;',
 549                 '  };',
 550                 '',
 551                 '  callback Callback1 = void();',
 552                 '  callback Callback2 = void(long x);',
 553                 '  callback Callback3 = void(MyType1 arg);',
 554                 '  callback Callback4 = void(EnumType type);',
 555                 '',
 556                 '  interface Functions {',
 557                 '    static void function1();',
 558                 '    static void function2(long x);',
 559                 '    static void function3(MyType1 arg);',
 560                 '    static void function4(Callback1 cb);',
 561                 '    static void function5(Callback2 cb);',
 562                 '    static void function6(Callback3 cb);',
 563                 '    static void function7(Callback4 cb);',
 564                 '  };',
 565                 '',
 566                 '  interface Events {',
 567                 '    static void onFoo1();',
 568                 '    static void onFoo2(long x);',
 569                 '    static void onFoo2(MyType1 arg);',
 570                 '    static void onFoo3(EnumType type);',
 571                 '  };',
 572                 '};'
 573                 ]
 574     input_api.files = [MockFile(filename, contents)]
 575     self.assertEqual(None,
 576                      PRESUBMIT._GetIDLParseError(input_api, filename))
 577
 578   def testFailure(self):
 579     input_api = MockInputApi()
 580     test_data = [
 581       ('invalid_idl_1.idl',
 582        ['//',
 583         'namespace test {',
 584         '  dictionary {',
 585         '    DOMString s;',
 586         '  };',
 587         '};'],
 588        'Unexpected "{" after keyword "dictionary".\n'),
 589       # TODO(yoz): Disabled because it causes the IDL parser to hang.
 590       # See crbug.com/363830.
 591       # ('invalid_idl_2.idl',
 592       #  (['namespace test {',
 593       #    '  dictionary MissingSemicolon {',
 594       #    '    DOMString a',
 595       #    '    DOMString b;',
 596       #    '  };',
 597       #    '};'],
 598       #   'Unexpected symbol DOMString after symbol a.'),
 599       ('invalid_idl_3.idl',
 600        ['//',
 601         'namespace test {',
 602         '  enum MissingComma {',
 603         '    name1',
 604         '    name2',
 605         '  };',
 606         '};'],
 607        'Unexpected symbol name2 after symbol name1.'),
 608       ('invalid_idl_4.idl',
 609        ['//',
 610         'namespace test {',
 611         '  enum TrailingComma {',
 612         '    name1,',
 613         '    name2,',
 614         '  };',
 615         '};'],
 616        'Trailing comma in block.'),
 617       ('invalid_idl_5.idl',
 618        ['//',
 619         'namespace test {',
 620         '  callback Callback1 = void(;',
 621         '};'],
 622        'Unexpected ";" after "(".'),
 623       ('invalid_idl_6.idl',
 624        ['//',
 625         'namespace test {',
 626         '  callback Callback1 = void(long );',
 627         '};'],
 628        'Unexpected ")" after symbol long.'),
 629       ('invalid_idl_7.idl',
 630        ['//',
 631         'namespace test {',
 632         '  interace Events {',
 633         '    static void onFoo1();',
 634         '  };',
 635         '};'],
 636        'Unexpected symbol Events after symbol interace.'),
 637       ('invalid_idl_8.idl',
 638        ['//',
 639         'namespace test {',
 640         '  interface NotEvent {',
 641         '    static void onFoo1();',
 642         '  };',
 643         '};'],
 644        'Did not process Interface Interface(NotEvent)'),
 645       ('invalid_idl_9.idl',
 646        ['//',
 647         'namespace test {',
 648         '  interface {',
 649         '    static void function1();',
 650         '  };',
 651         '};'],
 652        'Interface missing name.'),
 653       ]
 654
 655     input_api.files = [MockFile(filename, contents)
 656                        for (filename, contents, _) in test_data]
 657
 658     for (filename, _, expected_error) in test_data:
 659       actual_error = PRESUBMIT._GetIDLParseError(input_api, filename)
 660       self.assertTrue(expected_error in str(actual_error),
 661                       "'%s' not found in '%s'" % (expected_error, actual_error))
 662
 663
 664 class TryServerMasterTest(unittest.TestCase):
 665   def testTryServerMasters(self):
 666     bots = {
 667         'tryserver.chromium.gpu': [
 668             'win_gpu',
 669             'win_gpu_triggered_tests',
 670         ],
 671         'tryserver.chromium.mac': [
 672             'ios_dbg_simulator',
 673             'ios_rel_device',
 674             'ios_rel_device_ninja',
 675             'mac_asan',
 676             'mac_asan_64',
 677             'mac_chromium_compile_dbg',
 678             'mac_chromium_compile_rel',
 679             'mac_chromium_dbg',
 680             'mac_chromium_rel',
 681             'mac_nacl_sdk',
 682             'mac_nacl_sdk_build',
 683             'mac_rel_naclmore',
 684             'mac_valgrind',
 685             'mac_x64_rel',
 686             'mac_xcodebuild',
 687         ],
 688         'tryserver.chromium.linux': [
 689             'android_aosp',
 690             'android_chromium_gn_compile_dbg',
 691             'android_chromium_gn_compile_rel',
 692             'android_clang_dbg',
 693             'android_dbg',
 694             'android_dbg_recipe',
 695             'android_dbg_triggered_tests',
 696             'android_dbg_triggered_tests_recipe',
 697             'android_fyi_dbg',
 698             'android_fyi_dbg_triggered_tests',
 699             'android_rel',
 700             'android_rel_triggered_tests',
 701             'android_x86_dbg',
 702             'blink_android_compile_dbg',
 703             'blink_android_compile_rel',
 704             'blink_presubmit',
 705             'chromium_presubmit',
 706             'linux_arm_cross_compile',
 707             'linux_arm_tester',
 708             'linux_chromeos_asan',
 709             'linux_chromeos_browser_asan',
 710             'linux_chromeos_valgrind',
 711             'linux_chromium_chromeos_dbg',
 712             'linux_chromium_chromeos_rel',
 713             'linux_chromium_compile_dbg',
 714             'linux_chromium_compile_rel',
 715             'linux_chromium_dbg',
 716             'linux_chromium_gn_dbg',
 717             'linux_chromium_gn_rel',
 718             'linux_chromium_rel',
 719             'linux_chromium_trusty32_dbg',
 720             'linux_chromium_trusty32_rel',
 721             'linux_chromium_trusty_dbg',
 722             'linux_chromium_trusty_rel',
 723             'linux_clang_tsan',
 724             'linux_ecs_ozone',
 725             'linux_layout',
 726             'linux_layout_asan',
 727             'linux_layout_rel',
 728             'linux_layout_rel_32',
 729             'linux_nacl_sdk',
 730             'linux_nacl_sdk_bionic',
 731             'linux_nacl_sdk_bionic_build',
 732             'linux_nacl_sdk_build',
 733             'linux_redux',
 734             'linux_rel_naclmore',
 735             'linux_rel_precise32',
 736             'linux_valgrind',
 737             'tools_build_presubmit',
 738         ],
 739         'tryserver.chromium.win': [
 740             'win8_aura',
 741             'win8_chromium_dbg',
 742             'win8_chromium_rel',
 743             'win_chromium_compile_dbg',
 744             'win_chromium_compile_rel',
 745             'win_chromium_dbg',
 746             'win_chromium_rel',
 747             'win_chromium_rel',
 748             'win_chromium_x64_dbg',
 749             'win_chromium_x64_rel',
 750             'win_drmemory',
 751             'win_nacl_sdk',
 752             'win_nacl_sdk_build',
 753             'win_rel_naclmore',
 754          ],
 755     }
 756     for master, bots in bots.iteritems():
 757       for bot in bots:
 758         self.assertEqual(master, PRESUBMIT.GetTryServerMasterForBot(bot),
 759                          'bot=%s: expected %s, computed %s' % (
 760             bot, master, PRESUBMIT.GetTryServerMasterForBot(bot)))
 761
 762
 763 if __name__ == '__main__':
 764   unittest.main()