#!/usr/bin/env vpython3
# Copyright 2020 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import unittest

import apply_edits


def _FindPHB(filepath):
  return apply_edits._FindPrimaryHeaderBasename(filepath)


class FindPrimaryHeaderBasenameTest(unittest.TestCase):
  def testNoOpOnHeader(self):
    self.assertIsNone(_FindPHB('bar.h'))
    self.assertIsNone(_FindPHB('foo/bar.h'))

  def testStripDirectories(self):
    self.assertEqual('bar', _FindPHB('foo/bar.cc'))

  def testStripPlatformSuffix(self):
    self.assertEqual('bar', _FindPHB('bar_posix.cc'))
    self.assertEqual('bar', _FindPHB('bar_unittest.cc'))

  def testStripTestSuffix(self):
    self.assertEqual('bar', _FindPHB('bar_browsertest.cc'))
    self.assertEqual('bar', _FindPHB('bar_unittest.cc'))

  def testStripPlatformAndTestSuffix(self):
    self.assertEqual('bar', _FindPHB('bar_uitest_aura.cc'))
    self.assertEqual('bar', _FindPHB('bar_linux_unittest.cc'))

  def testNoSuffixStrippingWithoutUnderscore(self):
    self.assertEqual('barunittest', _FindPHB('barunittest.cc'))


def _ApplyEdit(old_contents_string,
               edit,
               contents_filepath="some_file.cc",
               last_edit=None):
  if last_edit is not None:
    assert (last_edit > edit)  # Test or prod caller should ensure.
  ba = bytearray()
  ba.extend(old_contents_string.encode('utf-8'))
  return apply_edits._ApplySingleEdit(contents_filepath,
                                      old_contents_string.encode("utf-8"), edit,
                                      last_edit).decode("utf-8")


def _InsertHeader(old_contents,
                  contents_filepath='foo/impl.cc',
                  new_header_path='new/header.h'):
  edit = apply_edits.Edit("include-user-header", -1, -1,
                          new_header_path.encode("utf-8"))
  return _ApplyEdit(old_contents, edit, contents_filepath)


class InsertIncludeHeaderTest(unittest.TestCase):
  def _assertEqualContents(self, expected, actual):
    if expected != actual:
      print("####################### EXPECTED:")
      print(expected)
      print("####################### ACTUAL:")
      print(actual)
      print("####################### END.")
    self.assertEqual(expected, actual)

  def testSkippingCppComments(self):
    old_contents = '''
// Copyright info here.

#include "old/header.h"
    '''
    expected_new_contents = '''
// Copyright info here.

#include "new/header.h"
#include "old/header.h"
    '''
    new_header_line = '#include "new/header.h'
    self._assertEqualContents(expected_new_contents,
                              _InsertHeader(old_contents))

  def testSkippingCppComments_DocCommentForStruct(self):
    """ This is a regression test for https://crbug.com/1175684 """
    old_contents = '''
// Copyright blah blah...

#ifndef SANDBOX_LINUX_SYSTEM_HEADERS_LINUX_FILTER_H_
#define SANDBOX_LINUX_SYSTEM_HEADERS_LINUX_FILTER_H_

#include <stdint.h>

// Doc comment for a struct.
// Multiline.
struct sock_filter {
  uint16_t code;
};
    '''
    expected_new_contents = '''
// Copyright blah blah...

#ifndef SANDBOX_LINUX_SYSTEM_HEADERS_LINUX_FILTER_H_
#define SANDBOX_LINUX_SYSTEM_HEADERS_LINUX_FILTER_H_

#include <stdint.h>

#include "new/header.h"

// Doc comment for a struct.
// Multiline.
struct sock_filter {
  uint16_t code;
};
    '''
    new_header_line = '#include "new/header.h'
    self._assertEqualContents(expected_new_contents,
                              _InsertHeader(old_contents))

  def testSkippingCppComments_DocCommentForStruct2(self):
    """ This is a regression test for https://crbug.com/1175684 """
    old_contents = '''
// Copyright blah blah...

// Doc comment for a struct.
struct sock_filter {
  uint16_t code;
};
    '''
    expected_new_contents = '''
// Copyright blah blah...

#include "new/header.h"

// Doc comment for a struct.
struct sock_filter {
  uint16_t code;
};
    '''
    new_header_line = '#include "new/header.h'
    self._assertEqualContents(expected_new_contents,
                              _InsertHeader(old_contents))

  def testSkippingCppComments_DocCommentForStruct3(self):
    """ This is a regression test for https://crbug.com/1175684 """
    old_contents = '''
// Doc comment for a struct.
struct sock_filter {
  uint16_t code;
};
    '''
    expected_new_contents = '''
#include "new/header.h"

// Doc comment for a struct.
struct sock_filter {
  uint16_t code;
};
    '''
    new_header_line = '#include "new/header.h'
    self._assertEqualContents(expected_new_contents,
                              _InsertHeader(old_contents))

  def testSkippingCppComments_DocCommentForInclude(self):
    """ This is a regression test for https://crbug.com/1175684 """
    old_contents = '''
// Copyright blah blah...

// System includes.
#include <stdint.h>

// Doc comment for a struct.
struct sock_filter {
  uint16_t code;
};
    '''
    expected_new_contents = '''
// Copyright blah blah...

// System includes.
#include <stdint.h>

#include "new/header.h"

// Doc comment for a struct.
struct sock_filter {
  uint16_t code;
};
    '''
    new_header_line = '#include "new/header.h'
    self._assertEqualContents(expected_new_contents,
                              _InsertHeader(old_contents))

  def testSkippingCppComments_DocCommentForWholeFile(self):
    """ This is a regression test for https://crbug.com/1175684 """
    old_contents = '''
// Copyright blah blah...

// Doc comment for the whole file.

struct sock_filter {
  uint16_t code;
};
    '''
    expected_new_contents = '''
// Copyright blah blah...

// Doc comment for the whole file.

#include "new/header.h"

struct sock_filter {
  uint16_t code;
};
    '''
    new_header_line = '#include "new/header.h'
    self._assertEqualContents(expected_new_contents,
                              _InsertHeader(old_contents))

  def testSkippingOldStyleComments(self):
    old_contents = '''
/* Copyright
 * info here.
 */

#include "old/header.h"
    '''
    expected_new_contents = '''
/* Copyright
 * info here.
 */

#include "new/header.h"
#include "old/header.h"
    '''
    self._assertEqualContents(expected_new_contents,
                              _InsertHeader(old_contents))

  def testSkippingOldStyleComments_NoWhitespaceAtLineStart(self):
    old_contents = '''
/* Copyright
* info here.
*/

#include "old/header.h"
    '''
    expected_new_contents = '''
/* Copyright
* info here.
*/

#include "new/header.h"
#include "old/header.h"
    '''
    self._assertEqualContents(expected_new_contents,
                              _InsertHeader(old_contents))

  def testSkippingSystemHeaders(self):
    old_contents = '''
#include <string>
#include <vector>  // blah

#include "old/header.h"
    '''
    expected_new_contents = '''
#include <string>
#include <vector>  // blah

#include "new/header.h"
#include "old/header.h"
    '''
    self._assertEqualContents(expected_new_contents,
                              _InsertHeader(old_contents))

  def testSkippingPrimaryHeader(self):
    old_contents = '''
// Copyright info here.

#include "foo/impl.h"

#include "old/header.h"
    '''
    expected_new_contents = '''
// Copyright info here.

#include "foo/impl.h"

#include "new/header.h"
#include "old/header.h"
    '''
    self._assertEqualContents(expected_new_contents,
                              _InsertHeader(old_contents))

  def testSimilarNonPrimaryHeader_WithPrimaryHeader(self):
    old_contents = '''
// Copyright info here.

#include "primary/impl.h"  // This is the primary header.

#include "unrelated/impl.h"  // This is *not* the primary header.
#include "zzz/foo.h"
    '''
    expected_new_contents = '''
// Copyright info here.

#include "primary/impl.h"  // This is the primary header.

#include "unrelated/impl.h"  // This is *not* the primary header.
#include "new/header.h"
#include "zzz/foo.h"
    '''
    self._assertEqualContents(expected_new_contents,
                              _InsertHeader(old_contents))

  def testSimilarNonPrimaryHeader_NoPrimaryHeader(self):
    old_contents = '''
// Copyright info here.

#include "unrelated/impl.h"  // This is *not* the primary header.
#include "zzz/foo.h"
    '''
    expected_new_contents = '''
// Copyright info here.

#include "unrelated/impl.h"  // This is *not* the primary header.
#include "new/header.h"
#include "zzz/foo.h"
    '''
    self._assertEqualContents(expected_new_contents,
                              _InsertHeader(old_contents))

  def testSkippingIncludeGuards(self):
    old_contents = '''
#ifndef FOO_IMPL_H_
#define FOO_IMPL_H_

#include "old/header.h"

#endif FOO_IMPL_H_
    '''
    expected_new_contents = '''
#ifndef FOO_IMPL_H_
#define FOO_IMPL_H_

#include "new/header.h"
#include "old/header.h"

#endif FOO_IMPL_H_
    '''
    self._assertEqualContents(
        expected_new_contents,
        _InsertHeader(old_contents, 'foo/impl.h', 'new/header.h'))

  def testSkippingIncludeGuards2(self):
    # This test is based on base/third_party/valgrind/memcheck.h
    old_contents = '''
#ifndef __MEMCHECK_H
#define __MEMCHECK_H

#include "old/header.h"

#endif
    '''
    expected_new_contents = '''
#ifndef __MEMCHECK_H
#define __MEMCHECK_H

#include "new/header.h"
#include "old/header.h"

#endif
    '''
    self._assertEqualContents(expected_new_contents,
                              _InsertHeader(old_contents))

  def testSkippingIncludeGuards3(self):
    # This test is based on base/third_party/xdg_mime/xdgmime.h
    old_contents = '''
#ifndef __XDG_MIME_H__
#define __XDG_MIME_H__

#include "old/header.h"

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

typedef void (*XdgMimeCallback) (void *user_data);

#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __XDG_MIME_H__ */
    '''
    expected_new_contents = '''
#ifndef __XDG_MIME_H__
#define __XDG_MIME_H__

#include "new/header.h"
#include "old/header.h"

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

typedef void (*XdgMimeCallback) (void *user_data);

#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __XDG_MIME_H__ */
    '''
    self._assertEqualContents(expected_new_contents,
                              _InsertHeader(old_contents))

  @unittest.skip(
      "Failing test due to regex (in apply_edits.py) not working as expected, please fix."
  )
  def testSkippingIncludeGuards4(self):
    # This test is based on ash/first_run/desktop_cleaner.h and/or
    # components/subresource_filter/core/common/scoped_timers.h and/or
    # device/gamepad/abstract_haptic_gamepad.h
    old_contents = '''
#ifndef ASH_FIRST_RUN_DESKTOP_CLEANER_
#define ASH_FIRST_RUN_DESKTOP_CLEANER_

#include "old/header.h"

namespace ash {
}  // namespace ash

#endif  // ASH_FIRST_RUN_DESKTOP_CLEANER_
    '''
    expected_new_contents = '''
#ifndef ASH_FIRST_RUN_DESKTOP_CLEANER_
#define ASH_FIRST_RUN_DESKTOP_CLEANER_

#include "new/header.h"
#include "old/header.h"

namespace ash {
}  // namespace ash

#endif  // ASH_FIRST_RUN_DESKTOP_CLEANER_
    '''
    self._assertEqualContents(expected_new_contents,
                              _InsertHeader(old_contents))

  @unittest.skip(
      "Failing test due to regex (in apply_edits.py) not working as expected, please fix."
  )
  def testSkippingIncludeGuards5(self):
    # This test is based on third_party/weston/include/GLES2/gl2.h (the |extern
    # "C"| part has been removed to make the test trickier to handle right -
    # otherwise it is easy to see that the header has to be included before the
    # |extern "C"| part).
    #
    # The tricky parts below include:
    # 1. upper + lower case characters allowed in the guard name
    # 2. Having to recognize that GL_APIENTRYP is *not* a guard
    old_contents = '''
#ifndef __gles2_gl2_h_
#define __gles2_gl2_h_ 1

#include <GLES2/gl2platform.h>

#ifndef GL_APIENTRYP
#define GL_APIENTRYP GL_APIENTRY*
#endif

#endif
    '''
    expected_new_contents = '''
#ifndef __gles2_gl2_h_
#define __gles2_gl2_h_ 1

#include <GLES2/gl2platform.h>

#include "new/header.h"

#ifndef GL_APIENTRYP
#define GL_APIENTRYP GL_APIENTRY*
#endif

#endif
    '''
    self._assertEqualContents(expected_new_contents,
                              _InsertHeader(old_contents))

  @unittest.skip(
      "Failing test due to regex (in apply_edits.py) not working as expected, please fix."
  )
  def testSkippingIncludeGuards6(self):
    # This test is based on ios/third_party/blink/src/html_token.h
    old_contents = '''
#ifndef HTMLToken_h
#define HTMLToken_h

#include <stddef.h>
#include <vector>

// ...

#endif
    '''
    expected_new_contents = '''
#ifndef HTMLToken_h
#define HTMLToken_h

#include <stddef.h>
#include <vector>

#include "new/header.h"

// ...

#endif
    '''
    self._assertEqualContents(expected_new_contents,
                              _InsertHeader(old_contents))

  def testNoOpIfAlreadyPresent(self):
    # This tests that the new header won't be inserted (and duplicated)
    # if it is already included.
    old_contents = '''
// Copyright info here.

#include "old/header.h"
#include "new/header.h"
#include "new/header2.h"
    '''
    expected_new_contents = '''
// Copyright info here.

#include "old/header.h"
#include "new/header.h"
#include "new/header2.h"
    '''
    self._assertEqualContents(expected_new_contents,
                              _InsertHeader(old_contents))

  def testNoOpIfAlreadyPresent_WithTrailingComment(self):
    # This tests that the new header won't be inserted (and duplicated)
    # if it is already included.
    old_contents = '''
// Copyright info here.

#include "old/header.h"
#include "new/header.h" // blah
#include "new/header2.h"
    '''
    expected_new_contents = '''
// Copyright info here.

#include "old/header.h"
#include "new/header.h" // blah
#include "new/header2.h"
    '''
    self._assertEqualContents(expected_new_contents,
                              _InsertHeader(old_contents))

  def testNoOldHeaders(self):
    # This tests that an extra new line is inserted after the new header
    # when there are no old headers immediately below.
    old_contents = '''
#include <vector>

struct S {};
    '''
    expected_new_contents = '''
#include <vector>

#include "new/header.h"

struct S {};
    '''
    self._assertEqualContents(expected_new_contents,
                              _InsertHeader(old_contents))

  def testPlatformIfDefs(self):
    # This test is based on
    # //base/third_party/double_conversion/double-conversion/utils.h
    # We need to insert the new header in a non-conditional part.
    old_contents = '''
#ifndef DOUBLE_CONVERSION_UTILS_H_
#define DOUBLE_CONVERSION_UTILS_H_

#include <cstdlib>
#include <cstring>

#ifndef DOUBLE_CONVERSION_UNREACHABLE
#ifdef _MSC_VER
void DOUBLE_CONVERSION_NO_RETURN abort_noreturn();
inline void abort_noreturn() { abort(); }
#define DOUBLE_CONVERSION_UNREACHABLE()   (abort_noreturn())
#else
#define DOUBLE_CONVERSION_UNREACHABLE()   (abort())
#endif
#endif

namespace double_conversion {
    '''
    expected_new_contents = '''
#ifndef DOUBLE_CONVERSION_UTILS_H_
#define DOUBLE_CONVERSION_UTILS_H_

#include <cstdlib>
#include <cstring>

#include "new/header.h"

#ifndef DOUBLE_CONVERSION_UNREACHABLE
#ifdef _MSC_VER
void DOUBLE_CONVERSION_NO_RETURN abort_noreturn();
inline void abort_noreturn() { abort(); }
#define DOUBLE_CONVERSION_UNREACHABLE()   (abort_noreturn())
#else
#define DOUBLE_CONVERSION_UNREACHABLE()   (abort())
#endif
#endif

namespace double_conversion {
    '''
    self._assertEqualContents(expected_new_contents,
                              _InsertHeader(old_contents))

  def testNoOldIncludesAndIfDefs(self):
    # Artificial test: no old #includes + some #ifdefs.  The main focus of the
    # test is ensuring that the new header will be inserted into the
    # unconditional part of the file.
    old_contents = '''
#ifndef NDEBUG
#include "base/logging.h"
#endif

void foo();
    '''
    expected_new_contents = '''
#include "new/header.h"

#ifndef NDEBUG
#include "base/logging.h"
#endif

void foo();
    '''
    self._assertEqualContents(expected_new_contents,
                              _InsertHeader(old_contents))

  def testNoOldIncludesAndIfDefs2(self):
    # Artificial test: no old #includes + some #ifdefs.  The main focus of the
    # test is ensuring that the new header will be inserted into the
    # unconditional part of the file.
    old_contents = '''
#if BUILDFLAG(IS_WIN)
#include "foo_win.h"
#endif

void foo();
    '''
    expected_new_contents = '''
#include "new/header.h"

#if BUILDFLAG(IS_WIN)
#include "foo_win.h"
#endif

void foo();
    '''
    self._assertEqualContents(expected_new_contents,
                              _InsertHeader(old_contents))

  def testUtf8BomMarker(self):
    # Test based on
    # //chrome/browser/ui/views/payments/payment_sheet_view_controller.cc
    # which at some point began as follows:
    # 00000000: efbb bf2f 2f20 436f 7079 7269 6768 7420  ...// Copyright
    #
    # Previous versions of apply_edits.py would not skip the BOM marker when
    # figuring out where to insert the new include header.
    old_contents = u'''\ufeff// Copyright

#include "old/header.h"
    '''
    expected_new_contents = u'''\ufeff// Copyright

#include "new/header.h"
#include "old/header.h"
    '''
    actual = bytearray()
    actual.extend(old_contents.encode('utf-8'))
    expected = bytearray()
    expected.extend(expected_new_contents.encode('utf-8'))
    # Test sanity check (i.e. not an assertion about code under test).
    utf8_bom = [0xef, 0xbb, 0xbf]
    self._assertEqualContents(list(actual[0:3]), utf8_bom)
    self._assertEqualContents(list(expected[0:3]), utf8_bom)
    # Actual test.
    edit = apply_edits.Edit('include-user-header', -1, -1, b"new/header.h")
    actual = apply_edits._ApplySingleEdit("foo/impl.cc", actual, edit, None)
    self._assertEqualContents(expected, actual)


def _CreateReplacement(content_string, old_substring, new_substring):
  """ Test helper for creating an Edit object with the right offset, etc. """
  b_content_string = content_string.encode("utf-8")
  b_old_string = old_substring.encode("utf-8")
  b_new_string = new_substring.encode("utf-8")
  offset = b_content_string.find(b_old_string)
  return apply_edits.Edit('r', offset, len(b_old_string), b_new_string)


class ApplyReplacementTest(unittest.TestCase):
  def testBasics(self):
    old_text = "123 456 789"
    r = _CreateReplacement(old_text, "456", "foo")
    new_text = _ApplyEdit(old_text, r)
    self.assertEqual("123 foo 789", new_text)

  def testMiddleListElementRemoval(self):
    old_text = "(123, 456, 789)  // foobar"
    r = _CreateReplacement(old_text, "456", "")
    new_text = _ApplyEdit(old_text, r)
    self.assertEqual("(123,  789)  // foobar", new_text)

  def testFinalElementRemoval(self):
    old_text = "(123, 456, 789)  // foobar"
    r = _CreateReplacement(old_text, "789", "")
    new_text = _ApplyEdit(old_text, r)
    self.assertEqual("(123, 456)  // foobar", new_text)

  def testConflictingReplacement(self):
    old_text = "123 456 789"
    last = _CreateReplacement(old_text, "456", "foo")
    edit = _CreateReplacement(old_text, "456", "bar")
    expected_msg_regex = 'Conflicting replacement text'
    expected_msg_regex += '.*some_file.cc at offset 4, length 3'
    expected_msg_regex += '.*"bar" != "foo"'
    with self.assertRaisesRegex(ValueError, expected_msg_regex):
      _ApplyEdit(old_text, edit, last_edit=last)

  def testUnrecognizedEditDirective(self):
    old_text = "123 456 789"
    edit = apply_edits.Edit('unknown_directive', 123, 456, "foo")
    expected_msg_regex = 'Unrecognized edit directive "unknown_directive"'
    expected_msg_regex += '.*some_file.cc'
    with self.assertRaisesRegex(ValueError, expected_msg_regex):
      _ApplyEdit(old_text, edit)

  def testOverlappingReplacement(self):
    old_text = "123 456 789"
    last = _CreateReplacement(old_text, "456 789", "foo")
    edit = _CreateReplacement(old_text, "123 456", "bar")
    expected_msg_regex = 'Overlapping replacements'
    expected_msg_regex += '.*some_file.cc'
    expected_msg_regex += '.*offset 0, length 7.*"bar"'
    expected_msg_regex += '.*offset 4, length 7.*"foo"'
    with self.assertRaisesRegex(ValueError, expected_msg_regex):
      _ApplyEdit(old_text, edit, last_edit=last)


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