diff --git a/.vscode/c_cpp_properties.json b/.vscode/c_cpp_properties.json new file mode 100644 index 0000000..c11401d --- /dev/null +++ b/.vscode/c_cpp_properties.json @@ -0,0 +1,16 @@ +{ + "configurations": [ + { + "name": "Linux", + "includePath": [ + "${workspaceFolder}/**" + ], + "defines": [], + "compilerPath": "/usr/bin/gcc", + "cStandard": "c17", + "cppStandard": "c++98", + "intelliSenseMode": "linux-gcc-x64" + } + ], + "version": 4 +} \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..355d4a1 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,8 @@ +{ + "C_Cpp.errorSquiggles": "disabled", + "files.associations": { + "testforoperator.h": "c", + "testfornumber.h": "c", + "programmingmode.h": "c" + } +} \ No newline at end of file diff --git a/Unity b/Unity new file mode 160000 index 0000000..134496c --- /dev/null +++ b/Unity @@ -0,0 +1 @@ +Subproject commit 134496c6c0c34b463d58daef1904a12abdc5c8e0 diff --git a/build-project.sh b/build-project.sh old mode 100644 new mode 100755 diff --git a/project.yml b/project.yml index 4801bd7..923b2e8 100644 --- a/project.yml +++ b/project.yml @@ -91,15 +91,15 @@ :system: - m # Example: add 'm' to use the math library :test: - - stdio - - string - - stdlib - - m # Example: add 'm' to use the math library in tests + #- stdio + #- string + #- stdlib + #- m # Example: add 'm' to use the math library in tests :release: - - stdio - - string - - stdlib - - m # Example: add 'm' to use the math library in release builds + #- stdio + #- string + #- stdlib + #- m # Example: add 'm' to use the math library in release builds :plugins: :load_paths: diff --git a/src/main/c/BasicMode.c b/src/main/c/BasicMode.c index d1e4d5c..a8dcc27 100644 --- a/src/main/c/BasicMode.c +++ b/src/main/c/BasicMode.c @@ -3,7 +3,7 @@ #include #include -#include "calculator.h" + void BasicMode() { diff --git a/src/main/c/ConvertMode.c b/src/main/c/ConvertMode.c index 6e985cf..23d808d 100644 --- a/src/main/c/ConvertMode.c +++ b/src/main/c/ConvertMode.c @@ -4,7 +4,6 @@ #include #include -#include "calculator.h" // Unit converter mode int choice, startingUnit, endingUnit; diff --git a/src/main/c/main_calculator.c b/src/main/c/main_calculator.c index 8bfa480..9ba9aa5 100644 --- a/src/main/c/main_calculator.c +++ b/src/main/c/main_calculator.c @@ -3,7 +3,7 @@ #include #include -#include "calculator.h" +#include "main_calculator.h" double add(double a, double b) { @@ -487,7 +487,7 @@ double ConGramToPounds(double weight, int startingUnit, int endingUnit) { switch (endingUnit) { case 0: //pounds to kg - return weight *= 0, 453592; + return weight *= 453.592; break; case 1: //pounds to pounds @@ -510,11 +510,11 @@ double ConTemp(double temp, int startingUnit, int endingUnit) { switch (endingUnit) { case 0: //celsius to fahrenheit - return temp = (temp - 32) * 0, 55555555; + return temp = (temp - 32) * 0,55555555; break; case 1: //celsius to celsius - return temp; + return (temp * 9 / 5) + 32; break; default: @@ -552,7 +552,7 @@ double ConSpeed(double speed, int startingUnit, int endingUnit) { break; case 1: //kmh to mph - return speed * 0.621371; + return speed / 1.60934; break; default: @@ -590,7 +590,7 @@ double ConLiter(double liter, int startingUnit, int endingUnit) { break; case 1: //ml to l - return liter / 1000; + return ( liter / 1000 ); break; default: @@ -628,7 +628,7 @@ double ConLiterToGallon(double fluid, int startingUnit, int endingUnit) { break; case 1: //l to gallon - return fluid * 0.264172; + return fluid / 3.785; break; default: @@ -960,7 +960,7 @@ double ConClock(double time, int startingUnit, int endingUnit) { case 1: //24 to 12 if (time > 12) { - return time -12; + return time - 12; } else { @@ -1003,31 +1003,31 @@ double ConTime(double time, int startingUnit, int endingUnit) { break; case 1: //s - return time / 1000; + return (double) time / 1000; break; case 2: //min - return time / (1000 * 60); + return (double) time / (1000 * 60); break; case 3: //h - return time / (1000 * 60 * 60); + return (double) time / (1000 * 60 * 60); break; case 4: //d - return time / (1000 * 60 * 60 * 24); + return (double) time / (1000 * 60 * 60 * 24); break; case 5: //w - return time / (1000 * 60 * 60 * 24 * 7); + return (double) time / (1000 * 60 * 60 * 24 * 7); break; case 6: //mon - return time / (1000 * 60 * 60 * 24 * 7 * 30); + return time / (1000.0 * 60.0 * 60.0 * 24.0 * 7.0 * 30.0); break; case 7: //y - return time / (1000 * 60 * 60 * 24 * 7 * 30 * 12); + return time / (1000.0 * 60.0 * 60.0 * 24.0 * 7.0 * 30.0 * 12.0); break; default: @@ -1310,27 +1310,6 @@ double ConTime(double time, int startingUnit, int endingUnit) { } -//.. -// graphMode -void graphMode() { - double x, y; - - printf("Enter the range for x (start end step): "); - double x_start, x_end, x_step; - scanf("%lf %lf %lf", &x_start, &x_end, &x_step); - - printf("\nGraph for the function y = sin(x):\n"); - - printf(" x\t| y\n"); - printf("--------------\n"); - - for (x = x_start; x <= x_end; x += x_step) { - y = sin(x); - printf("%.2lf\t| %.2lf\n", x, y); - } -} - - // change mode int mode(int userChoice){ diff --git a/src/main/c/calculator.h b/src/main/c/main_calculator.h similarity index 88% rename from src/main/c/calculator.h rename to src/main/c/main_calculator.h index 0a34ca1..45cb01e 100644 --- a/src/main/c/calculator.h +++ b/src/main/c/main_calculator.h @@ -1,5 +1,5 @@ -#ifndef CALCULATOR -#define CALCULATOR +#ifndef MAIN_CALCULATOR +#define MAIN_CALCULATOR // add function double add(double a, double b); @@ -13,12 +13,6 @@ double multiply(double a, double b); // divide function double divide(double a, double b); -// get input and check if its a number -double testForNumber(); - -// get input and check if its a operator -char testForOperator(); - // Square root function double squareRootFunction(double x); @@ -85,6 +79,5 @@ double ConClock(double time, int startingUnit, int endingUnit); double ConTime(double time, int startingUnit, int endingUnit); -int performOperation(int num1, char operatorType, int num2); -#endif // CALCULATOR +#endif // CALCULATOR \ No newline at end of file diff --git a/src/main/c/programmingMode.c b/src/main/c/programmingMode.c index 48bc867..b96b77c 100644 --- a/src/main/c/programmingMode.c +++ b/src/main/c/programmingMode.c @@ -3,7 +3,7 @@ #include #include -#include "calculator.h" +#include "programmingMode.h" // Function to convert an integer to binary representation diff --git a/src/main/c/programmingMode.h b/src/main/c/programmingMode.h new file mode 100644 index 0000000..4e800e4 --- /dev/null +++ b/src/main/c/programmingMode.h @@ -0,0 +1,8 @@ +#ifndef PROGRAMMINGMODE +#define PROGRAMMINGMODE + +// to test some calculations +int performOperation(int num1, char operatorType, int num2); + + +#endif // PROGRAMMINGMODE \ No newline at end of file diff --git a/src/main/c/scientificMode.c b/src/main/c/scientificMode.c index 8aa73e3..2dd40d8 100644 --- a/src/main/c/scientificMode.c +++ b/src/main/c/scientificMode.c @@ -2,7 +2,6 @@ #include #include -#include "calculator.h" // get the number which has to be calculated double getNumberFromUser() { diff --git a/src/main/c/testForNumber.c b/src/main/c/testForNumber.c index 06654b6..511de91 100644 --- a/src/main/c/testForNumber.c +++ b/src/main/c/testForNumber.c @@ -2,8 +2,9 @@ #include #include #include +#include -#include "calculator.h" +#include "testForNumber.h" double testForNumber() { double num; diff --git a/src/main/c/testForNumber.h b/src/main/c/testForNumber.h new file mode 100644 index 0000000..e1d9a91 --- /dev/null +++ b/src/main/c/testForNumber.h @@ -0,0 +1,7 @@ +#ifndef TESTFORNUMBER +#define TESTFORNUMBER + +// get input and check if its a number +double testForNumber(); + +#endif // TESTFORNUMBER \ No newline at end of file diff --git a/src/main/c/testForOperator.c b/src/main/c/testForOperator.c index d3a7c1f..4c243e0 100644 --- a/src/main/c/testForOperator.c +++ b/src/main/c/testForOperator.c @@ -4,7 +4,7 @@ #include #include -#include "calculator.h" +#include "testForOperator.h" char testForOperator() { //saving the number of operators in a variable so it only needs to be changed in one location @@ -16,7 +16,7 @@ char testForOperator() { //Loops as long as input isn't valid, enters at least one time while (!validInput) { - scanf_s("%c\n", &input); + scanf("%c\n", &input); //checks every position of the array if a position is equal to input returns the input, which also stopps the function for (int i = 0; i <= numberOfOperators; i++) { if (input == oppArray[i]) { diff --git a/src/main/c/testForOperator.h b/src/main/c/testForOperator.h new file mode 100644 index 0000000..34a8467 --- /dev/null +++ b/src/main/c/testForOperator.h @@ -0,0 +1,7 @@ +#ifndef TESTFOROPERATOR +#define TESTFOROPERATOR + +// get input and check if its a operator +char testForOperator(); + +#endif // TESTFOROPERATOR \ No newline at end of file diff --git a/src/test/c/test_calculator.c b/src/test/c/test_calculator.c index b3f261c..dde64f2 100644 --- a/src/test/c/test_calculator.c +++ b/src/test/c/test_calculator.c @@ -1,8 +1,9 @@ -#ifdef TEST - #include "unity.h" -#include "calculator.h" +#include "main_calculator.h" +#include "testForOperator.h" +#include "testForNumber.h" +#include "programmingMode.h" void setUp(void) { @@ -41,25 +42,25 @@ void test_divide(void) void test_ConMeter(void) {//5 mm to cm double result = ConMeter(5, 0, 1); - TEST_ASSERT_EQUAL(50, result); + TEST_ASSERT_EQUAL(0.5, result); } void test_ConMeterToFoot(void) {//5 m to foot - double result = ConMeterToFoot(5, 0, 1); + double result = ConMeterToFoot(5, 1, 0); TEST_ASSERT_EQUAL(16.4042, result); } void test_ConKilometerToMiles(void) {//5 miles to km double result = ConKilometerToMiles(5, 0, 1); - TEST_ASSERT_EQUAL(3.10686, result); + TEST_ASSERT_EQUAL(8.04672, result); } void test_ConGram(void) {//5 mg to g double result = ConGram(5, 0, 1); - TEST_ASSERT_EQUAL(5000, result); + TEST_ASSERT_EQUAL(0.005, result); } void test_ConGramToPounds(void) {//5 kg to pounds - double result = ConGramToPounds(5, 0, 1); + double result = ConGramToPounds(5, 0, 0); TEST_ASSERT_EQUAL(11.0231, result); } @@ -69,17 +70,17 @@ void test_ConTemp(void) {//5 celsius to fahrenheit } void test_ConSpeed(void) {//5 kmh to mph - double result = ConTemp(5, 0, 1); + double result = ConSpeed(5, 0, 1); TEST_ASSERT_EQUAL(3.10686, result); } void test_ConLiter(void) {//5 l to ml - double result = ConTemp(5, 1, 0); + double result = ConLiter(5, 1, 0); TEST_ASSERT_EQUAL(5000, result); } void test_ConLiterToGallon(void) {//5 l to gallon - double result = ConTemp(5, 0, 1); + double result = ConLiterToGallon(5, 0, 1); TEST_ASSERT_EQUAL(1.32086, result); } @@ -90,22 +91,22 @@ void test_ConData(void) {//5 b to kb void test_ConArea(void) {//5 mm to cm double result = ConData(5, 0, 1); - TEST_ASSERT_EQUAL(0.05), result); + TEST_ASSERT_EQUAL(0.05, result); } void test_ConVolume(void) {//5 mm to cm double result = ConData(5, 0, 1); - TEST_ASSERT_EQUAL(0.005), result); + TEST_ASSERT_EQUAL(0.005, result); } void test_ConClock(void) {//5:00 to 5AM - double result = ConData(5, 0, 1); - TEST_ASSERT_EQUAL(5), result); + double result = ConClock(5, 0, 1); + TEST_ASSERT_EQUAL(5, result); } void test_ConTime(void) {//5 ms to s double result = ConData(5, 0, 1); - TEST_ASSERT_EQUAL(0.005), result); + TEST_ASSERT_EQUAL(0.005, result); } @@ -191,5 +192,3 @@ void test_performOperation_Division(void) { // Assert TEST_ASSERT_EQUAL_INT(4, result); } - -#endif // TEST diff --git a/target/test/cache/defines_dependency.yml b/target/test/cache/defines_dependency.yml new file mode 100644 index 0000000..7c38508 --- /dev/null +++ b/target/test/cache/defines_dependency.yml @@ -0,0 +1,9 @@ +--- +src/main/c/main_calculator.c: +- TEST +src/main/c/testForOperator.c: +- TEST +src/main/c/testForNumber.c: +- TEST +src/main/c/programmingMode.c: +- TEST diff --git a/target/test/cache/input.yml b/target/test/cache/input.yml new file mode 100644 index 0000000..5d1078e --- /dev/null +++ b/target/test/cache/input.yml @@ -0,0 +1,243 @@ +--- +:project: + :use_exceptions: false + :use_mocks: true + :compile_threads: 1 + :test_threads: 1 + :use_test_preprocessor: true + :use_preprocessor_directives: false + :use_deep_dependencies: false + :generate_deep_dependencies: true + :auto_link_deep_dependencies: false + :test_file_prefix: test_ + :options_paths: [] + :release_build: false + :use_auxiliary_dependencies: true + :build_root: target + :which_ceedling: gem + :ceedling_version: 0.31.1 + :default_tasks: + - test:all +:release_build: + :use_assembly: false + :artifacts: [] +:paths: + :test: + - "+:src/test/c/**" + - "-:src/test/c/support" + :source: + - "+:src/main/c/**" + :support: + - src/test/c/support + :include: [] + :libraries: [] + :test_toolchain_include: [] + :release_toolchain_include: [] +:files: + :test: [] + :source: [] + :assembly: [] + :support: [] + :include: [] +:environment: +- :rake_columns: '120' +:defines: + :test: + - &1 [] + - TEST + :test_preprocess: + - *1 + - TEST + :release: [] + :release_preprocess: [] + :use_test_definition: false + :common: [] +:libraries: + :flag: "-l${1}" + :path_flag: "-L ${1}" + :test: [] + :test_preprocess: [] + :release: [] + :release_preprocess: [] + :placement: :end + :system: + - m +:flags: {} +:extension: + :header: ".h" + :source: ".c" + :assembly: ".s" + :object: ".o" + :libraries: + - ".a" + - ".so" + :executable: ".out" + :map: ".map" + :list: ".lst" + :testpass: ".pass" + :testfail: ".fail" + :dependencies: ".d" +:unity: + :vendor_path: "/var/lib/gems/3.0.0/gems/ceedling-0.31.1/vendor" + :defines: [] +:cmock: + :vendor_path: "/var/lib/gems/3.0.0/gems/ceedling-0.31.1/vendor" + :defines: [] + :includes: [] + :mock_prefix: mock_ + :when_no_prototypes: :warn + :enforce_strict_ordering: true + :plugins: + - :ignore + - :callback + :treat_as: + uint8: HEX8 + uint16: HEX16 + uint32: UINT32 + int8: INT8 + bool: UINT8 + :mock_path: target/test/mocks + :verbosity: 3 + :unity_helper: false +:cexception: + :vendor_path: "/var/lib/gems/3.0.0/gems/ceedling-0.31.1/vendor" + :defines: [] +:test_runner: + :includes: [] + :file_suffix: _runner +:tools: + :test_compiler: + :executable: gcc + :name: default_test_compiler + :stderr_redirect: :none + :background_exec: :none + :optional: false + :arguments: + - '' + - '' + - -I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR + - -I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE + - "-D$": COLLECTION_DEFINES_TEST_AND_VENDOR + - "-DGNU_COMPILER" + - "-g" + - '' + - -c "${1}" + - -o "${2}" + - "-MMD" + - -MF "${4}" + :test_fixture: + :executable: "${1}" + :name: default_test_fixture + :stderr_redirect: :auto + :background_exec: :none + :optional: false + :arguments: [] + :test_linker: + :executable: gcc + :name: default_test_linker + :stderr_redirect: :none + :background_exec: :none + :optional: false + :arguments: + - '' + - '' + - '' + - '"${1}"' + - "${5}" + - -o "${2}" + - '' + - "${4}" + - '' + :test_file_preprocessor: + :executable: gcc + :name: default_test_file_preprocessor + :stderr_redirect: :none + :background_exec: :none + :optional: false + :arguments: + - '' + - '' + - "-E" + - -I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR + - -I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE + - "-D$": COLLECTION_DEFINES_TEST_AND_VENDOR + - "-D$": DEFINES_TEST_PREPROCESS + - "-DGNU_COMPILER" + - '"${1}"' + - -o "${2}" + :test_file_preprocessor_directives: + :executable: gcc + :name: default_test_file_preprocessor_directives + :stderr_redirect: :none + :background_exec: :none + :optional: false + :arguments: + - "-E" + - -I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR + - -I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE + - "-D$": COLLECTION_DEFINES_TEST_AND_VENDOR + - "-D$": DEFINES_TEST_PREPROCESS + - "-DGNU_COMPILER" + - "-fdirectives-only" + - '"${1}"' + - -o "${2}" + :test_includes_preprocessor: + :executable: gcc + :name: default_test_includes_preprocessor + :stderr_redirect: :none + :background_exec: :none + :optional: false + :arguments: + - '' + - '' + - "-E" + - "-MM" + - "-MG" + - -I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR + - -I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE + - "-D$": COLLECTION_DEFINES_TEST_AND_VENDOR + - "-D$": DEFINES_TEST_PREPROCESS + - "-DGNU_COMPILER" + - '"${1}"' +:test_compiler: + :arguments: [] +:test_linker: + :arguments: [] +:test_fixture: + :arguments: [] + :link_objects: [] +:test_includes_preprocessor: + :arguments: [] +:test_file_preprocessor: + :arguments: [] +:test_file_preprocessor_directives: + :arguments: [] +:test_dependencies_generator: + :arguments: [] +:release_compiler: + :arguments: [] +:release_linker: + :arguments: [] +:release_assembler: + :arguments: [] +:release_dependencies_generator: + :arguments: [] +:plugins: + :load_paths: + - "/var/lib/gems/3.0.0/gems/ceedling-0.31.1/lib/../plugins" + :enabled: + - stdout_pretty_tests_report + - module_generator + :display_raw_test_results: false + :stdout_pretty_tests_report_path: "/var/lib/gems/3.0.0/gems/ceedling-0.31.1/lib/../plugins/stdout_pretty_tests_report" + :module_generator_path: "/var/lib/gems/3.0.0/gems/ceedling-0.31.1/lib/../plugins/module_generator" +:gcov: + :reports: + - HtmlDetailed + :gcovr: + :html_medium_threshold: 75 + :html_high_threshold: 90 +:module_generator: + :project_root: "./" + :source_root: src/ + :test_root: test/ diff --git a/target/test/cache/test_calculator.c b/target/test/cache/test_calculator.c new file mode 100644 index 0000000..b5bac52 --- /dev/null +++ b/target/test/cache/test_calculator.c @@ -0,0 +1,502 @@ +#include "src/main/c/programmingMode.h" +#include "src/main/c/testForNumber.h" +#include "src/main/c/testForOperator.h" +#include "src/main/c/main_calculator.h" +#include "/var/lib/gems/3.0.0/gems/ceedling-0.31.1/vendor/unity/src/unity.h" + + + + +void setUp(void) + +{ + +} + + + +void tearDown(void) + +{ + +} + + + +void test_addition(void) + +{ + + double result = add(1, 2); + + UnityAssertEqualNumber((UNITY_INT)((3)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(19), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_minus(void) + +{ + + double result = minus(3, 1); + + UnityAssertEqualNumber((UNITY_INT)((2)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(25), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_multiply(void) + +{ + + double result = multiply(1, 2); + + UnityAssertEqualNumber((UNITY_INT)((2)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(31), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_divide(void) + +{ + + double result = divide(4, 2); + + UnityAssertEqualNumber((UNITY_INT)((2)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(37), UNITY_DISPLAY_STYLE_INT); + + + + double result1 = divide(4, 0); + + UnityAssertEqualNumber((UNITY_INT)((0)), (UNITY_INT)((result1)), ( + + ((void *)0) + + ), (UNITY_UINT)(40), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_ConMeter(void) { + + double result = ConMeter(5, 0, 1); + + UnityAssertEqualNumber((UNITY_INT)((0.5)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(45), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_ConMeterToFoot(void) { + + double result = ConMeterToFoot(5, 1, 0); + + UnityAssertEqualNumber((UNITY_INT)((16.4042)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(50), UNITY_DISPLAY_STYLE_INT); + +} + +void test_ConKilometerToMiles(void) { + + double result = ConKilometerToMiles(5, 0, 1); + + UnityAssertEqualNumber((UNITY_INT)((8.04672)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(54), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_ConGram(void) { + + double result = ConGram(5, 0, 1); + + UnityAssertEqualNumber((UNITY_INT)((0.005)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(59), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_ConGramToPounds(void) { + + double result = ConGramToPounds(5, 0, 0); + + UnityAssertEqualNumber((UNITY_INT)((11.0231)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(64), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_ConTemp(void) { + + double result = ConTemp(5, 0, 1); + + UnityAssertEqualNumber((UNITY_INT)((41)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(69), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_ConSpeed(void) { + + double result = ConSpeed(5, 0, 1); + + UnityAssertEqualNumber((UNITY_INT)((3.10686)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(74), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_ConLiter(void) { + + double result = ConLiter(5, 1, 0); + + UnityAssertEqualNumber((UNITY_INT)((5000)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(79), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_ConLiterToGallon(void) { + + double result = ConLiterToGallon(5, 0, 1); + + UnityAssertEqualNumber((UNITY_INT)((1.32086)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(84), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_ConData(void) { + + double result = ConData(5, 0, 1); + + UnityAssertEqualNumber((UNITY_INT)((0.005)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(89), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_ConArea(void) { + + double result = ConData(5, 0, 1); + + UnityAssertEqualNumber((UNITY_INT)((0.05)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(94), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_ConVolume(void) { + + double result = ConData(5, 0, 1); + + UnityAssertEqualNumber((UNITY_INT)((0.005)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(99), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_ConClock(void) { + + double result = ConClock(5, 0, 1); + + UnityAssertEqualNumber((UNITY_INT)((5)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(104), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_ConTime(void) { + + double result = ConData(5, 0, 1); + + UnityAssertEqualNumber((UNITY_INT)((0.005)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(109), UNITY_DISPLAY_STYLE_INT); + +} + + + + + + + +void test_squareRootFunction(void) { + + UnityAssertFloatsWithin((UNITY_FLOAT)((UNITY_FLOAT)((2.0)) * (UNITY_FLOAT)(0.00001f)), (UNITY_FLOAT)((UNITY_FLOAT)((2.0))), (UNITY_FLOAT)((UNITY_FLOAT)((squareRootFunction(4.0)))), (( + + ((void *)0) + + )), (UNITY_UINT)((UNITY_UINT)(115))); + +} + + + + + +void test_sineFunction(void) { + + + + UnityAssertFloatsWithin((UNITY_FLOAT)((UNITY_FLOAT)((0.0)) * (UNITY_FLOAT)(0.00001f)), (UNITY_FLOAT)((UNITY_FLOAT)((0.0))), (UNITY_FLOAT)((UNITY_FLOAT)((sineFunction(0.0)))), (( + + ((void *)0) + + )), (UNITY_UINT)((UNITY_UINT)(121))); + +} + + + + + +void test_cosineFunction(void) { + + + + UnityAssertFloatsWithin((UNITY_FLOAT)((UNITY_FLOAT)((1.0)) * (UNITY_FLOAT)(0.00001f)), (UNITY_FLOAT)((UNITY_FLOAT)((1.0))), (UNITY_FLOAT)((UNITY_FLOAT)((cosineFunction(0.0)))), (( + + ((void *)0) + + )), (UNITY_UINT)((UNITY_UINT)(127))); + +} + + + + + +void test_tangentFunction(void) { + + + + UnityAssertFloatsWithin((UNITY_FLOAT)((UNITY_FLOAT)((0.0)) * (UNITY_FLOAT)(0.00001f)), (UNITY_FLOAT)((UNITY_FLOAT)((0.0))), (UNITY_FLOAT)((UNITY_FLOAT)((tangentFunction(0.0)))), (( + + ((void *)0) + + )), (UNITY_UINT)((UNITY_UINT)(133))); + +} + + + + + +void test_logarithmFunction(void) { + + + + UnityAssertFloatsWithin((UNITY_FLOAT)((UNITY_FLOAT)((1.0)) * (UNITY_FLOAT)(0.00001f)), (UNITY_FLOAT)((UNITY_FLOAT)((1.0))), (UNITY_FLOAT)((UNITY_FLOAT)((logarithmFunction(10.0)))), (( + + ((void *)0) + + )), (UNITY_UINT)((UNITY_UINT)(139))); + +} + + + + + +void test_naturalLogarithmFunction(void) { + + + + UnityAssertFloatsWithin((UNITY_FLOAT)((UNITY_FLOAT)((0.0)) * (UNITY_FLOAT)(0.00001f)), (UNITY_FLOAT)((UNITY_FLOAT)((0.0))), (UNITY_FLOAT)((UNITY_FLOAT)((naturalLogarithmFunction(1.0)))), (( + + ((void *)0) + + )), (UNITY_UINT)((UNITY_UINT)(145))); + +} + + + + + +void test_logarithmBase2Function(void) { + + + + UnityAssertFloatsWithin((UNITY_FLOAT)((UNITY_FLOAT)((3.0)) * (UNITY_FLOAT)(0.00001f)), (UNITY_FLOAT)((UNITY_FLOAT)((3.0))), (UNITY_FLOAT)((UNITY_FLOAT)((logarithmBase2Function(8.0)))), (( + + ((void *)0) + + )), (UNITY_UINT)((UNITY_UINT)(151))); + +} + + + + + +void test_exponentialFunction(void) { + + + + UnityAssertFloatsWithin((UNITY_FLOAT)((UNITY_FLOAT)((1.0)) * (UNITY_FLOAT)(0.00001f)), (UNITY_FLOAT)((UNITY_FLOAT)((1.0))), (UNITY_FLOAT)((UNITY_FLOAT)((exponentialFunction(0.0)))), (( + + ((void *)0) + + )), (UNITY_UINT)((UNITY_UINT)(157))); + +} + + + + + +void test_performOperation_Subtraction(void) { + + + + int result; + + + + + + result = performOperation(10, '-', 3); + + + + + + UnityAssertEqualNumber((UNITY_INT)((7)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(169), UNITY_DISPLAY_STYLE_INT); + +} + + + + + +void test_performOperation_Multiplication(void) { + + + + int result; + + + + + + result = performOperation(4, '*', 6); + + + + + + UnityAssertEqualNumber((UNITY_INT)((24)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(181), UNITY_DISPLAY_STYLE_INT); + +} + + + + + +void test_performOperation_Division(void) { + + + + int result; + + + + + + result = performOperation(8, '/', 2); + + + + + + UnityAssertEqualNumber((UNITY_INT)((4)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(193), UNITY_DISPLAY_STYLE_INT); + +} diff --git a/target/test/dependencies/cmock.d b/target/test/dependencies/cmock.d new file mode 100644 index 0000000..6992af8 --- /dev/null +++ b/target/test/dependencies/cmock.d @@ -0,0 +1,6 @@ +target/test/out/c/cmock.o: \ + /var/lib/gems/3.0.0/gems/ceedling-0.31.1/vendor/cmock/src/cmock.c \ + /var/lib/gems/3.0.0/gems/ceedling-0.31.1/vendor/cmock/src/cmock.h \ + /var/lib/gems/3.0.0/gems/ceedling-0.31.1/vendor/cmock/src/cmock_internals.h \ + /var/lib/gems/3.0.0/gems/ceedling-0.31.1/vendor/unity/src/unity.h \ + /var/lib/gems/3.0.0/gems/ceedling-0.31.1/vendor/unity/src/unity_internals.h diff --git a/target/test/dependencies/force_build b/target/test/dependencies/force_build new file mode 100644 index 0000000..e69de29 diff --git a/target/test/dependencies/main_calculator.d b/target/test/dependencies/main_calculator.d new file mode 100644 index 0000000..13621c0 --- /dev/null +++ b/target/test/dependencies/main_calculator.d @@ -0,0 +1,2 @@ +target/test/out/c/main_calculator.o: src/main/c/main_calculator.c \ + src/main/c/main_calculator.h diff --git a/target/test/dependencies/programmingMode.d b/target/test/dependencies/programmingMode.d new file mode 100644 index 0000000..057dedb --- /dev/null +++ b/target/test/dependencies/programmingMode.d @@ -0,0 +1,2 @@ +target/test/out/c/programmingMode.o: src/main/c/programmingMode.c \ + src/main/c/programmingMode.h diff --git a/target/test/dependencies/testForNumber.d b/target/test/dependencies/testForNumber.d new file mode 100644 index 0000000..9ae49d2 --- /dev/null +++ b/target/test/dependencies/testForNumber.d @@ -0,0 +1,2 @@ +target/test/out/c/testForNumber.o: src/main/c/testForNumber.c \ + src/main/c/testForNumber.h diff --git a/target/test/dependencies/testForOperator.d b/target/test/dependencies/testForOperator.d new file mode 100644 index 0000000..e2b19f7 --- /dev/null +++ b/target/test/dependencies/testForOperator.d @@ -0,0 +1,2 @@ +target/test/out/c/testForOperator.o: src/main/c/testForOperator.c \ + src/main/c/testForOperator.h diff --git a/target/test/dependencies/test_calculator.d b/target/test/dependencies/test_calculator.d new file mode 100644 index 0000000..1d59c61 --- /dev/null +++ b/target/test/dependencies/test_calculator.d @@ -0,0 +1,5 @@ +target/test/out/c/test_calculator.o: src/test/c/test_calculator.c \ + /var/lib/gems/3.0.0/gems/ceedling-0.31.1/vendor/unity/src/unity.h \ + /var/lib/gems/3.0.0/gems/ceedling-0.31.1/vendor/unity/src/unity_internals.h \ + src/main/c/main_calculator.h src/main/c/testForOperator.h \ + src/main/c/testForNumber.h src/main/c/programmingMode.h diff --git a/target/test/dependencies/test_calculator_runner.d b/target/test/dependencies/test_calculator_runner.d new file mode 100644 index 0000000..4972796 --- /dev/null +++ b/target/test/dependencies/test_calculator_runner.d @@ -0,0 +1,4 @@ +target/test/out/c/test_calculator_runner.o: \ + target/test/runners/test_calculator_runner.c \ + /var/lib/gems/3.0.0/gems/ceedling-0.31.1/vendor/unity/src/unity.h \ + /var/lib/gems/3.0.0/gems/ceedling-0.31.1/vendor/unity/src/unity_internals.h diff --git a/target/test/dependencies/unity.d b/target/test/dependencies/unity.d new file mode 100644 index 0000000..ed190f0 --- /dev/null +++ b/target/test/dependencies/unity.d @@ -0,0 +1,4 @@ +target/test/out/c/unity.o: \ + /var/lib/gems/3.0.0/gems/ceedling-0.31.1/vendor/unity/src/unity.c \ + /var/lib/gems/3.0.0/gems/ceedling-0.31.1/vendor/unity/src/unity.h \ + /var/lib/gems/3.0.0/gems/ceedling-0.31.1/vendor/unity/src/unity_internals.h diff --git a/target/test/out/c/cmock.o b/target/test/out/c/cmock.o new file mode 100644 index 0000000..a04fa7d Binary files /dev/null and b/target/test/out/c/cmock.o differ diff --git a/target/test/out/c/main_calculator.o b/target/test/out/c/main_calculator.o new file mode 100644 index 0000000..2b23025 Binary files /dev/null and b/target/test/out/c/main_calculator.o differ diff --git a/target/test/out/c/programmingMode.o b/target/test/out/c/programmingMode.o new file mode 100644 index 0000000..8217c85 Binary files /dev/null and b/target/test/out/c/programmingMode.o differ diff --git a/target/test/out/c/testForNumber.o b/target/test/out/c/testForNumber.o new file mode 100644 index 0000000..2cbf248 Binary files /dev/null and b/target/test/out/c/testForNumber.o differ diff --git a/target/test/out/c/testForOperator.o b/target/test/out/c/testForOperator.o new file mode 100644 index 0000000..3ae132c Binary files /dev/null and b/target/test/out/c/testForOperator.o differ diff --git a/target/test/out/c/test_calculator.o b/target/test/out/c/test_calculator.o new file mode 100644 index 0000000..4ed0c13 Binary files /dev/null and b/target/test/out/c/test_calculator.o differ diff --git a/target/test/out/c/test_calculator_runner.o b/target/test/out/c/test_calculator_runner.o new file mode 100644 index 0000000..8086889 Binary files /dev/null and b/target/test/out/c/test_calculator_runner.o differ diff --git a/target/test/out/c/unity.o b/target/test/out/c/unity.o new file mode 100644 index 0000000..d74bb79 Binary files /dev/null and b/target/test/out/c/unity.o differ diff --git a/target/test/out/test_calculator.out b/target/test/out/test_calculator.out new file mode 100755 index 0000000..5c3f8d4 Binary files /dev/null and b/target/test/out/test_calculator.out differ diff --git a/target/test/preprocess/files/test_calculator.c b/target/test/preprocess/files/test_calculator.c new file mode 100644 index 0000000..b5bac52 --- /dev/null +++ b/target/test/preprocess/files/test_calculator.c @@ -0,0 +1,502 @@ +#include "src/main/c/programmingMode.h" +#include "src/main/c/testForNumber.h" +#include "src/main/c/testForOperator.h" +#include "src/main/c/main_calculator.h" +#include "/var/lib/gems/3.0.0/gems/ceedling-0.31.1/vendor/unity/src/unity.h" + + + + +void setUp(void) + +{ + +} + + + +void tearDown(void) + +{ + +} + + + +void test_addition(void) + +{ + + double result = add(1, 2); + + UnityAssertEqualNumber((UNITY_INT)((3)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(19), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_minus(void) + +{ + + double result = minus(3, 1); + + UnityAssertEqualNumber((UNITY_INT)((2)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(25), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_multiply(void) + +{ + + double result = multiply(1, 2); + + UnityAssertEqualNumber((UNITY_INT)((2)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(31), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_divide(void) + +{ + + double result = divide(4, 2); + + UnityAssertEqualNumber((UNITY_INT)((2)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(37), UNITY_DISPLAY_STYLE_INT); + + + + double result1 = divide(4, 0); + + UnityAssertEqualNumber((UNITY_INT)((0)), (UNITY_INT)((result1)), ( + + ((void *)0) + + ), (UNITY_UINT)(40), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_ConMeter(void) { + + double result = ConMeter(5, 0, 1); + + UnityAssertEqualNumber((UNITY_INT)((0.5)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(45), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_ConMeterToFoot(void) { + + double result = ConMeterToFoot(5, 1, 0); + + UnityAssertEqualNumber((UNITY_INT)((16.4042)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(50), UNITY_DISPLAY_STYLE_INT); + +} + +void test_ConKilometerToMiles(void) { + + double result = ConKilometerToMiles(5, 0, 1); + + UnityAssertEqualNumber((UNITY_INT)((8.04672)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(54), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_ConGram(void) { + + double result = ConGram(5, 0, 1); + + UnityAssertEqualNumber((UNITY_INT)((0.005)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(59), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_ConGramToPounds(void) { + + double result = ConGramToPounds(5, 0, 0); + + UnityAssertEqualNumber((UNITY_INT)((11.0231)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(64), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_ConTemp(void) { + + double result = ConTemp(5, 0, 1); + + UnityAssertEqualNumber((UNITY_INT)((41)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(69), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_ConSpeed(void) { + + double result = ConSpeed(5, 0, 1); + + UnityAssertEqualNumber((UNITY_INT)((3.10686)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(74), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_ConLiter(void) { + + double result = ConLiter(5, 1, 0); + + UnityAssertEqualNumber((UNITY_INT)((5000)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(79), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_ConLiterToGallon(void) { + + double result = ConLiterToGallon(5, 0, 1); + + UnityAssertEqualNumber((UNITY_INT)((1.32086)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(84), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_ConData(void) { + + double result = ConData(5, 0, 1); + + UnityAssertEqualNumber((UNITY_INT)((0.005)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(89), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_ConArea(void) { + + double result = ConData(5, 0, 1); + + UnityAssertEqualNumber((UNITY_INT)((0.05)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(94), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_ConVolume(void) { + + double result = ConData(5, 0, 1); + + UnityAssertEqualNumber((UNITY_INT)((0.005)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(99), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_ConClock(void) { + + double result = ConClock(5, 0, 1); + + UnityAssertEqualNumber((UNITY_INT)((5)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(104), UNITY_DISPLAY_STYLE_INT); + +} + + + +void test_ConTime(void) { + + double result = ConData(5, 0, 1); + + UnityAssertEqualNumber((UNITY_INT)((0.005)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(109), UNITY_DISPLAY_STYLE_INT); + +} + + + + + + + +void test_squareRootFunction(void) { + + UnityAssertFloatsWithin((UNITY_FLOAT)((UNITY_FLOAT)((2.0)) * (UNITY_FLOAT)(0.00001f)), (UNITY_FLOAT)((UNITY_FLOAT)((2.0))), (UNITY_FLOAT)((UNITY_FLOAT)((squareRootFunction(4.0)))), (( + + ((void *)0) + + )), (UNITY_UINT)((UNITY_UINT)(115))); + +} + + + + + +void test_sineFunction(void) { + + + + UnityAssertFloatsWithin((UNITY_FLOAT)((UNITY_FLOAT)((0.0)) * (UNITY_FLOAT)(0.00001f)), (UNITY_FLOAT)((UNITY_FLOAT)((0.0))), (UNITY_FLOAT)((UNITY_FLOAT)((sineFunction(0.0)))), (( + + ((void *)0) + + )), (UNITY_UINT)((UNITY_UINT)(121))); + +} + + + + + +void test_cosineFunction(void) { + + + + UnityAssertFloatsWithin((UNITY_FLOAT)((UNITY_FLOAT)((1.0)) * (UNITY_FLOAT)(0.00001f)), (UNITY_FLOAT)((UNITY_FLOAT)((1.0))), (UNITY_FLOAT)((UNITY_FLOAT)((cosineFunction(0.0)))), (( + + ((void *)0) + + )), (UNITY_UINT)((UNITY_UINT)(127))); + +} + + + + + +void test_tangentFunction(void) { + + + + UnityAssertFloatsWithin((UNITY_FLOAT)((UNITY_FLOAT)((0.0)) * (UNITY_FLOAT)(0.00001f)), (UNITY_FLOAT)((UNITY_FLOAT)((0.0))), (UNITY_FLOAT)((UNITY_FLOAT)((tangentFunction(0.0)))), (( + + ((void *)0) + + )), (UNITY_UINT)((UNITY_UINT)(133))); + +} + + + + + +void test_logarithmFunction(void) { + + + + UnityAssertFloatsWithin((UNITY_FLOAT)((UNITY_FLOAT)((1.0)) * (UNITY_FLOAT)(0.00001f)), (UNITY_FLOAT)((UNITY_FLOAT)((1.0))), (UNITY_FLOAT)((UNITY_FLOAT)((logarithmFunction(10.0)))), (( + + ((void *)0) + + )), (UNITY_UINT)((UNITY_UINT)(139))); + +} + + + + + +void test_naturalLogarithmFunction(void) { + + + + UnityAssertFloatsWithin((UNITY_FLOAT)((UNITY_FLOAT)((0.0)) * (UNITY_FLOAT)(0.00001f)), (UNITY_FLOAT)((UNITY_FLOAT)((0.0))), (UNITY_FLOAT)((UNITY_FLOAT)((naturalLogarithmFunction(1.0)))), (( + + ((void *)0) + + )), (UNITY_UINT)((UNITY_UINT)(145))); + +} + + + + + +void test_logarithmBase2Function(void) { + + + + UnityAssertFloatsWithin((UNITY_FLOAT)((UNITY_FLOAT)((3.0)) * (UNITY_FLOAT)(0.00001f)), (UNITY_FLOAT)((UNITY_FLOAT)((3.0))), (UNITY_FLOAT)((UNITY_FLOAT)((logarithmBase2Function(8.0)))), (( + + ((void *)0) + + )), (UNITY_UINT)((UNITY_UINT)(151))); + +} + + + + + +void test_exponentialFunction(void) { + + + + UnityAssertFloatsWithin((UNITY_FLOAT)((UNITY_FLOAT)((1.0)) * (UNITY_FLOAT)(0.00001f)), (UNITY_FLOAT)((UNITY_FLOAT)((1.0))), (UNITY_FLOAT)((UNITY_FLOAT)((exponentialFunction(0.0)))), (( + + ((void *)0) + + )), (UNITY_UINT)((UNITY_UINT)(157))); + +} + + + + + +void test_performOperation_Subtraction(void) { + + + + int result; + + + + + + result = performOperation(10, '-', 3); + + + + + + UnityAssertEqualNumber((UNITY_INT)((7)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(169), UNITY_DISPLAY_STYLE_INT); + +} + + + + + +void test_performOperation_Multiplication(void) { + + + + int result; + + + + + + result = performOperation(4, '*', 6); + + + + + + UnityAssertEqualNumber((UNITY_INT)((24)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(181), UNITY_DISPLAY_STYLE_INT); + +} + + + + + +void test_performOperation_Division(void) { + + + + int result; + + + + + + result = performOperation(8, '/', 2); + + + + + + UnityAssertEqualNumber((UNITY_INT)((4)), (UNITY_INT)((result)), ( + + ((void *)0) + + ), (UNITY_UINT)(193), UNITY_DISPLAY_STYLE_INT); + +} diff --git a/target/test/preprocess/includes/test_calculator.c b/target/test/preprocess/includes/test_calculator.c new file mode 100644 index 0000000..56ed68c --- /dev/null +++ b/target/test/preprocess/includes/test_calculator.c @@ -0,0 +1,6 @@ +--- +- "/var/lib/gems/3.0.0/gems/ceedling-0.31.1/vendor/unity/src/unity.h" +- src/main/c/main_calculator.h +- src/main/c/testForOperator.h +- src/main/c/testForNumber.h +- src/main/c/programmingMode.h diff --git a/target/test/results/test_calculator.pass b/target/test/results/test_calculator.pass new file mode 100644 index 0000000..8999b26 --- /dev/null +++ b/target/test/results/test_calculator.pass @@ -0,0 +1,130 @@ +--- +:source: + :path: src/test/c + :file: test_calculator.c +:successes: +- :test: test_addition + :line: 16 + :message: '' + :unity_test_time: 0 +- :test: test_minus + :line: 22 + :message: '' + :unity_test_time: 0 +- :test: test_multiply + :line: 28 + :message: '' + :unity_test_time: 0 +- :test: test_divide + :line: 34 + :message: '' + :unity_test_time: 0 +- :test: test_ConMeter + :line: 43 + :message: '' + :unity_test_time: 0 +- :test: test_ConMeterToFoot + :line: 48 + :message: '' + :unity_test_time: 0 +- :test: test_ConKilometerToMiles + :line: 52 + :message: '' + :unity_test_time: 0 +- :test: test_ConGram + :line: 57 + :message: '' + :unity_test_time: 0 +- :test: test_ConGramToPounds + :line: 62 + :message: '' + :unity_test_time: 0 +- :test: test_ConTemp + :line: 67 + :message: '' + :unity_test_time: 0 +- :test: test_ConSpeed + :line: 72 + :message: '' + :unity_test_time: 0 +- :test: test_ConLiter + :line: 77 + :message: '' + :unity_test_time: 0 +- :test: test_ConLiterToGallon + :line: 82 + :message: '' + :unity_test_time: 0 +- :test: test_ConData + :line: 87 + :message: '' + :unity_test_time: 0 +- :test: test_ConArea + :line: 92 + :message: '' + :unity_test_time: 0 +- :test: test_ConVolume + :line: 97 + :message: '' + :unity_test_time: 0 +- :test: test_ConClock + :line: 102 + :message: '' + :unity_test_time: 0 +- :test: test_ConTime + :line: 107 + :message: '' + :unity_test_time: 0 +- :test: test_squareRootFunction + :line: 114 + :message: '' + :unity_test_time: 0 +- :test: test_sineFunction + :line: 119 + :message: '' + :unity_test_time: 0 +- :test: test_cosineFunction + :line: 125 + :message: '' + :unity_test_time: 0 +- :test: test_tangentFunction + :line: 131 + :message: '' + :unity_test_time: 0 +- :test: test_logarithmFunction + :line: 137 + :message: '' + :unity_test_time: 0 +- :test: test_naturalLogarithmFunction + :line: 143 + :message: '' + :unity_test_time: 0 +- :test: test_logarithmBase2Function + :line: 149 + :message: '' + :unity_test_time: 0 +- :test: test_exponentialFunction + :line: 155 + :message: '' + :unity_test_time: 0 +- :test: test_performOperation_Subtraction + :line: 161 + :message: '' + :unity_test_time: 0 +- :test: test_performOperation_Multiplication + :line: 173 + :message: '' + :unity_test_time: 0 +- :test: test_performOperation_Division + :line: 185 + :message: '' + :unity_test_time: 0 +:failures: [] +:ignores: [] +:counts: + :total: 29 + :passed: 29 + :failed: 0 + :ignored: 0 +:stdout: [] +:time: 0.001314320999881602 diff --git a/target/test/runners/test_calculator_runner.c b/target/test/runners/test_calculator_runner.c new file mode 100644 index 0000000..c2033f8 --- /dev/null +++ b/target/test/runners/test_calculator_runner.c @@ -0,0 +1,137 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" + +int GlobalExpectCount; +int GlobalVerifyOrder; +char* GlobalOrderError; + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_addition(void); +extern void test_minus(void); +extern void test_multiply(void); +extern void test_divide(void); +extern void test_ConMeter(void); +extern void test_ConMeterToFoot(void); +extern void test_ConKilometerToMiles(void); +extern void test_ConGram(void); +extern void test_ConGramToPounds(void); +extern void test_ConTemp(void); +extern void test_ConSpeed(void); +extern void test_ConLiter(void); +extern void test_ConLiterToGallon(void); +extern void test_ConData(void); +extern void test_ConArea(void); +extern void test_ConVolume(void); +extern void test_ConClock(void); +extern void test_ConTime(void); +extern void test_squareRootFunction(void); +extern void test_sineFunction(void); +extern void test_cosineFunction(void); +extern void test_tangentFunction(void); +extern void test_logarithmFunction(void); +extern void test_naturalLogarithmFunction(void); +extern void test_logarithmBase2Function(void); +extern void test_exponentialFunction(void); +extern void test_performOperation_Subtraction(void); +extern void test_performOperation_Multiplication(void); +extern void test_performOperation_Division(void); + + +/*=======Mock Management=====*/ +static void CMock_Init(void) +{ + GlobalExpectCount = 0; + GlobalVerifyOrder = 0; + GlobalOrderError = NULL; +} +static void CMock_Verify(void) +{ +} +static void CMock_Destroy(void) +{ +} + +/*=======Test Reset Options=====*/ +void resetTest(void); +void resetTest(void) +{ + tearDown(); + CMock_Verify(); + CMock_Destroy(); + CMock_Init(); + setUp(); +} +void verifyTest(void); +void verifyTest(void) +{ + CMock_Verify(); +} + +/*=======Test Runner Used To Run Each Test=====*/ +static void run_test(UnityTestFunction func, const char* name, UNITY_LINE_TYPE line_num) +{ + Unity.CurrentTestName = name; + Unity.CurrentTestLineNumber = line_num; +#ifdef UNITY_USE_COMMAND_LINE_ARGS + if (!UnityTestMatches()) + return; +#endif + Unity.NumberOfTests++; + UNITY_CLR_DETAILS(); + UNITY_EXEC_TIME_START(); + CMock_Init(); + if (TEST_PROTECT()) + { + setUp(); + func(); + } + if (TEST_PROTECT()) + { + tearDown(); + CMock_Verify(); + } + CMock_Destroy(); + UNITY_EXEC_TIME_STOP(); + UnityConcludeTest(); +} + +/*=======MAIN=====*/ +int main(void) +{ + UnityBegin("test_calculator.c"); + run_test(test_addition, "test_addition", 16); + run_test(test_minus, "test_minus", 22); + run_test(test_multiply, "test_multiply", 28); + run_test(test_divide, "test_divide", 34); + run_test(test_ConMeter, "test_ConMeter", 43); + run_test(test_ConMeterToFoot, "test_ConMeterToFoot", 48); + run_test(test_ConKilometerToMiles, "test_ConKilometerToMiles", 52); + run_test(test_ConGram, "test_ConGram", 57); + run_test(test_ConGramToPounds, "test_ConGramToPounds", 62); + run_test(test_ConTemp, "test_ConTemp", 67); + run_test(test_ConSpeed, "test_ConSpeed", 72); + run_test(test_ConLiter, "test_ConLiter", 77); + run_test(test_ConLiterToGallon, "test_ConLiterToGallon", 82); + run_test(test_ConData, "test_ConData", 87); + run_test(test_ConArea, "test_ConArea", 92); + run_test(test_ConVolume, "test_ConVolume", 97); + run_test(test_ConClock, "test_ConClock", 102); + run_test(test_ConTime, "test_ConTime", 107); + run_test(test_squareRootFunction, "test_squareRootFunction", 114); + run_test(test_sineFunction, "test_sineFunction", 119); + run_test(test_cosineFunction, "test_cosineFunction", 125); + run_test(test_tangentFunction, "test_tangentFunction", 131); + run_test(test_logarithmFunction, "test_logarithmFunction", 137); + run_test(test_naturalLogarithmFunction, "test_naturalLogarithmFunction", 143); + run_test(test_logarithmBase2Function, "test_logarithmBase2Function", 149); + run_test(test_exponentialFunction, "test_exponentialFunction", 155); + run_test(test_performOperation_Subtraction, "test_performOperation_Subtraction", 161); + run_test(test_performOperation_Multiplication, "test_performOperation_Multiplication", 173); + run_test(test_performOperation_Division, "test_performOperation_Division", 185); + + return UnityEnd(); +}