xaizek / stic (License: MIT) (since 2018-12-07)
Simple Tests In C with optional automatic test registration in C.
Clone URLs: https://code.reversed.top/user/xaizek/stic ssh://rocketgit@code.reversed.top/user/xaizek/stic
v0.5.2 v0.6 master
Commit f9812594adaa7c725a837d6a517259bb81363406

Pass file name around in stic
Author: xaizek
Author date (UTC): 2015-06-23 15:01
Committer name: xaizek
Committer date (UTC): 2015-06-23 17:02
Parent(s): 22343b3505e35c5c91b8d0bd9ec5d87f0c7b7aaf
Signing key:
Tree: 1c7ac274d6e9dca2768db3d79a390e43fffb844d
File Lines added Lines deleted
src/stic.c 35 35
src/stic.h 40 40
File src/stic.c changed (mode: 100644) (index e9354ce..18e209f)
... ... static stic_void_void stic_fixture_teardown = 0;
87 87
88 88 const char *stic_current_test; const char *stic_current_test;
89 89
90 void (*stic_simple_test_result)(int passed, char* reason, const char* function, unsigned int line) = stic_simple_test_result_log;
90 void (*stic_simple_test_result)(int passed, char* reason, const char* function, const char file[], unsigned int line) = stic_simple_test_result_log;
91 91
92 92 void suite_setup(stic_void_void setup) void suite_setup(stic_void_void setup)
93 93 { {
 
... ... static const char * test_file_name(const char path[])
156 156 static int stic_fixture_tests_run; static int stic_fixture_tests_run;
157 157 static int stic_fixture_tests_failed; static int stic_fixture_tests_failed;
158 158
159 void stic_simple_test_result_log(int passed, char* reason, const char* function, unsigned int line)
159 void stic_simple_test_result_log(int passed, char* reason, const char* function, const char file[], unsigned int line)
160 160 { {
161 161 /* TODO: do use function if it differs from test. */ /* TODO: do use function if it differs from test. */
162 162 (void)function; (void)function;
 
... ... void stic_simple_test_result_log(int passed, char* reason, const char* function,
195 195 } }
196 196 } }
197 197
198 void stic_assert_true(int test, const char* function, unsigned int line)
198 void stic_assert_true(int test, const char* function, const char file[], unsigned int line)
199 199 { {
200 stic_simple_test_result(test, "Should have been true", function, line);
200 stic_simple_test_result(test, "Should have been true", function, file, line);
201 201 } }
202 202
203 void stic_assert_false(int test, const char* function, unsigned int line)
203 void stic_assert_false(int test, const char* function, const char file[], unsigned int line)
204 204 { {
205 stic_simple_test_result(!test, "Should have been false", function, line);
205 stic_simple_test_result(!test, "Should have been false", function, file, line);
206 206 } }
207 207
208 void stic_assert_success(int test, const char function[], unsigned int line)
208 void stic_assert_success(int test, const char function[], const char file[], unsigned int line)
209 209 { {
210 stic_simple_test_result(test == 0, "Should have been success (zero)", function, line);
210 stic_simple_test_result(test == 0, "Should have been success (zero)", function, file, line);
211 211 } }
212 212
213 void stic_assert_failure(int test, const char function[], unsigned int line)
213 void stic_assert_failure(int test, const char function[], const char file[], unsigned int line)
214 214 { {
215 stic_simple_test_result(test != 0, "Should have been failure (non-zero)", function, line);
215 stic_simple_test_result(test != 0, "Should have been failure (non-zero)", function, file, line);
216 216 } }
217 217
218 void stic_assert_null(const void *value, const char function[], unsigned int line)
218 void stic_assert_null(const void *value, const char function[], const char file[], unsigned int line)
219 219 { {
220 stic_simple_test_result(value == NULL, "Should have been NULL", function, line);
220 stic_simple_test_result(value == NULL, "Should have been NULL", function, file, line);
221 221 } }
222 222
223 void stic_assert_non_null(const void *value, const char function[], unsigned int line)
223 void stic_assert_non_null(const void *value, const char function[], const char file[], unsigned int line)
224 224 { {
225 stic_simple_test_result(value != NULL, "Should have been non-NULL", function, line);
225 stic_simple_test_result(value != NULL, "Should have been non-NULL", function, file, line);
226 226 } }
227 227
228 void stic_assert_int_equal(int expected, int actual, const char* function, unsigned int line)
228 void stic_assert_int_equal(int expected, int actual, const char* function, const char file[], unsigned int line)
229 229 { {
230 230 char s[STIC_PRINT_BUFFER_SIZE]; char s[STIC_PRINT_BUFFER_SIZE];
231 231 sprintf(s, "Expected %d but was %d", expected, actual); sprintf(s, "Expected %d but was %d", expected, actual);
232 stic_simple_test_result(expected==actual, s, function, line);
232 stic_simple_test_result(expected==actual, s, function, file, line);
233 233 } }
234 234
235 void stic_assert_ulong_equal(unsigned long expected, unsigned long actual, const char* function, unsigned int line)
235 void stic_assert_ulong_equal(unsigned long expected, unsigned long actual, const char* function, const char file[], unsigned int line)
236 236 { {
237 237 char s[STIC_PRINT_BUFFER_SIZE]; char s[STIC_PRINT_BUFFER_SIZE];
238 238 sprintf(s, "Expected %lu but was %lu", expected, actual); sprintf(s, "Expected %lu but was %lu", expected, actual);
239 stic_simple_test_result(expected==actual, s, function, line);
239 stic_simple_test_result(expected==actual, s, function, file, line);
240 240 } }
241 241
242 void stic_assert_float_equal( float expected, float actual, float delta, const char* function, unsigned int line )
242 void stic_assert_float_equal( float expected, float actual, float delta, const char* function, const char file[], unsigned int line )
243 243 { {
244 244 char s[STIC_PRINT_BUFFER_SIZE]; char s[STIC_PRINT_BUFFER_SIZE];
245 245 float result = expected-actual; float result = expected-actual;
246 246 sprintf(s, "Expected %f but was %f", expected, actual); sprintf(s, "Expected %f but was %f", expected, actual);
247 247 if(result < 0.0) result = 0.0f - result; if(result < 0.0) result = 0.0f - result;
248 stic_simple_test_result( result <= delta, s, function, line);
248 stic_simple_test_result( result <= delta, s, function, file, line);
249 249 } }
250 250
251 void stic_assert_double_equal( double expected, double actual, double delta, const char* function, unsigned int line )
251 void stic_assert_double_equal( double expected, double actual, double delta, const char* function, const char file[], unsigned int line )
252 252 { {
253 253 char s[STIC_PRINT_BUFFER_SIZE]; char s[STIC_PRINT_BUFFER_SIZE];
254 254 double result = expected-actual; double result = expected-actual;
255 255 sprintf(s, "Expected %f but was %f", expected, actual); sprintf(s, "Expected %f but was %f", expected, actual);
256 256 if(result < 0.0) result = 0.0 - result; if(result < 0.0) result = 0.0 - result;
257 stic_simple_test_result( result <= delta, s, function, line);
257 stic_simple_test_result( result <= delta, s, function, file, line);
258 258 } }
259 259
260 void stic_assert_string_equal(const char* expected, const char* actual, const char* function, unsigned int line)
260 void stic_assert_string_equal(const char* expected, const char* actual, const char* function, const char file[], unsigned int line)
261 261 { {
262 262 int comparison; int comparison;
263 263 char s[STIC_PRINT_BUFFER_SIZE]; char s[STIC_PRINT_BUFFER_SIZE];
 
... ... void stic_assert_string_equal(const char* expected, const char* actual, const ch
283 283 sprintf(s, "Expected \"%s\" but was \"%s\"", expected, actual); sprintf(s, "Expected \"%s\" but was \"%s\"", expected, actual);
284 284 } }
285 285
286 stic_simple_test_result(comparison, s, function, line);
286 stic_simple_test_result(comparison, s, function, file, line);
287 287 } }
288 288
289 void stic_assert_wstring_equal(const wchar_t expected[], const wchar_t actual[], const char function[], unsigned int line)
289 void stic_assert_wstring_equal(const wchar_t expected[], const wchar_t actual[], const char function[], const char file[], unsigned int line)
290 290 { {
291 291 int comparison; int comparison;
292 292 char s[STIC_PRINT_BUFFER_SIZE]; char s[STIC_PRINT_BUFFER_SIZE];
 
... ... void stic_assert_wstring_equal(const wchar_t expected[], const wchar_t actual[],
324 324 #endif #endif
325 325 } }
326 326
327 stic_simple_test_result(comparison, s, function, line);
327 stic_simple_test_result(comparison, s, function, file, line);
328 328 } }
329 329
330 void stic_assert_string_ends_with(const char* expected, const char* actual, const char* function, unsigned int line)
330 void stic_assert_string_ends_with(const char* expected, const char* actual, const char* function, const char file[], unsigned int line)
331 331 { {
332 332 char s[STIC_PRINT_BUFFER_SIZE]; char s[STIC_PRINT_BUFFER_SIZE];
333 333 sprintf(s, "Expected \"%s\" to end with \"%s\"", actual, expected); sprintf(s, "Expected \"%s\" to end with \"%s\"", actual, expected);
334 stic_simple_test_result(strcmp(expected, actual+(strlen(actual)-strlen(expected)))==0, s, function, line);
334 stic_simple_test_result(strcmp(expected, actual+(strlen(actual)-strlen(expected)))==0, s, function, file, line);
335 335 } }
336 336
337 void stic_assert_string_starts_with(const char* expected, const char* actual, const char* function, unsigned int line)
337 void stic_assert_string_starts_with(const char* expected, const char* actual, const char* function, const char file[], unsigned int line)
338 338 { {
339 339 char s[STIC_PRINT_BUFFER_SIZE]; char s[STIC_PRINT_BUFFER_SIZE];
340 340 sprintf(s, "Expected \"%s\" to start with \"%s\"", actual, expected); sprintf(s, "Expected \"%s\" to start with \"%s\"", actual, expected);
341 stic_simple_test_result(strncmp(expected, actual, strlen(expected))==0, s, function, line);
341 stic_simple_test_result(strncmp(expected, actual, strlen(expected))==0, s, function, file, line);
342 342 } }
343 343
344 void stic_assert_string_contains(const char* expected, const char* actual, const char* function, unsigned int line)
344 void stic_assert_string_contains(const char* expected, const char* actual, const char* function, const char file[], unsigned int line)
345 345 { {
346 346 char s[STIC_PRINT_BUFFER_SIZE]; char s[STIC_PRINT_BUFFER_SIZE];
347 347 sprintf(s, "Expected \"%s\" to be in \"%s\"", expected, actual); sprintf(s, "Expected \"%s\" to be in \"%s\"", expected, actual);
348 stic_simple_test_result(strstr(actual, expected)!=0, s, function, line);
348 stic_simple_test_result(strstr(actual, expected)!=0, s, function, file, line);
349 349 } }
350 350
351 void stic_assert_string_doesnt_contain(const char* expected, const char* actual, const char* function, unsigned int line)
351 void stic_assert_string_doesnt_contain(const char* expected, const char* actual, const char* function, const char file[], unsigned int line)
352 352 { {
353 353 char s[STIC_PRINT_BUFFER_SIZE]; char s[STIC_PRINT_BUFFER_SIZE];
354 354 sprintf(s, "Expected \"%s\" not to have \"%s\" in it", actual, expected); sprintf(s, "Expected \"%s\" not to have \"%s\" in it", actual, expected);
355 stic_simple_test_result(strstr(actual, expected)==0, s, function, line);
355 stic_simple_test_result(strstr(actual, expected)==0, s, function, file, line);
356 356 } }
357 357
358 358 void stic_run_test(const char fixture[], const char test[]) void stic_run_test(const char fixture[], const char test[])
 
... ... int stic_testrunner(int argc, char** argv, stic_void_void tests, stic_void_void
575 575
576 576 #ifdef STIC_INTERNAL_TESTS #ifdef STIC_INTERNAL_TESTS
577 577
578 void stic_simple_test_result_nolog(int passed, char* reason, const char* function, unsigned int line)
578 void stic_simple_test_result_nolog(int passed, char* reason, const char* function, const char file[], unsigned int line)
579 579 { {
580 580 sea_test_last_passed = passed; sea_test_last_passed = passed;
581 581 } }
File src/stic.h changed (mode: 100644) (index 2a1b2b8..db37e09)
... ... typedef void (*stic_void_string)(char[]);
23 23
24 24 /* Declarations. */ /* Declarations. */
25 25
26 void (*stic_simple_test_result)(int passed, char* reason, const char* function, unsigned int line);
26 void (*stic_simple_test_result)(int passed, char* reason, const char* function, const char file[], unsigned int line);
27 27 void stic_test_fixture_start(const char filepath[]); void stic_test_fixture_start(const char filepath[]);
28 28 void stic_test_fixture_end( void ); void stic_test_fixture_end( void );
29 void stic_simple_test_result_log(int passed, char* reason, const char* function, unsigned int line);
30 void stic_assert_true(int test, const char* function, unsigned int line);
31 void stic_assert_false(int test, const char* function, unsigned int line);
32 void stic_assert_success(int test, const char function[], unsigned int line);
33 void stic_assert_failure(int test, const char function[], unsigned int line);
34 void stic_assert_null(const void *value, const char function[], unsigned int line);
35 void stic_assert_non_null(const void *value, const char function[], unsigned int line);
36 void stic_assert_int_equal(int expected, int actual, const char* function, unsigned int line);
37 void stic_assert_ulong_equal(unsigned long expected, unsigned long actual, const char* function, unsigned int line);
38 void stic_assert_float_equal(float expected, float actual, float delta, const char* function, unsigned int line);
39 void stic_assert_double_equal(double expected, double actual, double delta, const char* function, unsigned int line);
40 void stic_assert_string_equal(const char* expected, const char* actual, const char* function, unsigned int line);
41 void stic_assert_wstring_equal(const wchar_t expected[], const wchar_t actual[], const char function[], unsigned int line);
42 void stic_assert_string_ends_with(const char* expected, const char* actual, const char* function, unsigned int line);
43 void stic_assert_string_starts_with(const char* expected, const char* actual, const char* function, unsigned int line);
44 void stic_assert_string_contains(const char* expected, const char* actual, const char* function, unsigned int line);
45 void stic_assert_string_doesnt_contain(const char* expected, const char* actual, const char* function, unsigned int line);
29 void stic_simple_test_result_log(int passed, char* reason, const char* function, const char file[], unsigned int line);
30 void stic_assert_true(int test, const char* function, const char file[], unsigned int line);
31 void stic_assert_false(int test, const char* function, const char file[], unsigned int line);
32 void stic_assert_success(int test, const char function[], const char file[], unsigned int line);
33 void stic_assert_failure(int test, const char function[], const char file[], unsigned int line);
34 void stic_assert_null(const void *value, const char function[], const char file[], unsigned int line);
35 void stic_assert_non_null(const void *value, const char function[], const char file[], unsigned int line);
36 void stic_assert_int_equal(int expected, int actual, const char* function, const char file[], unsigned int line);
37 void stic_assert_ulong_equal(unsigned long expected, unsigned long actual, const char* function, const char file[], unsigned int line);
38 void stic_assert_float_equal(float expected, float actual, float delta, const char* function, const char file[], unsigned int line);
39 void stic_assert_double_equal(double expected, double actual, double delta, const char* function, const char file[], unsigned int line);
40 void stic_assert_string_equal(const char* expected, const char* actual, const char* function, const char file[], unsigned int line);
41 void stic_assert_wstring_equal(const wchar_t expected[], const wchar_t actual[], const char function[], const char file[], unsigned int line);
42 void stic_assert_string_ends_with(const char* expected, const char* actual, const char* function, const char file[], unsigned int line);
43 void stic_assert_string_starts_with(const char* expected, const char* actual, const char* function, const char file[], unsigned int line);
44 void stic_assert_string_contains(const char* expected, const char* actual, const char* function, const char file[], unsigned int line);
45 void stic_assert_string_doesnt_contain(const char* expected, const char* actual, const char* function, const char file[], unsigned int line);
46 46 int stic_should_run(const char fixture[], const char test[]); int stic_should_run(const char fixture[], const char test[]);
47 47 void stic_before_run( char* fixture, char* test); void stic_before_run( char* fixture, char* test);
48 48 void stic_run_test(const char fixture[], const char test[]); void stic_run_test(const char fixture[], const char test[]);
 
... ... void stic_printf(char buf[], const char format[], ...);
55 55
56 56 /* Assert macros. */ /* Assert macros. */
57 57
58 #define assert_true(test) do { stic_assert_true(test, __FUNCTION__, __LINE__); } while (0)
59 #define assert_false(test) do { stic_assert_false(test, __FUNCTION__, __LINE__); } while (0)
60 #define assert_success(test) do { stic_assert_success(test, __FUNCTION__, __LINE__); } while (0)
61 #define assert_failure(test) do { stic_assert_failure(test, __FUNCTION__, __LINE__); } while (0)
62 #define assert_null(value) do { stic_assert_null(value, __FUNCTION__, __LINE__); } while (0)
63 #define assert_non_null(value) do { stic_assert_non_null(value, __FUNCTION__, __LINE__); } while (0)
64 #define assert_int_equal(expected, actual) do { stic_assert_int_equal(expected, actual, __FUNCTION__, __LINE__); } while (0)
65 #define assert_ulong_equal(expected, actual) do { stic_assert_ulong_equal(expected, actual, __FUNCTION__, __LINE__); } while (0)
66 #define assert_string_equal(expected, actual) do { stic_assert_string_equal(expected, actual, __FUNCTION__, __LINE__); } while (0)
67 #define assert_wstring_equal(expected, actual) do { stic_assert_wstring_equal(expected, actual, __FUNCTION__, __LINE__); } while (0)
68 #define assert_n_array_equal(expected, actual, n) do { int stic_count; for(stic_count=0; stic_count<n; stic_count++) { char s_seatest[STIC_PRINT_BUFFER_SIZE]; stic_printf(s_seatest,"Expected %d to be %d at position %d", actual[stic_count], expected[stic_count], stic_count); stic_simple_test_result((expected[stic_count] == actual[stic_count]), s_seatest, __FUNCTION__, __LINE__);} } while (0)
69 #define assert_bit_set(bit_number, value) { stic_simple_test_result(((1 << bit_number) & value), " Expected bit to be set" , __FUNCTION__, __LINE__); } while (0)
70 #define assert_bit_not_set(bit_number, value) { stic_simple_test_result(!((1 << bit_number) & value), " Expected bit not to to be set" , __FUNCTION__, __LINE__); } while (0)
71 #define assert_bit_mask_matches(value, mask) { stic_simple_test_result(((value & mask) == mask), " Expected all bits of mask to be set" , __FUNCTION__, __LINE__); } while (0)
72 #define assert_fail(message) { stic_simple_test_result(0, message, __FUNCTION__, __LINE__); } while (0)
73 #define assert_float_equal(expected, actual, delta) do { stic_assert_float_equal(expected, actual, delta, __FUNCTION__, __LINE__); } while (0)
74 #define assert_double_equal(expected, actual, delta) do { stic_assert_double_equal(expected, actual, delta, __FUNCTION__, __LINE__); } while (0)
75 #define assert_string_contains(expected, actual) do { stic_assert_string_contains(expected, actual, __FUNCTION__, __LINE__); } while (0)
76 #define assert_string_doesnt_contain(expected, actual) do { stic_assert_string_doesnt_contain(expected, actual, __FUNCTION__, __LINE__); } while (0)
77 #define assert_string_starts_with(expected, actual) do { stic_assert_string_starts_with(expected, actual, __FUNCTION__, __LINE__); } while (0)
78 #define assert_string_ends_with(expected, actual) do { stic_assert_string_ends_with(expected, actual, __FUNCTION__, __LINE__); } while (0)
58 #define assert_true(test) do { stic_assert_true(test, __FUNCTION__, __FILE__, __LINE__); } while (0)
59 #define assert_false(test) do { stic_assert_false(test, __FUNCTION__, __FILE__, __LINE__); } while (0)
60 #define assert_success(test) do { stic_assert_success(test, __FUNCTION__, __FILE__, __LINE__); } while (0)
61 #define assert_failure(test) do { stic_assert_failure(test, __FUNCTION__, __FILE__, __LINE__); } while (0)
62 #define assert_null(value) do { stic_assert_null(value, __FUNCTION__, __FILE__, __LINE__); } while (0)
63 #define assert_non_null(value) do { stic_assert_non_null(value, __FUNCTION__, __FILE__, __LINE__); } while (0)
64 #define assert_int_equal(expected, actual) do { stic_assert_int_equal(expected, actual, __FUNCTION__, __FILE__, __LINE__); } while (0)
65 #define assert_ulong_equal(expected, actual) do { stic_assert_ulong_equal(expected, actual, __FUNCTION__, __FILE__, __LINE__); } while (0)
66 #define assert_string_equal(expected, actual) do { stic_assert_string_equal(expected, actual, __FUNCTION__, __FILE__, __LINE__); } while (0)
67 #define assert_wstring_equal(expected, actual) do { stic_assert_wstring_equal(expected, actual, __FUNCTION__, __FILE__, __LINE__); } while (0)
68 #define assert_n_array_equal(expected, actual, n) do { int stic_count; for(stic_count=0; stic_count<n; stic_count++) { char s_seatest[STIC_PRINT_BUFFER_SIZE]; stic_printf(s_seatest,"Expected %d to be %d at position %d", actual[stic_count], expected[stic_count], stic_count); stic_simple_test_result((expected[stic_count] == actual[stic_count]), s_seatest, __FUNCTION__, __FILE__, __LINE__);} } while (0)
69 #define assert_bit_set(bit_number, value) { stic_simple_test_result(((1 << bit_number) & value), " Expected bit to be set" , __FUNCTION__, __FILE__, __LINE__); } while (0)
70 #define assert_bit_not_set(bit_number, value) { stic_simple_test_result(!((1 << bit_number) & value), " Expected bit not to to be set" , __FUNCTION__, __FILE__, __LINE__); } while (0)
71 #define assert_bit_mask_matches(value, mask) { stic_simple_test_result(((value & mask) == mask), " Expected all bits of mask to be set" , __FUNCTION__, __FILE__, __LINE__); } while (0)
72 #define assert_fail(message) { stic_simple_test_result(0, message, __FUNCTION__, __FILE__, __LINE__); } while (0)
73 #define assert_float_equal(expected, actual, delta) do { stic_assert_float_equal(expected, actual, delta, __FUNCTION__, __FILE__, __LINE__); } while (0)
74 #define assert_double_equal(expected, actual, delta) do { stic_assert_double_equal(expected, actual, delta, __FUNCTION__, __FILE__, __LINE__); } while (0)
75 #define assert_string_contains(expected, actual) do { stic_assert_string_contains(expected, actual, __FUNCTION__, __FILE__, __LINE__); } while (0)
76 #define assert_string_doesnt_contain(expected, actual) do { stic_assert_string_doesnt_contain(expected, actual, __FUNCTION__, __FILE__, __LINE__); } while (0)
77 #define assert_string_starts_with(expected, actual) do { stic_assert_string_starts_with(expected, actual, __FUNCTION__, __FILE__, __LINE__); } while (0)
78 #define assert_string_ends_with(expected, actual) do { stic_assert_string_ends_with(expected, actual, __FUNCTION__, __FILE__, __LINE__); } while (0)
79 79
80 80 /* Fixture/test management. */ /* Fixture/test management. */
81 81
 
... ... void (*STIC_CAT(t, TESTID))(void) = &stic_fixture;
335 335
336 336 #ifdef STIC_INTERNAL_TESTS #ifdef STIC_INTERNAL_TESTS
337 337
338 void stic_simple_test_result_nolog(int passed, char* reason, const char* function, unsigned int line);
338 void stic_simple_test_result_nolog(int passed, char* reason, const char* function, const char file[], unsigned int line);
339 339 void stic_assert_last_passed(); void stic_assert_last_passed();
340 340 void stic_assert_last_failed(); void stic_assert_last_failed();
341 341 void stic_enable_logging(); void stic_enable_logging();
Hints
Before first commit, do not forget to setup your git environment:
git config --global user.name "your_name_here"
git config --global user.email "your@email_here"

Clone this repository using HTTP(S):
git clone https://code.reversed.top/user/xaizek/stic

Clone this repository using ssh (do not forget to upload a key first):
git clone ssh://rocketgit@code.reversed.top/user/xaizek/stic

You are allowed to anonymously push to this repository.
This means that your pushed commits will automatically be transformed into a pull request:
... clone the repository ...
... make some changes and some commits ...
git push origin master