xref: /llvm-project/lldb/test/API/python_api/find_in_memory/TestFindRangesInMemory.py (revision b88d94caba518bc63c25fe476c4de3d9b0bbd2c0) 
1"""
2Test Process::FindRangesInMemory.
3"""
4
5import lldb
6from lldbsuite.test.lldbtest import *
7from lldbsuite.test import lldbutil
8from address_ranges_helper import *
9
10
11class FindRangesInMemoryTestCase(TestBase):
12    NO_DEBUG_INFO_TESTCASE = True
13
14    def setUp(self):
15        TestBase.setUp(self)
16
17        self.build()
18        (
19            self.target,
20            self.process,
21            self.thread,
22            self.bp,
23        ) = lldbutil.run_to_source_breakpoint(
24            self, "break here", lldb.SBFileSpec("main.cpp")
25        )
26        self.assertTrue(self.bp.IsValid())
27
28    def test_find_ranges_in_memory_two_matches(self):
29        """Make sure two matches exist in the heap memory and the right address ranges are provided"""
30        self.assertTrue(self.process, PROCESS_IS_VALID)
31        self.assertState(self.process.GetState(), lldb.eStateStopped, PROCESS_STOPPED)
32
33        addr_ranges = GetHeapRanges(self, True)
34        error = lldb.SBError()
35        matches = self.process.FindRangesInMemory(
36            DOUBLE_INSTANCE_PATTERN_HEAP,
37            addr_ranges,
38            1,
39            10,
40            error,
41        )
42
43        self.assertSuccess(error)
44        self.assertEqual(matches.GetSize(), 2)
45
46    def test_find_ranges_in_memory_one_match(self):
47        """Make sure exactly one match exists in the heap memory and the right address ranges are provided"""
48        self.assertTrue(self.process, PROCESS_IS_VALID)
49        self.assertState(self.process.GetState(), lldb.eStateStopped, PROCESS_STOPPED)
50
51        addr_ranges = GetStackRanges(self, True)
52        error = lldb.SBError()
53        matches = self.process.FindRangesInMemory(
54            SINGLE_INSTANCE_PATTERN_STACK,
55            addr_ranges,
56            1,
57            10,
58            error,
59        )
60
61        self.assertSuccess(error)
62        self.assertEqual(matches.GetSize(), 1)
63
64    def test_find_ranges_in_memory_one_match_multiple_ranges(self):
65        """Make sure exactly one match exists in the heap memory and multiple address ranges are provided"""
66        self.assertTrue(self.process, PROCESS_IS_VALID)
67        self.assertState(self.process.GetState(), lldb.eStateStopped, PROCESS_STOPPED)
68
69        addr_ranges = GetRanges(self, True)
70        addr_ranges.Append(lldb.SBAddressRange())
71        self.assertGreater(addr_ranges.GetSize(), 2)
72        error = lldb.SBError()
73        matches = self.process.FindRangesInMemory(
74            SINGLE_INSTANCE_PATTERN_STACK,
75            addr_ranges,
76            1,
77            10,
78            error,
79        )
80
81        self.assertSuccess(error)
82        self.assertEqual(matches.GetSize(), 1)
83
84    def test_find_ranges_in_memory_one_match_max(self):
85        """Make sure at least one matche exists in the heap memory and the right address ranges are provided"""
86        self.assertTrue(self.process, PROCESS_IS_VALID)
87        self.assertState(self.process.GetState(), lldb.eStateStopped, PROCESS_STOPPED)
88
89        addr_ranges = GetHeapRanges(self, True)
90        error = lldb.SBError()
91        matches = self.process.FindRangesInMemory(
92            DOUBLE_INSTANCE_PATTERN_HEAP,
93            addr_ranges,
94            1,
95            1,
96            error,
97        )
98
99        self.assertSuccess(error)
100        self.assertEqual(matches.GetSize(), 1)
101
102    def test_find_ranges_in_memory_invalid_alignment(self):
103        """Make sure the alignment 0 is failing"""
104        self.assertTrue(self.process, PROCESS_IS_VALID)
105        self.assertState(self.process.GetState(), lldb.eStateStopped, PROCESS_STOPPED)
106
107        addr_ranges = GetHeapRanges(self, True)
108        error = lldb.SBError()
109        matches = self.process.FindRangesInMemory(
110            DOUBLE_INSTANCE_PATTERN_HEAP,
111            addr_ranges,
112            0,
113            10,
114            error,
115        )
116
117        self.assertFailure(error)
118        self.assertEqual(matches.GetSize(), 0)
119
120    def test_find_ranges_in_memory_invalid_range(self):
121        """Make sure the alignment 0 is failing"""
122        self.assertTrue(self.process, PROCESS_IS_VALID)
123        self.assertState(self.process.GetState(), lldb.eStateStopped, PROCESS_STOPPED)
124
125        addr_ranges = lldb.SBAddressRangeList()
126        addr_ranges.Append(lldb.SBAddressRange())
127        error = lldb.SBError()
128        matches = self.process.FindRangesInMemory(
129            DOUBLE_INSTANCE_PATTERN_HEAP,
130            addr_ranges,
131            1,
132            10,
133            error,
134        )
135
136        self.assertFailure(error)
137        self.assertIn("unable to resolve any ranges", str(error))
138        self.assertEqual(matches.GetSize(), 0)
139
140    def test_find_ranges_in_memory_empty_ranges(self):
141        """Make sure the empty ranges is failing"""
142        self.assertTrue(self.process, PROCESS_IS_VALID)
143        self.assertState(self.process.GetState(), lldb.eStateStopped, PROCESS_STOPPED)
144
145        addr_ranges = lldb.SBAddressRangeList()
146        error = lldb.SBError()
147        matches = self.process.FindRangesInMemory(
148            DOUBLE_INSTANCE_PATTERN_HEAP,
149            addr_ranges,
150            1,
151            10,
152            error,
153        )
154
155        self.assertFailure(error)
156        self.assertEqual(matches.GetSize(), 0)
157
158    def test_find_ranges_in_memory_invalid_buffer(self):
159        """Make sure the empty buffer is failing"""
160        self.assertTrue(self.process, PROCESS_IS_VALID)
161        self.assertState(self.process.GetState(), lldb.eStateStopped, PROCESS_STOPPED)
162
163        addr_ranges = GetHeapRanges(self, True)
164        error = lldb.SBError()
165        matches = self.process.FindRangesInMemory(
166            "",
167            addr_ranges,
168            1,
169            10,
170            error,
171        )
172
173        self.assertFailure(error)
174        self.assertEqual(matches.GetSize(), 0)
175
176    def test_find_ranges_in_memory_invalid_max_matches(self):
177        """Make sure the empty buffer is failing"""
178        self.assertTrue(self.process, PROCESS_IS_VALID)
179        self.assertState(self.process.GetState(), lldb.eStateStopped, PROCESS_STOPPED)
180
181        addr_ranges = GetHeapRanges(self, True)
182        error = lldb.SBError()
183        matches = self.process.FindRangesInMemory(
184            DOUBLE_INSTANCE_PATTERN_HEAP,
185            addr_ranges,
186            1,
187            0,
188            error,
189        )
190
191        self.assertFailure(error)
192        self.assertEqual(matches.GetSize(), 0)
193
194    def test_find_in_memory_unaligned(self):
195        """Make sure the unaligned match exists in the heap memory and is not found with alignment 8"""
196        self.assertTrue(self.process, PROCESS_IS_VALID)
197        self.assertState(self.process.GetState(), lldb.eStateStopped, PROCESS_STOPPED)
198
199        addr_ranges = lldb.SBAddressRangeList()
200        addr_ranges.Append(GetAlignedRange(self, True))
201        error = lldb.SBError()
202
203        matches = self.process.FindRangesInMemory(
204            UNALIGNED_INSTANCE_PATTERN_HEAP,
205            addr_ranges,
206            1,
207            10,
208            error,
209        )
210        self.assertSuccess(error)
211        self.assertEqual(matches.GetSize(), 1)
212
213        matches = self.process.FindRangesInMemory(
214            UNALIGNED_INSTANCE_PATTERN_HEAP,
215            addr_ranges,
216            8,
217            10,
218            error,
219        )
220        self.assertSuccess(error)
221        self.assertEqual(matches.GetSize(), 0)
222