ceedling 1.0.1 → 1.1.0

data/spec/units/c_extractor/c_extractor_code_text_spec.rb

@@ -0,0 +1,2091 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'spec_helper'
+require 'ceedling/c_extractor/c_extractor_code_text'
+require 'stringio'
+
+describe CExtractorCodeText do
+
+  ###
+  ### skip_c_string()
+  ###
+  describe "#skip_c_string" do
+    # Helper to access private method
+    let(:skip_c_string) do
+      ->(content, quote) do
+        scanner = StringScanner.new(content)
+        code_text = CExtractorCodeText.new
+        bytes_skipped = code_text.skip_c_string( scanner, quote )
+        return [bytes_skipped, scanner.pos, scanner.rest]
+      end
+    end
+
+    context "double-quoted string handling" do
+      it "skips simple double-quoted string" do
+        content = '"hello"code'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(7)
+        expect(pos).to eq(7)
+        expect(rest).to eq("code")
+      end
+
+      it "skips empty double-quoted string" do
+        content = '""code'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(2)
+        expect(pos).to eq(2)
+        expect(rest).to eq("code")
+      end
+
+      it "skips string with spaces" do
+        content = '"hello   world"code'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(15)
+        expect(pos).to eq(15)
+        expect(rest).to eq("code")
+      end
+
+      it "skips string with special characters" do
+        content = '"hello!@#$%^&*()"code'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(17)
+        expect(pos).to eq(17)
+        expect(rest).to eq("code")
+      end
+
+      it "skips string with newlines" do
+        content = "\"hello\nworld\"code"
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(13)
+        expect(pos).to eq(13)
+        expect(rest).to eq("code")
+      end
+
+      it "skips string with tabs" do
+        content = "\"hello\tworld\"code"
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(13)
+        expect(pos).to eq(13)
+        expect(rest).to eq("code")
+      end
+    end
+
+    context "single-quoted character handling" do
+      it "skips simple single-quoted character" do
+        content = "'a'code"
+        bytes_skipped, pos, rest = skip_c_string.call(content, "'")
+        
+        expect(bytes_skipped).to eq(3)
+        expect(pos).to eq(3)
+        expect(rest).to eq("code")
+      end
+
+      it "skips single-quoted digit" do
+        content = "'5'code"
+        bytes_skipped, pos, rest = skip_c_string.call(content, "'")
+        
+        expect(bytes_skipped).to eq(3)
+        expect(pos).to eq(3)
+        expect(rest).to eq("code")
+      end
+
+      it "skips single-quoted special character" do
+        content = "'@'code"
+        bytes_skipped, pos, rest = skip_c_string.call(content, "'")
+        
+        expect(bytes_skipped).to eq(3)
+        expect(pos).to eq(3)
+        expect(rest).to eq("code")
+      end
+
+      it "skips single-quoted space" do
+        content = "' 'code"
+        bytes_skipped, pos, rest = skip_c_string.call(content, "'")
+        
+        expect(bytes_skipped).to eq(3)
+        expect(pos).to eq(3)
+        expect(rest).to eq("code")
+      end
+    end
+
+    context "escape sequence handling" do
+      it "skips string with escaped double quote" do
+        content = '"hello \\"world\\""code'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(17)
+        expect(pos).to eq(17)
+        expect(rest).to eq("code")
+      end
+
+      it "skips string with escaped backslash" do
+        content = '"path\\\\to\\\\file"code'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(16)
+        expect(pos).to eq(16)
+        expect(rest).to eq("code")
+      end
+
+      it "skips string with escaped newline" do
+        content = '"hello\\nworld"code'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(14)
+        expect(pos).to eq(14)
+        expect(rest).to eq("code")
+      end
+
+      it "skips string with escaped tab" do
+        content = '"hello\\tworld"code'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(14)
+        expect(pos).to eq(14)
+        expect(rest).to eq("code")
+      end
+
+      it "skips string with escaped carriage return" do
+        content = '"hello\\rworld"code'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(14)
+        expect(pos).to eq(14)
+        expect(rest).to eq("code")
+      end
+
+      it "skips string with multiple escape sequences" do
+        content = '"\\n\\t\\r\\\\\\"\\\'"code'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(14)
+        expect(pos).to eq(14)
+        expect(rest).to eq("code")
+      end
+
+      it "skips character with escaped single quote" do
+        content = "'\\\''code"
+        bytes_skipped, pos, rest = skip_c_string.call(content, "'")
+        
+        expect(bytes_skipped).to eq(4)
+        expect(pos).to eq(4)
+        expect(rest).to eq("code")
+      end
+
+      it "skips character with escaped backslash" do
+        content = "'\\\\'code"
+        bytes_skipped, pos, rest = skip_c_string.call(content, "'")
+        
+        expect(bytes_skipped).to eq(4)
+        expect(pos).to eq(4)
+        expect(rest).to eq("code")
+      end
+
+      it "skips character with escaped newline" do
+        content = "'\\n'code"
+        bytes_skipped, pos, rest = skip_c_string.call(content, "'")
+        
+        expect(bytes_skipped).to eq(4)
+        expect(pos).to eq(4)
+        expect(rest).to eq("code")
+      end
+
+      it "skips string with octal escape sequence" do
+        content = '"\\101\\102\\103"code'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(14)
+        expect(pos).to eq(14)
+        expect(rest).to eq("code")
+      end
+
+      it "skips string with hexadecimal escape sequence" do
+        content = '"\\x41\\x42\\x43"code'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(14)
+        expect(pos).to eq(14)
+        expect(rest).to eq("code")
+      end
+
+      it "skips string with unicode escape sequence" do
+        content = '"\\u0041\\u0042"code'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(14)
+        expect(pos).to eq(14)
+        expect(rest).to eq("code")
+      end
+    end
+
+    context "unterminated string handling" do
+      it "handles unterminated double-quoted string" do
+        content = '"hello world'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(12)
+        expect(pos).to eq(12)
+        expect(rest).to eq("")
+      end
+
+      it "handles unterminated single-quoted character" do
+        content = "'a"
+        bytes_skipped, pos, rest = skip_c_string.call(content, "'")
+        
+        expect(bytes_skipped).to eq(2)
+        expect(pos).to eq(2)
+        expect(rest).to eq("")
+      end
+
+      it "handles unterminated string with escape at end" do
+        content = '"hello\\'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(7)
+        expect(pos).to eq(7)
+        expect(rest).to eq("")
+      end
+
+      it "handles unterminated string with newline" do
+        content = "\"hello\nworld"
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(12)
+        expect(pos).to eq(12)
+        expect(rest).to eq("")
+      end
+    end
+
+    context "edge cases" do
+      it "handles string with only opening quote" do
+        content = '"'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(1)
+        expect(pos).to eq(1)
+        expect(rest).to eq("")
+      end
+
+      it "handles character with only opening quote" do
+        content = "'"
+        bytes_skipped, pos, rest = skip_c_string.call(content, "'")
+        
+        expect(bytes_skipped).to eq(1)
+        expect(pos).to eq(1)
+        expect(rest).to eq("")
+      end
+
+      it "handles string with consecutive escaped backslashes" do
+        content = '"\\\\\\\\"code'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(6)
+        expect(pos).to eq(6)
+        expect(rest).to eq("code")
+      end
+
+      it "handles string ending with backslash before quote" do
+        content = '"test\\\\"code'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(8)
+        expect(pos).to eq(8)
+        expect(rest).to eq("code")
+      end
+
+      it "does not confuse single quote inside double-quoted string" do
+        content = '"don\'t"code'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(7)
+        expect(pos).to eq(7)
+        expect(rest).to eq("code")
+      end
+
+      it "does not confuse double quote inside single-quoted character" do
+        content = '\'"\'code'
+        bytes_skipped, pos, rest = skip_c_string.call(content, "'")
+        
+        expect(bytes_skipped).to eq(3)
+        expect(pos).to eq(3)
+        expect(rest).to eq("code")
+      end
+
+      it "handles very long string" do
+        long_string = '"' + ('x' * 1000) + '"code'
+        bytes_skipped, pos, rest = skip_c_string.call(long_string, '"')
+        
+        expect(bytes_skipped).to eq(1002)
+        expect(pos).to eq(1002)
+        expect(rest).to eq("code")
+      end
+
+      it "handles string with null character" do
+        content = "\"hello\\0world\"code"
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(14)
+        expect(pos).to eq(14)
+        expect(rest).to eq("code")
+      end
+    end
+
+    context "real-world C code patterns" do
+      it "skips string literal in printf statement" do
+        content = '"Hello, World!")'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(15)
+        expect(pos).to eq(15)
+        expect(rest).to eq(")")
+      end
+
+      it "skips format string with specifiers" do
+        content = '"%d %s %f", x, y, z)'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(10)
+        expect(pos).to eq(10)
+        expect(rest).to eq(', x, y, z)')
+      end
+
+      it "skips file path string" do
+        content = '"C:\\\\Users\\\\file.txt"code'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(21)
+        expect(pos).to eq(21)
+        expect(rest).to eq("code")
+      end
+
+      it "skips character constant in switch case" do
+        content = "'a': return 1;"
+        bytes_skipped, pos, rest = skip_c_string.call(content, "'")
+        
+        expect(bytes_skipped).to eq(3)
+        expect(pos).to eq(3)
+        expect(rest).to eq(": return 1;")
+      end
+
+      it "skips string with JSON-like content" do
+        content = '"{\"key\": \"value\"}"code'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(22)
+        expect(pos).to eq(22)
+        expect(rest).to eq("code")
+      end
+
+      it "skips multi-line string literal (C11 style)" do
+        content = "\"line1\\\nline2\\\nline3\"code"
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(21)
+        expect(pos).to eq(21)
+        expect(rest).to eq("code")
+      end
+
+      it "skips string with SQL query" do
+        content = '"SELECT * FROM users WHERE id = 1"code'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(34)
+        expect(pos).to eq(34)
+        expect(rest).to eq("code")
+      end
+    end
+
+    context "consecutive strings" do
+      it "skips first string when followed by another string" do
+        content = '"first" "second"'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(7)
+        expect(pos).to eq(7)
+        expect(rest).to eq(' "second"')
+      end
+
+      it "skips string followed by character literal" do
+        content = '"string" \'c\''
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(8)
+        expect(pos).to eq(8)
+        expect(rest).to eq(" 'c'")
+      end
+
+      it "skips character literal followed by string" do
+        content = "'c' \"string\""
+        bytes_skipped, pos, rest = skip_c_string.call(content, "'")
+        
+        expect(bytes_skipped).to eq(3)
+        expect(pos).to eq(3)
+        expect(rest).to eq(' "string"')
+      end
+    end
+
+    context "strings in complex expressions" do
+      it "skips string in array initialization" do
+        content = '"element1", "element2"'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(10)
+        expect(pos).to eq(10)
+        expect(rest).to eq(', "element2"')
+      end
+
+      it "skips string in function call" do
+        content = '"argument", 42)'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(10)
+        expect(pos).to eq(10)
+        expect(rest).to eq(", 42)")
+      end
+
+      it "skips string in ternary operator" do
+        content = '"true" : "false"'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(6)
+        expect(pos).to eq(6)
+        expect(rest).to eq(' : "false"')
+      end
+    end
+
+    context "performance and boundary conditions" do
+      it "handles string at end of input" do
+        content = '"last"'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(6)
+        expect(pos).to eq(6)
+        expect(rest).to eq("")
+      end
+
+      it "handles character at end of input" do
+        content = "'x'"
+        bytes_skipped, pos, rest = skip_c_string.call(content, "'")
+        
+        expect(bytes_skipped).to eq(3)
+        expect(pos).to eq(3)
+        expect(rest).to eq("")
+      end
+
+      it "handles alternating escaped and regular characters" do
+        content = '"a\\nb\\tc\\rd\\\\e"code'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(15)
+        expect(pos).to eq(15)
+        expect(rest).to eq("code")
+      end
+    end
+
+    context "invalid but handled gracefully" do
+      it "handles empty character literal" do
+        content = "''code"
+        bytes_skipped, pos, rest = skip_c_string.call(content, "'")
+        
+        expect(bytes_skipped).to eq(2)
+        expect(pos).to eq(2)
+        expect(rest).to eq("code")
+      end
+
+      it "handles string with unrecognized escape sequence" do
+        # \q is not a valid escape, but should still consume it
+        content = '"\\q"code'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(4)
+        expect(pos).to eq(4)
+        expect(rest).to eq("code")
+      end
+
+      it "handles incomplete octal escape at end of string" do
+        content = '"\\1"code'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(4)
+        expect(pos).to eq(4)
+        expect(rest).to eq("code")
+      end
+
+      it "handles incomplete hex escape at end of string" do
+        content = '"\\x"code'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(4)
+        expect(pos).to eq(4)
+        expect(rest).to eq("code")
+      end
+
+      it "handles backslash at very end of unterminated string" do
+        content = '"test\\'
+        bytes_skipped, pos, rest = skip_c_string.call(content, '"')
+        
+        expect(bytes_skipped).to eq(6)
+        expect(pos).to eq(6)
+        expect(rest).to eq("")
+      end
+    end
+  end
+
+  ###
+  ### skip_semicolons()
+  ###
+  describe "#skip_semicolons" do
+    let(:skip_semicolons) do
+      ->(content) do
+        scanner = StringScanner.new(content)
+        code_text = CExtractorCodeText.new()
+        code_text.skip_semicolons( scanner )
+        return [scanner.pos, scanner.rest]
+      end
+    end
+
+    context "single semicolon handling" do
+      it "skips single semicolon" do
+        content = ";code"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(1)
+        expect(rest).to eq("code")
+      end
+
+      it "skips semicolon with trailing space" do
+        content = "; code"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(1)
+        expect(rest).to eq(" code")
+      end
+
+      it "skips semicolon at end of input" do
+        content = ";"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(1)
+        expect(rest).to eq("")
+      end
+    end
+
+    context "multiple consecutive semicolons" do
+      it "skips two consecutive semicolons" do
+        content = ";;code"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(2)
+        expect(rest).to eq("code")
+      end
+
+      it "skips three consecutive semicolons" do
+        content = ";;;code"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(3)
+        expect(rest).to eq("code")
+      end
+
+      it "skips many consecutive semicolons" do
+        content = ";;;;;;;;;;code"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(10)
+        expect(rest).to eq("code")
+      end
+    end
+
+    context "semicolons with whitespace" do
+      it "skips semicolons separated by spaces" do
+        content = "; ; ;code"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(5)
+        expect(rest).to eq("code")
+      end
+
+      it "skips semicolons separated by tabs" do
+        content = ";\t;\t;code"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(5)
+        expect(rest).to eq("code")
+      end
+
+      it "skips semicolons separated by newlines" do
+        content = ";\n;\n;code"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(5)
+        expect(rest).to eq("code")
+      end
+
+      it "skips semicolons with mixed whitespace" do
+        content = "; \t\n ; \r\n ;code"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(11)
+        expect(rest).to eq("code")
+      end
+
+      it "skips leading whitespace before first semicolon" do
+        content = "  \t;code"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(4)
+        expect(rest).to eq("code")
+      end
+    end
+
+    context "semicolons with comments" do
+      it "skips semicolons separated by line comments" do
+        content = "; // comment\n;code"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(14)
+        expect(rest).to eq("code")
+      end
+
+      it "skips semicolons separated by block comments" do
+        content = "; /* comment */ ;code"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(17)
+        expect(rest).to eq("code")
+      end
+
+      it "skips semicolons with multi-line block comments" do
+        content = ";\n/* comment\n   spanning\n   lines */\n;code"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(38)
+        expect(rest).to eq("code")
+      end
+
+      it "skips semicolons with multiple comments" do
+        content = "; // first\n; /* second */ ;code"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(27)
+        expect(rest).to eq("code")
+      end
+    end
+
+    context "stopping at non-semicolon content" do
+      it "stops at identifier" do
+        content = ";code"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(1)
+        expect(rest).to eq("code")
+      end
+
+      it "stops at number" do
+        content = ";;123"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(2)
+        expect(rest).to eq("123")
+      end
+
+      it "stops at opening brace" do
+        content = "; ; {"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(3)
+        expect(rest).to eq(" {")
+      end
+
+      it "stops at closing brace" do
+        content = ";;}"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(2)
+        expect(rest).to eq("}")
+      end
+
+      it "stops at comma" do
+        content = "; , next"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(1)
+        expect(rest).to eq(" , next")
+      end
+
+      it "stops at operator" do
+        content = ";;++"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(2)
+        expect(rest).to eq("++")
+      end
+    end
+
+    context "no semicolons present" do
+      it "does not advance when no semicolons" do
+        content = "code"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(0)
+        expect(rest).to eq("code")
+      end
+
+      it "does not advance with only whitespace" do
+        content = "  \t\ncode"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(0)
+        expect(rest).to eq("  \t\ncode")
+      end
+
+      it "does not advance with only comments" do
+        content = "// comment\ncode"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(0)
+        expect(rest).to eq("// comment\ncode")
+      end
+
+      it "does not advance with only preprocessor" do
+        content = "#define FOO\ncode"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(0)
+        expect(rest).to eq("#define FOO\ncode")
+      end
+    end
+
+    context "edge cases" do
+      it "handles empty string" do
+        content = ""
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(0)
+        expect(rest).to eq("")
+      end
+
+      it "handles only semicolons" do
+        content = ";;;;;"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(5)
+        expect(rest).to eq("")
+      end
+
+      it "handles only semicolons and whitespace" do
+        content = "; ; ; "
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(6)
+        expect(rest).to eq("")
+      end
+
+      it "handles semicolons with unterminated comment" do
+        content = "; /* unterminated"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(17)
+        expect(rest).to eq("")
+      end
+
+    end
+
+    context "real-world C code patterns" do
+      it "skips null statements in for loop" do
+        content = ";;) {"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(2)
+        expect(rest).to eq(") {")
+      end
+
+      it "skips multiple null statements" do
+        content = ";;;\nreturn 0;"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(3)
+        expect(rest).to eq("\nreturn 0;")
+      end
+
+      it "handles semicolons from macro expansion pattern" do
+        content = "; // from MACRO_CALL()\n;code"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(24)
+        expect(rest).to eq("code")
+      end
+
+      it "skips null statements in switch case" do
+        content = ";case 2:"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(1)
+        expect(rest).to eq("case 2:")
+      end
+
+      it "skips multiple null statements between switch cases" do
+        content = ";;;\ncase 3:"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(3)
+        expect(rest).to eq("\ncase 3:")
+      end
+
+      it "skips null statements after break in switch" do
+        content = ";;default:"
+        pos, rest = skip_semicolons.call(content)
+        
+        expect(pos).to eq(2)
+        expect(rest).to eq("default:")
+      end
+    end
+  end
+
+  ###
+  ### skip_deadspace()
+  ###
+  describe "#skip_deadspace" do
+    # Helper to access private method
+    let(:skip_deadspace) do
+      ->(content) do
+        scanner = StringScanner.new(content)
+        code_text = CExtractorCodeText.new()
+        bytes_skipped = code_text.skip_deadspace( scanner )
+        return [bytes_skipped, scanner.pos, scanner.rest]
+      end
+    end
+
+    context "whitespace handling" do
+      it "skips spaces" do
+        content = "     code"
+        bytes_skipped, pos, rest = skip_deadspace.call(content)
+        
+        expect(bytes_skipped).to eq(5)
+        expect(pos).to eq(5)
+        expect(rest).to eq("code")
+      end
+
+      it "skips tabs" do
+        content = "\t\t\tcode"
+        bytes_skipped, pos, rest = skip_deadspace.call(content)
+        
+        expect(bytes_skipped).to eq(3)
+        expect(pos).to eq(3)
+        expect(rest).to eq("code")
+      end
+
+      it "skips newlines" do
+        content = "\n\n\ncode"
+        bytes_skipped, pos, rest = skip_deadspace.call(content)
+        
+        expect(bytes_skipped).to eq(3)
+        expect(pos).to eq(3)
+        expect(rest).to eq("code")
+      end
+
+      it "skips carriage returns" do
+        content = "\r\n\r\ncode"
+        bytes_skipped, pos, rest = skip_deadspace.call(content)
+        
+        expect(bytes_skipped).to eq(4)
+        expect(pos).to eq(4)
+        expect(rest).to eq("code")
+      end
+
+      it "skips mixed whitespace" do
+        content = " \t\n \r\n\t code"
+        bytes_skipped, pos, rest = skip_deadspace.call(content)
+        
+        expect(bytes_skipped).to eq(8)
+        expect(pos).to eq(8)
+        expect(rest).to eq("code")
+      end
+
+      it "returns 0 when no whitespace present" do
+        content = "code"
+        bytes_skipped, pos, rest = skip_deadspace.call(content)
+        
+        expect(bytes_skipped).to eq(0)
+        expect(pos).to eq(0)
+        expect(rest).to eq("code")
+      end
+    end
+
+    context "line comment handling" do
+      it "skips single line comment" do
+        content = "// comment\ncode"
+        bytes_skipped, pos, rest = skip_deadspace.call(content)
+        
+        expect(bytes_skipped).to eq(11)
+        expect(pos).to eq(11)
+        expect(rest).to eq("code")
+      end
+
+      it "skips line comment without trailing newline" do
+        content = "// comment at end"
+        bytes_skipped, pos, rest = skip_deadspace.call(content)
+        
+        expect(bytes_skipped).to eq(17)
+        expect(pos).to eq(17)
+        expect(rest).to eq("")
+      end
+
+      it "skips multiple consecutive line comments" do
+        content = "// comment 1\n// comment 2\n// comment 3\ncode"
+        bytes_skipped, pos, rest = skip_deadspace.call(content)
+        
+        expect(bytes_skipped).to eq(39)
+        expect(pos).to eq(39)
+        expect(rest).to eq("code")
+      end
+
+      it "skips line comment with whitespace before it" do
+        content = "   // comment\ncode"
+        bytes_skipped, pos, rest = skip_deadspace.call(content)
+        
+        expect(bytes_skipped).to eq(14)
+        expect(pos).to eq(14)
+        expect(rest).to eq("code")
+      end
+
+      it "handles line comment with special characters" do
+        content = "// TODO: fix this!!!\ncode"
+        bytes_skipped, pos, rest = skip_deadspace.call(content)
+        
+        expect(bytes_skipped).to eq(21)
+        expect(pos).to eq(21)
+        expect(rest).to eq("code")
+      end
+    end
+
+    context "block comment handling" do
+      it "skips single-line block comment" do
+        content = "/* comment */code"
+        bytes_skipped, pos, rest = skip_deadspace.call(content)
+        
+        expect(bytes_skipped).to eq(13)
+        expect(pos).to eq(13)
+        expect(rest).to eq("code")
+      end
+
+      it "skips multi-line block comment" do
+        content = "/* comment\nline 2\nline 3 */code"
+        bytes_skipped, pos, rest = skip_deadspace.call(content)
+        
+        expect(bytes_skipped).to eq(27)
+        expect(pos).to eq(27)
+        expect(rest).to eq("code")
+      end
+
+      it "skips multiple consecutive block comments" do
+        content = "/* first *//* second *//* third */code"
+        bytes_skipped, pos, rest = skip_deadspace.call(content)
+        
+        expect(bytes_skipped).to eq(34)
+        expect(pos).to eq(34)
+        expect(rest).to eq("code")
+      end
+
+      it "skips block comment with whitespace before it" do
+        content = "   /* comment */code"
+        bytes_skipped, pos, rest = skip_deadspace.call(content)
+        
+        expect(bytes_skipped).to eq(16)
+        expect(pos).to eq(16)
+        expect(rest).to eq("code")
+      end
+
+      it "handles block comment with asterisks inside" do
+        content = "/* ** comment ** */code"
+        bytes_skipped, pos, rest = skip_deadspace.call(content)
+        
+        expect(bytes_skipped).to eq(19)
+        expect(pos).to eq(19)
+        expect(rest).to eq("code")
+      end
+
+      it "handles block comment with forward slashes inside" do
+        content = "/* comment // not a line comment */code"
+        bytes_skipped, pos, rest = skip_deadspace.call(content)
+        
+        expect(bytes_skipped).to eq(35)
+        expect(pos).to eq(35)
+        expect(rest).to eq("code")
+      end
+
+      it "handles unterminated block comment" do
+        content = "/* unterminated comment"
+        bytes_skipped, pos, rest = skip_deadspace.call(content)
+        
+        expect(bytes_skipped).to eq(23)
+        expect(pos).to eq(23)
+        expect(rest).to eq("")
+      end
+    end
+
+    context "mixed deadspace handling" do
+      it "skips whitespace followed by comment" do
+        content = "  \t/* comment */code"
+        bytes_skipped, pos, rest = skip_deadspace.call(content)
+        
+        expect(bytes_skipped).to eq(16)
+        expect(pos).to eq(16)
+        expect(rest).to eq("code")
+      end
+
+      it "skips comment followed by whitespace" do
+        content = "/* comment */  \ncode"
+        bytes_skipped, pos, rest = skip_deadspace.call(content)
+        
+        expect(bytes_skipped).to eq(16)
+        expect(pos).to eq(16)
+        expect(rest).to eq("code")
+      end
+
+      it "skips line comment followed by block comment" do
+        content = "// line\n/* block */code"
+        bytes_skipped, pos, rest = skip_deadspace.call(content)
+        
+        expect(bytes_skipped).to eq(19)
+        expect(pos).to eq(19)
+        expect(rest).to eq("code")
+      end
+
+    end
+
+    context "edge cases" do
+      it "handles empty string" do
+        content = ""
+        bytes_skipped, pos, rest = skip_deadspace.call(content)
+        
+        expect(bytes_skipped).to eq(0)
+        expect(pos).to eq(0)
+        expect(rest).to eq("")
+      end
+
+      it "handles string with only whitespace" do
+        content = "   \t\n  "
+        bytes_skipped, pos, rest = skip_deadspace.call(content)
+        
+        expect(bytes_skipped).to eq(7)
+        expect(pos).to eq(7)
+        expect(rest).to eq("")
+      end
+
+      it "handles string with only comments" do
+        content = "// comment\n/* block */"
+        bytes_skipped, pos, rest = skip_deadspace.call(content)
+        
+        expect(bytes_skipped).to eq(22)
+        expect(pos).to eq(22)
+        expect(rest).to eq("")
+      end
+
+      it "does not skip code that looks like comment but isn't" do
+        content = "int a = 5 / 2; // actual comment\ncode"
+        bytes_skipped, pos, rest = skip_deadspace.call(content)
+        
+        expect(bytes_skipped).to eq(0)
+        expect(pos).to eq(0)
+        expect(rest).to start_with("int a")
+      end
+
+      it "handles nested block comments (not standard C)" do
+        # NOTE: C extraction is not implemented as a full C parser and/or preprocessor
+        # We assume that the file to be processed is either relatively simple or has already been preprocessed
+        # to remove complex preprocessor directives, etc.
+
+        content = "/* outer /* inner */ still outer */code"
+        bytes_skipped, pos, rest = skip_deadspace.call(content)
+        
+        # We expect only partial comment block handling for nested blocks
+        expect(bytes_skipped).to eq(21)
+        expect(pos).to eq(21)
+        expect(rest).to eq("still outer */code")
+      end
+    end
+
+    context "real-world C code patterns" do
+      it "handles Doxygen-style comments" do
+        content = <<~CODE
+          /**
+           * @brief Function description
+           * @param x The parameter
+           * @return The result
+           */
+          int func(int x) {
+        CODE
+        
+        _, _, rest = skip_deadspace.call(content)
+        
+        expect(rest).to start_with("int func(int x)")
+      end
+
+    end
+  end
+
+  ###
+  ### collect_balanced()
+  ###
+
+  describe "#collect_balanced" do
+    let(:collect_balanced) do
+      ->(content, open_char, close_char) do
+        scanner = StringScanner.new(content)
+        code_text = CExtractorCodeText.new
+        success, text = code_text.collect_balanced(scanner, open_char, close_char)
+        [success, text, scanner.pos, scanner.rest]
+      end
+    end
+
+    context "failure cases" do
+      it "returns [false, nil] when not positioned at open_char" do
+        success, text, pos, _ = collect_balanced.call("x{content}", '{', '}')
+        expect(success).to be false
+        expect(text).to be_nil
+        expect(pos).to eq(0)  # scanner not advanced
+      end
+
+      it "returns [false, nil] for empty input" do
+        success, text, _, _ = collect_balanced.call("", '{', '}')
+        expect(success).to be false
+        expect(text).to be_nil
+      end
+
+      it "returns [false, nil] for unbalanced input (no matching close)" do
+        success, text, _, _ = collect_balanced.call("{content without close", '{', '}')
+        expect(success).to be false
+        expect(text).to be_nil
+      end
+    end
+
+    context "successful extraction" do
+      it "extracts a simple brace pair and returns text including delimiters" do
+        success, text, pos, rest = collect_balanced.call("{content}", '{', '}')
+        expect(success).to be true
+        expect(text).to eq("{content}")
+        expect(pos).to eq(9)
+        expect(rest).to eq("")
+      end
+
+      it "extracts a simple paren pair" do
+        success, text, pos, rest = collect_balanced.call("(args)", '(', ')')
+        expect(success).to be true
+        expect(text).to eq("(args)")
+        expect(pos).to eq(6)
+      end
+
+      it "extracts a simple bracket pair" do
+        success, text, pos, rest = collect_balanced.call("[items]", '[', ']')
+        expect(success).to be true
+        expect(text).to eq("[items]")
+        expect(pos).to eq(7)
+      end
+
+      it "handles nested same-pair delimiters" do
+        success, text, pos, rest = collect_balanced.call("{a {b} c}", '{', '}')
+        expect(success).to be true
+        expect(text).to eq("{a {b} c}")
+        expect(pos).to eq(9)
+        expect(rest).to eq("")
+      end
+
+      it "stops at matching close and does not consume following code" do
+        success, text, pos, rest = collect_balanced.call("{block} remaining", '{', '}')
+        expect(success).to be true
+        expect(text).to eq("{block}")
+        expect(pos).to eq(7)
+        expect(rest).to eq(" remaining")
+      end
+    end
+
+    context "string literals" do
+      it "preserves string literals verbatim and does not treat close_char inside them as closer" do
+        success, text, _, _ = collect_balanced.call('{"string with }"}', '{', '}')
+        expect(success).to be true
+        expect(text).to eq('{"string with }"}')
+      end
+
+      it "preserves char literals verbatim" do
+        success, text, _, _ = collect_balanced.call("{ char c = '}'; }", '{', '}')
+        expect(success).to be true
+        expect(text).to eq("{ char c = '}'; }")
+      end
+    end
+
+    context "comments replaced with a single space" do
+      it "replaces a block comment containing close_char with a space — does not terminate early" do
+        success, text, pos, _ = collect_balanced.call("{ /* } */ }", '{', '}')
+        expect(success).to be true
+        expect(text).to eq("{   }")   # space + space (before/after comment) + space for comment
+        expect(pos).to eq(11)         # scanner advanced through full original content
+      end
+
+      it "replaces a line comment containing close_char with a space — does not terminate early" do
+        success, text, pos, _ = collect_balanced.call("{ // }\n}", '{', '}')
+        expect(success).to be true
+        expect(text).to eq("{  }")    # space before comment + space for comment+newline
+        expect(pos).to eq(8)
+      end
+
+      it "replaces a block comment with exactly one space regardless of comment length" do
+        success, text, _, _ = collect_balanced.call("{ /* long comment text */ code }", '{', '}')
+        expect(success).to be true
+        expect(text).to eq("{   code }")   # space + comment→space + space before code
+      end
+
+      it "replaces a line comment with exactly one space (consuming the newline too)" do
+        success, text, _, _ = collect_balanced.call("{ code // comment\n more }", '{', '}')
+        expect(success).to be true
+        expect(text).to eq("{ code   more }")  # space before comment + comment→space + space before more
+      end
+    end
+  end
+
+  ###
+  ### extract_balanced_braces()
+  ###
+
+  describe "#extract_balanced_braces" do
+    # Helper to access private method
+    let(:extract_braces) do
+      ->(content) do
+        scanner = StringScanner.new(content)
+        code_text = CExtractorCodeText.new()
+        success, block = code_text.extract_balanced_braces( scanner )
+        return [success, block, scanner.pos, scanner.rest]
+      end
+    end
+
+    context "simple balanced braces" do
+      it "extracts single-level braces" do
+        content = "{ code }"
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq("{ code }")
+        expect(pos).to eq(8)
+        expect(rest).to eq("")
+      end
+
+      it "extracts empty braces" do
+        content = "{}"
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq("{}")
+        expect(pos).to eq(2)
+        expect(rest).to eq("")
+      end
+
+      it "extracts braces with content after" do
+        content = "{ code } more"
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq("{ code }")
+        expect(pos).to eq(8)
+        expect(rest).to eq(" more")
+      end
+
+      it "extracts braces with whitespace" do
+        content = "{   \n\t  }"
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq("{   \n\t  }")
+        expect(pos).to eq(9)
+        expect(rest).to eq("")
+      end
+    end
+
+    context "nested braces" do
+      it "extracts one level of nesting" do
+        content = "{ outer { inner } }"
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq("{ outer { inner } }")
+        expect(pos).to eq(19)
+        expect(rest).to eq("")
+      end
+
+      it "extracts two levels of nesting" do
+        content = "{ a { b { c } } }"
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq("{ a { b { c } } }")
+        expect(pos).to eq(17)
+        expect(rest).to eq("")
+      end
+
+      it "extracts multiple nested blocks at same level" do
+        content = "{ { a } { b } { c } }"
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq("{ { a } { b } { c } }")
+        expect(pos).to eq(21)
+        expect(rest).to eq("")
+      end
+
+      it "extracts deeply nested braces" do
+        content = "{ { { { { deep } } } } }"
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq("{ { { { { deep } } } } }")
+        expect(pos).to eq(24)
+        expect(rest).to eq("")
+      end
+    end
+
+    context "braces in strings" do
+      it "ignores braces in double-quoted strings" do
+        content = '{ "string with brace }" }'
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq('{ "string with brace }" }')
+        expect(pos).to eq(25)
+        expect(rest).to eq("")
+      end
+
+      it "ignores braces in single-quoted strings" do
+        content = "{ 'char {' }"
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq("{ 'char {' }")
+        expect(pos).to eq(12)
+        expect(rest).to eq("")
+      end
+
+      it "handles escaped quotes in strings with braces" do
+        content = '{ "string with \\" and { brace" }'
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq('{ "string with \\" and { brace" }')
+        expect(pos).to eq(32)
+        expect(rest).to eq("")
+      end
+
+      it "handles multiple strings with braces" do
+        content = '{ "first { }" "second } " }'
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq('{ "first { }" "second } " }')
+        expect(pos).to eq(27)
+        expect(rest).to eq("")
+      end
+
+      it "handles empty strings" do
+        content = '{ "" }'
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq('{ "" }')
+        expect(pos).to eq(6)
+        expect(rest).to eq("")
+      end
+    end
+
+    context "braces in comments" do
+      it "ignores braces in line comments (comment replaced with space)" do
+        content = "{ code // comment with { brace\n}"
+        success, block, pos, rest = extract_braces.call(content)
+
+        expect(success).to be true
+        expect(block).to eq("{ code  }")  # comment+newline → single space
+        expect(pos).to eq(32)             # scanner.pos spans full original content
+        expect(rest).to eq("")
+      end
+
+      it "ignores braces in block comments (comment replaced with space)" do
+        content = "{ code /* comment with { brace */ }"
+        success, block, pos, rest = extract_braces.call(content)
+
+        expect(success).to be true
+        expect(block).to eq("{ code   }")  # comment → single space; space before } preserved
+        expect(pos).to eq(35)
+        expect(rest).to eq("")
+      end
+
+      it "handles multiple comments with braces (each comment replaced with space)" do
+        content = "{ /* { */ code // }\n}"
+        success, block, pos, rest = extract_braces.call(content)
+
+        expect(success).to be true
+        expect(block).to eq("{   code  }")  # block comment → space; line comment+newline → space
+        expect(pos).to eq(21)
+        expect(rest).to eq("")
+      end
+
+      it "handles nested block comments with braces (only innermost comment consumed)" do
+        content = "{ /* outer { /* inner } */ */ }"
+        success, block, pos, rest = extract_braces.call(content)
+
+        expect(success).to be true
+        # First */ closes the comment; remaining */ */ is literal text
+        expect(block).to eq("{   */ }")
+        expect(pos).to eq(31)
+        expect(rest).to eq("")
+      end
+    end
+
+    context "real C code patterns" do
+      it "extracts simple function body" do
+        content = "{ return 0; }"
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq("{ return 0; }")
+        expect(pos).to eq(13)
+        expect(rest).to eq("")
+      end
+
+      it "extracts function body with nested blocks" do
+        content = "{ if (x) { do_something(); } }"
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq("{ if (x) { do_something(); } }")
+        expect(pos).to eq(30)
+        expect(rest).to eq("")
+      end
+
+      it "extracts function body with multiple statements" do
+        content = <<~CODE.chomp
+          {
+            int x = 5;
+            printf("value: %d", x);
+            return x;
+          }
+        CODE
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq(content)
+        expect(pos).to eq(content.length)
+        expect(rest).to eq("")
+      end
+
+      it "extracts struct initialization" do
+        content = '{ .field1 = 10, .field2 = "test" }'
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq('{ .field1 = 10, .field2 = "test" }')
+        expect(pos).to eq(34)
+        expect(rest).to eq("")
+      end
+
+      it "extracts array initialization" do
+        content = "{ 1, 2, 3, 4, 5 }"
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq("{ 1, 2, 3, 4, 5 }")
+        expect(pos).to eq(17)
+        expect(rest).to eq("")
+      end
+
+      it "extracts switch statement" do
+        content = <<~CODE.chomp
+          {
+            switch (x) {
+              case 1: { action1(); break; }
+              case 2: { action2(); break; }
+              default: { action_default(); }
+            }
+          }
+        CODE
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq(content)
+        expect(pos).to eq(content.length)
+        expect(rest).to eq("")
+      end
+
+      it "extracts do-while loop" do
+        content = "{ do { process(); } while (condition); }"
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq("{ do { process(); } while (condition); }")
+        expect(pos).to eq(40)
+        expect(rest).to eq("")
+      end
+
+      it "extracts nested if-else blocks" do
+        content = <<~CODE.chomp
+          {
+            if (a) {
+              if (b) { x(); }
+              else { y(); }
+            } else {
+              z();
+            }
+          }
+        CODE
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq(content)
+        expect(pos).to eq(content.length)
+        expect(rest).to eq("")
+      end
+    end
+
+    context "failure cases" do
+      it "fails when not starting at opening brace" do
+        content = "not a brace"
+        success, block, pos, rest = extract_braces.call(content)
+
+        expect(success).to be false
+        expect(block).to be_nil
+        expect(pos).to eq(0) # Scanner not advanced on failure (peek, not getch)
+        expect(rest).to eq("not a brace")
+      end
+
+      it "fails on unbalanced braces (missing closing)" do
+        content = "{ incomplete"
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be false
+        expect(block).to be_nil
+        expect(pos).to eq(12) # At end of string
+        expect(rest).to eq("")
+      end
+
+      it "fails on unbalanced braces (extra closing)" do
+        content = "{ code } }"
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq("{ code }")
+        expect(pos).to eq(8)
+        expect(rest).to eq(" }")
+      end
+
+      it "fails on unbalanced nested braces" do
+        content = "{ outer { inner }"
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be false
+        expect(block).to be_nil
+        expect(pos).to eq(17)
+        expect(rest).to eq("")
+      end
+
+      it "fails on empty content" do
+        content = ""
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be false
+        expect(block).to be_nil
+        expect(pos).to eq(0)
+        expect(rest).to eq("")
+      end
+
+      it "fails when starting with closing brace" do
+        content = "} wrong"
+        success, block, pos, rest = extract_braces.call(content)
+
+        expect(success).to be false
+        expect(block).to be_nil
+        expect(pos).to eq(0) # Scanner not advanced on failure (peek, not getch)
+        expect(rest).to eq("} wrong")
+      end
+    end
+
+    context "edge cases with strings and comments" do
+      it "handles string with escaped backslash before quote" do
+        content = '{ "path\\\\file" }'
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq('{ "path\\\\file" }')
+        expect(pos).to eq(16)
+        expect(rest).to eq("")
+      end
+
+      it "handles string with escaped newline" do
+        content = '{ "line1\\nline2" }'
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq('{ "line1\\nline2" }')
+        expect(pos).to eq(18)
+        expect(rest).to eq("")
+      end
+
+      it "handles character literal with closing brace" do
+        content = "{ char c = '}'; }"
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq("{ char c = '}'; }")
+        expect(pos).to eq(17)
+        expect(rest).to eq("")
+      end
+
+      it "handles character literal with opening brace" do
+        content = "{ char c = '{'; }"
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq("{ char c = '{'; }")
+        expect(pos).to eq(17)
+        expect(rest).to eq("")
+      end
+
+      it "handles escaped single quote in character literal" do
+        content = "{ char c = '\\''; }"
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq("{ char c = '\\''; }")
+        expect(pos).to eq(18)
+        expect(rest).to eq("")
+      end
+
+      it "handles comment at end of line with brace (comment replaced with space)" do
+        content = "{ code; // comment }\n}"
+        success, block, pos, rest = extract_braces.call(content)
+
+        expect(success).to be true
+        expect(block).to eq("{ code;  }")  # comment+newline → single space; } is the real closer
+        expect(pos).to eq(22)
+        expect(rest).to eq("")
+      end
+
+      it "handles block comment spanning multiple lines with braces (comment replaced with space)" do
+        content = <<~CODE.chomp
+          {
+            /* This is a comment
+               with { braces } in it
+               spanning lines */
+            code;
+          }
+        CODE
+        success, block, pos, rest = extract_braces.call(content)
+
+        expect(success).to be true
+        expect(block).to eq("{\n   \n  code;\n}")  # comment block → single space; newline+indent after preserved
+        expect(pos).to eq(content.length)
+        expect(rest).to eq("")
+      end
+
+      it "handles unterminated string (malformed C)" do
+        # NOTE: This tests behavior with malformed C code
+        content = '{ "unterminated }'
+        success, block, _, _ = extract_braces.call(content)
+        
+        # The extractor should fail because the closing brace is inside an unterminated string
+        expect(success).to be false
+        expect(block).to be_nil
+      end
+
+      it "handles unterminated comment (malformed C)" do
+        # NOTE: This tests behavior with malformed C code
+        content = "{ /* unterminated }"
+        success, block, _, _ = extract_braces.call(content)
+        
+        # The extractor should fail because the closing brace is inside an unterminated comment
+        expect(success).to be false
+        expect(block).to be_nil
+      end
+    end
+
+    context "complex real-world patterns" do
+      it "extracts function with macro usage" do
+        content = <<~CODE.chomp
+          {
+            MACRO_CALL(arg1, arg2);
+            if (CHECK_FLAG(x)) {
+              DO_SOMETHING();
+            }
+          }
+        CODE
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq(content)
+        expect(pos).to eq(content.length)
+        expect(rest).to eq("")
+      end
+
+      it "extracts function with string containing comment-like text" do
+        content = '{ printf("/* not a comment */"); }'
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq('{ printf("/* not a comment */"); }')
+        expect(pos).to eq(34)
+        expect(rest).to eq("")
+      end
+
+      it "extracts function with comment containing string-like text (comment replaced with space)" do
+        content = '{ /* "not a string" */ code; }'
+        success, block, pos, rest = extract_braces.call(content)
+
+        expect(success).to be true
+        expect(block).to eq("{   code; }")  # comment → space; surrounding spaces preserved
+        expect(pos).to eq(30)
+        expect(rest).to eq("")
+      end
+
+      it "extracts nested struct and array initializers" do
+        content = <<~CODE.chomp
+          {
+            struct data d = {
+              .array = { 1, 2, 3 },
+              .nested = { { 4, 5 }, { 6, 7 } }
+            };
+          }
+        CODE
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq(content)
+        expect(pos).to eq(content.length)
+        expect(rest).to eq("")
+      end
+
+      it "extracts function with ternary operator and braces" do
+        content = "{ result = condition ? { .a = 1 } : { .b = 2 }; }"
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq("{ result = condition ? { .a = 1 } : { .b = 2 }; }")
+        expect(pos).to eq(49)
+        expect(rest).to eq("")
+      end
+
+      it "extracts function with compound literal" do
+        content = "{ func((struct point){ .x = 10, .y = 20 }); }"
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq("{ func((struct point){ .x = 10, .y = 20 }); }")
+        expect(pos).to eq(45)
+        expect(rest).to eq("")
+      end
+
+      it "extracts function with designated initializers and nested braces" do
+        content = <<~CODE.chomp
+          {
+            struct config cfg = {
+              [0] = { .name = "first", .value = { 1, 2 } },
+              [1] = { .name = "second", .value = { 3, 4 } }
+            };
+          }
+        CODE
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq(content)
+        expect(pos).to eq(content.length)
+        expect(rest).to eq("")
+      end
+    end
+
+    context "scanner position management" do
+      it "leaves scanner at correct position after successful extraction" do
+        content = "{ first }{ second }{third}"
+        scanner = StringScanner.new(content)
+        code_text = CExtractorCodeText.new()
+        
+        success1, block1 = code_text.extract_balanced_braces( scanner )
+
+        expect(success1).to be true
+        expect(block1).to eq("{ first }")
+
+        success2, block2 = code_text.extract_balanced_braces( scanner )
+        
+        expect(success2).to be true
+        expect(block2).to eq("{ second }")
+
+        success3, block3 = code_text.extract_balanced_braces( scanner )
+        
+        expect(success3).to be true
+        expect(block3).to eq("{third}")
+
+        expect(scanner.eos?).to be true
+      end
+
+      it "leaves scanner at correct position after failed extraction" do
+        content = "not_brace { valid }"
+        scanner = StringScanner.new(content)
+        code_text = CExtractorCodeText.new()
+
+        success1, block1 = code_text.extract_balanced_braces( scanner )
+
+        expect(success1).to be false
+        expect(block1).to be_nil
+        expect(scanner.pos).to eq(0) # Scanner not advanced on failure (peek, not getch)
+
+        # Skip to the valid brace
+        scanner.scan(/[^{]*/)
+        success2, block2 = code_text.extract_balanced_braces( scanner )
+
+        expect(success2).to be true
+        expect(block2).to eq("{ valid }")
+      end
+
+      it "handles scanner at end of string" do
+        content = "{ code }"
+        scanner = StringScanner.new(content)
+        code_text = CExtractorCodeText.new()
+        
+        # Extract the only block
+        code_text.extract_balanced_braces( scanner )
+        
+        # Try to extract again at end of string
+        success, block = code_text.extract_balanced_braces( scanner )
+        
+        expect(success).to be false
+        expect(block).to be_nil
+        expect(scanner.eos?).to be true
+      end
+    end
+
+    context "performance considerations" do
+      it "handles very long brace blocks" do
+        # Create a large but balanced brace block
+        inner_content = "int x = 0;\n" * 100
+        content = "{\n#{inner_content}}"
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq(content)
+        expect(pos).to eq(content.length)
+        expect(rest).to eq("")
+      end
+
+     it "handles deeply nested braces" do
+        # Create 50 levels of nesting
+        opening = "{ " * 50
+        closing = " }" * 50
+        content = opening + "core" + closing
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq(content)
+        expect(pos).to eq(content.length)
+        expect(rest).to eq("")
+      end
+
+      it "handles many sequential brace blocks" do
+        # Create 100 sequential blocks
+        blocks = (1..100).map { |i| "{ block#{i} }" }.join(" ")
+        scanner = StringScanner.new(blocks)
+        code_text = CExtractorCodeText.new()
+        
+        count = 0
+        while !scanner.eos?
+          scanner.scan(/\s*/)
+          break if scanner.eos?
+          success, _ = code_text.extract_balanced_braces( scanner )
+          break unless success
+          count += 1
+        end
+        
+        expect(count).to eq(100)
+      end
+
+      it "handles large strings within braces" do
+        large_string = "x" * 1000
+        content = "{ char* str = \"#{large_string}\"; }"
+        success, block, pos, rest = extract_braces.call(content)
+        
+        expect(success).to be true
+        expect(block).to eq(content)
+        expect(pos).to eq(content.length)
+        expect(rest).to eq("")
+      end
+
+      it "handles large comments within braces (comment replaced with space)" do
+        large_comment = "comment text " * 100
+        content = "{ /* #{large_comment} */ code; }"
+        success, block, pos, rest = extract_braces.call(content)
+
+        expect(success).to be true
+        expect(block).to eq("{   code; }")  # entire comment → single space; spaces around preserved
+        expect(pos).to eq(content.length)
+        expect(rest).to eq("")
+      end
+    end
+  end
+
+  ###
+  ### skip_compiler_extension()
+  ###
+  describe "#skip_compiler_extension" do
+    let(:skip_ext) do
+      ->(content) do
+        scanner = StringScanner.new(content)
+        code_text = CExtractorCodeText.new
+        result = code_text.skip_compiler_extension(scanner)
+        [result, scanner.pos, scanner.rest]
+      end
+    end
+
+    it "returns false and does not advance on plain identifier" do
+      result, pos, rest = skip_ext.call("int foo")
+      expect(result).to be false
+      expect(rest).to eq("int foo")
+    end
+
+    it "returns false and does not advance on empty input" do
+      result, pos, rest = skip_ext.call("")
+      expect(result).to be false
+      expect(pos).to eq(0)
+    end
+
+    it "skips __cdecl calling convention" do
+      result, _pos, rest = skip_ext.call("__cdecl foo")
+      expect(result).to be true
+      expect(rest).to eq(" foo")
+    end
+
+    it "skips __stdcall calling convention" do
+      result, _pos, rest = skip_ext.call("__stdcall foo")
+      expect(result).to be true
+      expect(rest).to eq(" foo")
+    end
+
+    it "skips __fastcall calling convention" do
+      result, _pos, rest = skip_ext.call("__fastcall foo")
+      expect(result).to be true
+      expect(rest).to eq(" foo")
+    end
+
+    it "skips __declspec(dllexport)" do
+      result, _pos, rest = skip_ext.call("__declspec(dllexport) void")
+      expect(result).to be true
+      expect(rest).to eq(" void")
+    end
+
+    it "skips __declspec with nested parens" do
+      result, _pos, rest = skip_ext.call("__declspec(align(8)) void")
+      expect(result).to be true
+      expect(rest).to eq(" void")
+    end
+
+    it 'skips __declspec with nested parens and string argument' do
+      result, _pos, rest = skip_ext.call('__declspec(deprecated("msg")) void')
+      expect(result).to be true
+      expect(rest).to eq(" void")
+    end
+
+    it "skips __attribute__((interrupt))" do
+      result, _pos, rest = skip_ext.call("__attribute__((interrupt)) void")
+      expect(result).to be true
+      expect(rest).to eq(" void")
+    end
+
+    it "skips __attribute__ with deeply nested arguments" do
+      result, _pos, rest = skip_ext.call("__attribute__((format(printf,1,2))) void")
+      expect(result).to be true
+      expect(rest).to eq(" void")
+    end
+
+    it "returns false for __int64 (MSVC type — must not be skipped)" do
+      result, _pos, rest = skip_ext.call("__int64 x")
+      expect(result).to be false
+      expect(rest).to eq("__int64 x")
+    end
+  end
+
+  ###
+  ### strip_compiler_extensions()
+  ###
+  describe "#strip_compiler_extensions" do
+    let(:strip_ext) do
+      ->(text) { CExtractorCodeText.new.strip_compiler_extensions(text) }
+    end
+
+    it "returns input unchanged when there are no extensions" do
+      expect(strip_ext.call("int foo(void)")).to eq("int foo(void)")
+    end
+
+    it "returns empty string for empty input" do
+      expect(strip_ext.call("")).to eq("")
+    end
+
+    it "strips __declspec(dllexport)" do
+      expect(strip_ext.call("__declspec(dllexport) void foo(void)")).to eq("void foo(void)")
+    end
+
+    it "strips __declspec with nested parens" do
+      expect(strip_ext.call("__declspec(align(8)) int foo(void)")).to eq("int foo(void)")
+    end
+
+    it "strips __attribute__((interrupt)) in mid-signature position" do
+      expect(strip_ext.call("void __attribute__((interrupt)) ISR(void)")).to eq("void ISR(void)")
+    end
+
+    it "strips __attribute__ with deeply nested arguments" do
+      expect(strip_ext.call("__attribute__((format(printf,1,2))) int foo(char *fmt, ...)")).to eq("int foo(char *fmt, ...)")
+    end
+
+    it "strips __cdecl calling convention" do
+      expect(strip_ext.call("int __cdecl foo(void)")).to eq("int foo(void)")
+    end
+
+    it "strips __stdcall calling convention" do
+      expect(strip_ext.call("int __stdcall foo(void)")).to eq("int foo(void)")
+    end
+
+    it "strips __forceinline" do
+      expect(strip_ext.call("__forceinline void foo(void)")).to eq("void foo(void)")
+    end
+
+    it "strips __inline__" do
+      expect(strip_ext.call("__inline__ void foo(void)")).to eq("void foo(void)")
+    end
+
+    it "strips _Noreturn C11 specifier" do
+      expect(strip_ext.call("_Noreturn void exit_prog(int code)")).to eq("void exit_prog(int code)")
+    end
+
+    it "strips _Thread_local C11 specifier" do
+      expect(strip_ext.call("_Thread_local int counter")).to eq("int counter")
+    end
+
+    it "strips multiple extensions in one signature" do
+      expect(strip_ext.call("__declspec(dllexport) __cdecl void foo(void)")).to eq("void foo(void)")
+    end
+
+    it "preserves __int64 (MSVC type — must not be stripped)" do
+      expect(strip_ext.call("__int64 foo(void)")).to eq("__int64 foo(void)")
+    end
+
+    it "preserves __int32 (MSVC type — must not be stripped)" do
+      expect(strip_ext.call("static __int32 foo(void)")).to eq("static __int32 foo(void)")
+    end
+
+    it "normalizes whitespace left by stripping" do
+      expect(strip_ext.call("void  __cdecl  foo(void)")).to eq("void foo(void)")
+    end
+  end
+
+end