ceedling 0.9.0 → 1.0.1

data/spec/system_utils_spec.rb

@@ -0,0 +1,65 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'spec_helper'
+require 'ceedling/system_utils'
+
+
+describe SystemUtils do
+  before(:each) do
+    # this will always be mocked
+    @sys_wrapper = nil
+    allow_message_expectations_on_nil
+
+    @sys_utils = described_class.new({:system_wrapper => @sys_wrapper})
+    @sys_utils.setup
+
+    @echo_test_cmd = {:command=>'echo $version'}
+  end
+ 
+  describe '#setup' do
+    it 'sets tcsh_shell to nil' do
+      expect(@sys_utils.instance_variable_get(:@tcsh_shell)).to eq(nil)
+    end
+
+    it 'sets tcsh_shell to nil after being set' do
+      expect(@sys_utils.instance_variable_get(:@tcsh_shell)).to eq(nil)
+     
+
+      allow(@loginator).to receive(:shell_backticks).with(@echo_test_cmd).and_return({:exit_code => 0, :output =>'tcsh 1234567890'})
+      @sys_utils.tcsh_shell?
+      
+      @sys_utils.setup
+      expect(@sys_utils.instance_variable_get(:@tcsh_shell)).to eq(nil)
+    end
+  end
+
+
+  describe '#tcsh_shell?' do
+    it 'returns true if exit code is zero and output contains tcsh' do
+      allow(@loginator).to receive(:shell_backticks).with(@echo_test_cmd).and_return({:exit_code => 0, :output =>'tcsh 1234567890'})
+      expect(@sys_utils.tcsh_shell?).to eq(true)
+    end
+
+    it 'returns false if exit code is not 0' do
+      allow(@loginator).to receive(:shell_backticks).with(@echo_test_cmd).and_return({:exit_code => 1, :output =>'tcsh 1234567890'})
+      expect(@sys_utils.tcsh_shell?).to eq(false)
+    end
+
+    it 'returns false if output does not contain tcsh' do
+      allow(@loginator).to receive(:shell_backticks).with(@echo_test_cmd).and_return({:exit_code => 0, :output =>'???'})
+      expect(@sys_utils.tcsh_shell?).to eq(false)
+    end
+
+    it 'returns last value if already run' do
+      allow(@loginator).to receive(:shell_backticks).with(@echo_test_cmd).and_return({:exit_code => 1, :output =>'???'})
+      expect(@sys_utils.tcsh_shell?).to eq(false)
+      allow(@loginator).to receive(:shell_backticks).with(@echo_test_cmd).and_return({:exit_code => 0, :output =>'tcsh 1234567890'})
+      expect(@sys_utils.tcsh_shell?).to eq(false)
+    end
+  end
+end

data/spec/test_context_extractor_spec.rb

@@ -0,0 +1,328 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'spec_helper'
+require 'ceedling/test_context_extractor'
+require 'ceedling/parsing_parcels'
+require 'ceedling/exceptions'
+
+describe TestContextExtractor do
+  before(:each) do
+    # Mock injected dependencies
+    @parsing_parcels = ParsingParcels.new()
+    @configurator = double( "Configurator" ) # Use double() so we can mock needed methods that are added dynamically at startup
+    @file_wrapper = double( "FileWrapper" ) # Not actually exercised in these test cases
+    loginator = instance_double( "Loginator" )
+    
+    # Ignore all logging calls
+    allow(loginator).to receive(:log)
+
+    # Provide configurations
+    mock_prefix = 'mock_'
+
+    # Rely on defaults in Unity's test runner generator
+    test_runner_config = {
+      :cmdline_args => false,
+      :mock_prefix => mock_prefix,
+      :mock_suffix => '',
+      :enforce_strict_ordering => false,
+      :defines => [],
+      :use_param_tests => false
+    }
+
+    allow(@configurator).to receive(:cmock_mock_prefix).and_return( mock_prefix )
+    allow(@configurator).to receive(:extension_header).and_return( '.h' )
+    allow(@configurator).to receive(:extension_source).and_return( '.c' )
+    allow(@configurator).to receive(:get_runner_config).and_return( test_runner_config )
+
+    @extractor = described_class.new(
+      {
+        :configurator => @configurator,
+        :file_wrapper => @file_wrapper,
+        :parsing_parcels => @parsing_parcels,
+        :loginator => loginator
+      }
+    )
+  end
+
+  context "#lookup_full_header_includes_list" do
+    it "should provide empty list when no context extraction has occurred" do
+      expect( @extractor.lookup_full_header_includes_list( "path" ) ).to eq []
+    end
+  end
+
+  context "#lookup_header_includes_list" do
+    it "should provide empty list when no context extraction has occurred" do
+      expect( @extractor.lookup_header_includes_list( "path" ) ).to eq []
+    end
+  end
+
+  context "#lookup_include_paths_list" do
+    it "should provide empty list when no context extraction has occurred" do
+      expect( @extractor.lookup_include_paths_list( "path" ) ).to eq []
+    end
+  end
+
+  context "#lookup_source_includes_list" do
+    it "should provide empty list when no context extraction has occurred" do
+      expect( @extractor.lookup_source_includes_list( "path" ) ).to eq []
+    end
+  end
+
+  context "#lookup_build_directive_sources_list" do
+    it "should provide empty list when no context extraction has occurred" do
+      expect( @extractor.lookup_build_directive_sources_list( "path" ) ).to eq []
+    end
+  end
+
+  context "#lookup_test_cases" do
+    it "should provide empty list when no context extraction has occurred" do
+      expect( @extractor.lookup_test_cases( "path" ) ).to eq []
+    end
+  end
+
+  context "#lookup_test_runner_generator" do
+    it "should provide no generator when no context extraction has occurred" do
+      expect( @extractor.lookup_test_runner_generator( "path" ) ).to eq nil
+    end
+  end
+
+  context "#lookup_raw_mock_list" do
+    it "should provide empty list when no context extraction has occurred" do
+      expect( @extractor.lookup_raw_mock_list( "path" ) ).to eq []
+    end
+  end
+
+  context "#extract_includes" do
+    it "should extract #include directives from code" do
+      # Complex comments tested in `clean_code_line()` test case
+      file_contents = <<~CONTENTS
+      #include "some_source.h"
+      #include "more_source.h"
+
+      #include  "some_source.h"          // Duplicate to be ignored
+
+        #include "unity.h"
+
+      #include "mock_File.h"
+        #include "mock_another_file.h"
+      #include  " mock_another_file.h "  // Duplicate to be ignored
+      CONTENTS
+
+      input = StringIO.new( file_contents )
+
+      expected = [
+        'some_source.h',
+        'more_source.h',
+        'unity.h',
+        'mock_File.h',
+        'mock_another_file.h'
+      ]
+
+      expect( @extractor.extract_includes( input ) ).to eq expected
+    end
+  end
+
+  context "#collect_simple_context" do
+    it "should raise an execption for unknown symbol argument" do
+      expect{ @extractor.collect_simple_context( "path", StringIO.new(), :bad ) }.to raise_error( CeedlingException )
+    end
+
+    # collect_simple_context() + lookup_full_header_includes_list() + lookup_header_includes_list() + lookup_raw_mock_list()
+    it "should extract contents of #include directives" do
+      filepath = "path/tests/test_file.c"
+      
+      # Complex comments tested in `clean_code_line()` test case
+      file_contents = <<~CONTENTS
+      #include "some_source.h"
+      #include "more_source.h"
+
+      #include  "some_source.h"          // Duplicate to be ignored
+
+        #include "unity.h"
+
+      #include "mock_File.h"
+        #include "mock_another_file.h"
+      #include  " mock_another_file.h "  // Duplicate to be ignored
+      CONTENTS
+
+      input = StringIO.new( file_contents )
+
+      @extractor.collect_simple_context( filepath, input, :includes )
+
+      expected_full = [
+        'some_source.h',
+        'more_source.h',
+        'unity.h',
+        'mock_File.h',
+        'mock_another_file.h'
+      ]
+
+      expected_trim = [
+        'some_source.h',
+        'more_source.h'
+      ]
+
+      expected_mocks = [
+        'mock_File',
+        'mock_another_file'
+      ]
+
+      expect( @extractor.lookup_full_header_includes_list( filepath ) ).to eq expected_full
+
+      expect( @extractor.lookup_header_includes_list( filepath ) ).to eq expected_trim
+
+      expect( @extractor.lookup_raw_mock_list( filepath ) ).to eq expected_mocks
+    end
+
+    # collect_simple_context() + lookup_build_directive_sources_list()
+    it "should extract extra source files by build directive macros" do
+      filepath = "path/tests/testfile.c"
+      
+      # Complex comments tested in `clean_code_line()` test case
+      file_contents = <<~CONTENTS
+      TEST_SOURE_FILE("bad_directive.c")              // Typo in macro name that blocks recognition
+
+      TEST_SOURCE_FILE("a.c") TEST_SOURCE_FILE("b.c") // Repeated calls on same line
+
+        TEST_SOURCE_FILE("path/baz.c")                // Leading whitespace to ignore
+      TEST_SOURCE_FILE( "some\\path\\boo.c"  )        // Spaces in macro call + path separators to fix
+
+      TEST_SOURCE_FILE()                              // Incomplete macro call that should be ignored
+      CONTENTS
+
+      input = StringIO.new( file_contents )
+
+      @extractor.collect_simple_context( filepath, input, :build_directive_source_files )
+
+      expected = [
+        'a.c',
+        'b.c',
+        'path/baz.c',
+        'some/path/boo.c'
+      ]
+
+      expect( @extractor.lookup_build_directive_sources_list( filepath ) ).to eq expected
+    end
+
+    # collect_simple_context() + lookup_include_paths_list()
+    it "should extract extra header search paths by build directive macros" do
+      filepath = "path/tests/testfile.c"
+      
+      # Complex comments tested in `clean_code_line()` test case
+      file_contents = <<~CONTENTS
+      TEST_INCLUE_PATH("bad_directive/")            // Typo in macro name that blocks recognition
+
+      TEST_INCLUDE_PATH("a") TEST_INCLUDE_PATH("b") // Repeated calls on same line
+
+        TEST_INCLUDE_PATH("this/path")              // Leading whitespace to ignore
+      TEST_INCLUDE_PATH( "some\\dir\\path/"  )      // Spaces in macro call + path separators to fix
+
+      TEST_INCLUDE_PATH()                           // Incomplete macro call that should be ignored
+      CONTENTS
+
+      input = StringIO.new( file_contents )
+
+      @extractor.collect_simple_context( filepath, input, :build_directive_include_paths )
+
+      expected = [
+        'a',
+        'b',
+        'this/path',
+        'some/dir/path'
+      ]
+
+      expect( @extractor.lookup_include_paths_list( filepath ) ).to eq expected
+    end
+
+    # collect_simple_context() + lookup_all_include_paths()
+    it "should extract extra header search paths for multiple files" do
+      # First File
+      filepath = "path/tests/testfile.c"
+      
+      # Complex comments tested in `clean_code_line()` test case
+      file_contents = <<~CONTENTS
+      TEST_INCLUDE_PATH("this/path")
+      TEST_INCLUDE_PATH("some/other/path")
+      CONTENTS
+
+      input = StringIO.new( file_contents )
+
+      @extractor.collect_simple_context( filepath, input, :build_directive_include_paths )
+
+      # Second File
+      filepath = "anotherfile.c"
+      
+      # Complex comments tested in `clean_code_line()` test case
+      file_contents = <<~CONTENTS
+      TEST_INCLUDE_PATH("more/paths")
+      TEST_INCLUDE_PATH("yet/more/paths")
+      TEST_INCLUDE_PATH("this/path")       // Duplicated from first file
+      CONTENTS
+
+      input = StringIO.new( file_contents )
+
+      @extractor.collect_simple_context( filepath, input, :build_directive_include_paths )
+
+      expected = [
+        'this/path',
+        'some/other/path',
+        'more/paths',
+        'yet/more/paths'
+      ]
+
+      expect( @extractor.lookup_all_include_paths() ).to eq expected
+    end
+
+    # collect_simple_context() + lookup_test_cases()
+    it "should extract test case names with line numbers" do
+      filepath = "path/tests/testfile.c"
+      
+      # Comments exercised because test case extraction relies on Unity's generate_test_runner.rb.
+      # Unity's Ruby code has its own handling of comments
+      file_contents = <<~CONTENTS
+
+      void test_this_function() {
+        // TEST_ASSERT_TRUE( 1 == 1);
+      }
+
+      /*
+        void test_this_other_function() {   // Ignored due to comment block
+          TEST_ASSERT_FALSE( 0 == 1 );
+        }
+      */
+
+       void   test_another_function( void )
+      {
+        // TEST_ASSERT_TRUE( 1 == 1);
+      }
+
+      void TestME() {                       // Ignored because of naming mismatch
+        TEST_ASSERT_TRUE( 1 == 1);
+      }
+
+      // void test_somestuff(void) {        // Ignored due to comment lines
+      //  // TEST_ASSERT_TRUE( 1 == 1);
+      // }
+
+      CONTENTS
+
+      input = StringIO.new( file_contents )
+
+      @extractor.collect_simple_context( filepath, input, :test_runner_details )
+
+      expected = [
+        {:line_number =>  2, :test => 'test_this_function'},
+        {:line_number => 12, :test => 'test_another_function'},
+      ]
+
+      expect( @extractor.lookup_test_cases( filepath ) ).to eq expected
+    end
+
+  end
+
+end

data/spec/tool_executor_helper_spec.rb

@@ -0,0 +1,219 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'spec_helper'
+require 'ceedling/constants'
+require 'ceedling/tool_executor_helper'
+require 'ceedling/system_wrapper'
+require 'ceedling/loginator'
+require 'ceedling/system_utils'
+require 'ceedling/verbosinator'
+
+
+describe ToolExecutorHelper do
+  before(:each) do
+    # these will always be mocked
+    @sys_wrapper = SystemWrapper.new
+    @sys_utils = SystemUtils.new({:system_wrapper => @sys_wrapper})
+    @loginator = Loginator.new({:verbosinator => nil, :file_wrapper => nil, :system_wrapper => nil})
+    @verbosinator = Verbosinator.new()
+    
+    @tool_exe_helper = described_class.new(
+      {
+        :loginator => @loginator,
+        :system_utils => @sys_utils,
+        :system_wrapper => @sys_wrapper,
+        :verbosinator => @verbosinator
+      }
+    )
+  end
+  
+
+  describe '#osify_path_separators' do
+    it 'returns path if system is not windows' do
+      exe = '/just/some/executable.out'
+      expect(@sys_wrapper).to receive(:windows?).and_return(false)
+      expect(@tool_exe_helper.osify_path_separators(exe)).to eq(exe)
+    end
+
+    it 'returns modifed if system is windows' do
+      exe = '/just/some/executable.exe'
+      expect(@sys_wrapper).to receive(:windows?).and_return(true)
+      expect(@tool_exe_helper.osify_path_separators(exe)).to eq("\\just\\some\\executable.exe")
+    end
+  end
+
+
+  describe '#stderr_redirect_cmdline_append' do
+    it 'returns nil if tool_config is nil' do
+      expect(@tool_exe_helper.stderr_redirect_cmdline_append(nil)).to be_nil
+    end
+
+    it 'returns nil if tool_config[:stderr_redirect] is nil' do
+      tool_config = {:stderr_redirect => nil}
+      expect(@tool_exe_helper.stderr_redirect_cmdline_append(tool_config)).to be_nil
+    end
+
+    it 'returns nil if tool_config is set to none' do
+      tool_config = {:stderr_redirect => StdErrRedirect::NONE}
+      expect(@tool_exe_helper.stderr_redirect_cmdline_append(tool_config)).to be_nil
+    end
+
+    context 'StdErrRedirect::AUTO' do
+      before(:each) do
+        @tool_config = {:stderr_redirect => StdErrRedirect::AUTO}
+      end
+
+
+      it 'returns "2>&1" if system is windows' do
+        expect(@sys_wrapper).to receive(:windows?).and_return(true)
+        expect(@tool_exe_helper.stderr_redirect_cmdline_append(@tool_config)).to eq('2>&1')
+      end
+
+      it 'returns "|&" if system is tcsh' do
+        expect(@sys_wrapper).to receive(:windows?).and_return(false)
+        expect(@sys_utils).to receive(:tcsh_shell?).and_return(true)
+        expect(@tool_exe_helper.stderr_redirect_cmdline_append(@tool_config)).to eq('|&')
+      end
+
+      it 'returns "2>&1" if system is unix' do
+        expect(@sys_wrapper).to receive(:windows?).and_return(false)
+        expect(@sys_utils).to receive(:tcsh_shell?).and_return(false)
+        expect(@tool_exe_helper.stderr_redirect_cmdline_append(@tool_config)).to eq('2>&1')
+      end     
+    end
+  end
+
+  describe '#log_results' do
+    it 'insufficient logging verbosity' do
+      # Do nothing
+      expect(@verbosinator).to receive(:should_output?).with(Verbosity::OBNOXIOUS).and_return(false)
+      @tool_exe_helper.log_results("gcc ab.c", {})
+    end
+
+    context 'when debug logging' do
+      before(:each) do
+        expect(@verbosinator).to receive(:should_output?).with(Verbosity::OBNOXIOUS).and_return(true)
+        expect(@verbosinator).to receive(:should_output?).with(Verbosity::DEBUG).and_return(true)
+        @shell_result = {:status => '<status>'}
+      end
+
+      it 'and $stderr and $stdout are both empty' do
+        @shell_result[:stderr] = ''
+        @shell_result[:stdout] = ''
+
+        message =
+          "> Shell executed command:\n" +
+          "`gcc ab.c`\n" +
+          "> With $stdout: <empty>\n" +
+          "> With $stderr: <empty>\n" +
+          "> And terminated with status: <status>\n"
+
+        expect(@loginator).to receive(:log).with('', Verbosity::DEBUG)
+        expect(@loginator).to receive(:log).with(message, Verbosity::DEBUG)
+        expect(@loginator).to receive(:log).with('', Verbosity::DEBUG)
+
+        @tool_exe_helper.log_results("gcc ab.c", @shell_result)
+      end
+
+      it 'and $stderr is not empty' do
+        @shell_result[:stderr] = "error output\n\n\n"
+        @shell_result[:stdout] = ''
+
+        message =
+          "> Shell executed command:\n" +
+          "`test.exe`\n" +
+          "> With $stdout: <empty>\n" +
+          "> With $stderr: \nerror output\n" +
+          "> And terminated with status: <status>\n"
+
+        expect(@loginator).to receive(:log).with('', Verbosity::DEBUG)
+        expect(@loginator).to receive(:log).with(message, Verbosity::DEBUG)
+        expect(@loginator).to receive(:log).with('', Verbosity::DEBUG)
+
+        @tool_exe_helper.log_results("test.exe", @shell_result)
+      end
+
+      it 'and $stdout is not empty' do
+        @shell_result[:stderr] = ''
+        @shell_result[:stdout] = "output\n\n\n"
+
+        message =
+          "> Shell executed command:\n" +
+          "`utility --flag`\n" +
+          "> With $stdout: \noutput\n" +
+          "> With $stderr: <empty>\n" +
+          "> And terminated with status: <status>\n"
+
+        expect(@loginator).to receive(:log).with('', Verbosity::DEBUG)
+        expect(@loginator).to receive(:log).with(message, Verbosity::DEBUG)
+        expect(@loginator).to receive(:log).with('', Verbosity::DEBUG)
+
+        @tool_exe_helper.log_results("utility --flag", @shell_result)
+      end
+    end
+
+    context 'when obnoxious logging' do
+      before(:each) do
+        expect(@verbosinator).to receive(:should_output?).with(Verbosity::OBNOXIOUS).and_return(true)
+        expect(@verbosinator).to receive(:should_output?).with(Verbosity::DEBUG).and_return(false)
+        @shell_result = {}
+      end
+
+      it 'and executable probably crashed' do
+        @shell_result[:output] = ''
+        @shell_result[:exit_code] = nil
+
+        message =
+          "> Shell executed command:\n" +
+          "`gcc ab.c`\n" +
+          "> And exited prematurely\n"
+
+        expect(@loginator).to receive(:log).with('', Verbosity::OBNOXIOUS)
+        expect(@loginator).to receive(:log).with(message, Verbosity::OBNOXIOUS)
+        expect(@loginator).to receive(:log).with('', Verbosity::OBNOXIOUS)
+
+        @tool_exe_helper.log_results("gcc ab.c", @shell_result)
+      end
+
+      it 'and executable produced output and zero exit code' do
+        @shell_result[:output] = 'some output'
+        @shell_result[:exit_code] = 0
+
+        message =
+          "> Shell executed command:\n" +
+          "`test.exe --a_flag`\n" +
+          "> Produced output: \nsome output\n" +
+          "> And terminated with exit code: [0]\n"
+
+        expect(@loginator).to receive(:log).with('', Verbosity::OBNOXIOUS)
+        expect(@loginator).to receive(:log).with(message, Verbosity::OBNOXIOUS)
+        expect(@loginator).to receive(:log).with('', Verbosity::OBNOXIOUS)
+
+        @tool_exe_helper.log_results("test.exe --a_flag", @shell_result)
+      end
+
+      it 'and executable produced output and non-zero exit code' do
+        @shell_result[:output] = 'some more output'
+        @shell_result[:exit_code] = 37
+
+        message =
+          "> Shell executed command:\n" +
+          "`utility.out args`\n" +
+          "> Produced output: \nsome more output\n" +
+          "> And terminated with exit code: [37]\n"
+
+        expect(@loginator).to receive(:log).with('', Verbosity::OBNOXIOUS)
+        expect(@loginator).to receive(:log).with(message, Verbosity::OBNOXIOUS)
+        expect(@loginator).to receive(:log).with('', Verbosity::OBNOXIOUS)
+
+        @tool_exe_helper.log_results("utility.out args", @shell_result)
+      end
+    end
+
+  end
+end

data/spec/uncategorized_specs_spec.rb

@@ -0,0 +1,15 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'spec_helper'
+
+describe "uncategorized" do
+  describe "set_verbosity" do
+    # drived from test_graveyard/unit/busted/configurator_test.rb:21
+    xit "needs to be defined"
+  end
+end