scripts/apply_edits_test.py - chromium/src/tools/clang - Git at Google

 #!/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()
	#!/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()