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, MockAffectedFile
  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 CheckSingletonInHeadersTest(unittest.TestCase):
 388   def testSingletonInArbitraryHeader(self):
 389     diff_singleton_h = ['base::subtle::AtomicWord '
 390                         'Singleton<Type, Traits, DifferentiatingType>::']
 391     diff_foo_h = ['// Singleton<Foo> in comment.',
 392                   'friend class Singleton<Foo>']
 393     diff_bad_h = ['Foo* foo = Singleton<Foo>::get();']
 394     mock_input_api = MockInputApi()
 395     mock_input_api.files = [MockAffectedFile('base/memory/singleton.h',
 396                                      diff_singleton_h),
 397                             MockAffectedFile('foo.h', diff_foo_h),
 398                             MockAffectedFile('bad.h', diff_bad_h)]
 399     warnings = PRESUBMIT._CheckSingletonInHeaders(mock_input_api,
 400                                                   MockOutputApi())
 401     self.assertEqual(1, len(warnings))
 402     self.assertEqual('error', warnings[0].type)
 403     self.assertTrue('Found Singleton<T>' in warnings[0].message)
 404
 405   def testSingletonInCC(self):
 406     diff_cc = ['Foo* foo = Singleton<Foo>::get();']
 407     mock_input_api = MockInputApi()
 408     mock_input_api.files = [MockAffectedFile('some/path/foo.cc', diff_cc)]
 409     warnings = PRESUBMIT._CheckSingletonInHeaders(mock_input_api,
 410                                                   MockOutputApi())
 411     self.assertEqual(0, len(warnings))
 412
 413
 414 class InvalidOSMacroNamesTest(unittest.TestCase):
 415   def testInvalidOSMacroNames(self):
 416     lines = ['#if defined(OS_WINDOWS)',
 417              ' #elif defined(OS_WINDOW)',
 418              ' # if defined(OS_MACOSX) || defined(OS_CHROME)',
 419              '# else  // defined(OS_MAC)',
 420              '#endif  // defined(OS_MACOS)']
 421     errors = PRESUBMIT._CheckForInvalidOSMacrosInFile(
 422         MockInputApi(), MockFile('some/path/foo_platform.cc', lines))
 423     self.assertEqual(len(lines), len(errors))
 424     self.assertTrue(':1 OS_WINDOWS' in errors[0])
 425     self.assertTrue('(did you mean OS_WIN?)' in errors[0])
 426
 427   def testValidOSMacroNames(self):
 428     lines = ['#if defined(%s)' % m for m in PRESUBMIT._VALID_OS_MACROS]
 429     errors = PRESUBMIT._CheckForInvalidOSMacrosInFile(
 430         MockInputApi(), MockFile('some/path/foo_platform.cc', lines))
 431     self.assertEqual(0, len(errors))
 432
 433
 434 class InvalidIfDefinedMacroNamesTest(unittest.TestCase):
 435   def testInvalidIfDefinedMacroNames(self):
 436     lines = ['#if defined(TARGET_IPHONE_SIMULATOR)',
 437              '#if !defined(TARGET_IPHONE_SIMULATOR)',
 438              '#elif defined(TARGET_IPHONE_SIMULATOR)',
 439              '#ifdef TARGET_IPHONE_SIMULATOR',
 440              ' # ifdef TARGET_IPHONE_SIMULATOR',
 441              '# if defined(VALID) || defined(TARGET_IPHONE_SIMULATOR)',
 442              '# else  // defined(TARGET_IPHONE_SIMULATOR)',
 443              '#endif  // defined(TARGET_IPHONE_SIMULATOR)',]
 444     errors = PRESUBMIT._CheckForInvalidIfDefinedMacrosInFile(
 445         MockInputApi(), MockFile('some/path/source.mm', lines))
 446     self.assertEqual(len(lines), len(errors))
 447
 448   def testValidIfDefinedMacroNames(self):
 449     lines = ['#if defined(FOO)',
 450              '#ifdef BAR',]
 451     errors = PRESUBMIT._CheckForInvalidIfDefinedMacrosInFile(
 452         MockInputApi(), MockFile('some/path/source.cc', lines))
 453     self.assertEqual(0, len(errors))
 454
 455
 456 class CheckAddedDepsHaveTetsApprovalsTest(unittest.TestCase):
 457   def testFilesToCheckForIncomingDeps(self):
 458     changed_lines = [
 459       '"+breakpad",',
 460       '"+chrome/installer",',
 461       '"+chrome/plugin/chrome_content_plugin_client.h",',
 462       '"+chrome/utility/chrome_content_utility_client.h",',
 463       '"+chromeos/chromeos_paths.h",',
 464       '"+components/crash",',
 465       '"+components/nacl/common",',
 466       '"+content/public/browser/render_process_host.h",',
 467       '"+jni/fooblat.h",',
 468       '"+grit",  # For generated headers',
 469       '"+grit/generated_resources.h",',
 470       '"+grit/",',
 471       '"+policy",  # For generated headers and source',
 472       '"+sandbox",',
 473       '"+tools/memory_watcher",',
 474       '"+third_party/lss/linux_syscall_support.h",',
 475     ]
 476     files_to_check = PRESUBMIT._FilesToCheckForIncomingDeps(re, changed_lines)
 477     expected = set([
 478       'breakpad/DEPS',
 479       'chrome/installer/DEPS',
 480       'chrome/plugin/chrome_content_plugin_client.h',
 481       'chrome/utility/chrome_content_utility_client.h',
 482       'chromeos/chromeos_paths.h',
 483       'components/crash/DEPS',
 484       'components/nacl/common/DEPS',
 485       'content/public/browser/render_process_host.h',
 486       'policy/DEPS',
 487       'sandbox/DEPS',
 488       'tools/memory_watcher/DEPS',
 489       'third_party/lss/linux_syscall_support.h',
 490     ])
 491     self.assertEqual(expected, files_to_check);
 492
 493
 494 class JSONParsingTest(unittest.TestCase):
 495   def testSuccess(self):
 496     input_api = MockInputApi()
 497     filename = 'valid_json.json'
 498     contents = ['// This is a comment.',
 499                 '{',
 500                 '  "key1": ["value1", "value2"],',
 501                 '  "key2": 3  // This is an inline comment.',
 502                 '}'
 503                 ]
 504     input_api.files = [MockFile(filename, contents)]
 505     self.assertEqual(None,
 506                      PRESUBMIT._GetJSONParseError(input_api, filename))
 507
 508   def testFailure(self):
 509     input_api = MockInputApi()
 510     test_data = [
 511       ('invalid_json_1.json',
 512        ['{ x }'],
 513        'Expecting property name:'),
 514       ('invalid_json_2.json',
 515        ['// Hello world!',
 516         '{ "hello": "world }'],
 517        'Unterminated string starting at:'),
 518       ('invalid_json_3.json',
 519        ['{ "a": "b", "c": "d", }'],
 520        'Expecting property name:'),
 521       ('invalid_json_4.json',
 522        ['{ "a": "b" "c": "d" }'],
 523        'Expecting , delimiter:'),
 524       ]
 525
 526     input_api.files = [MockFile(filename, contents)
 527                        for (filename, contents, _) in test_data]
 528
 529     for (filename, _, expected_error) in test_data:
 530       actual_error = PRESUBMIT._GetJSONParseError(input_api, filename)
 531       self.assertTrue(expected_error in str(actual_error),
 532                       "'%s' not found in '%s'" % (expected_error, actual_error))
 533
 534   def testNoEatComments(self):
 535     input_api = MockInputApi()
 536     file_with_comments = 'file_with_comments.json'
 537     contents_with_comments = ['// This is a comment.',
 538                               '{',
 539                               '  "key1": ["value1", "value2"],',
 540                               '  "key2": 3  // This is an inline comment.',
 541                               '}'
 542                               ]
 543     file_without_comments = 'file_without_comments.json'
 544     contents_without_comments = ['{',
 545                                  '  "key1": ["value1", "value2"],',
 546                                  '  "key2": 3',
 547                                  '}'
 548                                  ]
 549     input_api.files = [MockFile(file_with_comments, contents_with_comments),
 550                        MockFile(file_without_comments,
 551                                 contents_without_comments)]
 552
 553     self.assertEqual('No JSON object could be decoded',
 554                      str(PRESUBMIT._GetJSONParseError(input_api,
 555                                                       file_with_comments,
 556                                                       eat_comments=False)))
 557     self.assertEqual(None,
 558                      PRESUBMIT._GetJSONParseError(input_api,
 559                                                   file_without_comments,
 560                                                   eat_comments=False))
 561
 562
 563 class IDLParsingTest(unittest.TestCase):
 564   def testSuccess(self):
 565     input_api = MockInputApi()
 566     filename = 'valid_idl_basics.idl'
 567     contents = ['// Tests a valid IDL file.',
 568                 'namespace idl_basics {',
 569                 '  enum EnumType {',
 570                 '    name1,',
 571                 '    name2',
 572                 '  };',
 573                 '',
 574                 '  dictionary MyType1 {',
 575                 '    DOMString a;',
 576                 '  };',
 577                 '',
 578                 '  callback Callback1 = void();',
 579                 '  callback Callback2 = void(long x);',
 580                 '  callback Callback3 = void(MyType1 arg);',
 581                 '  callback Callback4 = void(EnumType type);',
 582                 '',
 583                 '  interface Functions {',
 584                 '    static void function1();',
 585                 '    static void function2(long x);',
 586                 '    static void function3(MyType1 arg);',
 587                 '    static void function4(Callback1 cb);',
 588                 '    static void function5(Callback2 cb);',
 589                 '    static void function6(Callback3 cb);',
 590                 '    static void function7(Callback4 cb);',
 591                 '  };',
 592                 '',
 593                 '  interface Events {',
 594                 '    static void onFoo1();',
 595                 '    static void onFoo2(long x);',
 596                 '    static void onFoo2(MyType1 arg);',
 597                 '    static void onFoo3(EnumType type);',
 598                 '  };',
 599                 '};'
 600                 ]
 601     input_api.files = [MockFile(filename, contents)]
 602     self.assertEqual(None,
 603                      PRESUBMIT._GetIDLParseError(input_api, filename))
 604
 605   def testFailure(self):
 606     input_api = MockInputApi()
 607     test_data = [
 608       ('invalid_idl_1.idl',
 609        ['//',
 610         'namespace test {',
 611         '  dictionary {',
 612         '    DOMString s;',
 613         '  };',
 614         '};'],
 615        'Unexpected "{" after keyword "dictionary".\n'),
 616       # TODO(yoz): Disabled because it causes the IDL parser to hang.
 617       # See crbug.com/363830.
 618       # ('invalid_idl_2.idl',
 619       #  (['namespace test {',
 620       #    '  dictionary MissingSemicolon {',
 621       #    '    DOMString a',
 622       #    '    DOMString b;',
 623       #    '  };',
 624       #    '};'],
 625       #   'Unexpected symbol DOMString after symbol a.'),
 626       ('invalid_idl_3.idl',
 627        ['//',
 628         'namespace test {',
 629         '  enum MissingComma {',
 630         '    name1',
 631         '    name2',
 632         '  };',
 633         '};'],
 634        'Unexpected symbol name2 after symbol name1.'),
 635       ('invalid_idl_4.idl',
 636        ['//',
 637         'namespace test {',
 638         '  enum TrailingComma {',
 639         '    name1,',
 640         '    name2,',
 641         '  };',
 642         '};'],
 643        'Trailing comma in block.'),
 644       ('invalid_idl_5.idl',
 645        ['//',
 646         'namespace test {',
 647         '  callback Callback1 = void(;',
 648         '};'],
 649        'Unexpected ";" after "(".'),
 650       ('invalid_idl_6.idl',
 651        ['//',
 652         'namespace test {',
 653         '  callback Callback1 = void(long );',
 654         '};'],
 655        'Unexpected ")" after symbol long.'),
 656       ('invalid_idl_7.idl',
 657        ['//',
 658         'namespace test {',
 659         '  interace Events {',
 660         '    static void onFoo1();',
 661         '  };',
 662         '};'],
 663        'Unexpected symbol Events after symbol interace.'),
 664       ('invalid_idl_8.idl',
 665        ['//',
 666         'namespace test {',
 667         '  interface NotEvent {',
 668         '    static void onFoo1();',
 669         '  };',
 670         '};'],
 671        'Did not process Interface Interface(NotEvent)'),
 672       ('invalid_idl_9.idl',
 673        ['//',
 674         'namespace test {',
 675         '  interface {',
 676         '    static void function1();',
 677         '  };',
 678         '};'],
 679        'Interface missing name.'),
 680       ]
 681
 682     input_api.files = [MockFile(filename, contents)
 683                        for (filename, contents, _) in test_data]
 684
 685     for (filename, _, expected_error) in test_data:
 686       actual_error = PRESUBMIT._GetIDLParseError(input_api, filename)
 687       self.assertTrue(expected_error in str(actual_error),
 688                       "'%s' not found in '%s'" % (expected_error, actual_error))
 689
 690
 691 class TryServerMasterTest(unittest.TestCase):
 692   def testTryServerMasters(self):
 693     bots = {
 694         'tryserver.chromium.mac': [
 695             'ios_dbg_simulator',
 696             'ios_rel_device',
 697             'ios_rel_device_ninja',
 698             'mac_asan',
 699             'mac_asan_64',
 700             'mac_chromium_compile_dbg',
 701             'mac_chromium_compile_rel',
 702             'mac_chromium_dbg',
 703             'mac_chromium_rel',
 704             'mac_nacl_sdk',
 705             'mac_nacl_sdk_build',
 706             'mac_rel_naclmore',
 707             'mac_valgrind',
 708             'mac_x64_rel',
 709             'mac_xcodebuild',
 710         ],
 711         'tryserver.chromium.linux': [
 712             'android_aosp',
 713             'android_chromium_gn_compile_dbg',
 714             'android_chromium_gn_compile_rel',
 715             'android_clang_dbg',
 716             'android_dbg',
 717             'android_dbg_recipe',
 718             'android_dbg_triggered_tests',
 719             'android_dbg_triggered_tests_recipe',
 720             'android_fyi_dbg',
 721             'android_fyi_dbg_triggered_tests',
 722             'android_rel',
 723             'android_rel_triggered_tests',
 724             'android_x86_dbg',
 725             'blink_android_compile_dbg',
 726             'blink_android_compile_rel',
 727             'blink_presubmit',
 728             'chromium_presubmit',
 729             'linux_arm_cross_compile',
 730             'linux_arm_tester',
 731             'linux_chromeos_asan',
 732             'linux_chromeos_browser_asan',
 733             'linux_chromeos_valgrind',
 734             'linux_chromium_chromeos_dbg',
 735             'linux_chromium_chromeos_rel',
 736             'linux_chromium_compile_dbg',
 737             'linux_chromium_compile_rel',
 738             'linux_chromium_dbg',
 739             'linux_chromium_gn_dbg',
 740             'linux_chromium_gn_rel',
 741             'linux_chromium_rel',
 742             'linux_chromium_trusty32_dbg',
 743             'linux_chromium_trusty32_rel',
 744             'linux_chromium_trusty_dbg',
 745             'linux_chromium_trusty_rel',
 746             'linux_clang_tsan',
 747             'linux_ecs_ozone',
 748             'linux_layout',
 749             'linux_layout_asan',
 750             'linux_layout_rel',
 751             'linux_layout_rel_32',
 752             'linux_nacl_sdk',
 753             'linux_nacl_sdk_bionic',
 754             'linux_nacl_sdk_bionic_build',
 755             'linux_nacl_sdk_build',
 756             'linux_redux',
 757             'linux_rel_naclmore',
 758             'linux_rel_precise32',
 759             'linux_valgrind',
 760             'tools_build_presubmit',
 761         ],
 762         'tryserver.chromium.win': [
 763             'win8_aura',
 764             'win8_chromium_dbg',
 765             'win8_chromium_rel',
 766             'win_chromium_compile_dbg',
 767             'win_chromium_compile_rel',
 768             'win_chromium_dbg',
 769             'win_chromium_rel',
 770             'win_chromium_rel',
 771             'win_chromium_x64_dbg',
 772             'win_chromium_x64_rel',
 773             'win_drmemory',
 774             'win_nacl_sdk',
 775             'win_nacl_sdk_build',
 776             'win_rel_naclmore',
 777          ],
 778     }
 779     for master, bots in bots.iteritems():
 780       for bot in bots:
 781         self.assertEqual(master, PRESUBMIT.GetTryServerMasterForBot(bot),
 782                          'bot=%s: expected %s, computed %s' % (
 783             bot, master, PRESUBMIT.GetTryServerMasterForBot(bot)))
 784
 785
 786 if __name__ == '__main__':
 787   unittest.main()