#!/usr/bin/env python3
# Copyright 2020 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""
angle_presubmit_utils_unittest.py: Top-level unittest script for ANGLE presubmit checks.
"""

import importlib.machinery
import os
import pathlib
import sys
import tempfile
import unittest
from angle_presubmit_utils import *

def SetCWDToAngleFolder():
    angle_folder = pathlib.Path(__file__).resolve().parents[1]
    os.chdir(angle_folder)


SetCWDToAngleFolder()

loader = importlib.machinery.SourceFileLoader('PRESUBMIT', 'PRESUBMIT.py')
PRESUBMIT = loader.load_module()


class CommitMessageFormattingCheckTest(unittest.TestCase):

    def __init__(self, *args, **kwargs):
        super(CommitMessageFormattingCheckTest, self).__init__(*args, **kwargs)
        self.output_api = OutputAPI_mock()

    def run_check_commit_message_formatting(self, commit_msg):
        input_api = InputAPI_mock(commit_msg)
        return PRESUBMIT._CheckCommitMessageFormatting(input_api, self.output_api)

    def test_correct_commit_message(self):
        commit_msg = """a

b

Bug: angleproject:42263262
Change-Id: I966c79d96175da9eee92ef6da20db50d488137b2
"""
        errors = self.run_check_commit_message_formatting(commit_msg)
        self.assertEqual(len(errors), 0)

    def test_missing_description_body_and_description_summary(self):
        commit_msg = """Change-Id: I966c79d96175da9eee92ef6da20db50d488137b2"""
        errors = self.run_check_commit_message_formatting(commit_msg)
        self.assertEqual(len(errors), 1)
        self.assertEqual(
            errors[0],
            self.output_api.PresubmitError(
                "Commit 1:Please ensure that your" +
                " description summary and description body are not blank."))

    def test_missing_description_body(self):
        commit_msg = """
        a

b: d
c: e
"""
        errors = self.run_check_commit_message_formatting(commit_msg)
        self.assertEqual(len(errors), 0)

    def test_missing_tag_paragraph(self):
        commit_msg = """a

bd
efgh"""
        errors = self.run_check_commit_message_formatting(commit_msg)
        self.assertEqual(len(errors), 1)
        self.assertEqual(
            errors[0],
            self.output_api.PresubmitError(
                "Commit 1:Please ensure that there are tags (e.g., Bug:, Test:) in your description."
            ))

    def test_missing_tag_paragraph_and_description_body(self):
        commit_msg = "a"
        errors = self.run_check_commit_message_formatting(commit_msg)
        self.assertEqual(len(errors), 1)
        self.assertEqual(
            errors[0],
            self.output_api.PresubmitError(
                "Commit 1:Please ensure that there are tags (e.g., Bug:, Test:) in your description."
            ))

    def test_missing_blank_line_between_description_summary_and_description_body(self):
        commit_msg = """a
b

Change-Id: I925cdb45779a9cdebe4e14f9e81e4211ade37c12"""
        errors = self.run_check_commit_message_formatting(commit_msg)
        self.assertEqual(len(errors), 1)
        self.assertEqual(errors[0], self.output_api.PresubmitError(
          "Commit 1:Please ensure the summary is only 1 line and there is 1 blank line" + \
          " between the summary and description body."))

    def test_missing_blank_line_between_description_body_and_tags_paragraph(self):
        commit_msg = """a

b
Change-Id: I925cdb45779a9cdebe4e14f9e81e4211ade37c12"""
        errors = self.run_check_commit_message_formatting(commit_msg)
        self.assertEqual(len(errors), 0)

    def test_multiple_blank_lines_before_and_after_commit_message(self):
        commit_msg = """


                a

                  b

Change-Id: I925cdb45779a9cdebe4e14f9e81e4211ade37c12
"""
        errors = self.run_check_commit_message_formatting(commit_msg)
        self.assertEqual(len(errors), 0)

    def test_newlines_within_description_body(self):
        commit_msg = """a

b

d

e

for

Change-Id: I443c36aaa8956c20da1abddf7aea613659e2cd5b"""
        errors = self.run_check_commit_message_formatting(commit_msg)
        self.assertEqual(len(errors), 0)

    # Summary description in warning threshold(at 65 characters)
    def test_summmary_description_in_warning_thresholds(self):
        commit_msg = """aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

b

Change-Id: I925cdb45779a9cdebe4e14f9e81e4211ade37c12
"""
        errors = self.run_check_commit_message_formatting(commit_msg)
        self.assertEqual(len(errors), 1)
        self.assertEqual(
            errors[0],
            self.output_api.PresubmitPromptWarning(
                "Commit 1:Your description summary should be on one line of 64 or less characters."
            ))

    # Summary description in error threshold(at 71 characters)
    def test_summary_description_in_error_threshold(self):
        commit_msg = """aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

b

Change-Id: I925cdb45779a9cdebe4e14f9e81e4211ade37c12"""
        errors = self.run_check_commit_message_formatting(commit_msg)
        self.assertEqual(len(errors), 1)
        self.assertEqual(
            errors[0],
            self.output_api.PresubmitError(
                "Commit 1:Please ensure that your description summary is on one line of 64 or less characters."
            ))

    def test_description_body_exceeds_line_count_limit(self):
        commit_msg = """a

bbbbbbbb bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb


Change-Id: I443c36aaa8956c20da1abddf7aea613659e2cd5b"""
        errors = self.run_check_commit_message_formatting(commit_msg)
        self.assertEqual(len(errors), 2)
        self.assertEqual(
            errors[0],
            self.output_api.PresubmitError(
                "Commit 1:Please ensure that there exists only 1 blank line between tags and description body."
            ))
        self.assertEqual(
            errors[1],
            self.output_api.PresubmitError("""Commit 1:Line 3 is too long.
"bbbbbbbb bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
Please wrap it to 72 characters. Lines without spaces or lines starting with 4 spaces are exempt."""
                                          ))

    def test_description_body_exceeds_line_count_limit_but_with_4_spaces_prefix(self):
        commit_msg = """a

cc

dddd

    bbbbbbbbbbbbbbbbbbbbbbb bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb

Change-Id: I443c36aaa8956c20da1abddf7aea613659e2cd5b"""
        errors = self.run_check_commit_message_formatting(commit_msg)
        self.assertEqual(len(errors), 0)

    def test_description_body_exceeds_line_count_limit_but_without_space(self):
        commit_msg = """a

cc

dddd

bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb

a: d"""
        errors = self.run_check_commit_message_formatting(commit_msg)
        self.assertEqual(len(errors), 0)

    def test_description_body_exceeds_line_count_limit_but_in_quote(self):
        commit_msg = """a

cc

dddd

> bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb

a: d"""
        errors = self.run_check_commit_message_formatting(commit_msg)
        self.assertEqual(len(errors), 0)

    def test_tabs_in_commit_message(self):
        commit_msg = """																a

bbbbbbbbbbbbbbbbbbbb

Change-Id: I443c36aaa8956c20da1abddf7aea613659e2cd5b"""
        errors = self.run_check_commit_message_formatting(commit_msg)
        self.assertEqual(len(errors), 1)
        self.assertEqual(
            errors[0],
            self.output_api.PresubmitError("Commit 1:Tabs are not allowed in commit message."))

    def test_allowlist_revert(self):
        commit_msg = """Revert "sssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssa

bbbbbbbbbbbbbbbbbbbb

Change-Id: I443c36aaa8956c20da1abddf7aea613659e2cd5b"""
        errors = self.run_check_commit_message_formatting(commit_msg)
        self.assertEqual(len(errors), 0)

    def test_allowlist_roll(self):
        commit_msg = """Roll sssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssadd

bbbbbbbbbbbbbbbbbbbb

Change-Id: I443c36aaa8956c20da1abddf7aea613659e2cd5b"""
        errors = self.run_check_commit_message_formatting(commit_msg)
        self.assertEqual(len(errors), 0)

    def test_allowlist_reland(self):
        commit_msg = """Reland sssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssadd

bbbbbbbbbbbbbbbbbbbb

Change-Id: I443c36aaa8956c20da1abddf7aea613659e2cd5b"""
        errors = self.run_check_commit_message_formatting(commit_msg)
        self.assertEqual(len(errors), 0)

    def test_allowlist_reland2(self):
        commit_msg = """Reland: sssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssadd

bbbbbbbbbbbbbbbbbbbb

Change-Id: I443c36aaa8956c20da1abddf7aea613659e2cd5b"""
        errors = self.run_check_commit_message_formatting(commit_msg)
        self.assertEqual(len(errors), 0)

    def test_multiple_commits_with_errors_in_multiple_commits(self):
        commit_msg = """a

bbbbbbbb bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb

Change-Id: I443c36aaa8956c20da1abddf7aea613659e2cd5b

a

cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccccccccccccccc

Change-Id: I443c36aaa8956c20da1abddf7aea613659e2cd5b"""
        errors = self.run_check_commit_message_formatting(commit_msg)
        self.assertEqual(len(errors), 2)
        self.assertEqual(
            errors[0],
            self.output_api.PresubmitError("""Commit 2:Line 3 is too long.
"bbbbbbbb bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
Please wrap it to 72 characters. Lines without spaces or lines starting with 4 spaces are exempt."""
                                          ))
        self.assertEqual(
            errors[1],
            self.output_api.PresubmitError("""Commit 1:Line 4 is too long.
"cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccccccccccccccc"
Please wrap it to 72 characters. Lines without spaces or lines starting with 4 spaces are exempt."""
                                          ))

    def test_multiple_commits_with_error_in_one_commit(self):
        commit_msg = """a

bbbbbbbb bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb

Change-Id: I443c36aaa8956c20da1abddf7aea613659e2cd5b

Roll sssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssadd

bbbbbbbbbbbbbbbbbbbb

Change-Id: I443c36aaa8956c20da1abddf7aea613659e2cd5b"""
        errors = self.run_check_commit_message_formatting(commit_msg)
        self.assertEqual(len(errors), 1)
        self.assertEqual(
            errors[0],
            self.output_api.PresubmitError("""Commit 2:Line 3 is too long.
"bbbbbbbb bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
Please wrap it to 72 characters. Lines without spaces or lines starting with 4 spaces are exempt."""
                                          ))

    def test_multiple_commits_with_no_error(self):
        commit_msg = """Reland sssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssadd

bbbbbbbbbbbbbbbbbbbb

Change-Id: I443c36aaa8956c20da1abddf7aea613659e2cd5b

Roll sssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssadd

bbbbbbbbbbbbbbbbbbbb

Change-Id: I443c36aaa8956c20da1abddf7aea613659e2cd5b"""
        errors = self.run_check_commit_message_formatting(commit_msg)
        self.assertEqual(len(errors), 0)


class GClientFileExistenceCheck(unittest.TestCase):

    def __init__(self, *args, **kwargs):
        super(GClientFileExistenceCheck, self).__init__(*args, **kwargs)
        self.output_api = OutputAPI_mock()

    def run_gclient_presubmit(self, cwd, search_limit):
        input_api = InputAPI_mock('')
        input_api.cwd = cwd
        return PRESUBMIT._CheckGClientExists(input_api, self.output_api,
                                             pathlib.Path(search_limit))

    def test_gclient_in_cwd(self):
        with tempfile.TemporaryDirectory() as cwd:
            pathlib.Path(cwd).joinpath('.gclient').touch()
            errors = self.run_gclient_presubmit(cwd, cwd)
            self.assertEqual(len(errors), 0)

    def test_missing_gclient(self):
        with tempfile.TemporaryDirectory() as cwd:
            errors = self.run_gclient_presubmit(cwd, cwd)
            self.assertEqual(len(errors), 1)
            self.assertEqual(errors[0], self.output_api.PresubmitError('Missing .gclient file.'))

    def test_gclient_in_parent(self):
        with tempfile.TemporaryDirectory() as cwd:
            cwd = pathlib.Path(cwd)
            cwd.joinpath('.gclient').touch()
            inner = cwd.joinpath('inner')
            inner.mkdir()
            errors = self.run_gclient_presubmit(str(inner), str(cwd))
            self.assertEqual(len(errors), 0)


class CheckShaderVersionInShaderLangHeaderTest(unittest.TestCase):

    def __init__(self, *args, **kwargs):
        super(CheckShaderVersionInShaderLangHeaderTest, self).__init__(*args, **kwargs)
        self.output_api = OutputAPI_mock()

    def run_shader_version_check_presubmit(self, commit_msg, diffs):
        affected_files = [AffectedFile_mock(diff) for diff in diffs]
        input_api = InputAPI_mock(commit_msg, affected_files)
        return PRESUBMIT._CheckShaderVersionInShaderLangHeader(input_api, self.output_api)

    def test_headers_not_changed(self):
        errors = self.run_shader_version_check_presubmit('', [])
        self.assertEqual(len(errors), 0)

    def test_shader_lang_changed_with_version_change(self):
        shader_lang_diff = """-#define ANGLE_SH_VERSION 100
+#define ANGLE_SH_VERSION 101
"""

        errors = self.run_shader_version_check_presubmit('', [shader_lang_diff])
        self.assertEqual(len(errors), 0)

    def test_both_changed_with_version_change(self):
        shader_lang_diff = """-#define ANGLE_SH_VERSION 100
+#define ANGLE_SH_VERSION 101
"""
        shader_vars_diff = """-any change"""

        errors = self.run_shader_version_check_presubmit('', [shader_lang_diff, shader_vars_diff])
        self.assertEqual(len(errors), 0)

    def test_shader_lang_changed_with_no_version_change(self):
        shader_lang_diff = """+some change"""

        errors = self.run_shader_version_check_presubmit('', [shader_lang_diff])
        self.assertEqual(len(errors), 1)
        self.assertEqual(
            errors[0],
            self.output_api.PresubmitError(
                'ANGLE_SH_VERSION should be incremented when ShaderLang.h or ShaderVars.h change.')
        )

    def test_shader_lang_changed_with_no_version_change(self):
        shader_lang_diff = """+some change
 #define ANGLE_SH_VERSION 100
-other changes"""

        errors = self.run_shader_version_check_presubmit('', [shader_lang_diff])
        self.assertEqual(len(errors), 1)
        self.assertEqual(
            errors[0],
            self.output_api.PresubmitError(
                'ANGLE_SH_VERSION should be incremented when ShaderLang.h or ShaderVars.h change.')
        )

    def test_shader_lang_changed_with_version_cosmetic_change(self):
        shader_lang_diff = """-#define ANGLE_SH_VERSION 100
+#define ANGLE_SH_VERSION 100 // cosmetic change
"""

        errors = self.run_shader_version_check_presubmit('', [shader_lang_diff])
        self.assertEqual(len(errors), 1)
        self.assertEqual(
            errors[0],
            self.output_api.PresubmitError(
                'ANGLE_SH_VERSION should be incremented when ShaderLang.h or ShaderVars.h change.')
        )

    def test_shader_lang_changed_with_version_decrement(self):
        shader_lang_diff = """-#define ANGLE_SH_VERSION 100
+#define ANGLE_SH_VERSION 99
"""

        errors = self.run_shader_version_check_presubmit('', [shader_lang_diff])
        self.assertEqual(len(errors), 1)
        self.assertEqual(
            errors[0],
            self.output_api.PresubmitError(
                'ANGLE_SH_VERSION should be incremented when ShaderLang.h or ShaderVars.h change.')
        )

    def test_shader_lang_changed_in_revert(self):
        shader_lang_diff = """-#define ANGLE_SH_VERSION 100
+#define ANGLE_SH_VERSION 99
"""

        errors = self.run_shader_version_check_presubmit('Revert some change', [shader_lang_diff])
        self.assertEqual(len(errors), 0)


class RestrictedTracesCheckTest(unittest.TestCase):

    def __init__(self, *args, **kwargs):
        super(RestrictedTracesCheckTest, self).__init__(*args, **kwargs)
        self.output_api = OutputAPI_mock()
        self.angle_root = os.getcwd()

    def setUp(self):
        json_path = os.path.join(self.angle_root,
                                 'src/tests/restricted_traces/restricted_traces.json')
        with open(json_path, 'r') as f:
            self.original_content = f.read().splitlines()

    def run_check(self, affected_files):
        input_api = InputAPI_mock('', affected_files=affected_files)
        input_api.cwd = self.angle_root
        return PRESUBMIT._CheckRestrictedTraces(input_api, self.output_api)

    def test_json_not_modified(self):
        affected_files = [AffectedFile_mock('', 'some/other/file.cpp')]
        errors = self.run_check(affected_files)
        self.assertEqual(len(errors), 0)

    def test_json_modified_limit_not_exceeded(self):
        affected_files = [
            AffectedFile_mock(
                '',
                'src/tests/restricted_traces/restricted_traces.json',
                old_contents=self.original_content)
        ]
        errors = self.run_check(affected_files)
        self.assertEqual(len(errors), 0)

    def test_json_modified_limit_exceeded(self):
        json_path = os.path.join(self.angle_root,
                                 'src/tests/restricted_traces/restricted_traces.json')
        with open(json_path, 'r') as f:
            original_data = json.load(f)

        try:
            temp_data = original_data.copy()
            # Add 11 extra traces (no 'ci' and no 'representative')
            temp_data['traces'] = original_data['traces'] + [
                f"dummy_trace_{i} 1" for i in range(11)
            ]
            with open(json_path, 'w') as f:
                json.dump(temp_data, f)

            affected_files = [
                AffectedFile_mock(
                    '',
                    'src/tests/restricted_traces/restricted_traces.json',
                    old_contents=self.original_content)
            ]
            errors = self.run_check(affected_files)
            self.assertEqual(len(errors), 1)
            self.assertIn("Too many CQ extra traces", errors[0]._message)
        finally:
            with open(json_path, 'w') as f:
                json.dump(original_data, f, indent=2)
                f.write('\n')

    def test_missing_traces_key(self):
        json_path = os.path.join(self.angle_root,
                                 'src/tests/restricted_traces/restricted_traces.json')
        with open(json_path, 'r') as f:
            original_data = json.load(f)

        try:
            temp_data = original_data.copy()
            if 'traces' in temp_data:
                del temp_data['traces']
            with open(json_path, 'w') as f:
                json.dump(temp_data, f)

            affected_files = [
                AffectedFile_mock(
                    '',
                    'src/tests/restricted_traces/restricted_traces.json',
                    old_contents=self.original_content)
            ]
            errors = self.run_check(affected_files)
            self.assertEqual(len(errors), 1)
            self.assertIn("missing the \"traces\" key", errors[0]._message)
        finally:
            with open(json_path, 'w') as f:
                json.dump(original_data, f, indent=2)
                f.write('\n')

    def test_allowed_coexisting_tags(self):
        json_path = os.path.join(self.angle_root,
                                 'src/tests/restricted_traces/restricted_traces.json')
        with open(json_path, 'r') as f:
            original_data = json.load(f)

        try:
            temp_data = original_data.copy()
            temp_data['traces'] = original_data['traces'] + [
                "dummy_trace_1 1 ci representative smoke"
            ]

            with open(json_path, 'w') as f:
                json.dump(temp_data, f)

            with open(json_path, 'r') as f:
                mutated_content = f.read().splitlines()
            affected_files = [
                AffectedFile_mock(
                    '',
                    'src/tests/restricted_traces/restricted_traces.json',
                    old_contents=mutated_content)
            ]
            errors = self.run_check(affected_files)
            self.assertEqual(len(errors), 0)
        finally:
            with open(json_path, 'w') as f:
                json.dump(original_data, f, indent=2)
                f.write('\n')

    def test_unsorted_tags(self):
        json_path = os.path.join(self.angle_root,
                                 'src/tests/restricted_traces/restricted_traces.json')
        with open(json_path, 'r') as f:
            original_data = json.load(f)

        try:
            temp_data = original_data.copy()
            new_traces = []
            modified = False
            for trace in original_data['traces']:
                if 'antutu_refinery' in trace and not modified:
                    new_traces.append("antutu_refinery 1 representative ci smoke")
                    modified = True
                else:
                    new_traces.append(trace)
            temp_data['traces'] = new_traces

            with open(json_path, 'w') as f:
                json.dump(temp_data, f)

            affected_files = [
                AffectedFile_mock(
                    '',
                    'src/tests/restricted_traces/restricted_traces.json',
                    old_contents=self.original_content)
            ]
            errors = self.run_check(affected_files)
            self.assertEqual(len(errors), 1)
            self.assertIn("has unsorted tags", errors[0]._message)
        finally:
            with open(json_path, 'w') as f:
                json.dump(original_data, f, indent=2)
                f.write('\n')

    def test_new_trace_with_tags_fails(self):
        json_path = os.path.join(self.angle_root,
                                 'src/tests/restricted_traces/restricted_traces.json')
        with open(json_path, 'r') as f:
            original_data = json.load(f)

        try:
            temp_data = original_data.copy()
            temp_data['traces'] = original_data['traces'] + ["dummy_new_trace 1 representative"]

            with open(json_path, 'w') as f:
                json.dump(temp_data, f)

            affected_files = [
                AffectedFile_mock(
                    '',
                    'src/tests/restricted_traces/restricted_traces.json',
                    old_contents=self.original_content)
            ]
            errors = self.run_check(affected_files)
            self.assertEqual(len(errors), 1)
            self.assertIn("must not have any tags initially", errors[0]._message)
        finally:
            with open(json_path, 'w') as f:
                json.dump(original_data, f, indent=2)
                f.write('\n')

    def test_new_trace_without_tags_passes(self):
        json_path = os.path.join(self.angle_root,
                                 'src/tests/restricted_traces/restricted_traces.json')
        with open(json_path, 'r') as f:
            original_data = json.load(f)

        try:
            temp_data = original_data.copy()
            temp_data['traces'] = original_data['traces'] + ["dummy_new_trace 1"]

            with open(json_path, 'w') as f:
                json.dump(temp_data, f)

            affected_files = [
                AffectedFile_mock(
                    '',
                    'src/tests/restricted_traces/restricted_traces.json',
                    old_contents=self.original_content)
            ]
            errors = self.run_check(affected_files)
            self.assertEqual(len(errors), 0)
        finally:
            with open(json_path, 'w') as f:
                json.dump(original_data, f, indent=2)
                f.write('\n')


class CheckUnsafeBuffersSafetyCommentsTest(unittest.TestCase):

    def testNoUsage(self):
        mock_input_api = InputAPI_mock('')
        mock_input_api.source_files = [
            AffectedFile_mock(
                '', 'src/libANGLE/Foo.cpp', new_contents=[
                    'void Foo() {',
                    '    int x = 0;',
                    '}',
                ])
        ]
        errors = PRESUBMIT._CheckUnsafeBuffersSafetyComments(mock_input_api, OutputAPI_mock())
        self.assertEqual(0, len(errors))

    def testValidUsageSameLine(self):
        mock_input_api = InputAPI_mock('')
        mock_input_api.source_files = [
            AffectedFile_mock(
                '',
                'src/libANGLE/Foo.cpp',
                new_contents=[
                    'void Foo() {',
                    '    ANGLE_UNSAFE_BUFFERS(ptr[0] = 0); // SAFETY: safe',
                    '}',
                ])
        ]
        errors = PRESUBMIT._CheckUnsafeBuffersSafetyComments(mock_input_api, OutputAPI_mock())
        self.assertEqual(0, len(errors))

    def testValidUsagePrecedingLine(self):
        mock_input_api = InputAPI_mock('')
        mock_input_api.source_files = [
            AffectedFile_mock(
                '',
                'src/libANGLE/Foo.cpp',
                new_contents=[
                    'void Foo() {',
                    '    // SAFETY: safe',
                    '    ANGLE_UNSAFE_BUFFERS(ptr[0] = 0);',
                    '}',
                ])
        ]
        errors = PRESUBMIT._CheckUnsafeBuffersSafetyComments(mock_input_api, OutputAPI_mock())
        self.assertEqual(0, len(errors))

    def testValidUsagePrecedingLineWithOtherComments(self):
        mock_input_api = InputAPI_mock('')
        mock_input_api.source_files = [
            AffectedFile_mock(
                '',
                'src/libANGLE/Foo.cpp',
                new_contents=[
                    'void Foo() {',
                    '    // SAFETY: safe',
                    '    // some other info',
                    '    ANGLE_UNSAFE_BUFFERS(ptr[0] = 0);',
                    '}',
                ])
        ]
        errors = PRESUBMIT._CheckUnsafeBuffersSafetyComments(mock_input_api, OutputAPI_mock())
        self.assertEqual(0, len(errors))

    def testValidUsageBrokenLine(self):
        mock_input_api = InputAPI_mock('')
        mock_input_api.source_files = [
            AffectedFile_mock(
                '',
                'src/libANGLE/Foo.cpp',
                new_contents=[
                    'void Foo() {',
                    '    // SAFETY: safe',
                    '    int very_long_line_due_lots_of_stuff = line_broken_by_clang_format +',
                    '    ANGLE_UNSAFE_BUFFERS(ptr[0] = 0);',
                    '}',
                ])
        ]
        errors = PRESUBMIT._CheckUnsafeBuffersSafetyComments(mock_input_api, OutputAPI_mock())
        self.assertEqual(0, len(errors))

    def testValidUsageSafetyCommentWithCodeSyntax(self):
        mock_input_api = InputAPI_mock('')
        mock_input_api.source_files = [
            AffectedFile_mock(
                '',
                'src/libANGLE/Foo.cpp',
                new_contents=[
                    'void Foo() {',
                    '    // SAFETY: Explanation too large to desplay in one line of comment and use of c++ syntax',
                    '    // to justify usage.... This is safe because',
                    '    // dummy[1] = dummy[0]++; is safe',
                    '    ANGLE_UNSAFE_BUFFERS(ptr[0] = 0);',
                    '}',
                ])
        ]
        errors = PRESUBMIT._CheckUnsafeBuffersSafetyComments(mock_input_api, OutputAPI_mock())
        self.assertEqual(0, len(errors))

    def testInvalidUsageCommentSeparatedByForLoop(self):
        mock_input_api = InputAPI_mock('')
        mock_input_api.source_files = [
            AffectedFile_mock(
                '',
                'src/libANGLE/Foo.cpp',
                new_contents=[
                    'void Foo() {',
                    '    // SAFETY: safe',
                    '    for(int b = 0; b < buffer_size; b++){',
                    '       ANGLE_UNSAFE_BUFFERS(dummy[b] += x);',
                    '    }'
                    '}',
                ])
        ]
        errors = PRESUBMIT._CheckUnsafeBuffersSafetyComments(mock_input_api, OutputAPI_mock())
        self.assertEqual(1, len(errors))

    def testInvalidUsageNoComment(self):
        mock_input_api = InputAPI_mock('')
        mock_input_api.source_files = [
            AffectedFile_mock(
                '',
                'src/libANGLE/Foo.cpp',
                new_contents=[
                    'void Foo() {',
                    '    ANGLE_UNSAFE_BUFFERS(ptr[0] = 0);',
                    '}',
                ])
        ]
        errors = PRESUBMIT._CheckUnsafeBuffersSafetyComments(mock_input_api, OutputAPI_mock())
        self.assertEqual(1, len(errors))
        self.assertIn('ANGLE_UNSAFE_BUFFERS usage must be accompanied', errors[0].items[0])

    def testInvalidUsageCommentNotSafety(self):
        mock_input_api = InputAPI_mock('')
        mock_input_api.source_files = [
            AffectedFile_mock(
                '',
                'src/libANGLE/Foo.cpp',
                new_contents=[
                    'void Foo() {',
                    '    // this is a comment but not safety',
                    '    ANGLE_UNSAFE_BUFFERS(ptr[0] = 0);',
                    '}',
                ])
        ]
        errors = PRESUBMIT._CheckUnsafeBuffersSafetyComments(mock_input_api, OutputAPI_mock())
        self.assertEqual(1, len(errors))

    def testInvalidUsageCommentSeparatedByCode(self):
        mock_input_api = InputAPI_mock('')
        mock_input_api.source_files = [
            AffectedFile_mock(
                '',
                'src/libANGLE/Foo.cpp',
                new_contents=[
                    'void Foo() {',
                    '    // SAFETY: safe',
                    '    int x = 0;',
                    '    ANGLE_UNSAFE_BUFFERS(ptr[0] = 0);',
                    '}',
                ])
        ]
        errors = PRESUBMIT._CheckUnsafeBuffersSafetyComments(mock_input_api, OutputAPI_mock())
        self.assertEqual(1, len(errors))

    def testIgnoreCommentedUsage(self):
        mock_input_api = InputAPI_mock('')
        mock_input_api.source_files = [
            AffectedFile_mock(
                '',
                'src/libANGLE/Foo.cpp',
                new_contents=[
                    'void Foo() {',
                    '    // ANGLE_UNSAFE_BUFFERS(ptr[0] = 0);',
                    '}',
                ])
        ]
        errors = PRESUBMIT._CheckUnsafeBuffersSafetyComments(mock_input_api, OutputAPI_mock())
        self.assertEqual(0, len(errors))


class CheckBannedPatternsTest(unittest.TestCase):

    def testNoUsage(self):
        mock_input_api = InputAPI_mock('')
        mock_input_api.source_files = [
            AffectedFile_mock(
                '', 'src/libANGLE/Foo.cpp', new_contents=[
                    'void Foo() {',
                    '    int x = 0;',
                    '}',
                ])
        ]
        errors = PRESUBMIT._CheckNoBannedPatterns(mock_input_api, OutputAPI_mock())
        self.assertEqual(0, len(errors))

    def testBannedUnsafeTodo(self):
        mock_input_api = InputAPI_mock('')
        mock_input_api.source_files = [
            AffectedFile_mock(
                '',
                'src/libANGLE/Foo.cpp',
                new_contents=[
                    'void Foo() {',
                    '    ANGLE_UNSAFE_TODO(ptr[0] = 0);',
                    '}',
                ])
        ]
        errors = PRESUBMIT._CheckNoBannedPatterns(mock_input_api, OutputAPI_mock())
        self.assertEqual(1, len(errors))
        self.assertIn('A banned pattern was used.', errors[0]._message)
        self.assertIn('src/libANGLE/Foo.cpp:2:', errors[0]._message)
        self.assertIn('Do not introduce new instances of ANGLE_UNSAFE_TODO', errors[0]._message)
        self.assertEqual(1, len(errors[0].locations))
        loc = errors[0].locations[0]
        self.assertEqual('src/libANGLE/Foo.cpp', loc.file_path)
        self.assertEqual(2, loc.start_line)
        self.assertEqual(2, loc.end_line)

    def testBannedPragma(self):
        mock_input_api = InputAPI_mock('')
        mock_input_api.source_files = [
            AffectedFile_mock(
                '', 'src/libANGLE/Foo.cpp', new_contents=[
                    '#pragma allow_unsafe_buffers',
                ])
        ]
        errors = PRESUBMIT._CheckNoBannedPatterns(mock_input_api, OutputAPI_mock())
        self.assertEqual(1, len(errors))
        self.assertIn('A banned pattern was used.', errors[0]._message)
        self.assertIn('src/libANGLE/Foo.cpp:1:', errors[0]._message)
        self.assertIn('#pragma allow_unsafe_buffers is discouraged', errors[0]._message)
        self.assertEqual(1, len(errors[0].locations))
        loc = errors[0].locations[0]
        self.assertEqual('src/libANGLE/Foo.cpp', loc.file_path)
        self.assertEqual(1, loc.start_line)
        self.assertEqual(1, loc.end_line)

    def testCommentedUsageIgnored(self):
        mock_input_api = InputAPI_mock('')
        mock_input_api.source_files = [
            AffectedFile_mock(
                '',
                'src/libANGLE/Foo.cpp',
                new_contents=[
                    '// ANGLE_UNSAFE_TODO(ptr[0] = 0);',
                    '// #pragma allow_unsafe_buffers',
                ])
        ]
        errors = PRESUBMIT._CheckNoBannedPatterns(mock_input_api, OutputAPI_mock())
        self.assertEqual(0, len(errors))

if __name__ == '__main__':
    unittest.main()