Added initial make build support into new scripts/ folder.

Moved temp sensor example into examples/temp_sensor.
Added basic make example in examples/make_example.

examples/make_example/Makefile

@@ -0,0 +1,32 @@
+CC ?= gcc
+BUILD_DIR ?= ./build
+SRC_DIR ?= ./src
+TEST_DIR ?= ./test
+#UNITY_DIR ?= ../../vendor/cmock/vendor/unity
+#CMOCK_DIR ?= ../..
+TEST_BUILD_DIR ?= ${BUILD_DIR}/test
+TEST_MAKEFILE = ${TEST_BUILD_DIR}/MakefileTestSupport
+OBJ ?= ${BUILD_DIR}/obj
+OBJ_DIR = ${OBJ}
+
+default: all
+
+all: setup test ${BUILD_DIR}/main run
+
+setup:
+	mkdir -p ${BUILD_DIR}
+	mkdir -p ${OBJ}
+	ruby ../../scripts/create_makefile.rb
+
+clean:
+	rm -rf ${BUILD_DIR}
+
+${BUILD_DIR}/main: ${SRC_DIR}/main.c ${SRC_DIR}/foo.c
+	${CC} $< -o $@
+
+run:
+	./build/main
+
+test: setup
+
+-include ${TEST_MAKEFILE}

examples/make_example/src/foo.c

@@ -0,0 +1,5 @@
+#include "foo.h"
+
+void foo_init(void)
+{
+}

examples/make_example/src/foo.h

@@ -0,0 +1,5 @@
+#ifndef _foo_h
+
+void foo_init(void);
+
+#endif

examples/make_example/src/main.c

@@ -0,0 +1,15 @@
+#include <stdio.h>
+#include "foo.h"
+
+int real_main(int argc, char ** argv)
+{
+    printf("Hello world!\n");
+    return 0;
+}
+
+#ifndef TEST
+int main(int argc, char ** argv)
+{
+    return real_main(argc, argv);
+}
+#endif

examples/make_example/test/test_foo.c

@@ -0,0 +1,17 @@
+#include "unity.h"
+#include "foo.h"
+
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
+void test_foo_init_should_initialize_multiplier()
+{
+    foo_init();
+
+    TEST_ASSERT_FALSE(1);
+}

examples/make_example/test/test_main.c

@@ -0,0 +1,15 @@
+#include "unity.h"
+#include "mock_foo.h"
+
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
+void test_main_should_initialize_foo(void)
+{
+    TEST_IGNORE_MESSAGE("TODO: Implement main!");
+}

scripts/create_makefile.rb

@@ -0,0 +1,162 @@
+require 'cmock'
+require 'fileutils'
+abs_root = FileUtils.pwd
+cmock_dir = File.expand_path(ENV.fetch('CMOCK_DIR', File.join(abs_root, '..', '..')))
+puts "___CMOCK: #{cmock_dir}"
+unity_dir = File.join(cmock_dir, 'vendor', 'unity')
+puts "___UNITY: #{unity_dir}"
+require "#{unity_dir}/auto/generate_test_runner"
+
+src_dir =  ENV.fetch('SRC_DIR',  './src')
+test_dir = ENV.fetch('TEST_DIR', './test')
+unity_src = File.join(unity_dir, 'src')
+cmock_src = File.join(cmock_dir, 'src')
+build_dir = ENV.fetch('BUILD_DIR', './build')
+test_build_dir = ENV.fetch('TEST_BUILD_DIR', File.join(build_dir, 'test'))
+obj_dir = File.join(test_build_dir, 'obj')
+unity_obj = File.join(obj_dir, 'unity.o')
+cmock_obj = File.join(obj_dir, 'cmock.o')
+runners_dir = File.join(test_build_dir, 'runners')
+mocks_dir = File.join(test_build_dir, 'mocks')
+test_bin_dir = test_build_dir
+mock_prefix = ENV.fetch('TEST_MOCK_PREFIX', 'mock_')
+test_makefile = ENV.fetch('TEST_MAKEFILE', File.join(test_build_dir, 'MakefileTestSupport'))
+MOCK_MATCHER = /#{mock_prefix}[A-Za-z_][A-Za-z0-9_\-\.]+/
+
+[test_build_dir, obj_dir, runners_dir, mocks_dir, test_bin_dir].each do |dir|
+  FileUtils.mkdir_p dir
+end
+
+all_headers_to_mock = []
+
+File.open(test_makefile, "w") do |mkfile|
+
+  # Define make variables
+  mkfile.puts "CC ?= gcc"
+  mkfile.puts "BUILD_DIR ?= ./build"
+  mkfile.puts "SRC_DIR ?= ./src"
+  mkfile.puts "TEST_DIR ?= ./test"
+  mkfile.puts "CMOCK_DIR ?= #{cmock_dir}"
+  mkfile.puts "UNITY_DIR ?= #{unity_dir}"
+  mkfile.puts "TEST_BUILD_DIR ?= ${BUILD_DIR}/test"
+  mkfile.puts "TEST_MAKEFILE = ${TEST_BUILD_DIR}/MakefileTestSupport"
+  mkfile.puts "OBJ ?= ${BUILD_DIR}/obj"
+  mkfile.puts "OBJ_DIR = ${OBJ}"
+  mkfile.puts ""
+
+  # Build Unity
+  mkfile.puts "#{unity_obj}: #{unity_src}/unity.c"
+  mkfile.puts "\t${CC} -o $@ -c $< -I #{unity_src}"
+  mkfile.puts ""
+
+  # Build CMock
+  mkfile.puts "#{cmock_obj}: #{cmock_src}/cmock.c"
+  mkfile.puts "\t${CC} -o $@ -c $< -I #{unity_src} -I #{cmock_src}"
+  mkfile.puts ""
+
+  test_sources = Dir["#{test_dir}/**/test_*.c"]
+  test_targets = []
+  generator = UnityTestRunnerGenerator.new
+  all_headers = Dir["#{src_dir}/**/*.h"]
+
+  test_sources.each do |test|
+    module_name = File.basename(test, '.c')
+    src_module_name = module_name.sub(/^test_/, '')
+    test_obj = File.join(obj_dir, "#{module_name}.o")
+    runner_source = File.join(runners_dir, "runner_#{module_name}.c")
+    runner_obj = File.join(obj_dir, "runner_#{module_name}.o")
+    test_bin = File.join(test_bin_dir, module_name)
+    test_results = File.join(test_bin_dir, module_name + '.result')
+
+    # Build main project modules, with TEST defined
+    module_src = File.join(src_dir, "#{src_module_name}.c")
+    module_obj = File.join(obj_dir, "#{src_module_name}.o")
+    mkfile.puts "#{module_obj}: #{module_src}"
+    mkfile.puts "\t${CC} -o $@ -c $< -DTEST -I #{src_dir}"
+    mkfile.puts ""
+
+    # Create runners
+    mkfile.puts "#{runner_source}: #{test}"
+    mkfile.puts "\t@UNITY_DIR=${UNITY_DIR} ruby ${CMOCK_DIR}/scripts/create_runner.rb #{test} #{runner_source}"
+    mkfile.puts ""
+
+    # Build runner
+    mkfile.puts "#{runner_obj}: #{runner_source}"
+    mkfile.puts "\t${CC} -o $@ -c $< -I #{src_dir} -I #{mocks_dir} -I #{unity_src} -I #{cmock_src}"
+    mkfile.puts ""
+
+    # Collect mocks to generate
+    cfg = {
+      src: test,
+      includes: generator.find_includes(File.readlines(test).join(''))
+    }
+    system_mocks = cfg[:includes][:system].select{|name| name =~ MOCK_MATCHER}
+    raise "Mocking of system headers is not yet supported!" if !system_mocks.empty?
+    local_mocks = cfg[:includes][:local].select{|name| name =~ MOCK_MATCHER}
+    module_names_to_mock = local_mocks.map{|name| "#{name.sub(/#{mock_prefix}/,'')}.h"}
+    headers_to_mock = []
+    module_names_to_mock.each do |name|
+      header_to_mock = nil
+      all_headers.each do |header|
+        if (header =~ /[\/\\]?#{name}$/)
+          header_to_mock = header
+          break
+        end
+      end
+      raise "Module header '#{name}' not found to mock!" unless header_to_mock
+      headers_to_mock << header_to_mock 
+    end
+    all_headers_to_mock += headers_to_mock
+    mock_objs = headers_to_mock.map do |hdr|
+      mock_name = mock_prefix + File.basename(hdr, '.h')
+      File.join(mocks_dir, mock_name + '.o')
+    end
+    all_headers_to_mock.uniq!
+
+    # Build test suite
+    mkfile.puts "#{test_obj}: #{test} #{module_obj} #{mock_objs.join(' ')}"
+    mkfile.puts "\t${CC} -o $@ -c $< -I #{src_dir} -I #{unity_src} -I #{cmock_src} -I #{mocks_dir}"
+    mkfile.puts ""
+
+    # Build test suite executable
+    test_objs = "#{test_obj} #{runner_obj} #{module_obj} #{mock_objs.join(' ')} #{unity_obj} #{cmock_obj}"
+    mkfile.puts "#{test_bin}: #{test_objs}"
+    mkfile.puts "\t${CC} -o $@ #{test_objs}"
+    mkfile.puts ""
+
+    # Run test suite and generate report
+    mkfile.puts "#{test_results}: #{test_bin}"
+    mkfile.puts "\t#{test_bin} &> #{test_results}"
+    mkfile.puts ""
+
+    test_targets << test_bin
+  end
+
+  # Generate and build mocks
+  all_headers_to_mock.each do |hdr|
+    mock_name = mock_prefix + File.basename(hdr, '.h')
+    mock_header = File.join(mocks_dir, mock_name + '.h')
+    mock_src = File.join(mocks_dir, mock_name + '.c')
+    mock_obj = File.join(mocks_dir, mock_name + '.o')
+
+    mkfile.puts "#{mock_src}: #{hdr}"
+    mkfile.puts "\t@CMOCK_DIR=${CMOCK_DIR} ruby ${CMOCK_DIR}/scripts/create_mock.rb #{hdr}"
+    mkfile.puts ""
+
+    mkfile.puts "#{mock_obj}: #{mock_src} #{mock_header}"
+    mkfile.puts "\t${CC} -o $@ -c $< -I #{mocks_dir} -I #{src_dir} -I #{unity_src} -I #{cmock_src}"
+    mkfile.puts ""
+  end
+
+  # Create test summary task
+  mkfile.puts "test_summary:"
+  mkfile.puts "\t@UNITY_DIR=${UNITY_DIR} ruby ${CMOCK_DIR}/scripts/test_summary.rb"
+  mkfile.puts ""
+  mkfile.puts ".PHONY: test_summary"
+  mkfile.puts ""
+
+  # Create target to run all tests
+  mkfile.puts "test: #{test_targets.map{|t| t + '.result'}.join(' ')} test_summary"
+  mkfile.puts ""
+
+end

scripts/create_mock.rb

@@ -0,0 +1,8 @@
+require 'cmock'
+
+raise "Header file to mock must be specified!" unless ARGV.length >= 1
+
+mock_out = ENV.fetch('MOCK_OUT', './build/test/mocks')
+mock_prefix = ENV.fetch('MOCK_PREFIX', 'mock_')
+cmock = CMock.new(plugins: [:ignore, :return_thru_ptr], mock_prefix: 'mock_', mock_path: mock_out)
+cmock.setup_mocks(ARGV[0])

scripts/create_runner.rb

@@ -0,0 +1,30 @@
+if ($0 == __FILE__)
+
+  #make sure there is at least one parameter left (the input file)
+  if ARGV.length < 2
+    puts ["\nusage: ruby #{__FILE__} input_test_file (output)",
+      "",
+      "  input_test_file         - this is the C file you want to create a runner for",
+      "  output                  - this is the name of the runner file to generate",
+      "                            defaults to (input_test_file)_Runner",
+    ].join("\n")
+    exit 1
+  end
+
+  require 'cmock'
+  require 'fileutils'
+  src_dir =  ENV.fetch('SRC_DIR',  './src')
+  test_dir = ENV.fetch('TEST_DIR', './test')
+  runners_dir = ENV.fetch('RUNNERS_DIR', './build/runners')
+  puts "UNITY_DIR_CREATE_RUNNER: #{ENV['UNITY_DIR']}"
+  unity_dir = ENV['UNITY_DIR']
+  require "#{unity_dir}/auto/generate_test_runner"
+
+  test = ARGV[0]
+  runner = ARGV[1]
+
+  generator = UnityTestRunnerGenerator.new
+
+  generator.run(test, runner)
+
+end

scripts/test_summary.rb

@@ -0,0 +1,13 @@
+require 'cmock'
+require 'fileutils'
+require "#{ENV['UNITY_DIR']}/auto/unity_test_summary.rb"
+
+build_dir = ENV.fetch('BUILD_DIR', './build')
+test_build_dir = ENV.fetch('TEST_BUILD_DIR', File.join(build_dir, 'test'))
+
+parser = UnityTestSummary.new
+results = Dir["#{test_build_dir}/*.result"]
+parser.set_targets(results)
+parser.run
+puts parser.report
+exit(parser.failures)