ceedling 0.13.0.rc1 → 0.13.0

data/vendor/unity/examples/readme.txt

@@ -0,0 +1,18 @@
+Example Project
+
+This example project gives an example of some passing, ignored, and failing tests.
+It's simple and meant for you to look over and get an idea for what all of this stuff does.
+
+You can build and test using the makefile if you have gcc installed (you may need to tweak
+the locations of some tools in the makefile).  Otherwise, the rake version will let you
+test with gcc or a couple versions of IAR.  You can tweak the yaml files to get those versions
+running.
+
+Ruby is required if you're using the rake version (obviously).  This version shows off most of
+Unity's advanced features (automatically creating test runners, fancy summaries, etc.)  
+
+The makefile version doesn't require anything outside of your normal build tools, but won't do the
+extras for you.  So that you can test right away, we've written the test runners for you and 
+put them in the test\no_ruby subdirectory.  If you make changes to the tests or source, you might
+need to update these (like when you add or remove tests).  Do that for a while and you'll learn
+why you really want to start using the Ruby tools.

data/vendor/unity/examples/src/ProductionCode.c

@@ -0,0 +1,24 @@
+
+#include "ProductionCode.h"
+
+int Counter = 0;
+int NumbersToFind[9] = { 0, 34, 55, 66, 32, 11, 1, 77, 888 }; //some obnoxious array to search that is 1-based indexing instead of 0.
+
+// This function is supposed to search through NumbersToFind and find a particular number.  
+// If it finds it, the index is returned.  Otherwise 0 is returned which sorta makes sense since 
+// NumbersToFind is indexed from 1.  Unfortunately it's broken 
+// (and should therefore be caught by our tests)
+int FindFunction_WhichIsBroken(int NumberToFind)
+{
+    int i = 0;
+    while (i <= 8) //Notice I should have been in braces
+        i++;
+        if (NumbersToFind[i] == NumberToFind) //Yikes!  I'm getting run after the loop finishes instead of during it!
+            return i;
+    return 0;
+}
+
+int FunctionWhichReturnsLocalVariable(void)
+{
+    return Counter;
+}

data/vendor/unity/examples/src/ProductionCode.h

@@ -0,0 +1,3 @@
+
+int FindFunction_WhichIsBroken(int NumberToFind);
+int FunctionWhichReturnsLocalVariable(void);

data/vendor/unity/examples/src/ProductionCode2.c

@@ -0,0 +1,9 @@
+
+#include "ProductionCode2.h"
+
+char* ThisFunctionHasNotBeenTested(int Poor, char* LittleFunction)
+{
+  //Since There Are No Tests Yet, This Function Could Be Empty For All We Know.
+  // Which isn't terribly useful... but at least we put in a TEST_IGNORE so we won't forget
+  return (char*)0;
+}

data/vendor/unity/examples/src/ProductionCode2.h

@@ -0,0 +1,2 @@
+
+char* ThisFunctionHasNotBeenTested(int Poor, char* LittleFunction);

data/vendor/unity/examples/test/TestProductionCode.c

@@ -0,0 +1,62 @@
+
+#include "ProductionCode.h"
+#include "unity.h"
+
+//sometimes you may want to get at local data in a module.
+//for example: If you plan to pass by reference, this could be useful
+//however, it should often be avoided
+extern int Counter; 
+
+void setUp(void)
+{
+  //This is run before EACH TEST
+  Counter = 0x5a5a;
+}
+
+void tearDown(void)
+{
+}
+
+void test_FindFunction_WhichIsBroken_ShouldReturnZeroIfItemIsNotInList_WhichWorksEvenInOurBrokenCode(void)
+{
+  //All of these should pass
+  TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(78));
+  TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(1));
+  TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(33));
+  TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(999));
+  TEST_ASSERT_EQUAL(0, FindFunction_WhichIsBroken(-1));
+}
+
+void test_FindFunction_WhichIsBroken_ShouldReturnTheIndexForItemsInList_WhichWillFailBecauseOurFunctionUnderTestIsBroken(void)
+{
+  // You should see this line fail in your test summary
+  TEST_ASSERT_EQUAL(1, FindFunction_WhichIsBroken(34));
+  
+  // Notice the rest of these didn't get a chance to run because the line above failed.  
+  // Unit tests abort each test function on the first sign of trouble. 
+  // Then NEXT test function runs as normal.
+  TEST_ASSERT_EQUAL(8, FindFunction_WhichIsBroken(8888));
+}
+
+void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValue(void)
+{
+    //This should be true because setUp set this up for us before this test
+    TEST_ASSERT_EQUAL_HEX(0x5a5a, FunctionWhichReturnsLocalVariable());
+    
+    //This should be true because we can still change our answer
+    Counter = 0x1234;
+    TEST_ASSERT_EQUAL_HEX(0x1234, FunctionWhichReturnsLocalVariable());
+}
+
+void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValueAgain(void)
+{
+    //This should be true again because setup was rerun before this test (and after we changed it to 0x1234)
+    TEST_ASSERT_EQUAL_HEX(0x5a5a, FunctionWhichReturnsLocalVariable());
+}
+
+void test_FunctionWhichReturnsLocalVariable_ShouldReturnCurrentCounter_ButFailsBecauseThisTestIsActuallyFlawed(void)
+{
+    //Sometimes you get the test wrong.  When that happens, you get a failure too... and a quick look should tell
+    // you what actually happened...which in this case was a failure to setup the initial condition.
+    TEST_ASSERT_EQUAL_HEX(0x1234, FunctionWhichReturnsLocalVariable());
+}

data/vendor/unity/examples/test/TestProductionCode2.c

@@ -0,0 +1,31 @@
+
+#include "ProductionCode2.h"
+#include "unity.h"
+
+/* These should be ignored because they are commented out in various ways:
+#include "whatever.h" 
+*/
+//#include "somethingelse.h"
+
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
+void test_IgnoredTest(void)
+{
+    TEST_IGNORE_MESSAGE("This Test Was Ignored On Purpose");
+}
+
+void test_AnotherIgnoredTest(void)
+{
+    TEST_IGNORE_MESSAGE("These Can Be Useful For Leaving Yourself Notes On What You Need To Do Yet");
+}
+
+void test_ThisFunctionHasNotBeenTested_NeedsToBeImplemented(void)
+{
+    TEST_IGNORE(); //Like This
+}

data/vendor/unity/examples/test/no_ruby/TestProductionCode2_Runner.c

@@ -0,0 +1,46 @@
+/* AUTOGENERATED FILE. DO NOT EDIT. */
+#include "unity.h"
+#include <setjmp.h>
+#include <stdio.h>
+
+char MessageBuffer[50];
+
+extern void setUp(void);
+extern void tearDown(void);
+
+extern void test_IgnoredTest(void);
+extern void test_AnotherIgnoredTest(void);
+extern void test_ThisFunctionHasNotBeenTested_NeedsToBeImplemented(void);
+
+static void runTest(UnityTestFunction test)
+{
+  if (TEST_PROTECT())
+  {
+      setUp();
+      test();
+  }
+  if (TEST_PROTECT() && !TEST_IS_IGNORED)
+  {
+    tearDown();
+  }
+}
+void resetTest()
+{
+  tearDown();
+  setUp();
+}
+
+
+int main(void)
+{
+  Unity.TestFile = "test/TestProductionCode2.c";
+  UnityBegin();
+
+  // RUN_TEST calls runTest
+  RUN_TEST(test_IgnoredTest, 13);
+  RUN_TEST(test_AnotherIgnoredTest, 18);
+  RUN_TEST(test_ThisFunctionHasNotBeenTested_NeedsToBeImplemented, 23);
+
+  UnityEnd();
+  return 0;
+}

data/vendor/unity/examples/test/no_ruby/TestProductionCode_Runner.c

@@ -0,0 +1,50 @@
+/* AUTOGENERATED FILE. DO NOT EDIT. */
+#include "unity.h"
+#include <setjmp.h>
+#include <stdio.h>
+
+char MessageBuffer[50];
+
+extern void setUp(void);
+extern void tearDown(void);
+
+extern void test_FindFunction_WhichIsBroken_ShouldReturnZeroIfItemIsNotInList_WhichWorksEvenInOurBrokenCode(void);
+extern void test_FindFunction_WhichIsBroken_ShouldReturnTheIndexForItemsInList_WhichWillFailBecauseOurFunctionUnderTestIsBroken(void);
+extern void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValue(void);
+extern void test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValueAgain(void);
+extern void test_FunctionWhichReturnsLocalVariable_ShouldReturnCurrentCounter_ButFailsBecauseThisTestIsActuallyFlawed(void);
+
+static void runTest(UnityTestFunction test)
+{
+  if (TEST_PROTECT())
+  {
+      setUp();
+      test();
+  }
+  if (TEST_PROTECT() && !TEST_IS_IGNORED)
+  {
+    tearDown();
+  }
+}
+void resetTest()
+{
+  tearDown();
+  setUp();
+}
+
+
+int main(void)
+{
+  Unity.TestFile = "test/TestProductionCode.c";
+  UnityBegin();
+
+  // RUN_TEST calls runTest
+  RUN_TEST(test_FindFunction_WhichIsBroken_ShouldReturnZeroIfItemIsNotInList_WhichWorksEvenInOurBrokenCode, 20);
+  RUN_TEST(test_FindFunction_WhichIsBroken_ShouldReturnTheIndexForItemsInList_WhichWillFailBecauseOurFunctionUnderTestIsBroken, 30);
+  RUN_TEST(test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValue, 41);
+  RUN_TEST(test_FunctionWhichReturnsLocalVariable_ShouldReturnTheCurrentCounterValueAgain, 51);
+  RUN_TEST(test_FunctionWhichReturnsLocalVariable_ShouldReturnCurrentCounter_ButFailsBecauseThisTestIsActuallyFlawed, 57);
+
+  UnityEnd();
+  return 0;
+}

data/vendor/unity/extras/fixture/build/MakefileWorker.mk

@@ -0,0 +1,331 @@
+#---------
+#
+# MakefileWorker.mk
+#
+# Include this helper file in your makefile
+# It makes
+#    A static library holding the application objs
+#    A test executable
+#
+# See this example for parameter settings 
+#    examples/Makefile
+#
+#----------
+# Inputs - these variables describe what to build
+#
+#   INCLUDE_DIRS - Directories used to search for include files.
+#                   This generates a -I for each directory
+#	SRC_DIRS - Directories containing source file to built into the library
+#   SRC_FILES - Specific source files to build into library. Helpful when not all code 
+#				in a directory can be built for test (hopefully a temporary situation)
+#	TEST_SRC_DIRS - Directories containing unit test code build into the unit test runner
+#				These do not go in a library. They are explicitly included in the test runner
+#	MOCKS_SRC_DIRS - Directories containing mock source files to build into the test runner
+#				These do not go in a library. They are explicitly included in the test runner
+#----------
+# You can adjust these variables to influence how to build the test target
+# and where to put and name outputs
+# See below to determine defaults
+#   COMPONENT_NAME - the name of the thing being built
+#   UNITY_HOME - where Unity home dir found
+#   UNITY_BUILD_HOME - place for scripts
+#   UNITY_OBJS_DIR - a directory where o and d files go
+#   UNITY_LIB_DIR - a directory where libs go
+#   UNITY_ENABLE_DEBUG - build for debug
+#   UNITY_USE_MEM_LEAK_DETECTION - Links with overridden new and delete
+#   UNITY_USE_STD_CPP_LIB - Set to N to keep the standard C++ library out
+#		of the test harness
+#   UNITY_USE_GCOV - Turn on coverage analysis
+#		Clean then build with this flag set to Y, then 'make gcov'
+#	UNITY_TEST_RUNNER_FLAGS
+#		None by default
+#   UNITY_MAPFILE - generate a map file
+#   UNITY_WARNINGFLAGS - overly picky by default
+#	OTHER_MAKEFILE_TO_INCLUDE - a hook to use this makefile to make 
+#		other targets. Like CSlim, which is part of fitnesse
+#----------
+#
+#  Other flags users can initialize to sneak in their settings
+#	UNITY_CFLAGS - C complier
+#	UNITY_LDFLAGS - Linker flags
+#----------
+
+
+ifndef COMPONENT_NAME
+    COMPONENT_NAME = name_this_in_the_makefile
+endif
+
+# Debug on by default
+ifndef UNITY_ENABLE_DEBUG
+	UNITY_ENABLE_DEBUG = Y
+endif
+
+# new and delete for memory leak detection on by default
+ifndef UNITY_USE_MEM_LEAK_DETECTION
+	UNITY_USE_MEM_LEAK_DETECTION = Y
+endif
+
+# Use gcov, off by default
+ifndef UNITY_USE_GCOV
+	UNITY_USE_GCOV = N
+endif
+
+# Default warnings
+ifndef UNITY_WARNINGFLAGS
+	UNITY_WARNINGFLAGS = -Wall -Werror -Wshadow -Wswitch-default 
+endif
+
+# Default dir for temporary files (d, o)
+ifndef UNITY_OBJS_DIR
+    UNITY_OBJS_DIR = objs
+endif
+
+# Default dir for the outout library
+ifndef UNITY_LIB_DIR
+    UNITY_LIB_DIR = lib
+endif
+
+# No map by default
+ifndef UNITY_MAP_FILE
+	UNITY_MAP_FILE = N
+endif
+
+#Not verbose by deafult
+ifdef VERBOSE
+	UNITY_TEST_RUNNER_FLAGS += -v
+endif
+
+ifdef GROUP
+	UNITY_TEST_RUNNER_FLAGS += -g $(GROUP)
+endif
+
+ifdef NAME
+	UNITY_TEST_RUNNER_FLAGS += -n $(NAME)
+endif
+
+ifdef REPEAT
+	UNITY_TEST_RUNNER_FLAGS += -r $(REPEAT)
+endif
+
+
+# --------------------------------------
+# derived flags in the following area
+# --------------------------------------
+ifeq ($(UNITY_USE_MEM_LEAK_DETECTION), N)
+	UNITY_CFLAGS += -DUNITY_MEM_LEAK_DETECTION_DISABLED
+else
+	UNITY_MEMLEAK_DETECTOR_MALLOC_MACRO_FILE = -include $(UNITY_HOME)/extras/fixture/src/unity_fixture_malloc_overrides.h
+endif
+
+ifeq ($(UNITY_ENABLE_DEBUG), Y)
+	UNITY_CFLAGS += -g
+endif
+
+ifeq ($(UNITY_USE_GCOV), Y)
+	UNITY_CFLAGS += -fprofile-arcs -ftest-coverage
+endif
+
+UNITY_CFLAGS += $(UNITY_MEMLEAK_DETECTOR_MALLOC_MACRO_FILE)
+
+TARGET_MAP = $(COMPONENT_NAME).map.txt
+ifeq ($(UNITY_MAP_FILE), Y)
+	UNITY_LDFLAGS += -Wl,-map,$(TARGET_MAP)
+endif
+
+LD_LIBRARIES += -lgcov
+
+TARGET_LIB = \
+    $(UNITY_LIB_DIR)/lib$(COMPONENT_NAME).a
+    
+TEST_TARGET = \
+    $(COMPONENT_NAME)_tests
+
+#Helper Functions
+get_src_from_dir  = $(wildcard $1/*.cpp) $(wildcard $1/*.c)
+get_dirs_from_dirspec  = $(wildcard $1)
+get_src_from_dir_list = $(foreach dir, $1, $(call get_src_from_dir,$(dir)))
+__src_to = $(subst .c,$1, $(subst .cpp,$1,$2))
+src_to = $(addprefix $(UNITY_OBJS_DIR)/,$(call __src_to,$1,$2))
+src_to_o = $(call src_to,.o,$1)
+src_to_d = $(call src_to,.d,$1)
+src_to_gcda = $(call src_to,.gcda,$1)
+src_to_gcno = $(call src_to,.gcno,$1)
+make_dotdot_a_subdir = $(subst ..,_dot_dot, $1)
+time = $(shell date +%s)
+delta_t = $(eval minus, $1, $2)
+debug_print_list = $(foreach word,$1,echo "  $(word)";) echo;
+
+#Derived
+STUFF_TO_CLEAN += $(TEST_TARGET) $(TEST_TARGET).exe $(TARGET_LIB) $(TARGET_MAP)
+
+SRC += $(call get_src_from_dir_list, $(SRC_DIRS)) $(SRC_FILES)			        
+OBJ = $(call src_to_o,$(SRC))
+OBJ2 = $(call make_dotdot_a_subdir. $(OBJ))
+
+STUFF_TO_CLEAN += $(OBJ)
+
+TEST_SRC = $(call get_src_from_dir_list, $(TEST_SRC_DIRS))
+TEST_OBJS = $(call src_to_o,$(TEST_SRC))
+STUFF_TO_CLEAN += $(TEST_OBJS)
+
+
+MOCKS_SRC = $(call get_src_from_dir_list, $(MOCKS_SRC_DIRS))
+MOCKS_OBJS = $(call src_to_o,$(MOCKS_SRC))
+STUFF_TO_CLEAN += $(MOCKS_OBJS)
+
+ALL_SRC = $(SRC) $(TEST_SRC) $(MOCKS_SRC)
+
+#Test coverage with gcov
+GCOV_OUTPUT = gcov_output.txt
+GCOV_REPORT = gcov_report.txt
+GCOV_ERROR = gcov_error.txt
+GCOV_GCDA_FILES = $(call src_to_gcda, $(ALL_SRC))
+GCOV_GCNO_FILES = $(call src_to_gcno, $(ALL_SRC))
+TEST_OUTPUT = $(TEST_TARGET).txt
+STUFF_TO_CLEAN += \
+	$(GCOV_OUTPUT)\
+	$(GCOV_REPORT)\
+	$(GCOV_REPORT).html\
+	$(GCOV_ERROR)\
+	$(GCOV_GCDA_FILES)\
+	$(GCOV_GCNO_FILES)\
+	$(TEST_OUTPUT)
+
+
+#The gcda files for gcov need to be deleted before each run
+#To avoid annoying messages.
+GCOV_CLEAN = $(SILENCE)rm -f $(GCOV_GCDA_FILES) $(GCOV_OUTPUT) $(GCOV_REPORT) $(GCOV_ERROR)
+RUN_TEST_TARGET = $(SILENCE)  $(GCOV_CLEAN) ; echo "Running $(TEST_TARGET)"; ./$(TEST_TARGET) $(UNITY_TEST_RUNNER_FLAGS)
+
+INCLUDES_DIRS_EXPANDED = $(call get_dirs_from_dirspec, $(INCLUDE_DIRS))
+INCLUDES += $(foreach dir, $(INCLUDES_DIRS_EXPANDED), -I$(dir))
+MOCK_DIRS_EXPANDED = $(call get_dirs_from_dirspec, $(MOCKS_SRC_DIRS))
+INCLUDES += $(foreach dir, $(MOCK_DIRS_EXPANDED), -I$(dir))
+
+
+DEP_FILES = $(call src_to_d, $(ALL_SRC))
+STUFF_TO_CLEAN += $(DEP_FILES) $(PRODUCTION_CODE_START) $(PRODUCTION_CODE_END)
+STUFF_TO_CLEAN += $(STDLIB_CODE_START) $(MAP_FILE) cpputest_*.xml junit_run_output
+
+# We'll use the UNITY_CFLAGS etc so that you can override AND add to the CppUTest flags
+CFLAGS = $(UNITY_CFLAGS) $(UNITY_ADDITIONAL_CFLAGS) $(INCLUDES) $(UNITY_WARNINGFLAGS)
+LDFLAGS = $(UNITY_LDFLAGS) $(UNITY_ADDITIONAL_LDFLAGS)
+
+# Targets
+
+.PHONY: all
+all: start $(TEST_TARGET)  
+	$(RUN_TEST_TARGET)	
+
+.PHONY: start
+start: $(TEST_TARGET) 
+	$(SILENCE)START_TIME=$(call time)
+
+.PHONY: all_no_tests
+all_no_tests: $(TEST_TARGET)
+
+.PHONY: flags
+flags: 
+	@echo
+	@echo "Compile C source with CFLAGS:"
+	@$(call debug_print_list,$(CFLAGS))
+	@echo "Link with LDFLAGS:"
+	@$(call debug_print_list,$(LDFLAGS))
+	@echo "Link with LD_LIBRARIES:"
+	@$(call debug_print_list,$(LD_LIBRARIES))
+	@echo "Create libraries with ARFLAGS:"
+	@$(call debug_print_list,$(ARFLAGS))
+	@echo "OBJ files:"
+	@$(call debug_print_list,$(OBJ2))
+	
+	
+$(TEST_TARGET): $(TEST_OBJS) $(MOCKS_OBJS)  $(PRODUCTION_CODE_START) $(TARGET_LIB) $(USER_LIBS) $(PRODUCTION_CODE_END) $(STDLIB_CODE_START) 
+	$(SILENCE)echo Linking $@
+	$(SILENCE)$(LINK.o) -o $@ $^ $(LD_LIBRARIES)
+
+$(TARGET_LIB): $(OBJ)
+	$(SILENCE)echo Building archive $@
+	$(SILENCE)mkdir -p lib
+	$(SILENCE)$(AR) $(ARFLAGS) $@ $^
+	$(SILENCE)ranlib $@
+
+test: $(TEST_TARGET)
+	$(RUN_TEST_TARGET) | tee $(TEST_OUTPUT)
+	
+vtest: $(TEST_TARGET)
+	$(RUN_TEST_TARGET) -v  | tee $(TEST_OUTPUT)
+
+$(UNITY_OBJS_DIR)/%.o: %.cpp
+	@echo compiling $(notdir $<)
+	$(SILENCE)mkdir -p $(dir $@)
+	$(SILENCE)$(COMPILE.cpp) -MMD -MP $(OUTPUT_OPTION) $<
+
+$(UNITY_OBJS_DIR)/%.o: %.c
+	@echo compiling $(notdir $<)
+	$(SILENCE)mkdir -p $(dir $@)
+	$(SILENCE)$(COMPILE.c) -MMD -MP  $(OUTPUT_OPTION) $<
+
+ifneq "$(MAKECMDGOALS)" "clean"
+-include $(DEP_FILES)
+endif
+
+.PHONY: clean
+clean:
+	$(SILENCE)echo Making clean
+	$(SILENCE)$(RM) $(STUFF_TO_CLEAN)
+	$(SILENCE)rm -rf gcov $(UNITY_OBJS_DIR)
+	$(SILENCE)find . -name "*.gcno" | xargs rm -f
+	$(SILENCE)find . -name "*.gcda" | xargs rm -f
+	
+#realclean gets rid of all gcov, o and d files in the directory tree
+#not just the ones made by this makefile
+.PHONY: realclean
+realclean: clean
+	$(SILENCE)rm -rf gcov
+	$(SILENCE)find . -name "*.gdcno" | xargs rm -f
+	$(SILENCE)find . -name "*.[do]" | xargs rm -f	
+
+gcov: test
+	$(SILENCE)for d in $(SRC_DIRS) ; do \
+		gcov --object-directory $(UNITY_OBJS_DIR)/$$d $$d/*.c $$d/*.cpp >> $(GCOV_OUTPUT) 2>>$(GCOV_ERROR) ; \
+	done
+	$(SILENCE)for f in $(SRC_FILES) ; do \
+		gcov --object-directory $(UNITY_OBJS_DIR)/$$f $$f >> $(GCOV_OUTPUT) 2>>$(GCOV_ERROR) ; \
+	done
+	$(UNITY_BUILD_HOME)/filterGcov.sh $(GCOV_OUTPUT) $(GCOV_ERROR) $(GCOV_REPORT) $(TEST_OUTPUT)
+	$(SILENCE)cat $(GCOV_REPORT)
+	$(SILENCE)mkdir -p gcov
+	$(SILENCE)mv *.gcov gcov
+	$(SILENCE)mv gcov_* gcov
+	$(SILENCE)echo "See gcov directory for details"
+ 
+debug:
+	@echo
+	@echo "Target Source files:"
+	@$(call debug_print_list,$(SRC))
+	@echo "Target Object files:"
+	@$(call debug_print_list,$(OBJ))
+	@echo "Test Source files:"
+	@$(call debug_print_list,$(TEST_SRC))
+	@echo "Test Object files:"
+	@$(call debug_print_list,$(TEST_OBJS))
+	@echo "Mock Source files:"
+	@$(call debug_print_list,$(MOCKS_SRC))
+	@echo "Mock Object files:"
+	@$(call debug_print_list,$(MOCKS_OBJS))
+	@echo "All Input Dependency files:"
+	@$(call debug_print_list,$(DEP_FILES))
+	@echo Stuff to clean:
+	@$(call debug_print_list,$(STUFF_TO_CLEAN))
+	@echo Includes:
+	@$(call debug_print_list,$(INCLUDES))
+
+ifneq "$(OTHER_MAKEFILE_TO_INCLUDE)" ""
+-include $(OTHER_MAKEFILE_TO_INCLUDE)
+endif
+
+	
+	
+st,$(TEST_SRC))
+	@echo "Test Object files:"
+	@$(call debug_print