[lldb] Modernize TestBitfields
This just does the usual modernizations such as using new test functions where
possible, clang-formatting the source, avoiding manual process setup,
assert improvements (` assertTrue(a == b) -> assertEqual(a, b)`).
This doesn't add any new test cases but removes some dependence on unrelated
features where possible (e.g., structs declared in functions, using the standard
library to printf stuff or initialize objects).
diff --git a/lldb/test/API/lang/c/bitfields/TestBitfields.py b/lldb/test/API/lang/c/bitfields/TestBitfields.py
index 2f52fce..4a144d5 100644
--- a/lldb/test/API/lang/c/bitfields/TestBitfields.py
+++ b/lldb/test/API/lang/c/bitfields/TestBitfields.py
@@ -1,4 +1,4 @@
-"""Show bitfields and check that they display correctly."""
+"""Test C bitfields."""
@@ -8,142 +8,100 @@
from lldbsuite.test import lldbutil
-class BitfieldsTestCase(TestBase):
+class TestCase(TestBase):
mydir = TestBase.compute_mydir(__file__)
- def setUp(self):
- # Call super's setUp().
- TestBase.setUp(self)
- # Find the line number to break inside main().
- self.line = line_number('main.c', '// Set break point at this line.')
+ def run_to_main(self):
+ self.build()
+ lldbutil.run_to_source_breakpoint(self, "// break here", lldb.SBFileSpec("main.c"))
# BitFields exhibit crashes in record layout on Windows
# (http://llvm.org/pr21800)
@skipIfWindows
- def test_and_run_command(self):
- """Test 'frame variable ...' on a variable with bitfields."""
- self.build()
- exe = self.getBuildArtifact("a.out")
- self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
+ def test_bits(self):
+ self.run_to_main()
- # Break inside the main.
- lldbutil.run_break_set_by_file_and_line(
- self, "main.c", self.line, num_expected_locations=1, loc_exact=True)
+ # Check each field of Bits.
+ bits_children = [
+ ValueCheck(type="int:1"), # Unnamed and uninitialized
+ ValueCheck(type="uint32_t:1", name="b1", value="1"),
+ ValueCheck(type="uint32_t:2", name="b2", value="3"),
+ ValueCheck(type="int:2"), # Unnamed and uninitialized
+ ValueCheck(type="uint32_t:3", name="b3", value="7"),
+ ValueCheck(type="uint32_t", name="b4", value="15"),
+ ValueCheck(type="uint32_t:5", name="b5", value="31"),
+ ValueCheck(type="uint32_t:6", name="b6", value="63"),
+ ValueCheck(type="uint32_t:7", name="b7", value="127"),
+ ValueCheck(type="uint32_t:4", name="four", value="15")
+ ]
+ self.expect_var_path("bits", type="Bits", children=bits_children)
+ self.expect_expr("bits", result_children=bits_children)
- self.runCmd("run", RUN_SUCCEEDED)
+ # Try accessing the different fields using the expression evaluator.
+ self.expect_expr("bits.b1", result_type="uint32_t", result_value="1")
+ self.expect_expr("bits.b2", result_type="uint32_t", result_value="3")
+ self.expect_expr("bits.b3", result_type="uint32_t", result_value="7")
+ self.expect_expr("bits.b4", result_type="uint32_t", result_value="15")
+ self.expect_expr("bits.b5", result_type="uint32_t", result_value="31")
+ self.expect_expr("bits.b6", result_type="uint32_t", result_value="63")
+ self.expect_expr("bits.b7", result_type="uint32_t", result_value="127")
+ self.expect_expr("bits.four", result_type="uint32_t", result_value="15")
- # The stop reason of the thread should be breakpoint.
- self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
- substrs=['stopped',
- 'stop reason = breakpoint'])
+ # Try accessing the different fields using variable paths.
+ self.expect_var_path("bits.b1", type="uint32_t:1", value="1")
+ self.expect_var_path("bits.b2", type="uint32_t:2", value="3")
+ self.expect_var_path("bits.b4", type="uint32_t", value="15")
+ self.expect_var_path("bits.b5", type="uint32_t:5", value="31")
+ self.expect_var_path("bits.b7", type="uint32_t:7", value="127")
- # The breakpoint should have a hit count of 1.
- self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
- substrs=[' resolved, hit count = 1'])
- # This should display correctly.
- self.expect(
- "frame variable --show-types bits",
- VARIABLES_DISPLAYED_CORRECTLY,
- substrs=[
- '(uint32_t:1) b1 = 1',
- '(uint32_t:2) b2 = 3',
- '(uint32_t:3) b3 = 7',
- '(uint32_t) b4 = 15',
- '(uint32_t:5) b5 = 31',
- '(uint32_t:6) b6 = 63',
- '(uint32_t:7) b7 = 127',
- '(uint32_t:4) four = 15'])
+ # Check each field of MoreBits.
+ more_bits_children = [
+ ValueCheck(type="uint32_t:3", name="a", value="3"),
+ ValueCheck(type="int:1", value="0"),
+ ValueCheck(type="uint8_t:1", name="b", value="'\\0'"),
+ ValueCheck(type="uint8_t:1", name="c", value="'\\x01'"),
+ ValueCheck(type="uint8_t:1", name="d", value="'\\0'"),
+ ]
+ self.expect_var_path("more_bits", type="MoreBits", children=more_bits_children)
+ self.expect_expr("more_bits", result_children=more_bits_children)
- # And so should this.
- # rdar://problem/8348251
- self.expect(
- "frame variable --show-types",
- VARIABLES_DISPLAYED_CORRECTLY,
- substrs=[
- '(uint32_t:1) b1 = 1',
- '(uint32_t:2) b2 = 3',
- '(uint32_t:3) b3 = 7',
- '(uint32_t) b4 = 15',
- '(uint32_t:5) b5 = 31',
- '(uint32_t:6) b6 = 63',
- '(uint32_t:7) b7 = 127',
- '(uint32_t:4) four = 15'])
+ self.expect_expr("more_bits.a", result_type="uint32_t", result_value="3")
+ self.expect_expr("more_bits.b", result_type="uint8_t", result_value="'\\0'")
+ self.expect_expr("more_bits.c", result_type="uint8_t", result_value="'\\x01'")
+ self.expect_expr("more_bits.d", result_type="uint8_t", result_value="'\\0'")
- self.expect("expr (bits.b1)", VARIABLES_DISPLAYED_CORRECTLY,
- substrs=['uint32_t', '1'])
- self.expect("expr (bits.b2)", VARIABLES_DISPLAYED_CORRECTLY,
- substrs=['uint32_t', '3'])
- self.expect("expr (bits.b3)", VARIABLES_DISPLAYED_CORRECTLY,
- substrs=['uint32_t', '7'])
- self.expect("expr (bits.b4)", VARIABLES_DISPLAYED_CORRECTLY,
- substrs=['uint32_t', '15'])
- self.expect("expr (bits.b5)", VARIABLES_DISPLAYED_CORRECTLY,
- substrs=['uint32_t', '31'])
- self.expect("expr (bits.b6)", VARIABLES_DISPLAYED_CORRECTLY,
- substrs=['uint32_t', '63'])
- self.expect("expr (bits.b7)", VARIABLES_DISPLAYED_CORRECTLY,
- substrs=['uint32_t', '127'])
- self.expect("expr (bits.four)", VARIABLES_DISPLAYED_CORRECTLY,
- substrs=['uint32_t', '15'])
+ # Test a struct with several single bit fields.
+ many_single_bits_children = [
+ ValueCheck(type="uint16_t:1", name="b1", value="1"),
+ ValueCheck(type="uint16_t:1", name="b2", value="0"),
+ ValueCheck(type="uint16_t:1", name="b3", value="0"),
+ ValueCheck(type="uint16_t:1", name="b4", value="0"),
+ ValueCheck(type="uint16_t:1", name="b5", value="1"),
+ ValueCheck(type="uint16_t:1", name="b6", value="0"),
+ ValueCheck(type="uint16_t:1", name="b7", value="1"),
+ ValueCheck(type="uint16_t:1", name="b8", value="0"),
+ ValueCheck(type="uint16_t:1", name="b9", value="0"),
+ ValueCheck(type="uint16_t:1", name="b10", value="0"),
+ ValueCheck(type="uint16_t:1", name="b11", value="0"),
+ ValueCheck(type="uint16_t:1", name="b12", value="0"),
+ ValueCheck(type="uint16_t:1", name="b13", value="1"),
+ ValueCheck(type="uint16_t:1", name="b14", value="0"),
+ ValueCheck(type="uint16_t:1", name="b15", value="0"),
+ ValueCheck(type="uint16_t:1", name="b16", value="0"),
+ ValueCheck(type="uint16_t:1", name="b17", value="0"),
+ ]
+ self.expect_var_path("many_single_bits", type="ManySingleBits", children=many_single_bits_children)
+ self.expect_expr("many_single_bits", result_type="ManySingleBits",
+ result_children=many_single_bits_children)
- self.expect(
- "frame variable --show-types more_bits",
- VARIABLES_DISPLAYED_CORRECTLY,
- substrs=[
- '(uint32_t:3) a = 3',
- '(uint8_t:1) b = \'\\0\'',
- '(uint8_t:1) c = \'\\x01\'',
- '(uint8_t:1) d = \'\\0\''])
+ # Check a packed struct.
+ self.expect_expr("packed.a", result_type="char", result_value="'a'")
+ self.expect_expr("packed.b", result_type="uint32_t", result_value="10")
+ self.expect_expr("packed.c", result_type="uint32_t", result_value=str(int("7112233", 16)))
- self.expect("expr (more_bits.a)", VARIABLES_DISPLAYED_CORRECTLY,
- substrs=['uint32_t', '3'])
- self.expect("expr (more_bits.b)", VARIABLES_DISPLAYED_CORRECTLY,
- substrs=['uint8_t', '\\0'])
- self.expect("expr (more_bits.c)", VARIABLES_DISPLAYED_CORRECTLY,
- substrs=['uint8_t', '\\x01'])
- self.expect("expr (more_bits.d)", VARIABLES_DISPLAYED_CORRECTLY,
- substrs=['uint8_t', '\\0'])
-
- self.expect("expr (packed.a)", VARIABLES_DISPLAYED_CORRECTLY,
- substrs=['char', "'a'"])
- self.expect("expr (packed.b)", VARIABLES_DISPLAYED_CORRECTLY,
- substrs=['uint32_t', "10"])
- self.expect("expr/x (packed.c)", VARIABLES_DISPLAYED_CORRECTLY,
- substrs=['uint32_t', "7112233"])
-
- for bit in range(1,18):
- expected = "1" if bit in [1, 5, 7, 13] else "0"
- self.expect("expr even_more_bits.b" + str(bit), VARIABLES_DISPLAYED_CORRECTLY,
- substrs=['uint8_t', expected])
-
- for bit in [3, 10, 14]:
- self.expect("expr even_more_bits.b" + str(bit) + " = 1", VARIABLES_DISPLAYED_CORRECTLY,
- substrs=['uint8_t', "1"])
-
- self.expect(
- "frame variable --show-types even_more_bits",
- VARIABLES_DISPLAYED_CORRECTLY,
- substrs=[
- '(uint8_t:1) b1 = \'\\x01\'',
- '(uint8_t:1) b2 = \'\\0\'',
- '(uint8_t:1) b3 = \'\\x01\'',
- '(uint8_t:1) b4 = \'\\0\'',
- '(uint8_t:1) b5 = \'\\x01\'',
- '(uint8_t:1) b6 = \'\\0\'',
- '(uint8_t:1) b7 = \'\\x01\'',
- '(uint8_t:1) b8 = \'\\0\'',
- '(uint8_t:1) b9 = \'\\0\'',
- '(uint8_t:1) b10 = \'\\x01\'',
- '(uint8_t:1) b12 = \'\\0\'',
- '(uint8_t:1) b13 = \'\\x01\'',
- '(uint8_t:1) b14 = \'\\x01\'',
- '(uint8_t:1) b15 = \'\\0\'',
- '(uint8_t:1) b16 = \'\\0\'',
- '(uint8_t:1) b17 = \'\\0\'',
- ])
-
+ # A packed struct with bitfield size > 32.
self.expect("v/x large_packed", VARIABLES_DISPLAYED_CORRECTLY,
substrs=["a = 0x0000000cbbbbaaaa", "b = 0x0000000dffffeee"])
@@ -161,9 +119,8 @@
# values for already parsed variables. The expression is run twice
# because the very first expression can resume a target (to allocate
# memory, etc.) even if it is not being jitted.
- self.build()
- lldbutil.run_to_line_breakpoint(self, lldb.SBFileSpec("main.c"),
- self.line)
+ self.run_to_main()
+
self.expect("v/x large_packed", VARIABLES_DISPLAYED_CORRECTLY,
substrs=["a = 0x0000000cbbbbaaaa", "b = 0x0000000dffffeee"])
self.expect("expr --allow-jit false -- more_bits.a", VARIABLES_DISPLAYED_CORRECTLY,
@@ -181,67 +138,33 @@
@skipIfWindows
def test_and_python_api(self):
"""Use Python APIs to inspect a bitfields variable."""
- self.build()
- exe = self.getBuildArtifact("a.out")
-
- target = self.dbg.CreateTarget(exe)
- self.assertTrue(target, VALID_TARGET)
-
- breakpoint = target.BreakpointCreateByLocation("main.c", self.line)
- self.assertTrue(breakpoint, VALID_BREAKPOINT)
-
- process = target.LaunchSimple(
- None, None, self.get_process_working_directory())
- self.assertTrue(process, PROCESS_IS_VALID)
-
- # The stop reason of the thread should be breakpoint.
- thread = lldbutil.get_stopped_thread(
- process, lldb.eStopReasonBreakpoint)
- self.assertIsNotNone(thread)
-
- # The breakpoint should have a hit count of 1.
- self.assertEqual(breakpoint.GetHitCount(), 1, BREAKPOINT_HIT_ONCE)
+ self.run_to_main()
# Lookup the "bits" variable which contains 8 bitfields.
- frame = thread.GetFrameAtIndex(0)
- bits = frame.FindVariable("bits")
+ bits = self.frame().FindVariable("bits")
self.DebugSBValue(bits)
- self.assertEqual(
- bits.GetTypeName(), 'Bits',
- "bits.GetTypeName() == 'Bits'")
- self.assertEqual(
- bits.GetNumChildren(), 10,
- "bits.GetNumChildren() == 10")
- test_compiler = self.getCompiler()
- self.assertEqual(bits.GetByteSize(), 32, "bits.GetByteSize() == 32")
+ self.assertEqual(bits.GetTypeName(), 'Bits')
+ self.assertEqual(bits.GetNumChildren(), 10)
+ self.assertEqual(bits.GetByteSize(), 32)
# Notice the pattern of int(b1.GetValue(), 0). We pass a base of 0
# so that the proper radix is determined based on the contents of the
# string.
b1 = bits.GetChildMemberWithName("b1")
self.DebugSBValue(b1)
- self.assertTrue(b1.GetName() == "b1" and
- b1.GetTypeName() == "uint32_t:1" and
- b1.IsInScope() and
- int(b1.GetValue(), 0) == 1,
- 'bits.b1 has type uint32_t:1, is in scope, and == 1')
+ self.assertEqual(b1.GetName(), "b1")
+ self.assertEqual(b1.GetTypeName(), "uint32_t:1")
+ self.assertTrue(b1.IsInScope())
+ self.assertEqual(int(b1.GetValue(), 0), 1)
b7 = bits.GetChildMemberWithName("b7")
- self.DebugSBValue(b7)
- self.assertTrue(b7.GetName() == "b7" and
- b7.GetTypeName() == "uint32_t:7" and
- b7.IsInScope() and
- int(b7.GetValue(), 0) == 127,
- 'bits.b7 has type uint32_t:7, is in scope, and == 127')
+ self.assertEqual(b7.GetName(), "b7")
+ self.assertEqual(b7.GetTypeName(), "uint32_t:7")
+ self.assertTrue(b7.IsInScope())
+ self.assertEqual(int(b7.GetValue(), 0), 127)
four = bits.GetChildMemberWithName("four")
- self.DebugSBValue(four)
- self.assertTrue(four.GetName() == "four" and
- four.GetTypeName() == "uint32_t:4" and
- four.IsInScope() and
- int(four.GetValue(), 0) == 15,
- 'bits.four has type uint32_t:4, is in scope, and == 15')
-
- # Now kill the process, and we are done.
- rc = target.GetProcess().Kill()
- self.assertTrue(rc.Success())
+ self.assertEqual(four.GetName(), "four")
+ self.assertEqual(four.GetTypeName(), "uint32_t:4")
+ self.assertTrue(four.IsInScope())
+ self.assertEqual(int(four.GetValue(), 0), 15)
\ No newline at end of file
diff --git a/lldb/test/API/lang/c/bitfields/main.c b/lldb/test/API/lang/c/bitfields/main.c
index f3f4d6a..ba085f2 100644
--- a/lldb/test/API/lang/c/bitfields/main.c
+++ b/lldb/test/API/lang/c/bitfields/main.c
@@ -1,97 +1,77 @@
#include <stdint.h>
-#include <stdio.h>
-#include <string.h>
-int main (int argc, char const *argv[])
-{
- struct Bits
- {
- uint32_t : 1, // Unnamed bitfield
- b1 : 1,
- b2 : 2,
- : 2, // Unnamed bitfield
- b3 : 3,
- : 2, // Unnamed bitfield (this will get removed)
- b4 __attribute__ ((aligned(16))),
- b5 : 5,
- b6 : 6,
- b7 : 7,
- four : 4;
- };
+struct Bits {
+ uint32_t : 1;
+ uint32_t b1 : 1;
+ uint32_t b2 : 2;
+ uint32_t : 2;
+ uint32_t b3 : 3;
+ // Unnamed bitfield (this will get removed).
+ uint32_t : 2;
+ uint32_t b4 __attribute__ ((aligned(16)));
+ uint32_t b5 : 5;
+ uint32_t b6 : 6;
+ uint32_t b7 : 7;
+ uint32_t four : 4;
+};
- printf("%lu", sizeof(struct Bits));
+struct MoreBits {
+ uint32_t a : 3;
+ uint8_t : 1;
+ uint8_t b : 1;
+ uint8_t c : 1;
+ uint8_t d : 1;
+};
+struct MoreBits more_bits;
- struct Bits bits;
- int i;
- for (i=0; i<(1<<1); i++)
- bits.b1 = i; //// break $source:$line
- for (i=0; i<(1<<2); i++)
- bits.b2 = i; //// break $source:$line
- for (i=0; i<(1<<3); i++)
- bits.b3 = i; //// break $source:$line
- for (i=0; i<(1<<4); i++)
- bits.b4 = i; //// break $source:$line
- for (i=0; i<(1<<5); i++)
- bits.b5 = i; //// break $source:$line
- for (i=0; i<(1<<6); i++)
- bits.b6 = i; //// break $source:$line
- for (i=0; i<(1<<7); i++)
- bits.b7 = i; //// break $source:$line
- for (i=0; i<(1<<4); i++)
- bits.four = i; //// break $source:$line
+struct ManySingleBits {
+ uint16_t b1 : 1, b2 : 1, b3 : 1, b4 : 1, b5 : 1, b6 : 1, b7 : 1, b8 : 1,
+ b9 : 1, b10 : 1, b11 : 1, b12 : 1, b13 : 1, b14 : 1, b15 : 1, b16 : 1,
+ b17 : 1;
+};
+struct ManySingleBits many_single_bits;
- struct MoreBits
- {
- uint32_t a : 3;
- uint8_t : 1;
- uint8_t b : 1;
- uint8_t c : 1;
- uint8_t d : 1;
- };
-
- struct MoreBits more_bits;
-
- more_bits.a = 3;
- more_bits.b = 0;
- more_bits.c = 1;
- more_bits.d = 0;
-
- struct EvenMoreBits
- {
- uint8_t b1 : 1, b2 : 1, b3 : 1, b4 : 1, b5 : 1, b6 : 1,
- b7 : 1, b8 : 1, b9 : 1, b10 : 1, b11 : 1, b12 : 1,
- b13 : 1, b14 : 1, b15 : 1, b16 : 1, b17 : 1;
- };
-
- struct EvenMoreBits even_more_bits;
- memset(&even_more_bits, 0, sizeof(even_more_bits));
- even_more_bits.b1 = 1;
- even_more_bits.b5 = 1;
- even_more_bits.b7 = 1;
- even_more_bits.b13 = 1;
+struct LargePackedBits {
+ uint64_t a : 36;
+ uint64_t b : 36;
+} __attribute__((packed));
#pragma pack(1)
- struct PackedBits
- {
- char a;
- uint32_t b : 5,
- c : 27;
- };
-#pragma pack()
- struct PackedBits packed;
- packed.a = 'a';
- packed.b = 10;
- packed.c = 0x7112233;
+struct PackedBits {
+ char a;
+ uint32_t b : 5, c : 27;
+};
+#pragma pack()
- struct LargePackedBits {
- uint64_t a: 36;
- uint64_t b: 36;
- } __attribute__((packed));
+int main(int argc, char const *argv[]) {
+ struct Bits bits;
+ bits.b1 = 1;
+ bits.b2 = 3;
+ bits.b3 = 7;
+ bits.b4 = 15;
+ bits.b5 = 31;
+ bits.b6 = 63;
+ bits.b7 = 127;
+ bits.four = 15;
- struct LargePackedBits large_packed =
- (struct LargePackedBits){ 0xcbbbbaaaa, 0xdffffeeee };
- struct LargePackedBits *large_packed_ptr = &large_packed;
-
- return 0; //// Set break point at this line.
+ more_bits.a = 3;
+ more_bits.b = 0;
+ more_bits.c = 1;
+ more_bits.d = 0;
+ many_single_bits.b1 = 1;
+ many_single_bits.b5 = 1;
+ many_single_bits.b7 = 1;
+ many_single_bits.b13 = 1;
+
+ struct PackedBits packed;
+ packed.a = 'a';
+ packed.b = 10;
+ packed.c = 0x7112233;
+
+ struct LargePackedBits large_packed =
+ (struct LargePackedBits){0xcbbbbaaaa, 0xdffffeeee};
+ struct LargePackedBits *large_packed_ptr = &large_packed;
+
+ return 0; // break here
}
