scripts/gdbclient_test.py - platform/development - Git at Google

 #
 # Copyright (C) 2023 The Android Open Source Project
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #

 import copy
 import json
 import textwrap
 import unittest
 from typing import Any

 import gdbclient


 class LaunchConfigMergeTest(unittest.TestCase):
     def merge_compare(self, base: dict[str, Any], to_add: dict[str, Any] | None, expected: dict[str, Any]) -> None:
         actual = copy.deepcopy(base)
         gdbclient.merge_launch_dict(actual, to_add)
         self.assertEqual(actual, expected, f'base={base}, to_add={to_add}')

     def test_add_none(self) -> None:
         base = { 'foo' : 1 }
         to_add = None
         expected = { 'foo' : 1 }
         self.merge_compare(base, to_add, expected)

     def test_add_val(self) -> None:
         base = { 'foo' : 1 }
         to_add = { 'bar' : 2}
         expected = { 'foo' : 1, 'bar' : 2 }
         self.merge_compare(base, to_add, expected)

     def test_overwrite_val(self) -> None:
         base = { 'foo' : 1 }
         to_add = { 'foo' : 2}
         expected = { 'foo' : 2 }
         self.merge_compare(base, to_add, expected)

     def test_lists_get_appended(self) -> None:
         base = { 'foo' : [1, 2] }
         to_add = { 'foo' : [3, 4]}
         expected = { 'foo' : [1, 2, 3, 4] }
         self.merge_compare(base, to_add, expected)

     def test_add_elem_to_dict(self) -> None:
         base = { 'foo' : { 'bar' : 1 } }
         to_add = { 'foo' : { 'baz' : 2 } }
         expected = { 'foo' : { 'bar' :  1, 'baz' : 2 } }
         self.merge_compare(base, to_add, expected)

     def test_overwrite_elem_in_dict(self) -> None:
         base = { 'foo' : { 'bar' : 1 } }
         to_add = { 'foo' : { 'bar' : 2 } }
         expected = { 'foo' : { 'bar' : 2 } }
         self.merge_compare(base, to_add, expected)

     def test_merging_dict_and_value_raises(self) -> None:
         base = { 'foo' : { 'bar' : 1 } }
         to_add = { 'foo' : 2 }
         with self.assertRaises(ValueError):
             gdbclient.merge_launch_dict(base, to_add)

     def test_merging_value_and_dict_raises(self) -> None:
         base = { 'foo' : 2 }
         to_add = { 'foo' : { 'bar' : 1 } }
         with self.assertRaises(ValueError):
             gdbclient.merge_launch_dict(base, to_add)

     def test_merging_dict_and_list_raises(self) -> None:
         base = { 'foo' : { 'bar' : 1 } }
         to_add = { 'foo' : [1] }
         with self.assertRaises(ValueError):
             gdbclient.merge_launch_dict(base, to_add)

     def test_merging_list_and_dict_raises(self) -> None:
         base = { 'foo' : [1] }
         to_add = { 'foo' : { 'bar' : 1 } }
         with self.assertRaises(ValueError):
             gdbclient.merge_launch_dict(base, to_add)

     def test_adding_elem_to_list_raises(self) -> None:
         base = { 'foo' : [1] }
         to_add = { 'foo' : 2}
         with self.assertRaises(ValueError):
             gdbclient.merge_launch_dict(base, to_add)

     def test_adding_list_to_elem_raises(self) -> None:
         base = { 'foo' : 1 }
         to_add = { 'foo' : [2]}
         with self.assertRaises(ValueError):
             gdbclient.merge_launch_dict(base, to_add)


 class VsCodeLaunchGeneratorTest(unittest.TestCase):
     def setUp(self) -> None:
         # These tests can generate long diffs, so we remove the limit
         self.maxDiff = None

     def test_generate_script(self) -> None:
         self.assertEqual(json.loads(gdbclient.generate_vscode_lldb_script(root='/root',
                                                             sysroot='/sysroot',
                                                             binary_name='test',
                                                             port=123,
                                                             solib_search_path=['/path1',
                                                                                '/path2'],
                                                             extra_props=None)),
         {
              'name': '(lldbclient.py) Attach test (port: 123)',
              'type': 'lldb',
              'request': 'custom',
              'relativePathBase': '/root',
              'sourceMap': { '/b/f/w' : '/root', '': '/root', '.': '/root' },
              'initCommands': ['settings append target.exec-search-paths /path1 /path2'],
              'targetCreateCommands': ['target create test',
                                       'target modules search-paths add / /sysroot/'],
              'processCreateCommands': ['gdb-remote 123']
          })

     def test_generate_script_with_extra_props(self) -> None:
         extra_props = {
             'initCommands' : ['settings append target.exec-search-paths /path3'],
             'processCreateCommands' : ['break main', 'continue'],
             'sourceMap' : { '/test/' : '/root/test'},
             'preLaunchTask' : 'Build'
         }
         self.assertEqual(json.loads(gdbclient.generate_vscode_lldb_script(root='/root',
                                                             sysroot='/sysroot',
                                                             binary_name='test',
                                                             port=123,
                                                             solib_search_path=['/path1',
                                                                                '/path2'],
                                                             extra_props=extra_props)),
         {
              'name': '(lldbclient.py) Attach test (port: 123)',
              'type': 'lldb',
              'request': 'custom',
              'relativePathBase': '/root',
              'sourceMap': { '/b/f/w' : '/root',
                            '': '/root',
                            '.': '/root',
                            '/test/' : '/root/test' },
              'initCommands': [
                  'settings append target.exec-search-paths /path1 /path2',
                  'settings append target.exec-search-paths /path3',
              ],
              'targetCreateCommands': ['target create test',
                                       'target modules search-paths add / /sysroot/'],
              'processCreateCommands': ['gdb-remote 123',
                                        'break main',
                                        'continue'],
              'preLaunchTask' : 'Build'
          })


 class LaunchConfigInsertTest(unittest.TestCase):
     def setUp(self) -> None:
         # These tests can generate long diffs, so we remove the limit
         self.maxDiff = None

     def test_insert_config(self) -> None:
         dst = textwrap.dedent("""\
             // #lldbclient-generated-begin
             // #lldbclient-generated-end""")
         to_insert = textwrap.dedent("""\
                                     foo
                                     bar""")
         self.assertEqual(gdbclient.insert_commands_into_vscode_config(dst,
                                                                       to_insert),
                          textwrap.dedent("""\
                             // #lldbclient-generated-begin
                             foo
                             bar
                             // #lldbclient-generated-end"""))

     def test_insert_into_start(self) -> None:
         dst = textwrap.dedent("""\
             // #lldbclient-generated-begin
             // #lldbclient-generated-end
             more content""")
         to_insert = textwrap.dedent("""\
             foo
             bar""")
         self.assertEqual(gdbclient.insert_commands_into_vscode_config(dst,
                                                                       to_insert),
                          textwrap.dedent("""\
                             // #lldbclient-generated-begin
                             foo
                             bar
                             // #lldbclient-generated-end
                             more content"""))

     def test_insert_into_mid(self) -> None:
         dst = textwrap.dedent("""\
             start content
             // #lldbclient-generated-begin
             // #lldbclient-generated-end
             more content""")
         to_insert = textwrap.dedent("""\
             foo
             bar""")
         self.assertEqual(gdbclient.insert_commands_into_vscode_config(dst,
                                                                       to_insert),
                          textwrap.dedent("""\
                             start content
                             // #lldbclient-generated-begin
                             foo
                             bar
                             // #lldbclient-generated-end
                             more content"""))

     def test_insert_into_end(self) -> None:
         dst = textwrap.dedent("""\
             start content
             // #lldbclient-generated-begin
             // #lldbclient-generated-end""")
         to_insert = textwrap.dedent("""\
             foo
             bar""")
         self.assertEqual(gdbclient.insert_commands_into_vscode_config(dst,
                                                                       to_insert),
                          textwrap.dedent("""\
                             start content
                             // #lldbclient-generated-begin
                             foo
                             bar
                             // #lldbclient-generated-end"""))

     def test_insert_twice(self) -> None:
         dst = textwrap.dedent("""\
             // #lldbclient-generated-begin
             // #lldbclient-generated-end
             // #lldbclient-generated-begin
             // #lldbclient-generated-end
             """)
         to_insert = 'foo'
         self.assertEqual(gdbclient.insert_commands_into_vscode_config(dst,
                                                                       to_insert),
                          textwrap.dedent("""\
                             // #lldbclient-generated-begin
                             foo
                             // #lldbclient-generated-end
                             // #lldbclient-generated-begin
                             foo
                             // #lldbclient-generated-end
                          """))

     def test_preserve_space_indent(self) -> None:
         dst = textwrap.dedent("""\
             {
               "version": "0.2.0",
               "configurations": [
                 // #lldbclient-generated-begin
                 // #lldbclient-generated-end
               ]
             }
         """)
         to_insert = textwrap.dedent("""\
             {
                 "name": "(lldbclient.py) Attach test",
                 "type": "lldb",
                 "processCreateCommands": [
                     "gdb-remote 123",
                     "test"
                 ]
             }""")
         self.assertEqual(gdbclient.insert_commands_into_vscode_config(dst,
                                                                       to_insert),
                          textwrap.dedent("""\
                              {
                                "version": "0.2.0",
                                "configurations": [
                                  // #lldbclient-generated-begin
                                  {
                                      "name": "(lldbclient.py) Attach test",
                                      "type": "lldb",
                                      "processCreateCommands": [
                                          "gdb-remote 123",
                                          "test"
                                      ]
                                  }
                                  // #lldbclient-generated-end
                                ]
                              }
                          """))

     def test_preserve_tab_indent(self) -> None:
         dst = textwrap.dedent("""\
             {
             \t"version": "0.2.0",
             \t"configurations": [
             \t\t// #lldbclient-generated-begin
             \t\t// #lldbclient-generated-end
             \t]
             }
         """)
         to_insert = textwrap.dedent("""\
             {
             \t"name": "(lldbclient.py) Attach test",
             \t"type": "lldb",
             \t"processCreateCommands": [
             \t\t"gdb-remote 123",
             \t\t"test"
             \t]
             }""")
         self.assertEqual(gdbclient.insert_commands_into_vscode_config(dst,
                                                                       to_insert),
                          textwrap.dedent("""\
                             {
                             \t"version": "0.2.0",
                             \t"configurations": [
                             \t\t// #lldbclient-generated-begin
                             \t\t{
                             \t\t\t"name": "(lldbclient.py) Attach test",
                             \t\t\t"type": "lldb",
                             \t\t\t"processCreateCommands": [
                             \t\t\t\t"gdb-remote 123",
                             \t\t\t\t"test"
                             \t\t\t]
                             \t\t}
                             \t\t// #lldbclient-generated-end
                             \t]
                             }
                          """))

     def test_preserve_trailing_whitespace(self) -> None:
         dst = textwrap.dedent("""\
             // #lldbclient-generated-begin \t
             // #lldbclient-generated-end\t """)
         to_insert = 'foo'
         self.assertEqual(gdbclient.insert_commands_into_vscode_config(dst,
                                                                       to_insert),
                          textwrap.dedent("""\
                             // #lldbclient-generated-begin \t
                             foo
                             // #lldbclient-generated-end\t """))

     def test_fail_if_no_begin(self) -> None:
         dst = textwrap.dedent("""\
             // #lldbclient-generated-end""")
         with self.assertRaisesRegex(ValueError, 'Did not find begin marker line'):
             gdbclient.insert_commands_into_vscode_config(dst, 'foo')

     def test_fail_if_no_end(self) -> None:
         dst = textwrap.dedent("""\
             // #lldbclient-generated-begin""")
         with self.assertRaisesRegex(ValueError, 'Unterminated begin marker at line 1'):
             gdbclient.insert_commands_into_vscode_config(dst, 'foo')

     def test_fail_if_begin_has_extra_text(self) -> None:
         dst = textwrap.dedent("""\
             // #lldbclient-generated-begin text
             // #lldbclient-generated-end""")
         with self.assertRaisesRegex(ValueError, 'Did not find begin marker line'):
             gdbclient.insert_commands_into_vscode_config(dst, 'foo')

     def test_fail_if_end_has_extra_text(self) -> None:
         dst = textwrap.dedent("""\
             // #lldbclient-generated-begin
             // #lldbclient-generated-end text""")
         with self.assertRaisesRegex(ValueError, 'Unterminated begin marker at line 1'):
             gdbclient.insert_commands_into_vscode_config(dst, 'foo')

     def test_fail_if_begin_end_swapped(self) -> None:
         dst = textwrap.dedent("""\
             // #lldbclient-generated-end
             // #lldbclient-generated-begin""")
         with self.assertRaisesRegex(ValueError, 'Unterminated begin marker at line 2'):
             gdbclient.insert_commands_into_vscode_config(dst, 'foo')


 if __name__ == '__main__':
     unittest.main(verbosity=2)
	#
	# Copyright (C) 2023 The Android Open Source Project
	#
	# Licensed under the Apache License, Version 2.0 (the "License");
	# you may not use this file except in compliance with the License.
	# You may obtain a copy of the License at
	#
	# http://www.apache.org/licenses/LICENSE-2.0
	#
	# Unless required by applicable law or agreed to in writing, software
	# distributed under the License is distributed on an "AS IS" BASIS,
	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	# See the License for the specific language governing permissions and
	# limitations under the License.
	#

	import copy
	import json
	import textwrap
	import unittest
	from typing import Any

	import gdbclient


	class LaunchConfigMergeTest(unittest.TestCase):
	def merge_compare(self, base: dict[str, Any], to_add: dict[str, Any] \| None, expected: dict[str, Any]) -> None:
	actual = copy.deepcopy(base)
	gdbclient.merge_launch_dict(actual, to_add)
	self.assertEqual(actual, expected, f'base={base}, to_add={to_add}')

	def test_add_none(self) -> None:
	base = { 'foo' : 1 }
	to_add = None
	expected = { 'foo' : 1 }
	self.merge_compare(base, to_add, expected)

	def test_add_val(self) -> None:
	base = { 'foo' : 1 }
	to_add = { 'bar' : 2}
	expected = { 'foo' : 1, 'bar' : 2 }
	self.merge_compare(base, to_add, expected)

	def test_overwrite_val(self) -> None:
	base = { 'foo' : 1 }
	to_add = { 'foo' : 2}
	expected = { 'foo' : 2 }
	self.merge_compare(base, to_add, expected)

	def test_lists_get_appended(self) -> None:
	base = { 'foo' : [1, 2] }
	to_add = { 'foo' : [3, 4]}
	expected = { 'foo' : [1, 2, 3, 4] }
	self.merge_compare(base, to_add, expected)

	def test_add_elem_to_dict(self) -> None:
	base = { 'foo' : { 'bar' : 1 } }
	to_add = { 'foo' : { 'baz' : 2 } }
	expected = { 'foo' : { 'bar' : 1, 'baz' : 2 } }
	self.merge_compare(base, to_add, expected)

	def test_overwrite_elem_in_dict(self) -> None:
	base = { 'foo' : { 'bar' : 1 } }
	to_add = { 'foo' : { 'bar' : 2 } }
	expected = { 'foo' : { 'bar' : 2 } }
	self.merge_compare(base, to_add, expected)

	def test_merging_dict_and_value_raises(self) -> None:
	base = { 'foo' : { 'bar' : 1 } }
	to_add = { 'foo' : 2 }
	with self.assertRaises(ValueError):
	gdbclient.merge_launch_dict(base, to_add)

	def test_merging_value_and_dict_raises(self) -> None:
	base = { 'foo' : 2 }
	to_add = { 'foo' : { 'bar' : 1 } }
	with self.assertRaises(ValueError):
	gdbclient.merge_launch_dict(base, to_add)

	def test_merging_dict_and_list_raises(self) -> None:
	base = { 'foo' : { 'bar' : 1 } }
	to_add = { 'foo' : [1] }
	with self.assertRaises(ValueError):
	gdbclient.merge_launch_dict(base, to_add)

	def test_merging_list_and_dict_raises(self) -> None:
	base = { 'foo' : [1] }
	to_add = { 'foo' : { 'bar' : 1 } }
	with self.assertRaises(ValueError):
	gdbclient.merge_launch_dict(base, to_add)

	def test_adding_elem_to_list_raises(self) -> None:
	base = { 'foo' : [1] }
	to_add = { 'foo' : 2}
	with self.assertRaises(ValueError):
	gdbclient.merge_launch_dict(base, to_add)

	def test_adding_list_to_elem_raises(self) -> None:
	base = { 'foo' : 1 }
	to_add = { 'foo' : [2]}
	with self.assertRaises(ValueError):
	gdbclient.merge_launch_dict(base, to_add)


	class VsCodeLaunchGeneratorTest(unittest.TestCase):
	def setUp(self) -> None:
	# These tests can generate long diffs, so we remove the limit
	self.maxDiff = None

	def test_generate_script(self) -> None:
	self.assertEqual(json.loads(gdbclient.generate_vscode_lldb_script(root='/root',
	sysroot='/sysroot',
	binary_name='test',
	port=123,
	solib_search_path=['/path1',
	'/path2'],
	extra_props=None)),
	{
	'name': '(lldbclient.py) Attach test (port: 123)',
	'type': 'lldb',
	'request': 'custom',
	'relativePathBase': '/root',
	'sourceMap': { '/b/f/w' : '/root', '': '/root', '.': '/root' },
	'initCommands': ['settings append target.exec-search-paths /path1 /path2'],
	'targetCreateCommands': ['target create test',
	'target modules search-paths add / /sysroot/'],
	'processCreateCommands': ['gdb-remote 123']
	})

	def test_generate_script_with_extra_props(self) -> None:
	extra_props = {
	'initCommands' : ['settings append target.exec-search-paths /path3'],
	'processCreateCommands' : ['break main', 'continue'],
	'sourceMap' : { '/test/' : '/root/test'},
	'preLaunchTask' : 'Build'
	}
	self.assertEqual(json.loads(gdbclient.generate_vscode_lldb_script(root='/root',
	sysroot='/sysroot',
	binary_name='test',
	port=123,
	solib_search_path=['/path1',
	'/path2'],
	extra_props=extra_props)),
	{
	'name': '(lldbclient.py) Attach test (port: 123)',
	'type': 'lldb',
	'request': 'custom',
	'relativePathBase': '/root',
	'sourceMap': { '/b/f/w' : '/root',
	'': '/root',
	'.': '/root',
	'/test/' : '/root/test' },
	'initCommands': [
	'settings append target.exec-search-paths /path1 /path2',
	'settings append target.exec-search-paths /path3',
	],
	'targetCreateCommands': ['target create test',
	'target modules search-paths add / /sysroot/'],
	'processCreateCommands': ['gdb-remote 123',
	'break main',
	'continue'],
	'preLaunchTask' : 'Build'
	})


	class LaunchConfigInsertTest(unittest.TestCase):
	def setUp(self) -> None:
	# These tests can generate long diffs, so we remove the limit
	self.maxDiff = None

	def test_insert_config(self) -> None:
	dst = textwrap.dedent("""\
	// #lldbclient-generated-begin
	// #lldbclient-generated-end""")
	to_insert = textwrap.dedent("""\
	foo
	bar""")
	self.assertEqual(gdbclient.insert_commands_into_vscode_config(dst,
	to_insert),
	textwrap.dedent("""\
	// #lldbclient-generated-begin
	foo
	bar
	// #lldbclient-generated-end"""))

	def test_insert_into_start(self) -> None:
	dst = textwrap.dedent("""\
	// #lldbclient-generated-begin
	// #lldbclient-generated-end
	more content""")
	to_insert = textwrap.dedent("""\
	foo
	bar""")
	self.assertEqual(gdbclient.insert_commands_into_vscode_config(dst,
	to_insert),
	textwrap.dedent("""\
	// #lldbclient-generated-begin
	foo
	bar
	// #lldbclient-generated-end
	more content"""))

	def test_insert_into_mid(self) -> None:
	dst = textwrap.dedent("""\
	start content
	// #lldbclient-generated-begin
	// #lldbclient-generated-end
	more content""")
	to_insert = textwrap.dedent("""\
	foo
	bar""")
	self.assertEqual(gdbclient.insert_commands_into_vscode_config(dst,
	to_insert),
	textwrap.dedent("""\
	start content
	// #lldbclient-generated-begin
	foo
	bar
	// #lldbclient-generated-end
	more content"""))

	def test_insert_into_end(self) -> None:
	dst = textwrap.dedent("""\
	start content
	// #lldbclient-generated-begin
	// #lldbclient-generated-end""")
	to_insert = textwrap.dedent("""\
	foo
	bar""")
	self.assertEqual(gdbclient.insert_commands_into_vscode_config(dst,
	to_insert),
	textwrap.dedent("""\
	start content
	// #lldbclient-generated-begin
	foo
	bar
	// #lldbclient-generated-end"""))

	def test_insert_twice(self) -> None:
	dst = textwrap.dedent("""\
	// #lldbclient-generated-begin
	// #lldbclient-generated-end
	// #lldbclient-generated-begin
	// #lldbclient-generated-end
	""")
	to_insert = 'foo'
	self.assertEqual(gdbclient.insert_commands_into_vscode_config(dst,
	to_insert),
	textwrap.dedent("""\
	// #lldbclient-generated-begin
	foo
	// #lldbclient-generated-end
	// #lldbclient-generated-begin
	foo
	// #lldbclient-generated-end
	"""))

	def test_preserve_space_indent(self) -> None:
	dst = textwrap.dedent("""\
	{
	"version": "0.2.0",
	"configurations": [
	// #lldbclient-generated-begin
	// #lldbclient-generated-end
	]
	}
	""")
	to_insert = textwrap.dedent("""\
	{
	"name": "(lldbclient.py) Attach test",
	"type": "lldb",
	"processCreateCommands": [
	"gdb-remote 123",
	"test"
	]
	}""")
	self.assertEqual(gdbclient.insert_commands_into_vscode_config(dst,
	to_insert),
	textwrap.dedent("""\
	{
	"version": "0.2.0",
	"configurations": [
	// #lldbclient-generated-begin
	{
	"name": "(lldbclient.py) Attach test",
	"type": "lldb",
	"processCreateCommands": [
	"gdb-remote 123",
	"test"
	]
	}
	// #lldbclient-generated-end
	]
	}
	"""))

	def test_preserve_tab_indent(self) -> None:
	dst = textwrap.dedent("""\
	{
	\t"version": "0.2.0",
	\t"configurations": [
	\t\t// #lldbclient-generated-begin
	\t\t// #lldbclient-generated-end
	\t]
	}
	""")
	to_insert = textwrap.dedent("""\
	{
	\t"name": "(lldbclient.py) Attach test",
	\t"type": "lldb",
	\t"processCreateCommands": [
	\t\t"gdb-remote 123",
	\t\t"test"
	\t]
	}""")
	self.assertEqual(gdbclient.insert_commands_into_vscode_config(dst,
	to_insert),
	textwrap.dedent("""\
	{
	\t"version": "0.2.0",
	\t"configurations": [
	\t\t// #lldbclient-generated-begin
	\t\t{
	\t\t\t"name": "(lldbclient.py) Attach test",
	\t\t\t"type": "lldb",
	\t\t\t"processCreateCommands": [
	\t\t\t\t"gdb-remote 123",
	\t\t\t\t"test"
	\t\t\t]
	\t\t}
	\t\t// #lldbclient-generated-end
	\t]
	}
	"""))

	def test_preserve_trailing_whitespace(self) -> None:
	dst = textwrap.dedent("""\
	// #lldbclient-generated-begin \t
	// #lldbclient-generated-end\t """)
	to_insert = 'foo'
	self.assertEqual(gdbclient.insert_commands_into_vscode_config(dst,
	to_insert),
	textwrap.dedent("""\
	// #lldbclient-generated-begin \t
	foo
	// #lldbclient-generated-end\t """))

	def test_fail_if_no_begin(self) -> None:
	dst = textwrap.dedent("""\
	// #lldbclient-generated-end""")
	with self.assertRaisesRegex(ValueError, 'Did not find begin marker line'):
	gdbclient.insert_commands_into_vscode_config(dst, 'foo')

	def test_fail_if_no_end(self) -> None:
	dst = textwrap.dedent("""\
	// #lldbclient-generated-begin""")
	with self.assertRaisesRegex(ValueError, 'Unterminated begin marker at line 1'):
	gdbclient.insert_commands_into_vscode_config(dst, 'foo')

	def test_fail_if_begin_has_extra_text(self) -> None:
	dst = textwrap.dedent("""\
	// #lldbclient-generated-begin text
	// #lldbclient-generated-end""")
	with self.assertRaisesRegex(ValueError, 'Did not find begin marker line'):
	gdbclient.insert_commands_into_vscode_config(dst, 'foo')

	def test_fail_if_end_has_extra_text(self) -> None:
	dst = textwrap.dedent("""\
	// #lldbclient-generated-begin
	// #lldbclient-generated-end text""")
	with self.assertRaisesRegex(ValueError, 'Unterminated begin marker at line 1'):
	gdbclient.insert_commands_into_vscode_config(dst, 'foo')

	def test_fail_if_begin_end_swapped(self) -> None:
	dst = textwrap.dedent("""\
	// #lldbclient-generated-end
	// #lldbclient-generated-begin""")
	with self.assertRaisesRegex(ValueError, 'Unterminated begin marker at line 2'):
	gdbclient.insert_commands_into_vscode_config(dst, 'foo')


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