ceedling 1.1.2 → 1.1.4

data/site-local/testing-guide/test-sample.html

@@ -1865,6 +1865,8 @@
         
       
         
+      
+        
       
         
       
@@ -2012,6 +2014,34 @@
   
   
   
+    <li class="md-nav__item">
+      <a href="../configuration/reference/partials.html" class="md-nav__link">
+        
+  
+  
+  <span class="md-ellipsis">
+    
+  
+    Partials Settings
+  
+
+    
+  </span>
+  
+  
+
+      </a>
+    </li>
+  
+
+              
+            
+              
+                
+  
+  
+  
+  
     <li class="md-nav__item">
       <a href="../configuration/reference/release-build.html" class="md-nav__link">
         

data/site-local/testing-guide/test-suite-anatomy.html

@@ -1876,6 +1876,8 @@
         
       
         
+      
+        
       
         
       
@@ -2023,6 +2025,34 @@
   
   
   
+    <li class="md-nav__item">
+      <a href="../configuration/reference/partials.html" class="md-nav__link">
+        
+  
+  
+  <span class="md-ellipsis">
+    
+  
+    Partials Settings
+  
+
+    
+  </span>
+  
+  
+
+      </a>
+    </li>
+  
+
+              
+            
+              
+                
+  
+  
+  
+  
     <li class="md-nav__item">
       <a href="../configuration/reference/release-build.html" class="md-nav__link">
         

data/spec/support/system/spec_system_helper.rb

@@ -185,6 +185,21 @@ def valgrind_available?
   tool_available?('valgrind --version 2>&1')
 end
 
+# Real UBSan support is Linux-specific in practice for this test suite -- macOS's
+# system `gcc` is really Clang under a compatibility shim with different sanitizer
+# runtime behavior, and MinGW gcc on Windows doesn't ship the sanitizer runtime at
+# all. Restricting to Linux avoids flaky, platform-dependent compiler probing.
+def ubsan_available?
+  return false unless RUBY_PLATFORM.downcase.include?('linux')
+
+  Dir.mktmpdir do |dir|
+    source = File.join(dir, 'ubsan_check.c')
+    binary = File.join(dir, 'ubsan_check')
+    File.write(source, "int main(void) { return 0; }\n")
+    tool_available?(%(gcc -fsanitize=undefined -o "#{binary}" "#{source}" 2>&1))
+  end
+end
+
 RSpec.shared_context "requires gdb" do
   before :all do
     @gdb_available = gdb_available?
@@ -204,3 +219,13 @@ RSpec.shared_context "requires valgrind" do
     skip "valgrind is not installed or not in PATH" unless @valgrind_available
   end
 end
+
+RSpec.shared_context "requires gcc with UBSan" do
+  before :all do
+    @ubsan_available = ubsan_available?
+  end
+
+  before do
+    skip "gcc UBSan support not available (Linux + gcc -fsanitize=undefined required)" unless @ubsan_available
+  end
+end

data/spec/support/system/system_context.rb

@@ -279,6 +279,21 @@ class SystemContext
       sections << stderr.strip
     end
 
+    # Loginator routes `Verbosity::DEBUG` messages (including the backtrace
+    # `log_debug_backtrace` emits for a caught exception) to stdout rather than
+    # stderr, and this method's stdout scan above only pulls lines containing
+    # the literal substrings 'ERROR'/'EXCEPTION' -- a bare backtrace line
+    # (file:line:in `method') contains neither, so without surfacing it here
+    # explicitly, the one piece of stdout most useful for diagnosing *why* a
+    # command failed would otherwise only ever reach the full raw-output log
+    # file, not this console-visible summary (what CI output actually shows).
+    label = 'Debug Backtrace ==>'
+    backtrace_block = extract_section(stdout, label)
+    unless backtrace_block.empty?
+      sections << ">> DEBUG BACKTRACE"
+      sections.concat(backtrace_block)
+    end
+
     label = 'FAILED TEST SUMMARY'
     failed_block = extract_section(stdout, label)
     unless failed_block.empty?

data/spec/system/deployment_as_gem_spec.rb

@@ -62,6 +62,11 @@ ceedling_system_tests do
       test_case :test_project_with_preprocessing_for_mocks
       test_case :test_project_with_preprocessing_for_missing_mock
       test_case :test_project_with_preprocessing_all
+      test_case :test_project_preprocessing_same_dir_mock_pairing
+    end
+
+    describe "Partials" do
+      test_case :test_project_partial_all_module_mocks_declaration_only_function
     end
 
     describe "Defines and configuration" do
@@ -91,6 +96,14 @@ ceedling_system_tests do
       test_case :crash_none_writes_fail_results_file
       test_case :crash_simple_sigsegv_all_test_cases
       test_case :crash_simple_sigabrt_assert_failure
+      test_case :crash_simple_sigsegv_with_parameterized_test
+      test_case :crash_simple_diagnostic_retry_disagrees_with_main_fixture
+    end
+
+    describe "Crash handling with real UBSan" do
+      include_context "requires gcc with UBSan"
+
+      test_case :crash_simple_ubsan_diagnostic_retry_disagrees_with_main_fixture
     end
 
     describe "Backtrace with GDB" do
@@ -100,6 +113,7 @@ ceedling_system_tests do
       test_case :crash_gdb_sigsegv_targets_test_case_filter
       test_case :crash_gdb_sigsegv_excludes_test_case_filter
       test_case :crash_gdb_sigabrt_assert_failure
+      test_case :crash_gdb_sigsegv_with_parameterized_test
     end
 
     describe "Test filtering" do

data/spec/system/deployment_as_vendor_spec.rb

@@ -65,6 +65,11 @@ ceedling_system_tests do
       test_case :test_project_with_preprocessing_for_mocks
       test_case :test_project_with_preprocessing_for_missing_mock
       test_case :test_project_with_preprocessing_all
+      test_case :test_project_preprocessing_same_dir_mock_pairing
+    end
+
+    describe "Partials" do
+      test_case :test_project_partial_all_module_mocks_declaration_only_function
     end
 
     describe "Defines and configuration" do
@@ -94,6 +99,14 @@ ceedling_system_tests do
       test_case :crash_none_writes_fail_results_file
       test_case :crash_simple_sigsegv_all_test_cases
       test_case :crash_simple_sigabrt_assert_failure
+      test_case :crash_simple_sigsegv_with_parameterized_test
+      test_case :crash_simple_diagnostic_retry_disagrees_with_main_fixture
+    end
+
+    describe "Crash handling with real UBSan" do
+      include_context "requires gcc with UBSan"
+
+      test_case :crash_simple_ubsan_diagnostic_retry_disagrees_with_main_fixture
     end
 
     describe "Backtrace with GDB" do
@@ -103,6 +116,7 @@ ceedling_system_tests do
       test_case :crash_gdb_sigsegv_targets_test_case_filter
       test_case :crash_gdb_sigsegv_excludes_test_case_filter
       test_case :crash_gdb_sigabrt_assert_failure
+      test_case :crash_gdb_sigsegv_with_parameterized_test
     end
 
     describe "Test filtering" do
@@ -170,6 +184,11 @@ ceedling_system_tests do
       test_case :test_project_with_preprocessing_for_mocks
       test_case :test_project_with_preprocessing_for_missing_mock
       test_case :test_project_with_preprocessing_all
+      test_case :test_project_preprocessing_same_dir_mock_pairing
+    end
+
+    describe "Partials" do
+      test_case :test_project_partial_all_module_mocks_declaration_only_function
     end
 
     describe "Defines and configuration" do

data/spec/system/encoding_stress_spec.rb

@@ -131,8 +131,8 @@ ceedling_system_tests do
           @c.merge_project_yml_for_test({ :test_build => { :preprocess_force_fallback => false } })
           output = @c.ceedling_build_exec("test:all")
           expect(@c.last_exit_status).to eq(0)
-          expect(output).to match(/TESTED:\s+65/)
-          expect(output).to match(/PASSED:\s+65/)
+          expect(output).to match(/TESTED:\s+67/)
+          expect(output).to match(/PASSED:\s+67/)
         end
       end
     end
@@ -144,8 +144,8 @@ ceedling_system_tests do
           @c.merge_project_yml_for_test({ :test_build => { :preprocess_force_fallback => true } })
           output = @c.ceedling_build_exec("test:all")
           expect(@c.last_exit_status).to eq(0)
-          expect(output).to match(/TESTED:\s+65/)
-          expect(output).to match(/PASSED:\s+65/)
+          expect(output).to match(/TESTED:\s+67/)
+          expect(output).to match(/PASSED:\s+67/)
         end
       end
     end

data/spec/system/example_wondrous_forest_spec.rb

@@ -46,8 +46,8 @@ ceedling_system_tests do
         @c.with_context do
           Dir.chdir "wondrous_forest" do
             @output = @c.ceedling_build_exec("test:all")
-            expect(@output).to match(/TESTED:\s+65/)
-            expect(@output).to match(/PASSED:\s+65/)
+            expect(@output).to match(/TESTED:\s+67/)
+            expect(@output).to match(/PASSED:\s+67/)
             expect(@output).to match(/FAILED:\s+0/)
           end
         end

data/spec/system/support/common_test_cases.rb

@@ -5,6 +5,8 @@
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 
+require 'rbconfig'
+
 module CommonSystemTestCases
   def can_report_version_no_git_commit_sha
     @c.with_context do
@@ -437,6 +439,69 @@ module CommonSystemTestCases
     end
   end
 
+  # A module splits its function declarations (same_dir_pairing_module_func.h, mocked by
+  # this test) from its type declarations (same_dir_pairing_module.h, reached only
+  # transitively via same_dir_pairing_other.h, never included directly by the test). All
+  # of these files are colocated in the test's own directory, which is what exercises
+  # GCC's same-directory quoted #include resolution during bare-includes extraction.
+  # Auto source-pairing must not pull the real source implementing the type header's
+  # like-named stem into this build alongside its mock of the differently-named header.
+  def test_project_preprocessing_same_dir_mock_pairing
+    @c.with_context do
+      Dir.chdir @proj_name do
+        FileUtils.cp test_asset_path("same_dir_pairing_module.h"), 'test/'
+        FileUtils.cp test_asset_path("same_dir_pairing_module_func.h"), 'test/'
+        FileUtils.cp test_asset_path("same_dir_pairing_module.c"), 'test/'
+        FileUtils.cp test_asset_path("same_dir_pairing_other.h"), 'test/'
+        FileUtils.cp test_asset_path("same_dir_pairing_other.c"), 'test/'
+        FileUtils.cp test_asset_path("test_same_dir_pairing.c"), 'test/'
+
+        settings = {
+          :project => { :use_test_preprocessor => :all },
+          :paths => {
+            :source  => ['src/**', 'test/**'],
+            :include => ['src/**', 'test/**']
+          }
+        }
+        @c.merge_project_yml_for_test(settings)
+
+        output = @c.ceedling_build_exec("test:same_dir_pairing")
+        expect(@c.last_exit_status).to eq(0) # Successful build and tests
+        expect(output).to match(/TESTED:\s+1/)
+        expect(output).to match(/PASSED:\s+1/)
+        expect(output).to match(/FAILED:\s+0/)
+        expect(output).not_to match(/multiple definition|duplicate symbol/)
+      end
+    end
+  end
+
+  # A module header with both a plain (non-inline) function prototype and a `static
+  # inline` function, with no paired .c source providing a body for the plain prototype
+  # (so it exists only as a bare declaration, never a definition). MOCK_PARTIAL_ALL_MODULE()
+  # must mock both functions, not just the one with a body.
+  def test_project_partial_all_module_mocks_declaration_only_function
+    @c.with_context do
+      Dir.chdir @proj_name do
+        FileUtils.cp test_asset_path("partial_all_module.h"), 'src/'
+        FileUtils.cp test_asset_path("test_partial_all_module.c"), 'test/'
+
+        settings = {
+          :project => {
+            :use_partials          => true,
+            :use_test_preprocessor => :all
+          }
+        }
+        @c.merge_project_yml_for_test(settings)
+
+        output = @c.ceedling_build_exec("test:partial_all_module")
+        expect(@c.last_exit_status).to eq(0) # Successful build and tests
+        expect(output).to match(/TESTED:\s+1/)
+        expect(output).to match(/PASSED:\s+1/)
+        expect(output).to match(/FAILED:\s+0/)
+      end
+    end
+  end
+
   def test_project_fail
     @c.with_context do
       Dir.chdir @proj_name do
@@ -892,6 +957,168 @@ module CommonSystemTestCases
     end
   end
 
+  # Regression test for issue #1185: a parameterized test (TEST_CASE) defined after a
+  # crashing test in the same file must still report its own real PASS results instead
+  # of being swept up as "crashed" alongside the actual crash. Uses :use_backtrace => :simple
+  # (Ceedling's default), which is the mode in which the bug was reported.
+  def crash_simple_sigsegv_with_parameterized_test
+    @c.with_context do
+      Dir.chdir @proj_name do
+        FileUtils.cp test_asset_path("example_file.h"), 'src/'
+        FileUtils.cp test_asset_path("example_file.c"), 'src/'
+        FileUtils.cp test_asset_path("test_example_file_crash_sigsegv_with_param.c"), 'test/'
+
+        @c.merge_project_yml_for_test({
+          :project => { :use_backtrace => :simple },
+          :unity   => { :use_param_tests => true }
+        })
+
+        output = @c.ceedling_build_exec("test:all")
+        expect(@c.last_exit_status).to eq(1) # Test should fail because of crash
+        expect(output).to match(/Unit test failures/)
+        # 1 crashing test + 3 parameterized cases
+        expect(output).to match(/TESTED:\s+4/)
+        expect(output).to match(/PASSED:\s+3/)
+        expect(output).to match(/FAILED:\s+1/)
+        expect(output).to match(/IGNORED:\s+0/)
+
+        result_file = './build/test/results/test_example_file_crash_sigsegv_with_param.fail'
+        expect(File.exist?(result_file)).to be(true)
+        results = YamlWrapper.new.load(result_file)
+
+        # Only the truly crashing test is reported as a failure/crash
+        expect(results[:failures].map { |f| f[:test] }).to eq(['test_add_numbers_will_fail'])
+        expect(results[:failures].first[:message]).to match(/Test case crashed/)
+
+        # Each parameterized case reports its own real (passing) result, by name, not a crash
+        expect(results[:successes].map { |s| s[:test] }).to contain_exactly(
+          'test_difference_between_numbers_is_correct(5, 3, 2)',
+          'test_difference_between_numbers_is_correct(10, 4, 6)',
+          'test_difference_between_numbers_is_correct(0, 0, 0)'
+        )
+      end
+    end
+  end
+
+  # Same regression coverage as `crash_simple_sigsegv_with_parameterized_test`, but for
+  # :use_backtrace => :gdb: confirms gdb-based isolation also correctly distinguishes the
+  # crashing test from the unrelated parameterized test, and still attributes the crash to
+  # the correct source line (exercising the gdb crash-frame symbol matching fix).
+  def crash_gdb_sigsegv_with_parameterized_test
+    @c.with_context do
+      Dir.chdir @proj_name do
+        FileUtils.cp test_asset_path("example_file.h"), 'src/'
+        FileUtils.cp test_asset_path("example_file.c"), 'src/'
+        FileUtils.cp test_asset_path("test_example_file_crash_sigsegv_with_param.c"), 'test/'
+
+        @c.merge_project_yml_for_test({
+          :project => { :use_backtrace => :gdb },
+          :unity   => { :use_param_tests => true }
+        })
+
+        output = @c.ceedling_build_exec("test:all")
+        expect(@c.last_exit_status).to eq(1) # Test should fail because of crash
+        expect(output).to match(/Unit test failures/)
+        expect(output).to match(/TESTED:\s+4/)
+        expect(output).to match(/PASSED:\s+3/)
+        expect(output).to match(/FAILED:\s+1/)
+        expect(output).to match(/IGNORED:\s+0/)
+
+        result_file = './build/test/results/test_example_file_crash_sigsegv_with_param.fail'
+        expect(File.exist?(result_file)).to be(true)
+        results = YamlWrapper.new.load(result_file)
+
+        # Only the truly crashing test is reported as a failure/crash
+        expect(results[:failures].map { |f| f[:test] }).to eq(['test_add_numbers_will_fail'])
+        expect(results[:failures].first[:message]).to match(/Test case crashed/)
+        expect(results[:failures].first[:message]).to match(/SIGSEGV/i)
+
+        # Each parameterized case reports its own real (passing) result, by name, not a crash
+        expect(results[:successes].map { |s| s[:test] }).to contain_exactly(
+          'test_difference_between_numbers_is_correct(5, 3, 2)',
+          'test_difference_between_numbers_is_correct(10, 4, 6)',
+          'test_difference_between_numbers_is_correct(0, 0, 0)'
+        )
+
+        log_path = './build/logs/test/test_example_file_crash_sigsegv_with_param/test_add_numbers_will_fail.gdb.log'
+        expect(File.exist?(log_path)).to be(true)
+        expect(File.read(log_path)).to match(/SIGSEGV|Segmentation fault/i)
+      end
+    end
+  end
+
+  # Regression test for issue #1198: a custom :test_fixture tool (e.g. a wrapper
+  # enabling a sanitizer's halt-on-error) can correctly detect a crash on the main run,
+  # only for that crash to be silently overwritten by a :simple backtrace diagnostic
+  # retry that runs through a *different*, independently-configured tool
+  # (test_fixture_simple_backtrace) and behaves differently there -- legitimately
+  # passing in that other environment. fake_crash_test_fixture.rb reproduces the
+  # mismatch without needing a real sanitizer: it always exits nonzero without ever
+  # running the real, bug-free test executable it's given, while the unmodified default
+  # backtrace retry tool runs that same executable directly and passes.
+  def crash_simple_diagnostic_retry_disagrees_with_main_fixture
+    @c.with_context do
+      Dir.chdir @proj_name do
+        FileUtils.cp test_asset_path("example_file.h"), 'src/'
+        FileUtils.cp test_asset_path("example_file.c"), 'src/'
+        FileUtils.cp test_asset_path("test_example_file_success.c"), 'test/'
+        FileUtils.cp test_asset_path("fake_crash_test_fixture.rb"), 'test/'
+
+        @c.merge_project_yml_for_test({
+          :project => { :use_backtrace => :simple },
+          :tools   => {
+            :test_fixture => {
+              :executable => RbConfig.ruby,
+              :arguments  => ['test/fake_crash_test_fixture.rb']
+            }
+          }
+        })
+
+        output = @c.ceedling_build_exec("test:all")
+        expect(@c.last_exit_status).not_to eq(0)
+        expect(output).to match(/Unit test failures/)
+        expect(output).not_to match(/PASSED:\s+1/)
+      end
+    end
+  end
+
+  # Same regression coverage as crash_simple_diagnostic_retry_disagrees_with_main_fixture
+  # above, but with a real UBSan-triggered crash (matching issue #1198's own
+  # reproduction exactly) instead of the portable simulated fixture. UBSan doesn't
+  # produce an OS-level crash signal the way a segfault does -- run_with_ubsan.rb's
+  # halt_on_error setting is what turns the undefined behavior into a hard stop, and
+  # only the main :test_fixture invocation goes through that wrapper. Requires a Linux
+  # gcc toolchain with -fsanitize=undefined support -- see "requires gcc with UBSan".
+  def crash_simple_ubsan_diagnostic_retry_disagrees_with_main_fixture
+    @c.with_context do
+      Dir.chdir @proj_name do
+        FileUtils.cp test_asset_path("test_example_file_ub_shift_overflow.c"), 'test/'
+        FileUtils.cp test_asset_path("run_with_ubsan.rb"), 'test/'
+
+        @c.merge_project_yml_for_test({
+          :project => { :use_backtrace => :simple },
+          :flags   => {
+            :test => {
+              :compile => { '*' => ['-fsanitize=undefined'] },
+              :link    => { '*' => ['-fsanitize=undefined'] }
+            }
+          },
+          :tools => {
+            :test_fixture => {
+              :executable => RbConfig.ruby,
+              :arguments  => ['test/run_with_ubsan.rb', '${1}']
+            }
+          }
+        })
+
+        output = @c.ceedling_build_exec("test:all")
+        expect(@c.last_exit_status).not_to eq(0)
+        expect(output).to match(/Unit test failures/)
+        expect(output).not_to match(/PASSED:\s+1/)
+      end
+    end
+  end
+
   def project_with_test_file_directly_including_source_file
     @c.with_context do
       Dir.chdir @proj_name do

data/spec/units/c_extractor/c_extractor_declarations_spec.rb

@@ -19,11 +19,10 @@ describe CExtractorDeclarations do
   describe "#try_extract_variable" do
     # Helper to create extractor and test variable extraction
     let(:extract_variable) do
-      ->(content, max_line_length=1000) do
+      ->(content) do
         scanner = StringScanner.new(content)
         declarations = CExtractorDeclarations.new({ c_extractor_code_text: CExtractorCodeText.new() })
         declarations.setup()
-        declarations.max_line_length = max_line_length
         success, variable = declarations.try_extract_variable(scanner)
         return [success, variable, scanner.pos, scanner.rest]
       end
@@ -194,11 +193,35 @@ describe CExtractorDeclarations do
         success, variable, pos, rest = extract_variable.call(content)
 
         expect(success).to be true
-        # Leading `const` is a decorator; gsub removes all `const` occurrences
-        check_single(variable, name: 'ptr', type: 'int*', decorators: ['const'], text: 'int* ptr;')
+        # Leading `const` (qualifying `int`) is a decorator; the second `const`
+        # (qualifying the pointer itself) is part of the declarator and stays put
+        check_single(variable, name: 'ptr', type: 'int* const', decorators: ['const'], text: 'int* const ptr;')
         expect(pos).to eq(21)
         expect(rest).to eq("")
       end
+
+      it "extracts volatile pointer to volatile" do
+        content = "volatile int* volatile ptr;"
+        success, variable, pos, rest = extract_variable.call(content)
+
+        expect(success).to be true
+        # Same as const/const above: only the leading qualifier is a decorator
+        check_single(variable, name: 'ptr', type: 'int* volatile', decorators: ['volatile'], text: 'int* volatile ptr;')
+        expect(pos).to eq(27)
+        expect(rest).to eq("")
+      end
+
+      it "extracts static const pointer to const" do
+        content = "static const int* const ptr;"
+        success, variable, pos, rest = extract_variable.call(content)
+
+        expect(success).to be true
+        # `static` and the leading `const` are decorators; the trailing `const`
+        # on the pointer itself is retained in both `.type` and `.text`
+        check_single(variable, name: 'ptr', type: 'int* const', decorators: ['static', 'const'], text: 'int* const ptr;')
+        expect(pos).to eq(28)
+        expect(rest).to eq("")
+      end
     end
 
     context "array variable declarations" do

data/spec/units/c_extractor/c_extractor_functions_spec.rb

@@ -20,11 +20,10 @@ describe CExtractorFunctions do
   describe "#extract_function_signature (private method testing)" do
     # Helper to access private method
     let(:extract_signature) do
-      ->(content, type, max_line_length=1000) do
+      ->(content, type) do
         scanner = StringScanner.new(content)
         functions = CExtractorFunctions.new({ c_extractor_code_text: CExtractorCodeText.new() })
         functions.setup()
-        functions.max_line_length = max_line_length
         signature = functions.send( :extract_function_signature, scanner, type )
         return [signature, scanner.pos, scanner.rest]
       end
@@ -797,7 +796,6 @@ describe CExtractorFunctions do
       ->(signature) do
         functions = CExtractorFunctions.new({ c_extractor_code_text: CExtractorCodeText.new() })
         functions.setup()
-        functions.max_line_length = 1000
         name = functions.send( :extract_function_name, signature )
         return name
       end
@@ -1485,7 +1483,6 @@ describe CExtractorFunctions do
         scanner = StringScanner.new(content)
         functions = CExtractorFunctions.new({ c_extractor_code_text: CExtractorCodeText.new() })
         functions.setup()
-        functions.max_line_length = 1000
         success, func = functions.try_extract_function_definition( scanner, filepath )
         return [success, func, scanner.pos, scanner.rest]
       end
@@ -2036,7 +2033,6 @@ describe CExtractorFunctions do
         scanner = StringScanner.new(content)
         functions = CExtractorFunctions.new({ c_extractor_code_text: CExtractorCodeText.new() })
         functions.setup()
-        functions.max_line_length = 1000
 
         success1, func1 = functions.try_extract_function_definition(scanner, filepath)
         expect(success1).to be true
@@ -2067,7 +2063,6 @@ describe CExtractorFunctions do
         code_text = CExtractorCodeText.new()
         functions = CExtractorFunctions.new({ c_extractor_code_text: code_text })
         functions.setup()
-        functions.max_line_length = 1000
 
         success1, func1 = functions.try_extract_function_definition(scanner, filepath)
         expect(success1).to be true
@@ -2106,7 +2101,6 @@ describe CExtractorFunctions do
         scanner = StringScanner.new(content)
         functions = CExtractorFunctions.new({ c_extractor_code_text: CExtractorCodeText.new() })
         functions.setup()
-        functions.max_line_length = 1000
 
         success1, func1 = functions.try_extract_function_definition(scanner, filepath)
         expect(success1).to be true
@@ -2130,7 +2124,6 @@ describe CExtractorFunctions do
     let(:functions) do
       f = CExtractorFunctions.new({ c_extractor_code_text: CExtractorCodeText.new() })
       f.setup()
-      f.max_line_length = 1000
       f
     end
 
@@ -2364,7 +2357,6 @@ describe CExtractorFunctions do
     let(:functions) do
       f = CExtractorFunctions.new({ c_extractor_code_text: CExtractorCodeText.new() })
       f.setup()
-      f.max_line_length = 1000
       f
     end
 
@@ -2482,7 +2474,6 @@ describe CExtractorFunctions do
         scanner = StringScanner.new(content)
         functions = CExtractorFunctions.new({ c_extractor_code_text: CExtractorCodeText.new() })
         functions.setup()
-        functions.max_line_length = 1000
         success, decl = functions.try_extract_function_declaration(scanner)
         return [success, decl, scanner.pos, scanner.rest]
       end
@@ -2711,7 +2702,6 @@ describe CExtractorFunctions do
         scanner = StringScanner.new(content)
         functions = CExtractorFunctions.new({ c_extractor_code_text: CExtractorCodeText.new() })
         functions.setup()
-        functions.max_line_length = 1000
         success, func = functions.try_extract_function_definition( scanner, filepath )
         return [success, func]
       end