├── PCUnit ├── PCU_Test.h ├── PCU_Suite.h ├── COPYING.ja ├── COPYING ├── Makefile ├── PCU_Suite.c ├── PCU_Libc.h ├── pcunit_template.rb ├── pcunit_xml_output.rb ├── pcunit_register.rb ├── PCUnit.c └── PCU_Test.c ├── test ├── pcunit_mock_test │ ├── main.c │ ├── Makefile │ ├── MockTest.c │ └── create_header.rb ├── PCU_format_test │ ├── main.c │ ├── Makefile │ ├── test_format.c │ └── test_formatW.c ├── assert_output_test │ ├── main.c │ ├── AssertNotSupportedTest.c │ ├── Makefile │ ├── AssertOutputTest.c │ ├── assert_output_expected.txt │ └── assert_not_supported_expected.txt ├── PCU_Libc_test │ ├── main.c │ ├── Makefile │ ├── test_string.c │ ├── test_strtol.c │ └── test_format_no_stdarg.c ├── Makefile └── assert_test │ ├── CleanupTest.c │ ├── InitializeTest.c │ ├── SetupTest.c │ ├── FailTest.c │ ├── main.c │ ├── AssertTest.c │ ├── AssertDoubleTest.c │ ├── Makefile │ ├── AssertEqualTest.c │ ├── AssertPtrTest.c │ ├── AssertOperatorTest.c │ ├── AssertMemoryTest.c │ ├── AssertStringTest.c │ └── AssertStringWTest.c ├── sample ├── StrToken.h ├── RingBuf.h ├── main.c ├── Makefile ├── RingBuf.c ├── StrToken.c ├── test_StrToken.c └── test_RingBuf.c └── .hgtags /PCUnit/PCU_Test.h: -------------------------------------------------------------------------------- 1 | #ifndef PCU_TEST_H_INCLUDED 2 | #define PCU_TEST_H_INCLUDED 3 | 4 | #include "PCUnit.h" 5 | 6 | void PCU_Test_reset(PCU_Test *self); 7 | void PCU_Test_run(PCU_Test *self); 8 | int PCU_Test_is_skipped(const PCU_Test *self); 9 | int PCU_Test_is_failed(const PCU_Test *self); 10 | 11 | 12 | #endif /* PCU_TEST_H_INCLUDED */ 13 | -------------------------------------------------------------------------------- /test/pcunit_mock_test/main.c: -------------------------------------------------------------------------------- 1 | #include "PCUnit/PCUnit.h" 2 | #include 3 | 4 | PCU_Suite *MockTest_suite(void); 5 | 6 | int main(int argc, char *argv[]) 7 | { 8 | const PCU_SuiteMethod suites[] = { 9 | MockTest_suite, 10 | }; 11 | PCU_set_putchar(putchar); 12 | PCU_set_getchar(getchar); 13 | PCU_enable_color(); 14 | if (argc >= 2) { 15 | PCU_set_verbose(1); 16 | } 17 | return PCU_run(suites, sizeof suites / sizeof suites[0]); 18 | } 19 | 20 | -------------------------------------------------------------------------------- /PCUnit/PCU_Suite.h: -------------------------------------------------------------------------------- 1 | #ifndef PCU_SUITE_H_INCLUDED 2 | #define PCU_SUITE_H_INCLUDED 3 | 4 | #include "PCUnit.h" 5 | 6 | void PCU_Suite_reset(PCU_Suite *self); 7 | void PCU_Suite_run(PCU_Suite *self); 8 | void PCU_Suite_run_selected(PCU_Suite *self, int idx); 9 | int PCU_Suite_initialize(PCU_Suite *self); 10 | int PCU_Suite_cleanup(PCU_Suite *self); 11 | int PCU_Suite_setup(void); 12 | int PCU_Suite_teardown(void); 13 | 14 | 15 | #endif /* PCU_SUITE_H_INCLUDED */ 16 | -------------------------------------------------------------------------------- /sample/StrToken.h: -------------------------------------------------------------------------------- 1 | #ifndef STRTOKEN_H_INCLUDED 2 | #define STRTOKEN_H_INCLUDED 3 | 4 | #include 5 | 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | typedef struct StrToken StrToken; 11 | StrToken *StrToken_new(const char *str, const char *delims); 12 | void StrToken_delete(StrToken *self); 13 | size_t StrToken_count(StrToken *self); 14 | const char *StrToken_get(StrToken *self, size_t idx); 15 | 16 | #ifdef __cplusplus 17 | } 18 | #endif 19 | 20 | #endif /* STRTOKEN_H_INCLUDED */ 21 | -------------------------------------------------------------------------------- /test/PCU_format_test/main.c: -------------------------------------------------------------------------------- 1 | #include "../../PCUnit/PCUnit.h" 2 | #include 3 | #include 4 | 5 | 6 | PCU_Suite *FormatTest_suite(void); 7 | PCU_Suite *FormatWTest_suite(void); 8 | 9 | int main(void) 10 | { 11 | const PCU_SuiteMethod suites[] = { 12 | FormatTest_suite, 13 | FormatWTest_suite, 14 | }; 15 | 16 | PCU_enable_color(); 17 | PCU_set_putchar(putchar); 18 | PCU_set_getchar(getchar); 19 | PCU_set_verbose(1); 20 | return PCU_run(suites, sizeof suites / sizeof *suites); 21 | } 22 | 23 | -------------------------------------------------------------------------------- /test/assert_output_test/main.c: -------------------------------------------------------------------------------- 1 | #include "../../PCUnit/PCUnit.h" 2 | #include 3 | 4 | PCU_Suite *AssertNotSupportedTest_suite(void); 5 | PCU_Suite *AssertOutputTest_suite(void); 6 | 7 | int main(void) 8 | { 9 | const PCU_SuiteMethod suites[] = { 10 | AssertNotSupportedTest_suite, 11 | AssertOutputTest_suite, 12 | }; 13 | PCU_set_putchar(putchar); 14 | PCU_set_getchar(getchar); 15 | PCU_set_verbose(1); 16 | PCU_enable_color(); 17 | return PCU_run(suites, sizeof suites / sizeof suites[0]); 18 | } 19 | 20 | -------------------------------------------------------------------------------- /sample/RingBuf.h: -------------------------------------------------------------------------------- 1 | #ifndef RINGBUF_H_INCLUDED 2 | #define RINGBUF_H_INCLUDED 3 | 4 | typedef struct RingBuf { 5 | int read_ptr; 6 | int write_ptr; 7 | unsigned char *buf; 8 | int buf_size; 9 | } RingBuf; 10 | 11 | void RingBuf_init(RingBuf *self, unsigned char *buf, int buf_size); 12 | int RingBuf_push(RingBuf *self, unsigned char data); 13 | unsigned char RingBuf_pop(RingBuf *self); 14 | int RingBuf_maxsize(RingBuf *self); 15 | int RingBuf_size(RingBuf *self); 16 | int RingBuf_empty(RingBuf *self); 17 | int RingBuf_full(RingBuf *self); 18 | 19 | 20 | #endif /* RINGBUF_H_INCLUDED */ 21 | -------------------------------------------------------------------------------- /test/PCU_Libc_test/main.c: -------------------------------------------------------------------------------- 1 | #include "../../PCUnit/PCUnit.h" 2 | #include 3 | #include 4 | 5 | 6 | PCU_Suite *FormatNoStdargTest_suite(void); 7 | PCU_Suite *StringTest_suite(void); 8 | PCU_Suite *StrtolTest_suite(void); 9 | 10 | int main(void) 11 | { 12 | const PCU_SuiteMethod suites[] = { 13 | FormatNoStdargTest_suite, 14 | StringTest_suite, 15 | StrtolTest_suite, 16 | }; 17 | 18 | PCU_enable_color(); 19 | PCU_set_putchar(putchar); 20 | PCU_set_getchar(getchar); 21 | PCU_set_verbose(1); 22 | return PCU_run(suites, sizeof suites / sizeof *suites); 23 | } 24 | 25 | -------------------------------------------------------------------------------- /.hgtags: -------------------------------------------------------------------------------- 1 | d1298cbfc3a08d58bec654d9f96d88392757d53d 1.0.0 2 | 630455015fbe992860175222d5d404cf83e44762 1.1.0 3 | b6e5fb176807dd3484181735ce9ff549de87e820 1.1.1 4 | 3c1105ba483f08a5319f493382dbcdf7872fe911 1.1.2 5 | fc9c40244d7c5102424982b0cd85c830ef4e5bf1 1.2.0 6 | 401209f2543b7428878bf0a53529c8cb769e2fb4 1.2.1 7 | 67b5f80d9bbef521b879818acddeacada1aa109a 1.3.0 8 | ce59f6d0405e8275c5b21590affd8d13cf250241 1.4.0 9 | d96d175e5c207c0e546e725bacc437ce7bb89d38 1.4.1 10 | 4c76dde6a3c958445abe01c8df3e53c98f05b4ad 1.5.0 11 | 5de35f6e9435d2c9fe693d21880132f775e35c93 1.6.0 12 | a54cb0788dd838ccf93903e96cc31404d60f7879 1.7.0 13 | -------------------------------------------------------------------------------- /test/Makefile: -------------------------------------------------------------------------------- 1 | .PHONY: all test xml build clean 2 | 3 | all: test 4 | 5 | test: build 6 | -cd PCU_Libc_test && $(MAKE) test 7 | -cd PCU_format_test && $(MAKE) test 8 | -cd assert_output_test && $(MAKE) test 9 | 10 | xml: build 11 | -cd PCU_Libc_test && $(MAKE) xml && cp *_results.xml ../ 12 | -cd PCU_format_test && $(MAKE) xml && cp *_results.xml ../ 13 | -cd assert_output_test && $(MAKE) xml && cp *_results.xml ../ 14 | 15 | build: 16 | -cd PCU_Libc_test && $(MAKE) 17 | -cd PCU_format_test && $(MAKE) 18 | -cd assert_output_test && $(MAKE) 19 | 20 | clean: 21 | -cd PCU_Libc_test && $(MAKE) clean 22 | -cd PCU_format_test && $(MAKE) clean 23 | -cd assert_output_test && $(MAKE) clean 24 | -rm *.xml 25 | -------------------------------------------------------------------------------- /test/assert_test/CleanupTest.c: -------------------------------------------------------------------------------- 1 | #include "../../PCUnit/PCUnit.h" 2 | 3 | static int initialize(void) 4 | { 5 | return 0; 6 | } 7 | 8 | static int cleanup(void) 9 | { 10 | return -1; 11 | } 12 | 13 | static int setup(void) 14 | { 15 | return 0; 16 | } 17 | 18 | static int teardown(void) 19 | { 20 | return 0; 21 | } 22 | 23 | 24 | static void test_assert_cleanup_err(void) 25 | { 26 | PCU_ASSERT(1); 27 | } 28 | 29 | 30 | static PCU_Test tests[] = { 31 | PCU_TEST(test_assert_cleanup_err), 32 | }; 33 | 34 | PCU_Suite *CleanupTest_suite(void) 35 | { 36 | static PCU_Suite suite = { 37 | "CleanupTest", tests, sizeof tests / sizeof tests[0], setup, teardown, initialize, cleanup 38 | }; 39 | return &suite; 40 | } 41 | 42 | -------------------------------------------------------------------------------- /PCUnit/COPYING.ja: -------------------------------------------------------------------------------- 1 | PCUnitはzlibライセンスに従って配布されます。 2 | 以下はzlibライセンスの日本語参考訳です。 3 | 4 | ---------------------------------------------------------------------------- 5 | Copyright (c) 2010-2015, KATO Noriaki 6 | 7 | 本ソフトウェアは「現状のまま」で、明示であるか暗黙であるかを問わず、何らの保 8 | 証もなく提供されます。本ソフトウェアの使用によって生じるいかなる損害について 9 | も、作者は一切の責任を負わないものとします。 10 | 11 | 以下の制限に従う限り、商用アプリケーションを含めて、本ソフトウェアを任意の目 12 | 的に使用し、自由に改変して再頒布することをすべての人に許可します。 13 | 14 | 1. 本ソフトウェアの出自について虚偽の表示をしてはなりません。あなたがオリ 15 | ジナルのソフトウェアを作成したと主張してはなりません。あなたが本ソフト 16 | ウェアを製品内で使用する場合、製品の文書に謝辞を入れていただければ幸い 17 | ですが、必須ではありません。 18 | 19 | 2. ソースを変更した場合は、そのことを明示しなければなりません。オリジナル 20 | のソフトウェアであるという虚偽の表示をしてはなりません。 21 | 22 | 3. ソースの頒布物から、この表示を削除したり、表示の内容を変更したりしては 23 | なりません。 24 | 25 | -------------------------------------------------------------------------------- /test/assert_test/InitializeTest.c: -------------------------------------------------------------------------------- 1 | #include "../../PCUnit/PCUnit.h" 2 | #include 3 | 4 | static int initialize(void) 5 | { 6 | return -1; 7 | } 8 | 9 | static int cleanup(void) 10 | { 11 | printf("NOT REACHED\n"); 12 | return 0; 13 | } 14 | 15 | static int setup(void) 16 | { 17 | printf("NOT REACHED\n"); 18 | return 0; 19 | } 20 | 21 | static int teardown(void) 22 | { 23 | printf("NOT REACHED\n"); 24 | return 0; 25 | } 26 | 27 | 28 | static void test_assert_initialize_err(void) 29 | { 30 | printf("NOT REACHED\n"); 31 | PCU_ASSERT(1); 32 | } 33 | 34 | 35 | static PCU_Test tests[] = { 36 | PCU_TEST(test_assert_initialize_err), 37 | }; 38 | 39 | PCU_Suite *InitializeTest_suite(void) 40 | { 41 | static PCU_Suite suite = { 42 | "InitializeTest", tests, sizeof tests / sizeof tests[0], setup, teardown, initialize, cleanup 43 | }; 44 | return &suite; 45 | } 46 | 47 | -------------------------------------------------------------------------------- /sample/main.c: -------------------------------------------------------------------------------- 1 | #include "PCUnit/PCUnit.h" 2 | #include 3 | 4 | PCU_Suite *RingBufTest_suite(void); 5 | PCU_Suite *StrTokenTest_suite(void); 6 | 7 | int main(int argc, char *argv[]) 8 | { 9 | const PCU_SuiteMethod suites[] = { 10 | RingBufTest_suite, 11 | StrTokenTest_suite, 12 | }; 13 | int i; 14 | int console_mode = 0; 15 | PCU_set_putchar(putchar); 16 | PCU_set_getchar(getchar); 17 | PCU_enable_color(); 18 | for (i = 1; i < argc; i++) { 19 | if (argv[i][0] == '-') { 20 | switch (argv[i][1]) { 21 | case 'c': 22 | console_mode = 1; 23 | break; 24 | case 'v': 25 | PCU_set_verbose(1); 26 | break; 27 | case 'd': 28 | PCU_disable_color(); 29 | break; 30 | default: 31 | break; 32 | } 33 | } 34 | } 35 | if (console_mode) { 36 | return PCU_console_run(suites, sizeof suites / sizeof suites[0]); 37 | } 38 | return PCU_run(suites, sizeof suites / sizeof suites[0]); 39 | } 40 | 41 | -------------------------------------------------------------------------------- /test/pcunit_mock_test/Makefile: -------------------------------------------------------------------------------- 1 | CC = gcc 2 | CFLAGS = -Wall -g 3 | CFLAGS += -I../.. 4 | PCUNIT_DIR = ../../PCUnit 5 | LFLAGS = -L$(PCUNIT_DIR) -lpcunit 6 | 7 | TARGET = alltests 8 | OBJS = main.o 9 | OBJS += MockTest.o 10 | OBJS += mock_target.o 11 | 12 | 13 | .PHONY: all clean pcunit_register test xml 14 | 15 | all: pcunit_register $(TARGET) 16 | 17 | pcunit_register: 18 | -ruby $(PCUNIT_DIR)/pcunit_register.rb -e mock_target 19 | 20 | .SUFFIXES: .c .o 21 | 22 | .c.o: 23 | $(CC) $(CFLAGS) -c $< 24 | 25 | $(TARGET): $(OBJS) 26 | cd $(PCUNIT_DIR) && $(MAKE) 27 | $(CC) $(CFLAGS) $(OBJS) -o $@ $(LFLAGS) 28 | 29 | test: all 30 | ./$(TARGET) 31 | 32 | xml: all 33 | ./$(TARGET) verbose | ruby $(PCUNIT_DIR)/pcunit_xml_output.rb $(OUTPUT) 34 | 35 | clean: 36 | cd $(PCUNIT_DIR) && $(MAKE) clean 37 | rm -f *.o $(TARGET) target.h mock_target.* 38 | 39 | mock_target.o: $(PCUNIT_DIR)/pcunit_mock.rb create_header.rb 40 | -ruby ./create_header.rb 41 | -ruby $(PCUNIT_DIR)/pcunit_mock.rb target.h 42 | $(CC) $(CFLAGS) -c $*.c 43 | 44 | MockTest.o: mock_target.o 45 | -------------------------------------------------------------------------------- /PCUnit/COPYING: -------------------------------------------------------------------------------- 1 | 'PCUnit' is distributed under the zlib license. 2 | The license is below. 3 | 4 | ---------------------------------------------------------------------------- 5 | Copyright (c) 2010-2015, KATO Noriaki 6 | 7 | This software is provided 'as-is', without any express or implied warranty. 8 | In no event will the authors be held liable for any damages arising from the 9 | use of this software. 10 | 11 | Permission is granted to anyone to use this software for any purpose, 12 | including commercial applications, and to alter it and redistribute it 13 | freely, subject to the following restrictions: 14 | 15 | 1. The origin of this software must not be misrepresented; you must not 16 | claim that you wrote the original software. If you use this software 17 | in a product, an acknowledgment in the product documentation would be 18 | appreciated but is not required. 19 | 20 | 2. Altered source versions must be plainly marked as such, and must not be 21 | misrepresented as being the original software. 22 | 23 | 3. This notice may not be removed or altered from any source distribution. 24 | 25 | -------------------------------------------------------------------------------- /test/assert_output_test/AssertNotSupportedTest.c: -------------------------------------------------------------------------------- 1 | #include "../../PCUnit/PCUnit.h" 2 | #include 3 | #include 4 | 5 | static FILE *fp_expected; 6 | static FILE *fp_actual; 7 | 8 | static int initialize(void) 9 | { 10 | fp_expected = fopen("assert_not_supported_expected.txt", "r"); 11 | fp_actual = fopen("assert_not_supported_actual.txt", "r"); 12 | return !(fp_expected && fp_actual); 13 | } 14 | 15 | static int cleanup(void) 16 | { 17 | fclose(fp_expected); 18 | fclose(fp_actual); 19 | return 0; 20 | } 21 | 22 | static int setup(void) 23 | { 24 | return 0; 25 | } 26 | 27 | static int teardown(void) 28 | { 29 | return 0; 30 | } 31 | 32 | 33 | void output_test(FILE *fp_exp, FILE *fp_act); 34 | 35 | static void test_not_supported(void) 36 | { 37 | output_test(fp_expected, fp_actual); 38 | } 39 | 40 | 41 | PCU_Suite *AssertNotSupportedTest_suite(void) 42 | { 43 | static PCU_Test tests[] = { 44 | PCU_TEST(test_not_supported), 45 | }; 46 | static PCU_Suite suite = { 47 | "AssertNotSupportedTest", tests, sizeof tests / sizeof tests[0], setup, teardown, initialize, cleanup 48 | }; 49 | return &suite; 50 | } 51 | 52 | -------------------------------------------------------------------------------- /sample/Makefile: -------------------------------------------------------------------------------- 1 | CC = gcc 2 | CFLAGS = -Wall -g 3 | # CFLAGS += -DPCU_NO_LIBC 4 | TARGET = sample 5 | PCUNITDIR = ../PCUnit 6 | CFLAGS += -I$(PCUNITDIR)/../ 7 | LIBPCUNIT = $(PCUNITDIR)/libpcunit.a 8 | LFLAGS = -L$(PCUNITDIR) -lpcunit 9 | OBJS = main.o 10 | OBJS += RingBuf.o test_RingBuf.o 11 | OBJS += StrToken.o test_StrToken.o 12 | OBJS += $(LIBPCUNIT) 13 | 14 | .PHONY: all clean pcunit_register test xml 15 | 16 | all: pcunit_register $(TARGET) 17 | 18 | pcunit_register: 19 | -ruby $(PCUNITDIR)/pcunit_register.rb 20 | 21 | .SUFFIXES: .c .o 22 | 23 | .c.o: 24 | $(CC) $(CFLAGS) -c $< 25 | 26 | $(LIBPCUNIT): 27 | cd $(PCUNITDIR) && $(MAKE) 28 | 29 | $(TARGET): $(OBJS) 30 | $(CC) $(CFLAGS) $(OBJS) -o $@ $(LFLAGS) 31 | 32 | test: all 33 | ./$(TARGET) 34 | 35 | xml: all 36 | ./$(TARGET) -v | ruby $(PCUNITDIR)/pcunit_xml_output.rb $(OUTPUT) 37 | 38 | clean: 39 | rm -f *.o $(TARGET) $(PCUNITDIR)/*.o $(LIBPCUNIT) 40 | 41 | main.o: $(PCUNITDIR)/PCUnit.h 42 | StrToken.o: StrToken.h 43 | test_StrToken.o: StrToken.h $(PCUNITDIR)/PCUnit.h 44 | RingBuf.o: RingBuf.h 45 | test_RingBuf.o: RingBuf.h $(PCUNITDIR)/PCUnit.h 46 | 47 | $(LIBPCUNIT): $(PCUNITDIR)/*.h $(PCUNITDIR)/*.c 48 | -------------------------------------------------------------------------------- /sample/RingBuf.c: -------------------------------------------------------------------------------- 1 | #include "RingBuf.h" 2 | 3 | 4 | void RingBuf_init(RingBuf *self, unsigned char *buf, int buf_size) 5 | { 6 | self->read_ptr = self->write_ptr = 0; 7 | self->buf = buf; 8 | self->buf_size = buf_size; 9 | } 10 | 11 | int RingBuf_push(RingBuf *self, unsigned char data) 12 | { 13 | if (RingBuf_full(self)) { 14 | return 0; 15 | } 16 | self->buf[self->write_ptr] = data; 17 | self->write_ptr = ((self->write_ptr + 1) & (self->buf_size - 1)); 18 | return 1; 19 | } 20 | 21 | unsigned char RingBuf_pop(RingBuf *self) 22 | { 23 | unsigned char ret; 24 | ret = self->buf[self->read_ptr]; 25 | self->read_ptr = ((self->read_ptr + 1) & (self->buf_size - 1)); 26 | return ret; 27 | } 28 | 29 | int RingBuf_maxsize(RingBuf *self) 30 | { 31 | return self->buf_size - 1; 32 | } 33 | 34 | int RingBuf_size(RingBuf *self) 35 | { 36 | return (self->read_ptr <= self->write_ptr) ? 37 | self->write_ptr - self->read_ptr : 38 | self->buf_size - self->read_ptr + self->write_ptr; 39 | } 40 | 41 | int RingBuf_empty(RingBuf *self) 42 | { 43 | return self->read_ptr == self->write_ptr; 44 | } 45 | 46 | int RingBuf_full(RingBuf *self) 47 | { 48 | return self->read_ptr == ((self->write_ptr + 1) & (self->buf_size - 1)); 49 | } 50 | 51 | -------------------------------------------------------------------------------- /test/assert_output_test/Makefile: -------------------------------------------------------------------------------- 1 | CFLAGS = -Wall -g 2 | 3 | 4 | TARGET = assert_output_test 5 | 6 | OBJS = main.o 7 | OBJS += ../../PCUnit/libpcunit.a 8 | OBJS += AssertOutputTest.o 9 | OBJS += AssertNotSupportedTest.o 10 | 11 | 12 | .PHONY: all clean pcunit_register test xml 13 | 14 | all: pcunit_register $(TARGET) 15 | 16 | pcunit_register: 17 | -ruby ../../PCUnit/pcunit_register.rb 18 | cd ../assert_test && $(MAKE) 19 | - ../assert_test/assert_test nocolor > assert_output_actual.txt 20 | - ../assert_test/assert_test nocolor verbose > assert_output_verbose_actual.txt 21 | cd ../assert_test && $(MAKE) not_supported 22 | - ../assert_test/assert_test_not_supported nocolor > assert_not_supported_actual.txt 23 | 24 | .SUFFIXES: .c .o 25 | 26 | .c.o: 27 | $(CC) $(CFLAGS) -c $< 28 | 29 | ../../PCUnit/libpcunit.a: 30 | cd ../../PCUnit && $(MAKE) 31 | 32 | 33 | $(TARGET): $(OBJS) 34 | $(CC) $(CFLAGS) $(OBJS) -o $@ 35 | 36 | test: 37 | ./$(TARGET) 38 | 39 | xml: 40 | ./$(TARGET) | ruby ../../PCUnit/pcunit_xml_output.rb $(TARGET)_results.xml 41 | 42 | clean: 43 | cd ../assert_test && $(MAKE) clean 44 | rm -f *.o $(TARGET) assert_output_actual.txt assert_output_verbose_actual.txt assert_not_supported_actual.txt *.xml 45 | 46 | 47 | main.o: ../../PCUnit/PCUnit.h 48 | AssertOutputTest.o: ../../PCUnit/PCUnit.h 49 | AssertNotSupportedTest.o: ../../PCUnit/PCUnit.h 50 | -------------------------------------------------------------------------------- /test/assert_test/SetupTest.c: -------------------------------------------------------------------------------- 1 | #include "../../PCUnit/PCUnit.h" 2 | #include 3 | #include 4 | 5 | static int initialize(void) 6 | { 7 | return 0; 8 | } 9 | 10 | static int cleanup(void) 11 | { 12 | return 0; 13 | } 14 | 15 | static int setup(void) 16 | { 17 | if (strcmp(PCU_test_name(), "test_assert_setup_err") == 0) { 18 | return -1; 19 | } 20 | return 0; 21 | } 22 | 23 | static int teardown(void) 24 | { 25 | if (strcmp(PCU_test_name(), "test_assert_teardown_err") == 0) { 26 | return -2; 27 | } 28 | return 0; 29 | } 30 | 31 | 32 | static void test_assert_setup_err(void) 33 | { 34 | printf("NOT REACHED\n"); 35 | PCU_ASSERT(0); 36 | } 37 | 38 | static void test_assert_teardown_err(void) 39 | { 40 | PCU_ASSERT(1); 41 | } 42 | 43 | 44 | static void test_skip(void) 45 | { 46 | printf("NOT REACHED\n"); 47 | PCU_ASSERT(0); 48 | } 49 | 50 | static void test_repeated(void) 51 | { 52 | PCU_ASSERT_EQUAL(-1, PCU_repeat_counter()); 53 | } 54 | 55 | 56 | 57 | static PCU_Test tests[] = { 58 | PCU_TEST(test_assert_setup_err), 59 | PCU_TEST(test_assert_teardown_err), 60 | PCU_TEST_SKIPPED(test_skip), 61 | PCU_TEST_REPEATED(test_repeated, 5), 62 | }; 63 | 64 | PCU_Suite *SetupTest_suite(void) 65 | { 66 | static PCU_Suite suite = { 67 | "SetupTest", tests, sizeof tests / sizeof tests[0], setup, teardown, initialize, cleanup 68 | }; 69 | return &suite; 70 | } 71 | 72 | -------------------------------------------------------------------------------- /test/assert_test/FailTest.c: -------------------------------------------------------------------------------- 1 | #include "../../PCUnit/PCUnit.h" 2 | #include 3 | 4 | static int initialize(void) 5 | { 6 | return 0; 7 | } 8 | 9 | static int cleanup(void) 10 | { 11 | return 0; 12 | } 13 | 14 | static int setup(void) 15 | { 16 | return 0; 17 | } 18 | 19 | static int teardown(void) 20 | { 21 | return 0; 22 | } 23 | 24 | 25 | static void test_fail1(void) 26 | { 27 | PCU_FAIL("test_fail"); 28 | printf("NOT REACHED\n"); 29 | } 30 | 31 | static void test_fail2(void) 32 | { 33 | PCU_FAIL(PCU_format("test_fail: %d,%#x, %c, %04d, %s, 0x%08X, %+d, %-8x,% d, %10d", 1, 2, '3', 4, "5", 6, 7, 8, -9, 10)); 34 | } 35 | 36 | static void test_message1(void) 37 | { 38 | PCU_MESSAGE("test_message"); 39 | } 40 | 41 | static void test_message2(void) 42 | { 43 | PCU_MESSAGE(PCU_format("test_message: %d,%#x, %c, %04d, %s, 0x%08X, %+d, %-8x,% d, %10d", 1, 2, '3', 4, "5", 6, 7, 8, -9, 10)); 44 | } 45 | 46 | static void test_message_fail(void) 47 | { 48 | PCU_MESSAGE("test_message"); 49 | PCU_FAIL("test_fail"); 50 | } 51 | 52 | 53 | static PCU_Test tests[] = { 54 | PCU_TEST(test_fail1), 55 | PCU_TEST(test_fail2), 56 | PCU_TEST(test_message1), 57 | PCU_TEST(test_message2), 58 | PCU_TEST(test_message_fail), 59 | }; 60 | 61 | PCU_Suite *FailTest_suite(void) 62 | { 63 | static PCU_Suite suite = { 64 | "FailTest", tests, sizeof tests / sizeof tests[0], setup, teardown, initialize, cleanup 65 | }; 66 | return &suite; 67 | } 68 | 69 | -------------------------------------------------------------------------------- /PCUnit/Makefile: -------------------------------------------------------------------------------- 1 | CC = gcc 2 | AR = ar 3 | CFLAGS = -Wall -W -Os 4 | # CFLAGS += -DPCU_NO_VSPRINTF 5 | # CFLAGS += -DPCU_NO_SETJMP 6 | # CFLAGS += -DPCU_NO_LIBC 7 | # CFLAGS += -DPCU_NO_STDARG 8 | # CFLAGS += -DPCU_NO_FLOATINGPOINT 9 | # CFLAGS += -DPCU_NO_DIV32 10 | # CFLAGS += -DPCU_NO_CONSOLE_RUN 11 | CFLAGS += -DPCU_USE_WCHAR 12 | # CFLAGS += -DPCU_FORMAT_BUFSIZE=256 13 | 14 | TARGET = libpcunit.a 15 | OBJS = PCUnit.o 16 | OBJS += PCU_Test.o 17 | OBJS += PCU_Suite.o 18 | OBJS += PCU_Libc.o 19 | 20 | .PHONY: all clean install uninstall 21 | 22 | all: $(TARGET) 23 | 24 | .SUFFIXES: .c .o 25 | 26 | .c.o: 27 | $(CC) $(CFLAGS) -c $< 28 | 29 | $(TARGET): $(OBJS) 30 | $(AR) rcs $(TARGET) $^ 31 | 32 | INSTALLDIR = /usr/local 33 | 34 | install: 35 | install -d $(INSTALLDIR)/lib 36 | install -d $(INSTALLDIR)/include/PCUnit 37 | install -d $(INSTALLDIR)/bin 38 | install -m 644 $(TARGET) $(INSTALLDIR)/lib 39 | install -m 644 PCUnit.h $(INSTALLDIR)/include/PCUnit 40 | for i in `ls pcunit_*.rb`; do\ 41 | install -m 755 $$i $(INSTALLDIR)/bin;\ 42 | done 43 | 44 | uninstall: 45 | rm -f $(INSTALLDIR)/lib/$(TARGET) 46 | rm -rf $(INSTALLDIR)/include/PCUnit 47 | rm -f $(INSTALLDIR)/bin/pcunit_*.rb 48 | 49 | clean: 50 | rm -f *.o *.a 51 | 52 | PCUnit.o: PCU_Test.h PCU_Suite.h PCU_Libc.h PCUnit.h Makefile 53 | PCU_Test.o: PCU_Test.h PCU_Suite.h PCU_Libc.h PCUnit.h Makefile 54 | PCU_Suite.o: PCU_Test.h PCU_Suite.h PCU_Libc.h PCUnit.h Makefile 55 | PCU_Libc.o: PCU_Libc.h PCUnit.h Makefile 56 | -------------------------------------------------------------------------------- /test/assert_test/main.c: -------------------------------------------------------------------------------- 1 | #include "../../PCUnit/PCUnit.h" 2 | #include 3 | #include 4 | 5 | PCU_Suite *AssertDoubleTest_suite(void); 6 | PCU_Suite *AssertEqualTest_suite(void); 7 | PCU_Suite *AssertMemoryTest_suite(void); 8 | PCU_Suite *AssertOperatorTest_suite(void); 9 | PCU_Suite *AssertPtrTest_suite(void); 10 | PCU_Suite *AssertStringTest_suite(void); 11 | PCU_Suite *AssertStringWTest_suite(void); 12 | PCU_Suite *AssertTest_suite(void); 13 | PCU_Suite *CleanupTest_suite(void); 14 | PCU_Suite *FailTest_suite(void); 15 | PCU_Suite *InitializeTest_suite(void); 16 | PCU_Suite *SetupTest_suite(void); 17 | 18 | int main(int argc, char **argv) 19 | { 20 | const PCU_SuiteMethod suites[] = { 21 | AssertDoubleTest_suite, 22 | AssertEqualTest_suite, 23 | AssertMemoryTest_suite, 24 | AssertOperatorTest_suite, 25 | AssertPtrTest_suite, 26 | AssertStringTest_suite, 27 | AssertStringWTest_suite, 28 | AssertTest_suite, 29 | CleanupTest_suite, 30 | FailTest_suite, 31 | InitializeTest_suite, 32 | SetupTest_suite, 33 | }; 34 | 35 | PCU_set_putchar(putchar); 36 | PCU_set_getchar(getchar); 37 | if (argc > 1 && !strcmp(argv[1], "console")) { 38 | PCU_enable_color(); 39 | PCU_console_run(suites, sizeof suites / sizeof *suites); 40 | } else if (argc > 1 && !strcmp(argv[1], "nocolor")) { 41 | PCU_disable_color(); 42 | if (argc > 2 && !strcmp(argv[2], "verbose")) { 43 | PCU_set_verbose(1); 44 | } 45 | return PCU_run(suites, sizeof suites / sizeof *suites); 46 | } else { 47 | PCU_enable_color(); 48 | return PCU_run(suites, sizeof suites / sizeof *suites); 49 | } 50 | return 0; 51 | } 52 | 53 | -------------------------------------------------------------------------------- /test/PCU_Libc_test/Makefile: -------------------------------------------------------------------------------- 1 | CFLAGS = -Wall -std=c99 -g 2 | 3 | TARGET = PCU_Libc_test 4 | 5 | OBJS = main.o 6 | OBJS += PCU_Libc.o 7 | OBJS += test_format_no_stdarg.o 8 | OBJS += test_string.o 9 | OBJS += test_strtol.o 10 | OBJS += ../../PCUnit/libpcunit.a 11 | 12 | .PHONY: all clean pcunit_register test xml 13 | 14 | all: pcunit_register $(TARGET) 15 | 16 | pcunit_register: 17 | -ruby ../../PCUnit/pcunit_register.rb 18 | cd ../../PCUnit && $(MAKE) clean 19 | cd ../../PCUnit && $(MAKE) CFLAGS="-Wall -W -std=c99 -DPCU_USE_WCHAR -g -DPCU_FORMAT_BUFSIZE=256" 20 | 21 | 22 | PCU_LIBC_DEFINE = -DPCU_NO_LIBC -DPCU_NO_STDARG 23 | PCU_LIBC_DEFINE += -DPCU_FORMAT_BUFSIZE=256 24 | PCU_LIBC_DEFINE += -DPCU_set_putchar=PCU_set_putchar_dummy 25 | PCU_LIBC_DEFINE += -DPCU_set_getchar=PCU_set_getchar_dummy 26 | PCU_LIBC_DEFINE += -DPCU_getchar=PCU_getchar_dummy 27 | PCU_LIBC_DEFINE += -DPCU_puts=PCU_puts_dummy 28 | PCU_LIBC_DEFINE += -DPCU_formatW=PCU_formatW_dummy 29 | 30 | PCU_Libc.o: ../../PCUnit/PCU_Libc.c 31 | $(CC) $(CFLAGS) $(PCU_LIBC_DEFINE) -c $< 32 | 33 | 34 | .SUFFIXES: .c .o 35 | 36 | .c.o: 37 | $(CC) $(CFLAGS) -c $< 38 | 39 | 40 | $(TARGET): $(OBJS) 41 | $(CC) $(CFLAGS) $(OBJS) -o $@ 42 | cd ../../PCUnit && $(MAKE) clean 43 | 44 | test: 45 | ./$(TARGET) 46 | 47 | xml: 48 | ./$(TARGET) | ruby ../../PCUnit/pcunit_xml_output.rb $(TARGET)_results.xml 49 | 50 | clean: 51 | rm -f *.o $(TARGET) *.xml 52 | 53 | 54 | PCU_Libc.o: ../../PCUnit/PCU_Libc.h ../../PCUnit/PCUnit.h 55 | main.o: ../../PCUnit/PCUnit.h 56 | test_format_no_stdarg.o: ../../PCUnit/PCUnit.h 57 | test_string.o: ../../PCUnit/PCUnit.h 58 | test_strtol.o: ../../PCUnit/PCUnit.h 59 | 60 | -------------------------------------------------------------------------------- /test/PCU_format_test/Makefile: -------------------------------------------------------------------------------- 1 | CFLAGS = -Wall -std=c99 -g 2 | 3 | TARGET = PCU_format_test 4 | 5 | OBJS = main.o 6 | OBJS += PCU_Libc.o 7 | OBJS += test_format.o 8 | OBJS += test_formatW.o 9 | OBJS += ../../PCUnit/libpcunit.a 10 | 11 | .PHONY: all clean pcunit_register test xml 12 | 13 | all: pcunit_register $(TARGET) 14 | 15 | pcunit_register: 16 | -ruby ../../PCUnit/pcunit_register.rb 17 | cd ../../PCUnit && $(MAKE) clean 18 | cd ../../PCUnit && $(MAKE) CFLAGS="-Wall -W -std=c99 -DPCU_USE_WCHAR -g -DPCU_FORMAT_BUFSIZE=256" 19 | 20 | 21 | PCU_LIBC_DEFINE = -DPCU_NO_VSPRINTF 22 | PCU_LIBC_DEFINE += -DPCU_FORMAT_BUFSIZE=256 23 | PCU_LIBC_DEFINE += -DPCU_set_putchar=PCU_set_putchar_dummy 24 | PCU_LIBC_DEFINE += -DPCU_set_getchar=PCU_set_getchar_dummy 25 | PCU_LIBC_DEFINE += -DPCU_getchar=PCU_getchar_dummy 26 | PCU_LIBC_DEFINE += -DPCU_puts=PCU_puts_dummy 27 | PCU_LIBC_DEFINE += -DPCU_printf=PCU_printf_dummy 28 | PCU_LIBC_DEFINE += -DPCU_format=PCU_format_test 29 | PCU_LIBC_DEFINE += -DPCU_formatW=PCU_formatW_dummy 30 | 31 | PCU_Libc.o: ../../PCUnit/PCU_Libc.c 32 | $(CC) $(CFLAGS) $(PCU_LIBC_DEFINE) -c $< 33 | 34 | 35 | .SUFFIXES: .c .o 36 | 37 | .c.o: 38 | $(CC) $(CFLAGS) -c $< 39 | 40 | 41 | $(TARGET): $(OBJS) 42 | $(CC) $(CFLAGS) $(OBJS) -o $@ 43 | cd ../../PCUnit && $(MAKE) clean 44 | 45 | test: 46 | ./$(TARGET) 47 | 48 | xml: 49 | ./$(TARGET) | ruby ../../PCUnit/pcunit_xml_output.rb $(TARGET)_results.xml 50 | 51 | clean: 52 | rm -f *.o $(TARGET) *.xml 53 | 54 | 55 | PCU_Libc.o: ../../PCUnit/PCU_Libc.h ../../PCUnit/PCUnit.h 56 | main.o: ../../PCUnit/PCUnit.h 57 | test_format.o: ../../PCUnit/PCUnit.h 58 | test_formatW.o: ../../PCUnit/PCUnit.h 59 | 60 | -------------------------------------------------------------------------------- /sample/StrToken.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "StrToken.h" 5 | 6 | struct StrToken { 7 | char *buf; 8 | char **token; 9 | size_t token_count; 10 | }; 11 | 12 | static int is_delim(char c, const char *delims) 13 | { 14 | const char *p; 15 | for (p = delims; *p; p++) { 16 | if (*p == c) { 17 | return 1; 18 | } 19 | } 20 | return 0; 21 | } 22 | 23 | StrToken *StrToken_new(const char *str, const char *delims) 24 | { 25 | StrToken *self; 26 | char *p; 27 | size_t len; 28 | size_t token_max; 29 | int prev_is_delim; 30 | assert(str); 31 | assert(delims); 32 | 33 | len = strlen(str) + 1; 34 | #define ALIGN(size) (((size) + sizeof(void *) - 1) & ~(sizeof(void *) - 1)) 35 | token_max = ALIGN(sizeof(char *) * len >> 1); 36 | self = (StrToken *) malloc(sizeof(StrToken) + token_max + len); 37 | if (!self) return 0; 38 | 39 | self->token = (char **) (self + 1); 40 | self->buf = ((char *) self->token) + token_max; 41 | strcpy(self->buf, str); 42 | 43 | self->token_count = 0; 44 | prev_is_delim = 1; 45 | for (p = self->buf; *p; p++) { 46 | if (is_delim(*p, delims)) { 47 | *p = '\0'; 48 | prev_is_delim = 1; 49 | } else { 50 | if (prev_is_delim) { 51 | self->token[self->token_count++] = p; 52 | } 53 | prev_is_delim = 0; 54 | } 55 | } 56 | assert(self->token_count <= (len >> 1)); 57 | 58 | return self; 59 | } 60 | 61 | void StrToken_delete(StrToken *self) 62 | { 63 | if (!self) return; 64 | free(self); 65 | } 66 | 67 | size_t StrToken_count(StrToken *self) 68 | { 69 | assert(self); 70 | return self->token_count; 71 | } 72 | 73 | const char *StrToken_get(StrToken *self, size_t idx) 74 | { 75 | assert(self); 76 | assert(idx < self->token_count); 77 | return self->token[idx]; 78 | } 79 | 80 | -------------------------------------------------------------------------------- /PCUnit/PCU_Suite.c: -------------------------------------------------------------------------------- 1 | #include "PCU_Suite.h" 2 | #include "PCU_Test.h" 3 | #include "PCU_Libc.h" 4 | 5 | static PCU_Suite *current_suite; 6 | 7 | static void PCU_Suite_clear_result(PCU_Suite *self) 8 | { 9 | PCU_MEMSET(&self->result, 0, sizeof(self->result)); 10 | } 11 | 12 | void PCU_Suite_reset(PCU_Suite *self) 13 | { 14 | int i; 15 | PCU_Test *p; 16 | for (i = 0, p = self->tests; i < self->ntests; i++, p++) { 17 | PCU_Test_reset(p); 18 | } 19 | PCU_Suite_clear_result(self); 20 | self->result.num_tests = i; 21 | } 22 | 23 | int PCU_Suite_initialize(PCU_Suite *self) 24 | { 25 | current_suite = self; 26 | self->result.initialize_error = 0; 27 | if (self->initialize) { 28 | self->result.initialize_error = self->initialize(); 29 | } 30 | return self->result.initialize_error; 31 | } 32 | 33 | int PCU_Suite_cleanup(PCU_Suite *self) 34 | { 35 | self->result.cleanup_error = 0; 36 | if (self->cleanup) { 37 | self->result.cleanup_error = self->cleanup(); 38 | } 39 | return self->result.cleanup_error; 40 | } 41 | 42 | int PCU_Suite_setup(void) 43 | { 44 | int ret = 0; 45 | if (current_suite->setup) { 46 | ret = current_suite->setup(); 47 | } 48 | return ret; 49 | } 50 | 51 | int PCU_Suite_teardown(void) 52 | { 53 | int ret = 0; 54 | if (current_suite->teardown) { 55 | ret = current_suite->teardown(); 56 | } 57 | return ret; 58 | } 59 | 60 | void PCU_Suite_run(PCU_Suite *self) 61 | { 62 | int i; 63 | for (i = 0; i < self->ntests; i++) { 64 | PCU_Suite_run_selected(self, i); 65 | } 66 | } 67 | 68 | void PCU_Suite_run_selected(PCU_Suite *self, int idx) 69 | { 70 | PCU_Test *p = self->tests + idx; 71 | PCU_Test_run(p); 72 | if (!PCU_Test_is_skipped(p)) { 73 | self->result.num_tests_ran++; 74 | } 75 | if (PCU_Test_is_failed(p)) { 76 | self->result.num_tests_failed++; 77 | } 78 | } 79 | 80 | const char *PCU_suite_name(void) 81 | { 82 | return current_suite->name; 83 | } 84 | 85 | -------------------------------------------------------------------------------- /sample/test_StrToken.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Data Driven Test 3 | */ 4 | #include "PCUnit/PCUnit.h" 5 | #include "StrToken.h" 6 | 7 | typedef struct { 8 | const char *src; 9 | const char *delims; 10 | size_t expected_count; 11 | const char *expected_token[9]; 12 | } StrTokenTestData; 13 | 14 | static const StrTokenTestData test_data[] = { 15 | { "abc;def;gh;ij" , ";" , 4 , { "abc", "def", "gh", "ij"}}, 16 | { "abc;def;gh;ij;" , ";" , 4 , { "abc", "def", "gh", "ij"}}, 17 | { ";abc;def;gh;ij" , ";" , 4 , { "abc", "def", "gh", "ij"}}, 18 | { "abc,def;,;gh" , ",;" , 3 , { "abc", "def", "gh" }}, 19 | { ",abc,def;gh," , ";" , 2 , { ",abc,def", "gh," }}, 20 | { ",,abc,def,gh" , "," , 3 , { "abc", "def", "gh" }}, 21 | { ",,,abc,def,gh,,i," , "," , 4 , { "abc", "def", "gh", "i" }}, 22 | { "" , "," , 0 , { "" }}, 23 | { "abc" , "," , 1 , { "abc" }}, 24 | { "abc" , "" , 1 , { "abc" }}, 25 | { "" , "" , 0 , { "" }}, 26 | { ",,,;,,;,,;,;" , ",;" , 0 , { "" }}, 27 | }; 28 | 29 | static StrToken *tok; 30 | static const StrTokenTestData *data; 31 | 32 | static int setup(void) 33 | { 34 | data = &test_data[PCU_repeat_counter()]; 35 | 36 | tok = StrToken_new(data->src, data->delims); 37 | return tok == 0; 38 | } 39 | 40 | static int teardown(void) 41 | { 42 | StrToken_delete(tok); 43 | tok = 0; 44 | return 0; 45 | } 46 | 47 | static void test_StrToken(void) 48 | { 49 | size_t i; 50 | 51 | PCU_ASSERT_EQUAL(data->expected_count, StrToken_count(tok)); 52 | for (i = 0; i < data->expected_count; i++) { 53 | PCU_ASSERT_STRING_EQUAL_MESSAGE(data->expected_token[i], StrToken_get(tok, i), PCU_format("%dth token err", i)); 54 | } 55 | } 56 | 57 | 58 | PCU_Suite *StrTokenTest_suite(void) 59 | { 60 | static PCU_Test tests[] = { 61 | PCU_TEST_REPEATED(test_StrToken, sizeof test_data / sizeof test_data[0]), 62 | }; 63 | static PCU_Suite suite = { "StrTokenTest", tests, sizeof tests / sizeof tests[0], setup, teardown }; 64 | return &suite; 65 | } 66 | 67 | -------------------------------------------------------------------------------- /test/assert_test/AssertTest.c: -------------------------------------------------------------------------------- 1 | #include "../../PCUnit/PCUnit.h" 2 | #include 3 | 4 | static int initialize(void) 5 | { 6 | return 0; 7 | } 8 | 9 | static int cleanup(void) 10 | { 11 | return 0; 12 | } 13 | 14 | static int setup(void) 15 | { 16 | return 0; 17 | } 18 | 19 | static int teardown(void) 20 | { 21 | return 0; 22 | } 23 | 24 | 25 | static void test_assert_OK(void) 26 | { 27 | PCU_ASSERT(1); 28 | } 29 | 30 | static void test_assert_FAIL(void) 31 | { 32 | PCU_ASSERT(0); 33 | printf("NOT REACHED\n"); 34 | } 35 | 36 | static void test_assert_MSG(void) 37 | { 38 | int a = 1; 39 | PCU_ASSERT_MESSAGE(a, PCU_format("%d", a)); 40 | a = 0; 41 | PCU_ASSERT_MESSAGE(a, PCU_format("%d", a)); 42 | } 43 | 44 | static void test_assert_true_OK(void) 45 | { 46 | int a = 1; 47 | PCU_ASSERT_TRUE(a); 48 | } 49 | 50 | static void test_assert_true_FAIL(void) 51 | { 52 | int a = 0; 53 | PCU_ASSERT_TRUE(a); 54 | printf("NOT REACHED\n"); 55 | } 56 | 57 | static void test_assert_true_MSG(void) 58 | { 59 | int a = 1; 60 | PCU_ASSERT_TRUE_MESSAGE(a, PCU_format("%d", a)); 61 | a = 0; 62 | PCU_ASSERT_TRUE_MESSAGE(a, PCU_format("%d", a)); 63 | } 64 | 65 | static void test_assert_false_OK(void) 66 | { 67 | int a = 0; 68 | PCU_ASSERT_FALSE(a); 69 | } 70 | 71 | static void test_assert_false_FAIL(void) 72 | { 73 | int a = 1; 74 | PCU_ASSERT_FALSE(a); 75 | printf("NOT REACHED\n"); 76 | } 77 | 78 | static void test_assert_false_MSG(void) 79 | { 80 | int a = 0; 81 | PCU_ASSERT_FALSE_MESSAGE(a, PCU_format("%d", a)); 82 | a = 1; 83 | PCU_ASSERT_FALSE_MESSAGE(a, PCU_format("%d", a)); 84 | } 85 | 86 | static PCU_Test tests[] = { 87 | PCU_TEST(test_assert_OK), 88 | PCU_TEST(test_assert_FAIL), 89 | PCU_TEST(test_assert_MSG), 90 | PCU_TEST(test_assert_true_OK), 91 | PCU_TEST(test_assert_true_FAIL), 92 | PCU_TEST(test_assert_true_MSG), 93 | PCU_TEST(test_assert_false_OK), 94 | PCU_TEST(test_assert_false_FAIL), 95 | PCU_TEST(test_assert_false_MSG), 96 | }; 97 | 98 | 99 | PCU_Suite *AssertTest_suite(void) 100 | { 101 | static PCU_Suite suite = { 102 | "AssertTest", tests, sizeof tests / sizeof tests[0], setup, teardown, initialize, cleanup 103 | }; 104 | return &suite; 105 | } 106 | 107 | -------------------------------------------------------------------------------- /test/assert_test/AssertDoubleTest.c: -------------------------------------------------------------------------------- 1 | #include "../../PCUnit/PCUnit.h" 2 | #include 3 | 4 | static int initialize(void) 5 | { 6 | return 0; 7 | } 8 | 9 | static int cleanup(void) 10 | { 11 | return 0; 12 | } 13 | 14 | static int setup(void) 15 | { 16 | return 0; 17 | } 18 | 19 | static int teardown(void) 20 | { 21 | return 0; 22 | } 23 | 24 | 25 | 26 | static void test_assert_dbl_equal_OK(void) 27 | { 28 | double a, b, delta; 29 | a = 100.0; 30 | b = 100.0; 31 | delta = 0.0; 32 | PCU_ASSERT_DOUBLE_EQUAL(a, b, delta); 33 | 34 | a = 100.0; 35 | b = 100.1; 36 | delta = 0.1; 37 | PCU_ASSERT_DOUBLE_EQUAL(a, b, delta); 38 | 39 | } 40 | 41 | static void test_assert_dbl_equal_FAIL(void) 42 | { 43 | double a, b, delta; 44 | a = 100.0; 45 | b = 100.1; 46 | delta = 0.0999; 47 | PCU_ASSERT_DOUBLE_EQUAL(a, b, delta); 48 | printf("NOT REACHED\n"); 49 | } 50 | 51 | static void test_assert_dbl_equal_MSG(void) 52 | { 53 | double a, b, delta; 54 | a = 100.0; 55 | b = 100.1; 56 | delta = 0.1000; 57 | PCU_ASSERT_DOUBLE_EQUAL_MESSAGE(a, b, delta, PCU_format("%g, %g", a, b)); 58 | delta = 0.0999; 59 | PCU_ASSERT_DOUBLE_EQUAL_MESSAGE(a, b, delta, PCU_format("%g, %g", a, b)); 60 | } 61 | 62 | 63 | 64 | static void test_assert_dbl_not_equal_OK(void) 65 | { 66 | double a, b, delta; 67 | a = 100.0; 68 | b = 100.1; 69 | delta = 0.0999; 70 | PCU_ASSERT_DOUBLE_NOT_EQUAL(a, b, delta); 71 | 72 | a = 100.01; 73 | b = 100.0; 74 | delta = 0.001; 75 | PCU_ASSERT_DOUBLE_NOT_EQUAL(a, b, delta); 76 | 77 | } 78 | 79 | static void test_assert_dbl_not_equal_FAIL(void) 80 | { 81 | double a, b, delta; 82 | a = 100.0; 83 | b = 100.1; 84 | delta = 0.1; 85 | PCU_ASSERT_DOUBLE_NOT_EQUAL(a, b, delta); 86 | printf("NOT REACHED\n"); 87 | } 88 | 89 | static void test_assert_dbl_not_equal_MSG(void) 90 | { 91 | double a, b, delta; 92 | a = 100.0; 93 | b = 100.1; 94 | delta = 0.0999; 95 | PCU_ASSERT_DOUBLE_NOT_EQUAL_MESSAGE(a, b, delta, PCU_format("%g, %g", a, b)); 96 | delta = 0.1000; 97 | PCU_ASSERT_DOUBLE_NOT_EQUAL_MESSAGE(a, b, delta, PCU_format("%g, %g", a, b)); 98 | } 99 | 100 | 101 | 102 | static PCU_Test tests[] = { 103 | PCU_TEST(test_assert_dbl_equal_OK), 104 | PCU_TEST(test_assert_dbl_equal_FAIL), 105 | PCU_TEST(test_assert_dbl_equal_MSG), 106 | PCU_TEST(test_assert_dbl_not_equal_OK), 107 | PCU_TEST(test_assert_dbl_not_equal_FAIL), 108 | PCU_TEST(test_assert_dbl_not_equal_MSG), 109 | }; 110 | 111 | PCU_Suite *AssertDoubleTest_suite(void) 112 | { 113 | static PCU_Suite suite = { 114 | "AssertDoubleTest", tests, sizeof tests / sizeof tests[0], setup, teardown, initialize, cleanup 115 | }; 116 | return &suite; 117 | } 118 | 119 | -------------------------------------------------------------------------------- /test/assert_test/Makefile: -------------------------------------------------------------------------------- 1 | CFLAGS = -Wall -std=c99 -g 2 | 3 | TARGET = assert_test 4 | TARGET_NO_SETJMP = assert_test_nosetjmp 5 | TARGET_NOT_SUPPORTED = assert_test_not_supported 6 | 7 | LIBPCUNIT = ../../PCUnit/libpcunit.a 8 | LIBPCUNIT_NO_SETJMP = dummy.a 9 | LIBPCUNIT_NOT_SUPPORTED = dummy2.a 10 | OBJS = main.o 11 | OBJS += $(LIBPCUNIT) 12 | OBJS += AssertTest.o 13 | OBJS += AssertEqualTest.o 14 | OBJS += AssertPtrTest.o 15 | OBJS += AssertStringTest.o 16 | OBJS += AssertStringWTest.o 17 | OBJS += AssertMemoryTest.o 18 | OBJS += AssertDoubleTest.o 19 | OBJS += AssertOperatorTest.o 20 | OBJS += FailTest.o 21 | OBJS += SetupTest.o 22 | OBJS += InitializeTest.o 23 | OBJS += CleanupTest.o 24 | 25 | .PHONY: all clean pcunit_register test xml no_setjmp not_supported console 26 | 27 | all: pcunit_register $(LIBPCUNIT) $(TARGET) 28 | 29 | no_setjmp: pcunit_register $(LIBPCUNIT_NO_SETJMP) $(TARGET_NO_SETJMP) 30 | $(MAKE) all 31 | - ./$(TARGET) > $(TARGET).txt 32 | - ./$(TARGET_NO_SETJMP) > $(TARGET_NO_SETJMP).txt 33 | diff $(TARGET).txt $(TARGET_NO_SETJMP).txt 34 | 35 | not_supported: pcunit_register $(LIBPCUNIT_NOT_SUPPORTED) $(TARGET_NOT_SUPPORTED) 36 | 37 | pcunit_register: 38 | -ruby ../../PCUnit/pcunit_register.rb 39 | cd ../../PCUnit && $(MAKE) clean 40 | 41 | 42 | .SUFFIXES: .c .o 43 | 44 | .c.o: 45 | # $(CC) $(CFLAGS) -E $< > $<.i 46 | $(CC) $(CFLAGS) -c $< 47 | 48 | $(LIBPCUNIT): 49 | cd ../../PCUnit && $(MAKE) CFLAGS="-Wall -W -std=c99 -DPCU_USE_WCHAR -g" 50 | 51 | $(LIBPCUNIT_NO_SETJMP): 52 | cd ../../PCUnit && $(MAKE) CFLAGS="-Wall -W -std=c99 -DPCU_USE_WCHAR -DPCU_NO_SETJMP -g" 53 | 54 | $(LIBPCUNIT_NOT_SUPPORTED): 55 | cd ../../PCUnit && $(MAKE) CFLAGS="-Wall -W -std=c99 -DPCU_NO_FLOATINGPOINT -g" 56 | 57 | $(TARGET): $(OBJS) 58 | $(CC) $(CFLAGS) $(OBJS) -o $@ 59 | cd ../../PCUnit && $(MAKE) clean 60 | 61 | $(TARGET_NO_SETJMP): $(OBJS) 62 | $(CC) $(CFLAGS) $(OBJS) -o $@ 63 | cd ../../PCUnit && $(MAKE) clean 64 | 65 | $(TARGET_NOT_SUPPORTED): $(OBJS) 66 | $(CC) $(CFLAGS) $(OBJS) -o $@ 67 | cd ../../PCUnit && $(MAKE) clean 68 | 69 | test: 70 | ./$(TARGET) nocolor verbose 71 | 72 | xml: 73 | ./$(TARGET) nocolor verbose | ruby ../../PCUnit/pcunit_xml_output.rb 74 | 75 | console: 76 | ./$(TARGET) console 77 | 78 | clean: 79 | rm -f *.o *.i $(TARGET) $(TARGET_NO_SETJMP) $(TARGET_NOT_SUPPORTED) $(TARGET).txt $(TARGET_NO_SETJMP).txt *.xml 80 | 81 | 82 | main.o: ../../PCUnit/PCUnit.h 83 | AssertTest.o: ../../PCUnit/PCUnit.h 84 | AssertEqualTest.o: ../../PCUnit/PCUnit.h 85 | AssertPtrTest.o: ../../PCUnit/PCUnit.h 86 | AssertStringTest.o: ../../PCUnit/PCUnit.h 87 | AssertStringWTest.o: ../../PCUnit/PCUnit.h 88 | AssertDoubleTest.o: ../../PCUnit/PCUnit.h 89 | AssertOperatorTest.o: ../../PCUnit/PCUnit.h 90 | FailTest.o: ../../PCUnit/PCUnit.h 91 | SetupTest.o: ../../PCUnit/PCUnit.h 92 | InitializeTest.o: ../../PCUnit/PCUnit.h 93 | CleanupTest.o: ../../PCUnit/PCUnit.h 94 | -------------------------------------------------------------------------------- /test/assert_test/AssertEqualTest.c: -------------------------------------------------------------------------------- 1 | #include "../../PCUnit/PCUnit.h" 2 | #include 3 | 4 | static int initialize(void) 5 | { 6 | return 0; 7 | } 8 | 9 | static int cleanup(void) 10 | { 11 | return 0; 12 | } 13 | 14 | static int setup(void) 15 | { 16 | return 0; 17 | } 18 | 19 | static int teardown(void) 20 | { 21 | return 0; 22 | } 23 | 24 | 25 | static void test_assert_equal_OK(void) 26 | { 27 | int a, b; 28 | a = 100; 29 | b = 100; 30 | PCU_ASSERT_EQUAL(a, b); 31 | } 32 | 33 | static void test_assert_equal_FAIL(void) 34 | { 35 | int a, b; 36 | a = 100; 37 | b = 99; 38 | PCU_ASSERT_EQUAL(a, b); 39 | printf("NOT REACHED\n"); 40 | } 41 | 42 | static void test_assert_equal_MSG(void) 43 | { 44 | int a, b; 45 | a = 100; 46 | b = 100; 47 | PCU_ASSERT_EQUAL_MESSAGE(a, b, PCU_format("%d, %d", a, b)); 48 | b++; 49 | PCU_ASSERT_EQUAL_MESSAGE(a, b, PCU_format("%d, %d", a, b)); 50 | } 51 | 52 | static void test_assert_equal_char_FAIL(void) 53 | { 54 | char a, b; 55 | a = 100; 56 | b = -1; 57 | PCU_ASSERT_EQUAL(a, b); 58 | } 59 | 60 | static void test_assert_equal_short_FAIL(void) 61 | { 62 | short a, b; 63 | a = 100; 64 | b = -1; 65 | PCU_ASSERT_EQUAL(a, b); 66 | } 67 | 68 | static void test_assert_equal_long_FAIL(void) 69 | { 70 | long a, b; 71 | a = 100; 72 | b = -1; 73 | PCU_ASSERT_EQUAL(a, b); 74 | } 75 | 76 | static void test_assert_equal_longlong_FAIL(void) 77 | { 78 | long long a, b; 79 | a = 100; 80 | b = -1; 81 | PCU_ASSERT_EQUAL(a, b); 82 | } 83 | 84 | 85 | 86 | 87 | static void test_assert_not_equal_OK(void) 88 | { 89 | int a, b; 90 | a = 100; 91 | b = 99; 92 | PCU_ASSERT_NOT_EQUAL(a, b); 93 | } 94 | 95 | static void test_assert_not_equal_FAIL(void) 96 | { 97 | int a, b; 98 | a = 100; 99 | b = 100; 100 | PCU_ASSERT_NOT_EQUAL(a, b); 101 | printf("NOT REACHED\n"); 102 | } 103 | 104 | static void test_assert_not_equal_MSG(void) 105 | { 106 | int a, b; 107 | a = 100; 108 | b = 99; 109 | PCU_ASSERT_NOT_EQUAL_MESSAGE(a, b, PCU_format("%d, %d", a, b)); 110 | b++; 111 | PCU_ASSERT_NOT_EQUAL_MESSAGE(a, b, PCU_format("%d, %d", a, b)); 112 | } 113 | 114 | 115 | 116 | 117 | static PCU_Test tests[] = { 118 | PCU_TEST(test_assert_equal_OK), 119 | PCU_TEST(test_assert_equal_FAIL), 120 | PCU_TEST(test_assert_equal_MSG), 121 | PCU_TEST(test_assert_equal_char_FAIL), 122 | PCU_TEST(test_assert_equal_short_FAIL), 123 | PCU_TEST(test_assert_equal_long_FAIL), 124 | PCU_TEST(test_assert_equal_longlong_FAIL), 125 | PCU_TEST(test_assert_not_equal_OK), 126 | PCU_TEST(test_assert_not_equal_FAIL), 127 | PCU_TEST(test_assert_not_equal_MSG), 128 | }; 129 | 130 | PCU_Suite *AssertEqualTest_suite(void) 131 | { 132 | static PCU_Suite suite = { 133 | "AssertEqualTest", tests, sizeof tests / sizeof tests[0], setup, teardown, initialize, cleanup 134 | }; 135 | return &suite; 136 | } 137 | 138 | -------------------------------------------------------------------------------- /test/PCU_Libc_test/test_string.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | #include "../../PCUnit/PCUnit.h" 7 | int PCU_strcmp(const char *s1, const char *s2); 8 | int PCU_strncmp(const char *s1, const char *s2, size_t len); 9 | void *PCU_memset(void *b, int c, size_t len); 10 | 11 | 12 | void test_strcmp(void) 13 | { 14 | const char *s1; 15 | const char *s2; 16 | #define ASSERT_STRCMP(s1, s2) \ 17 | do { int tmp = strcmp(s1, s2);\ 18 | if (tmp < 0) tmp = -1; else if (tmp > 0) tmp = 1;\ 19 | PCU_ASSERT_EQUAL(tmp, PCU_strcmp(s1, s2)); } while (0) 20 | 21 | s1 = "hoge"; 22 | s2 = "hoge"; 23 | ASSERT_STRCMP(s1, s2); 24 | 25 | s1 = "hoge"; 26 | s2 = "piyo"; 27 | ASSERT_STRCMP(s1, s2); 28 | 29 | s1 = "hoge"; 30 | s2 = "hog"; 31 | ASSERT_STRCMP(s1, s2); 32 | 33 | s1 = "hog"; 34 | s2 = "hoge"; 35 | ASSERT_STRCMP(s1, s2); 36 | 37 | s1 = ""; 38 | s2 = ""; 39 | ASSERT_STRCMP(s1, s2); 40 | 41 | s1 = "hoge"; 42 | s2 = ""; 43 | ASSERT_STRCMP(s1, s2); 44 | 45 | s1 = ""; 46 | s2 = "hoge"; 47 | ASSERT_STRCMP(s1, s2); 48 | } 49 | 50 | void test_strncmp(void) 51 | { 52 | const char *s1; 53 | const char *s2; 54 | size_t i; 55 | #define ASSERT_STRNCMP(s1, s2, n) \ 56 | do { int tmp = strncmp(s1, s2, n);\ 57 | if (tmp < 0) tmp = -1; else if (tmp > 0) tmp = 1;\ 58 | PCU_ASSERT_EQUAL(tmp, PCU_strncmp(s1, s2, n)); } while (0) 59 | 60 | for (i = 0; i < 6; i++) { 61 | s1 = "hoge"; 62 | s2 = "hoge"; 63 | ASSERT_STRNCMP(s1, s2, i); 64 | 65 | s1 = "hoge"; 66 | s2 = "piyo"; 67 | ASSERT_STRNCMP(s1, s2, i); 68 | 69 | s1 = "hoge"; 70 | s2 = "hog"; 71 | ASSERT_STRNCMP(s1, s2, i); 72 | 73 | s1 = "hog"; 74 | s2 = "hoge"; 75 | ASSERT_STRNCMP(s1, s2, i); 76 | 77 | s1 = ""; 78 | s2 = ""; 79 | ASSERT_STRNCMP(s1, s2, i); 80 | 81 | s1 = "hoge"; 82 | s2 = ""; 83 | ASSERT_STRNCMP(s1, s2, i); 84 | 85 | s1 = ""; 86 | s2 = "hoge"; 87 | ASSERT_STRNCMP(s1, s2, i); 88 | } 89 | } 90 | 91 | void test_memset(void) 92 | { 93 | static char c_buf[256]; 94 | static int i_buf[256]; 95 | static struct { 96 | int a; 97 | char b[3]; 98 | } st_buf[10]; 99 | unsigned char *p; 100 | size_t i; 101 | 102 | memset(c_buf, 0, sizeof(c_buf)); 103 | memset(i_buf, 0xFF, sizeof(i_buf)); 104 | memset(st_buf, 1, sizeof(st_buf)); 105 | 106 | p = (unsigned char *) PCU_memset(c_buf, 0xFF, sizeof(c_buf)); 107 | PCU_ASSERT_PTR_EQUAL(c_buf, p); 108 | for (i = 0; i < sizeof(c_buf); i++) { 109 | PCU_ASSERT_EQUAL(0xFF, p[i]); 110 | } 111 | 112 | p = (unsigned char *) PCU_memset(i_buf, 0, sizeof(i_buf)); 113 | PCU_ASSERT_PTR_EQUAL(i_buf, p); 114 | for (i = 0; i < sizeof(i_buf); i++) { 115 | PCU_ASSERT_EQUAL(0, p[i]); 116 | } 117 | 118 | p = (unsigned char *) PCU_memset(st_buf, 128, sizeof(st_buf)); 119 | PCU_ASSERT_PTR_EQUAL(st_buf, p); 120 | for (i = 0; i < sizeof(st_buf); i++) { 121 | PCU_ASSERT_EQUAL(128, p[i]); 122 | } 123 | 124 | } 125 | 126 | PCU_Suite *StringTest_suite(void) 127 | { 128 | static PCU_Test tests[] = { 129 | PCU_TEST(test_strcmp), 130 | PCU_TEST(test_strncmp), 131 | PCU_TEST(test_memset), 132 | }; 133 | static PCU_Suite suite = { "StringTest", tests, sizeof tests / sizeof tests[0] }; 134 | return &suite; 135 | } 136 | -------------------------------------------------------------------------------- /test/assert_test/AssertPtrTest.c: -------------------------------------------------------------------------------- 1 | #include "../../PCUnit/PCUnit.h" 2 | #include 3 | 4 | static int initialize(void) 5 | { 6 | return 0; 7 | } 8 | 9 | static int cleanup(void) 10 | { 11 | return 0; 12 | } 13 | 14 | static int setup(void) 15 | { 16 | return 0; 17 | } 18 | 19 | static int teardown(void) 20 | { 21 | return 0; 22 | } 23 | 24 | 25 | static void test_assert_ptr_equal_OK(void) 26 | { 27 | int a; 28 | PCU_ASSERT_PTR_EQUAL(&a, &a); 29 | PCU_ASSERT_PTR_EQUAL(NULL, NULL); 30 | } 31 | 32 | static void test_assert_ptr_equal_FAIL(void) 33 | { 34 | int a, b; 35 | PCU_ASSERT_PTR_EQUAL(&a, &b); 36 | printf("NOT REACHED\n"); 37 | } 38 | 39 | static void test_assert_ptr_equal_MSG(void) 40 | { 41 | int a, b; 42 | PCU_ASSERT_PTR_EQUAL_MESSAGE(&a, &a, PCU_format("%p, %p", &a, &b)); 43 | PCU_ASSERT_PTR_EQUAL_MESSAGE(&a, &b, PCU_format("%p, %p", &a, &b)); 44 | } 45 | 46 | 47 | 48 | static void test_assert_ptr_not_equal_OK(void) 49 | { 50 | int a, b; 51 | PCU_ASSERT_PTR_NOT_EQUAL(&a, &b); 52 | PCU_ASSERT_PTR_NOT_EQUAL(&a, NULL); 53 | } 54 | 55 | static void test_assert_ptr_not_equal_FAIL(void) 56 | { 57 | int a; 58 | PCU_ASSERT_PTR_NOT_EQUAL(&a, &a); 59 | printf("NOT REACHED\n"); 60 | } 61 | 62 | static void test_assert_ptr_not_equal_MSG(void) 63 | { 64 | int a, b; 65 | PCU_ASSERT_PTR_NOT_EQUAL_MESSAGE(&a, &b, PCU_format("%p, %p", &a, &b)); 66 | PCU_ASSERT_PTR_NOT_EQUAL_MESSAGE(&a, &a, PCU_format("%p, %p", &a, &b)); 67 | } 68 | 69 | 70 | 71 | static void test_assert_ptr_null_OK(void) 72 | { 73 | int *p = NULL; 74 | PCU_ASSERT_PTR_NULL(p); 75 | PCU_ASSERT_PTR_NULL(NULL); 76 | } 77 | 78 | static void test_assert_ptr_null_FAIL(void) 79 | { 80 | int a; 81 | int *p = NULL; 82 | p = &a; 83 | PCU_ASSERT_PTR_NULL(p); 84 | printf("NOT REACHED\n"); 85 | } 86 | 87 | static void test_assert_ptr_null_MSG(void) 88 | { 89 | int a; 90 | int *p = NULL; 91 | PCU_ASSERT_PTR_NULL_MESSAGE(p, PCU_format("%p", p)); 92 | p = &a; 93 | PCU_ASSERT_PTR_NULL_MESSAGE(p, PCU_format("%p", p)); 94 | } 95 | 96 | 97 | 98 | static void test_assert_ptr_not_null_OK(void) 99 | { 100 | int a; 101 | int *p = NULL; 102 | p = &a; 103 | PCU_ASSERT_PTR_NOT_NULL(p); 104 | PCU_ASSERT_PTR_NOT_NULL(&a); 105 | } 106 | 107 | static void test_assert_ptr_not_null_FAIL(void) 108 | { 109 | int *p = NULL; 110 | PCU_ASSERT_PTR_NOT_NULL(p); 111 | printf("NOT REACHED\n"); 112 | } 113 | 114 | static void test_assert_ptr_not_null_MSG(void) 115 | { 116 | int a; 117 | int *p = &a; 118 | PCU_ASSERT_PTR_NOT_NULL_MESSAGE(p, PCU_format("%p", p)); 119 | p = NULL; 120 | PCU_ASSERT_PTR_NOT_NULL_MESSAGE(p, PCU_format("%p", p)); 121 | } 122 | 123 | 124 | 125 | static PCU_Test tests[] = { 126 | PCU_TEST(test_assert_ptr_equal_OK), 127 | PCU_TEST(test_assert_ptr_equal_FAIL), 128 | PCU_TEST(test_assert_ptr_equal_MSG), 129 | PCU_TEST(test_assert_ptr_not_equal_OK), 130 | PCU_TEST(test_assert_ptr_not_equal_FAIL), 131 | PCU_TEST(test_assert_ptr_not_equal_MSG), 132 | PCU_TEST(test_assert_ptr_null_OK), 133 | PCU_TEST(test_assert_ptr_null_FAIL), 134 | PCU_TEST(test_assert_ptr_null_MSG), 135 | PCU_TEST(test_assert_ptr_not_null_OK), 136 | PCU_TEST(test_assert_ptr_not_null_FAIL), 137 | PCU_TEST(test_assert_ptr_not_null_MSG), 138 | }; 139 | 140 | PCU_Suite *AssertPtrTest_suite(void) 141 | { 142 | static PCU_Suite suite = { 143 | "AssertPtrTest", tests, sizeof tests / sizeof tests[0], setup, teardown, initialize, cleanup 144 | }; 145 | return &suite; 146 | } 147 | 148 | -------------------------------------------------------------------------------- /sample/test_RingBuf.c: -------------------------------------------------------------------------------- 1 | #include "PCUnit/PCUnit.h" 2 | #include "RingBuf.h" 3 | #include 4 | 5 | #define RB_BUF_SIZE 256 6 | static RingBuf ringbuf; 7 | static RingBuf *rb = &ringbuf; 8 | static unsigned char rb_buffer[RB_BUF_SIZE]; 9 | 10 | static int initialize(void) 11 | { 12 | /* Suiteの最初に呼ばれる */ 13 | /* printf("initialize: %s\n", PCU_suite_name()); */ 14 | return 0; 15 | } 16 | 17 | static int cleanup(void) 18 | { 19 | /* Suiteの最後に呼ばれる */ 20 | /* printf("cleanup : %s\n", PCU_suite_name()); */ 21 | return 0; 22 | } 23 | 24 | static int setup(void) 25 | { 26 | /* test_rb_xxx毎に呼ばれる */ 27 | RingBuf_init(rb, rb_buffer, sizeof rb_buffer); 28 | /* printf(" setup : %s\n", PCU_test_name()); */ 29 | return 0; 30 | } 31 | 32 | static int teardown(void) 33 | { 34 | /* test_rb_xxx毎に呼ばれる */ 35 | /* printf(" teardown: %s\n", PCU_test_name()); */ 36 | return 0; 37 | } 38 | 39 | static void test_rb_init(void) 40 | { 41 | PCU_ASSERT_EQUAL(0, RingBuf_size(rb)); 42 | PCU_ASSERT_EQUAL(RB_BUF_SIZE - 1, RingBuf_maxsize(rb)); 43 | PCU_ASSERT_TRUE(RingBuf_empty(rb)); 44 | PCU_ASSERT_FALSE(RingBuf_full(rb)); 45 | } 46 | 47 | static void test_rb_push(void) 48 | { 49 | int i; 50 | int ret; 51 | for (i = 0; i < RingBuf_maxsize(rb); i++) { 52 | ret = RingBuf_push(rb, (unsigned char)i); 53 | PCU_ASSERT_TRUE(ret); 54 | PCU_ASSERT_EQUAL(i + 1, RingBuf_size(rb)); 55 | } 56 | PCU_ASSERT_EQUAL(RB_BUF_SIZE - 1, RingBuf_size(rb)); 57 | PCU_ASSERT_EQUAL(RB_BUF_SIZE - 1, RingBuf_maxsize(rb)); 58 | PCU_ASSERT_FALSE(RingBuf_empty(rb)); 59 | PCU_ASSERT_TRUE(RingBuf_full(rb)); 60 | ret = RingBuf_push(rb, (unsigned char)i); 61 | PCU_ASSERT_FALSE(ret); 62 | } 63 | 64 | static void test_rb_pop(void) 65 | { 66 | int i; 67 | int ret; 68 | for (i = 0; i < RingBuf_maxsize(rb); i++) { 69 | ret = RingBuf_push(rb, (unsigned char)i); 70 | PCU_ASSERT_TRUE(ret); 71 | PCU_ASSERT_EQUAL(i + 1, RingBuf_size(rb)); 72 | } 73 | PCU_ASSERT_EQUAL(RB_BUF_SIZE - 1, RingBuf_size(rb)); 74 | PCU_ASSERT_EQUAL(RB_BUF_SIZE - 1, RingBuf_maxsize(rb)); 75 | PCU_ASSERT_FALSE(RingBuf_empty(rb)); 76 | PCU_ASSERT_TRUE(RingBuf_full(rb)); 77 | ret = RingBuf_push(rb, (unsigned char)i); 78 | PCU_ASSERT_FALSE(ret); 79 | 80 | for (i = 0; !RingBuf_empty(rb); i++) { 81 | PCU_ASSERT_EQUAL(i, RingBuf_pop(rb)); 82 | PCU_ASSERT_EQUAL(RB_BUF_SIZE - 1 - i - 1, RingBuf_size(rb)); 83 | } 84 | PCU_ASSERT_EQUAL(0, RingBuf_size(rb)); 85 | PCU_ASSERT_EQUAL(RB_BUF_SIZE - 1, RingBuf_maxsize(rb)); 86 | PCU_ASSERT_TRUE(RingBuf_empty(rb)); 87 | PCU_ASSERT_FALSE(RingBuf_full(rb)); 88 | 89 | 90 | for (i = 0; i < RingBuf_maxsize(rb) / 2; i++) { 91 | ret = RingBuf_push(rb, (unsigned char)i); 92 | PCU_ASSERT_TRUE(ret); 93 | PCU_ASSERT_EQUAL(i + 1, RingBuf_size(rb)); 94 | } 95 | PCU_ASSERT_EQUAL((RB_BUF_SIZE - 1) / 2, RingBuf_size(rb)); 96 | PCU_ASSERT_FALSE(RingBuf_empty(rb)); 97 | 98 | for (i = 0; !RingBuf_empty(rb); i++) { 99 | PCU_ASSERT_EQUAL(i, RingBuf_pop(rb)); 100 | PCU_ASSERT_EQUAL((RB_BUF_SIZE - 1) / 2 - i - 1, RingBuf_size(rb)); 101 | } 102 | PCU_ASSERT_EQUAL(0, RingBuf_size(rb)); 103 | PCU_ASSERT_TRUE(RingBuf_empty(rb)); 104 | PCU_ASSERT_FALSE(RingBuf_full(rb)); 105 | } 106 | 107 | 108 | PCU_Suite *RingBufTest_suite(void) 109 | { 110 | static PCU_Test tests[] = { 111 | PCU_TEST(test_rb_init), 112 | PCU_TEST(test_rb_push), 113 | PCU_TEST(test_rb_pop), 114 | }; 115 | static PCU_Suite suite = { "RingBufTest", tests, sizeof tests / sizeof tests[0], setup, teardown, initialize, cleanup }; 116 | return &suite; 117 | } 118 | 119 | -------------------------------------------------------------------------------- /test/assert_output_test/AssertOutputTest.c: -------------------------------------------------------------------------------- 1 | #include "../../PCUnit/PCUnit.h" 2 | #include 3 | #include 4 | 5 | static FILE *fp_expected; 6 | static FILE *fp_actual; 7 | 8 | static const char * const file_map[][2] = { 9 | {"assert_output_expected.txt" , "assert_output_actual.txt"}, 10 | {"assert_output_verbose_expected.txt", "assert_output_verbose_actual.txt"}, 11 | }; 12 | 13 | static int initialize(void) 14 | { 15 | return 0; 16 | } 17 | 18 | static int cleanup(void) 19 | { 20 | return 0; 21 | } 22 | 23 | static int setup(void) 24 | { 25 | int idx = !strcmp(PCU_test_name(), "test_output") ? 0 : 1; 26 | fp_expected = fopen(file_map[idx][0], "r"); 27 | fp_actual = fopen(file_map[idx][1], "r"); 28 | return !(fp_expected && fp_actual); 29 | } 30 | 31 | static int teardown(void) 32 | { 33 | fclose(fp_expected); 34 | fclose(fp_actual); 35 | return 0; 36 | } 37 | 38 | static void line_check(const char *expected, const char *actual, int line) 39 | { 40 | static int state = 0; 41 | const char *ptr_test_file = " AssertPtrTest.c"; 42 | const char *str_test_file = " AssertString"; 43 | const char *mem_test_file = " AssertMemoryTest.c"; 44 | if (!strncmp(ptr_test_file, expected, strlen(ptr_test_file)) || 45 | !strncmp(str_test_file, expected, strlen(str_test_file)) || 46 | !strncmp(mem_test_file, expected, strlen(mem_test_file))) { 47 | state = 1; 48 | } 49 | 50 | if (state == 2 && !strcmp(expected, "")) { 51 | state = 0; 52 | } 53 | 54 | if (state == 2) { 55 | const char *p = strstr(expected, "0x"); 56 | if (!p) { 57 | p = strstr(expected, "("); 58 | } 59 | if (p) { 60 | PCU_ASSERT_NSTRING_EQUAL_MESSAGE(expected, actual, p - expected, PCU_format("line:%d", line)); 61 | } else { 62 | PCU_ASSERT_STRING_EQUAL_MESSAGE(expected, actual, PCU_format("line:%d", line)); 63 | } 64 | } else if (strstr(expected, "Test.c:")) { 65 | const char *p = strchr(expected, ':'); 66 | const char *q; 67 | p++; 68 | PCU_ASSERT_NSTRING_EQUAL_MESSAGE(expected, actual, p - expected, PCU_format("line:%d", line)); 69 | p = strrchr(expected, ':'); 70 | q = strrchr(actual, ':'); 71 | PCU_ASSERT_STRING_EQUAL_MESSAGE(p, q, PCU_format("line:%d", line)); 72 | } else { 73 | PCU_ASSERT_STRING_EQUAL_MESSAGE(expected, actual, PCU_format("line:%d", line)); 74 | } 75 | 76 | if (state == 1) { 77 | state = 2; 78 | } 79 | } 80 | 81 | static void cut_newline(char *str, int line) 82 | { 83 | char *p; 84 | p = strpbrk(str, "\r\n"); 85 | PCU_ASSERT_PTR_NOT_NULL_MESSAGE(p, PCU_format("line:%d", line)); 86 | *p = '\0'; 87 | } 88 | 89 | void output_test(FILE *fp_exp, FILE *fp_act) 90 | { 91 | int line = 1; 92 | while (1) { 93 | char buf_expected[512]; 94 | char buf_actual[512]; 95 | char *ret_expected, *ret_actual; 96 | ret_expected = fgets(buf_expected, sizeof buf_expected, fp_exp); 97 | ret_actual = fgets(buf_actual, sizeof buf_actual, fp_act); 98 | PCU_ASSERT_FALSE_MESSAGE( ret_expected && !ret_actual, PCU_format("line:%d", line)); 99 | PCU_ASSERT_FALSE_MESSAGE(!ret_expected && ret_actual, PCU_format("line:%d", line)); 100 | if (!ret_expected && !ret_actual) { 101 | break; 102 | } 103 | 104 | cut_newline(buf_expected, line); 105 | cut_newline(buf_actual, line); 106 | line_check(buf_expected, buf_actual, line); 107 | line++; 108 | } 109 | } 110 | 111 | static void test_output(void) 112 | { 113 | output_test(fp_expected, fp_actual); 114 | } 115 | 116 | static void test_output_verbose(void) 117 | { 118 | output_test(fp_expected, fp_actual); 119 | } 120 | 121 | 122 | PCU_Suite *AssertOutputTest_suite(void) 123 | { 124 | static PCU_Test tests[] = { 125 | PCU_TEST(test_output), 126 | PCU_TEST(test_output_verbose), 127 | }; 128 | static PCU_Suite suite = { 129 | "AssertOutputTest", tests, sizeof tests / sizeof tests[0], setup, teardown, initialize, cleanup 130 | }; 131 | return &suite; 132 | } 133 | 134 | -------------------------------------------------------------------------------- /PCUnit/PCU_Libc.h: -------------------------------------------------------------------------------- 1 | #ifndef PCU_LIBC_H_INCLUDED 2 | #define PCU_LIBC_H_INCLUDED 3 | 4 | #include "PCUnit.h" 5 | 6 | #if (defined(_UNICODE) || defined(UNICODE)) && !defined(PCU_USE_WCHAR) 7 | #define PCU_USE_WCHAR 8 | #endif 9 | 10 | int PCU_getchar(void); 11 | void PCU_puts(const char *str); 12 | 13 | 14 | #ifdef PCU_NO_LIBC 15 | # define PCU_STRCMP PCU_strcmp 16 | # define PCU_STRNCMP PCU_strncmp 17 | # define PCU_MEMSET PCU_memset 18 | # define PCU_ATOI PCU_atoi 19 | int PCU_strcmp(const char *s1, const char *s2); 20 | int PCU_strncmp(const char *s1, const char *s2, size_t len); 21 | void *PCU_memset(void *b, int c, size_t len); 22 | long PCU_strtol(const char *s, char **endptr, int base); 23 | unsigned long PCU_strtoul(const char *s, char **endptr, int base); 24 | int PCU_atoi(const char *s); 25 | #else 26 | # include 27 | # include 28 | # define PCU_STRCMP strcmp 29 | # define PCU_STRNCMP strncmp 30 | # define PCU_MEMSET memset 31 | # define PCU_ATOI atoi 32 | #endif 33 | 34 | 35 | #ifdef PCU_NO_STDARG 36 | extern PCU_FormatBuf PCU_printf_buf; 37 | # define PCU_PRINTF0(f) PCU_puts(PCU_format_aux0(&PCU_printf_buf, f)) 38 | # define PCU_PRINTF1(f, a1) PCU_puts(PCU_format_aux1(&PCU_printf_buf, f, (PCU_size_t)(a1))) 39 | # define PCU_PRINTF2(f, a1, a2) PCU_puts(PCU_format_aux2(&PCU_printf_buf, f, (PCU_size_t)(a1), (PCU_size_t)(a2))) 40 | # define PCU_PRINTF3(f, a1, a2, a3) PCU_puts(PCU_format_aux3(&PCU_printf_buf, f, (PCU_size_t)(a1), (PCU_size_t)(a2), (PCU_size_t)(a3))) 41 | # define PCU_PRINTF4(f, a1, a2, a3, a4) PCU_puts(PCU_format_aux4(&PCU_printf_buf, f, (PCU_size_t)(a1), (PCU_size_t)(a2), (PCU_size_t)(a3), (PCU_size_t)(a4))) 42 | # define PCU_PRINTF5(f, a1, a2, a3, a4, a5) PCU_puts(PCU_format_aux5(&PCU_printf_buf, f, (PCU_size_t)(a1), (PCU_size_t)(a2), (PCU_size_t)(a3), (PCU_size_t)(a4), (PCU_size_t)(a5))) 43 | # define PCU_PRINTF6(f, a1, a2, a3, a4, a5, a6) PCU_puts(PCU_format_aux6(&PCU_printf_buf, f, (PCU_size_t)(a1), (PCU_size_t)(a2), (PCU_size_t)(a3), (PCU_size_t)(a4), (PCU_size_t)(a5), (PCU_size_t)(a6))) 44 | # define PCU_PRINTF7(f, a1, a2, a3, a4, a5, a6, a7) PCU_puts(PCU_format_aux7(&PCU_printf_buf, f, (PCU_size_t)(a1), (PCU_size_t)(a2), (PCU_size_t)(a3), (PCU_size_t)(a4), (PCU_size_t)(a5), (PCU_size_t)(a6), (PCU_size_t)(a7))) 45 | # define PCU_PRINTF8(f, a1, a2, a3, a4, a5, a6, a7, a8) PCU_puts(PCU_format_aux8(&PCU_printf_buf, f, (PCU_size_t)(a1), (PCU_size_t)(a2), (PCU_size_t)(a3), (PCU_size_t)(a4), (PCU_size_t)(a5), (PCU_size_t)(a6), (PCU_size_t)(a7), (PCU_size_t)(a8))) 46 | # define PCU_PRINTF9(f, a1, a2, a3, a4, a5, a6, a7, a8, a9) PCU_puts(PCU_format_aux9(&PCU_printf_buf, f, (PCU_size_t)(a1), (PCU_size_t)(a2), (PCU_size_t)(a3), (PCU_size_t)(a4), (PCU_size_t)(a5), (PCU_size_t)(a6), (PCU_size_t)(a7), (PCU_size_t)(a8), (PCU_size_t)(a9))) 47 | #else 48 | # include 49 | # define PCU_PRINTF0 PCU_printf 50 | # define PCU_PRINTF1 PCU_printf 51 | # define PCU_PRINTF2 PCU_printf 52 | # define PCU_PRINTF3 PCU_printf 53 | # define PCU_PRINTF4 PCU_printf 54 | # define PCU_PRINTF5 PCU_printf 55 | # define PCU_PRINTF6 PCU_printf 56 | # define PCU_PRINTF7 PCU_printf 57 | # define PCU_PRINTF8 PCU_printf 58 | # define PCU_PRINTF9 PCU_printf 59 | void PCU_printf(const char *format, ...); 60 | #endif 61 | 62 | 63 | #if defined(PCU_NO_SETJMP) || defined(PCU_NO_LIBC) 64 | typedef int PCU_jmp_buf; 65 | # define PCU_SETJMP(j) ((void)(j), 0) 66 | # define PCU_LONGJMP(j, v) 67 | #else 68 | # include 69 | typedef jmp_buf PCU_jmp_buf; 70 | # define PCU_SETJMP setjmp 71 | # define PCU_LONGJMP longjmp 72 | #endif 73 | 74 | 75 | #ifdef PCU_USE_WCHAR 76 | # if (defined(_MSC_VER) && _MSC_VER < 1400) /* VC2005 */ 77 | # include 78 | # else 79 | # include 80 | # endif 81 | # define PCU_WCSCMP wcscmp 82 | # define PCU_WCSNCMP wcsncmp 83 | # define PCU_WCSLEN wcslen 84 | #endif 85 | 86 | #endif /* PCU_LIBC_H_INCLUDED */ 87 | -------------------------------------------------------------------------------- /test/PCU_Libc_test/test_strtol.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include "../../PCUnit/PCUnit.h" 6 | long PCU_strtol(const char *s, char **endptr, int base); 7 | unsigned long PCU_strtoul(const char *s, char **endptr, int base); 8 | int PCU_atoi(const char *s); 9 | 10 | 11 | #define ASSERT_STRTOL(s, base) \ 12 | do {\ 13 | long ret1, ret2;\ 14 | char *p1, *p2;\ 15 | ret1 = strtol(s, &p1, base);\ 16 | ret2 = PCU_strtol(s, &p2, base);\ 17 | PCU_ASSERT_EQUAL(ret1, ret2);\ 18 | PCU_ASSERT_PTR_EQUAL(p1, p2);\ 19 | } while (0) 20 | 21 | #define ASSERT_STRTOUL(s, base) \ 22 | do {\ 23 | unsigned long ret1, ret2;\ 24 | char *p1, *p2;\ 25 | ret1 = strtoul(s, &p1, base);\ 26 | ret2 = PCU_strtoul(s, &p2, base);\ 27 | PCU_ASSERT_EQUAL(ret1, ret2);\ 28 | PCU_ASSERT_PTR_EQUAL(p1, p2);\ 29 | } while (0) 30 | 31 | #define ASSERT_ATOI(s) \ 32 | do {\ 33 | int ret1, ret2;\ 34 | ret1 = atoi(s);\ 35 | ret2 = PCU_atoi(s);\ 36 | PCU_ASSERT_EQUAL(ret1, ret2);\ 37 | } while (0) 38 | 39 | 40 | void test_strtol(void) 41 | { 42 | ASSERT_STRTOL("0", 10); 43 | ASSERT_STRTOL("0000", 10); 44 | ASSERT_STRTOL("123", 10); 45 | ASSERT_STRTOL("-0", 10); 46 | ASSERT_STRTOL("-123", 10); 47 | ASSERT_STRTOL("- 123", 10); 48 | ASSERT_STRTOL(" -123", 10); 49 | ASSERT_STRTOL("+0", 10); 50 | ASSERT_STRTOL("+123", 10); 51 | ASSERT_STRTOL("+ 123", 10); 52 | ASSERT_STRTOL(" +123", 10); 53 | ASSERT_STRTOL(" 123aa", 10); 54 | ASSERT_STRTOL(" 123 ", 10); 55 | ASSERT_STRTOL("zzz123zzz", 10); 56 | ASSERT_STRTOL("0x123", 10); 57 | ASSERT_STRTOL("zzz", 10); 58 | 59 | ASSERT_STRTOL("0", 16); 60 | ASSERT_STRTOL("0000", 16); 61 | ASSERT_STRTOL("0x0000", 16); 62 | ASSERT_STRTOL("123", 16); 63 | ASSERT_STRTOL("- 0123", 16); 64 | ASSERT_STRTOL("-0123", 16); 65 | ASSERT_STRTOL("-0", 16); 66 | ASSERT_STRTOL("-0x0", 16); 67 | ASSERT_STRTOL("+ 0123", 16); 68 | ASSERT_STRTOL("+0123", 16); 69 | ASSERT_STRTOL("+0", 16); 70 | ASSERT_STRTOL("+0x0", 16); 71 | ASSERT_STRTOL("0x123", 16); 72 | ASSERT_STRTOL("0x7eadBeef", 16); 73 | ASSERT_STRTOL("0X7EADBEEF", 16); 74 | ASSERT_STRTOL(" 0012a", 16); 75 | ASSERT_STRTOL(" 123aa", 16); 76 | ASSERT_STRTOL(" 123 ", 16); 77 | ASSERT_STRTOL("zzz123zzz", 16); 78 | ASSERT_STRTOL("1zzz123zzz", 16); 79 | ASSERT_STRTOL("0z", 16); 80 | /* ASSERT_STRTOL("0x", 16);*/ 81 | /* ASSERT_STRTOL("0xz", 16);*/ 82 | /* ASSERT_STRTOL("0xZ123", 16);*/ 83 | /* ASSERT_STRTOL("0xx123", 16);*/ 84 | ASSERT_STRTOL("zzz", 16); 85 | 86 | ASSERT_STRTOL("0x123", 0); 87 | ASSERT_STRTOL("-0xABCD", 0); 88 | ASSERT_STRTOL("123", 0); 89 | ASSERT_STRTOL("-123", 0); 90 | ASSERT_STRTOL("+123", 0); 91 | ASSERT_STRTOL("1A3", 0); 92 | ASSERT_STRTOL("zzz", 0); 93 | } 94 | 95 | void test_strtoul(void) 96 | { 97 | ASSERT_STRTOUL("0", 10); 98 | ASSERT_STRTOUL("0000", 10); 99 | ASSERT_STRTOUL("123", 10); 100 | ASSERT_STRTOUL("-0", 10); 101 | ASSERT_STRTOUL("-123", 10); 102 | ASSERT_STRTOUL("- 123", 10); 103 | ASSERT_STRTOUL(" -123", 10); 104 | ASSERT_STRTOUL(" 123aa", 10); 105 | ASSERT_STRTOUL(" 123 ", 10); 106 | ASSERT_STRTOUL("zzz123zzz", 10); 107 | ASSERT_STRTOUL("zzz", 10); 108 | 109 | ASSERT_STRTOUL("0", 16); 110 | ASSERT_STRTOUL("0000", 16); 111 | ASSERT_STRTOUL("0x0000", 16); 112 | ASSERT_STRTOUL("123", 16); 113 | ASSERT_STRTOUL("0123", 16); 114 | ASSERT_STRTOUL("-0", 16); 115 | ASSERT_STRTOUL("-0123", 16); 116 | ASSERT_STRTOUL("0x123", 16); 117 | ASSERT_STRTOUL("-0x123", 16); 118 | ASSERT_STRTOUL("-0x0", 16); 119 | ASSERT_STRTOUL("- 0x123", 16); 120 | ASSERT_STRTOUL("0xDeadBeef", 16); 121 | ASSERT_STRTOUL("0XDEADBEEF", 16); 122 | ASSERT_STRTOUL("-0XDEADBEEF", 16); 123 | ASSERT_STRTOUL(" 0012a", 16); 124 | ASSERT_STRTOUL(" 123aa", 16); 125 | ASSERT_STRTOUL(" 123 ", 16); 126 | ASSERT_STRTOUL("zzz123zzz", 16); 127 | ASSERT_STRTOUL("1zzz123zzz", 16); 128 | ASSERT_STRTOUL("0z", 16); 129 | /* ASSERT_STRTOUL("0x", 16);*/ 130 | /* ASSERT_STRTOUL("0xz", 16);*/ 131 | /* ASSERT_STRTOUL("0xZ123", 16);*/ 132 | /* ASSERT_STRTOUL("0xx123", 16);*/ 133 | ASSERT_STRTOUL("zzz", 16); 134 | 135 | ASSERT_STRTOUL("0x123", 0); 136 | ASSERT_STRTOUL("-0xABCD", 0); 137 | ASSERT_STRTOUL("123", 0); 138 | ASSERT_STRTOUL("-123", 0); 139 | ASSERT_STRTOUL("+123", 0); 140 | ASSERT_STRTOUL("1A3", 0); 141 | ASSERT_STRTOUL("zzz", 0); 142 | } 143 | 144 | void test_atoi(void) 145 | { 146 | ASSERT_ATOI("0"); 147 | ASSERT_ATOI("0000"); 148 | ASSERT_ATOI("123"); 149 | ASSERT_ATOI("-0"); 150 | ASSERT_ATOI("-123"); 151 | ASSERT_ATOI("- 123"); 152 | ASSERT_ATOI(" -123"); 153 | ASSERT_ATOI("+0"); 154 | ASSERT_ATOI("+123"); 155 | ASSERT_ATOI("+ 123"); 156 | ASSERT_ATOI(" +123"); 157 | ASSERT_ATOI(" 123aa"); 158 | ASSERT_ATOI(" 123 "); 159 | ASSERT_ATOI("zzz123zzz"); 160 | ASSERT_ATOI("0x123"); 161 | ASSERT_ATOI("zzz"); 162 | } 163 | 164 | 165 | PCU_Suite *StrtolTest_suite(void) 166 | { 167 | static PCU_Test tests[] = { 168 | { "test_strtol", test_strtol }, 169 | { "test_strtoul", test_strtoul }, 170 | { "test_atoi", test_atoi }, 171 | }; 172 | static PCU_Suite suite = { "StrtolTest", tests, sizeof tests / sizeof tests[0] }; 173 | return &suite; 174 | } 175 | -------------------------------------------------------------------------------- /test/assert_test/AssertOperatorTest.c: -------------------------------------------------------------------------------- 1 | #include "../../PCUnit/PCUnit.h" 2 | #include 3 | 4 | static int initialize(void) 5 | { 6 | return 0; 7 | } 8 | 9 | static int cleanup(void) 10 | { 11 | return 0; 12 | } 13 | 14 | static int setup(void) 15 | { 16 | return 0; 17 | } 18 | 19 | static int teardown(void) 20 | { 21 | return 0; 22 | } 23 | 24 | 25 | 26 | static void test_assert_operator_OK(void) 27 | { 28 | unsigned int a, b; 29 | a = 0x100; 30 | b = 0x100; 31 | PCU_ASSERT_OPERATOR(0, <, 1); 32 | PCU_ASSERT_OPERATOR(0, <=, 1); 33 | PCU_ASSERT_OPERATOR(-1, >, 1); 34 | PCU_ASSERT_OPERATOR(-1, >=, 1); 35 | PCU_ASSERT_OPERATOR(a, ==, b); 36 | PCU_ASSERT_OPERATOR(a, ^, b+1); 37 | PCU_ASSERT_OPERATOR(a, &, b); 38 | PCU_ASSERT_OPERATOR(a, |, b); 39 | } 40 | 41 | static void test_assert_operator_FAIL1(void) 42 | { 43 | PCU_ASSERT_OPERATOR(-1, <, 1); 44 | printf("NOT REACHED\n"); 45 | } 46 | 47 | static void test_assert_operator_FAIL2(void) 48 | { 49 | unsigned int a, b; 50 | a = 0x100; 51 | b = 0x100; 52 | PCU_ASSERT_OPERATOR(a, ^, b); 53 | } 54 | 55 | static void test_assert_operator_FAIL3(void) 56 | { 57 | unsigned int a, b; 58 | a = 0x100; 59 | b = 0x100; 60 | PCU_ASSERT_OPERATOR(a, &, ~b); 61 | } 62 | 63 | static void test_assert_operator_FAIL4(void) 64 | { 65 | unsigned int a, b; 66 | a = 0x100; 67 | b = 0x101; 68 | PCU_ASSERT_OPERATOR(a, ==, b); 69 | } 70 | 71 | static void test_assert_operator_FAIL5(void) 72 | { 73 | unsigned int a; 74 | a = 0x100; 75 | PCU_ASSERT_OPERATOR(0x10 <= a, &&, a < 0x100); 76 | } 77 | 78 | static void test_assert_operator_FAIL6(void) 79 | { 80 | unsigned int a; 81 | a = 0x100; 82 | PCU_ASSERT_OPERATOR(a < 0x10, ||, 0x100 < a); 83 | } 84 | 85 | static void test_assert_operator_MSG(void) 86 | { 87 | unsigned int a, b; 88 | a = 0x100; 89 | b = 0x100; 90 | PCU_ASSERT_OPERATOR_MESSAGE(a, ==, b, PCU_format("%d, %d", a, b)); 91 | b = 0x0; 92 | PCU_ASSERT_OPERATOR_MESSAGE(a, ==, b, PCU_format("%d, %d", a, b)); 93 | } 94 | 95 | 96 | 97 | static void test_assert_operator_int_OK(void) 98 | { 99 | int a, b; 100 | a = 0x100; 101 | b = 0x100; 102 | PCU_ASSERT_OPERATOR_INT(0, <, 1); 103 | PCU_ASSERT_OPERATOR_INT(0, <=, 1); 104 | PCU_ASSERT_OPERATOR_INT(-1, <, 1); 105 | PCU_ASSERT_OPERATOR_INT(-1, <=, 1); 106 | PCU_ASSERT_OPERATOR_INT(a, ==, b); 107 | PCU_ASSERT_OPERATOR_INT(a, ^, b+1); 108 | PCU_ASSERT_OPERATOR_INT(a, &, b); 109 | PCU_ASSERT_OPERATOR_INT(a, |, b); 110 | } 111 | 112 | static void test_assert_operator_int_FAIL1(void) 113 | { 114 | PCU_ASSERT_OPERATOR_INT(-1, >, 1); 115 | } 116 | 117 | static void test_assert_operator_int_FAIL2(void) 118 | { 119 | int a, b; 120 | a = 0x100; 121 | b = 0x100; 122 | PCU_ASSERT_OPERATOR_INT(a, ^, b); 123 | } 124 | 125 | static void test_assert_operator_int_FAIL3(void) 126 | { 127 | int a, b; 128 | a = 0x100; 129 | b = 0x100; 130 | PCU_ASSERT_OPERATOR_INT(a, &, ~b); 131 | } 132 | 133 | static void test_assert_operator_int_FAIL4(void) 134 | { 135 | int a, b; 136 | a = 0x100; 137 | b = 0x101; 138 | PCU_ASSERT_OPERATOR_INT(a, ==, b); 139 | } 140 | 141 | static void test_assert_operator_int_FAIL5(void) 142 | { 143 | int a; 144 | a = 0x100; 145 | PCU_ASSERT_OPERATOR_INT(0x10 <= a, &&, a < 0x100); 146 | } 147 | 148 | static void test_assert_operator_int_FAIL6(void) 149 | { 150 | int a; 151 | a = 0x100; 152 | PCU_ASSERT_OPERATOR_INT(a < 0x10, ||, 0x100 < a); 153 | } 154 | 155 | static void test_assert_operator_int_MSG(void) 156 | { 157 | int a, b; 158 | a = 0x100; 159 | b = 0x100; 160 | PCU_ASSERT_OPERATOR_INT_MESSAGE(a, ==, b, PCU_format("%d, %d", a, b)); 161 | b = 0x0; 162 | PCU_ASSERT_OPERATOR_INT_MESSAGE(a, ==, b, PCU_format("%d, %d", a, b)); 163 | } 164 | 165 | 166 | 167 | static void test_assert_operator_dbl_OK(void) 168 | { 169 | double a, b; 170 | a = 100.0; 171 | b = 100.0; 172 | PCU_ASSERT_OPERATOR_DOUBLE(0, <, 1); 173 | PCU_ASSERT_OPERATOR_DOUBLE(0, <=, 1); 174 | PCU_ASSERT_OPERATOR_DOUBLE(-1, <, 1); 175 | PCU_ASSERT_OPERATOR_DOUBLE(-1, <=, 1); 176 | 177 | PCU_ASSERT_OPERATOR_DOUBLE(a, ==, b); 178 | PCU_ASSERT_OPERATOR_DOUBLE(a, <=, b); 179 | PCU_ASSERT_OPERATOR_DOUBLE(a, <, b + 0.01); 180 | } 181 | 182 | static void test_assert_operator_dbl_FAIL1(void) 183 | { 184 | PCU_ASSERT_OPERATOR_DOUBLE(0, >, 1); 185 | } 186 | 187 | static void test_assert_operator_dbl_FAIL2(void) 188 | { 189 | double a, b; 190 | a = 100.0; 191 | b = 100.0; 192 | PCU_ASSERT_OPERATOR_DOUBLE(a, <, b); 193 | } 194 | 195 | static void test_assert_operator_dbl_FAIL3(void) 196 | { 197 | double a, b; 198 | a = 100.0; 199 | b = 100.1; 200 | PCU_ASSERT_OPERATOR_DOUBLE(a, ==, b); 201 | } 202 | 203 | 204 | static PCU_Test tests[] = { 205 | PCU_TEST(test_assert_operator_OK), 206 | PCU_TEST(test_assert_operator_FAIL1), 207 | PCU_TEST(test_assert_operator_FAIL2), 208 | PCU_TEST(test_assert_operator_FAIL3), 209 | PCU_TEST(test_assert_operator_FAIL4), 210 | PCU_TEST(test_assert_operator_FAIL5), 211 | PCU_TEST(test_assert_operator_FAIL6), 212 | PCU_TEST(test_assert_operator_MSG), 213 | PCU_TEST(test_assert_operator_int_OK), 214 | PCU_TEST(test_assert_operator_int_FAIL1), 215 | PCU_TEST(test_assert_operator_int_FAIL2), 216 | PCU_TEST(test_assert_operator_int_FAIL3), 217 | PCU_TEST(test_assert_operator_int_FAIL4), 218 | PCU_TEST(test_assert_operator_int_FAIL5), 219 | PCU_TEST(test_assert_operator_int_FAIL6), 220 | PCU_TEST(test_assert_operator_int_MSG), 221 | PCU_TEST(test_assert_operator_dbl_OK), 222 | PCU_TEST(test_assert_operator_dbl_FAIL1), 223 | PCU_TEST(test_assert_operator_dbl_FAIL2), 224 | PCU_TEST(test_assert_operator_dbl_FAIL3), 225 | }; 226 | 227 | PCU_Suite *AssertOperatorTest_suite(void) 228 | { 229 | static PCU_Suite suite = { 230 | "AssertOperatorTest", tests, sizeof tests / sizeof tests[0], setup, teardown, initialize, cleanup 231 | }; 232 | return &suite; 233 | } 234 | 235 | -------------------------------------------------------------------------------- /PCUnit/pcunit_template.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/ruby 2 | 3 | require 'optparse' 4 | 5 | opt = OptionParser.new 6 | OPTS = {} 7 | 8 | OPTS[:d] = "./" 9 | OPTS[:p] = ".c" 10 | 11 | opt.on('-m [VAL]') {|v| 12 | if v 13 | OPTS[:m] = v 14 | else 15 | OPTS[:m] = "main" 16 | end 17 | } 18 | opt.on('-M [VAL]') {|v| 19 | if v 20 | OPTS[:M] = v 21 | else 22 | OPTS[:M] = "Makefile" 23 | end 24 | } 25 | opt.on('-i') {|v| OPTS[:i] = v } 26 | opt.on('-d VAL') {|v| OPTS[:d] = v + "/" } 27 | opt.on('-o') {|v| OPTS[:o] = v } 28 | opt.on('-p [VAL]') {|v| 29 | if v =~ /(cpp|cc|cxx)/i 30 | OPTS[:p] = "." + $1 31 | else 32 | OPTS[:p] = ".cpp" 33 | end 34 | } 35 | opt.on('-h', '--help') { 36 | print <<-"EOB" 37 | Usage: pcunit_template.rb [suite_name ...] [-d DIR] [-p [EXT]] [-m [FILE]] [-M [FILE] [-i]] [-o] 38 | -d DIR output directory 39 | -p [EXT] change file extension from C to C++ (default: cpp) 40 | -m [FILE] create main file (default: main.c or main.cpp) 41 | -M [FILE] create Makefile (default: Makefile) 42 | [-i] whether libpcunit.a is installed 43 | -o overwrite flag 44 | 45 | EOB 46 | exit 47 | } 48 | 49 | 50 | opt.parse!(ARGV) 51 | 52 | if OPTS[:m] == "main" 53 | OPTS[:m] += OPTS[:p] 54 | end 55 | 56 | def create_test(suite_name) 57 | pcutests_ext = ".pcutests" 58 | file = File.open(OPTS[:d] + suite_name + OPTS[:p], "w") 59 | file.print <<-"EOB" 60 | #include "PCUnit/PCUnit.h" 61 | 62 | static int initialize(void) 63 | { 64 | return 0; 65 | } 66 | 67 | static int cleanup(void) 68 | { 69 | return 0; 70 | } 71 | 72 | static int setup(void) 73 | { 74 | return 0; 75 | } 76 | 77 | static int teardown(void) 78 | { 79 | return 0; 80 | } 81 | 82 | 83 | static void test_TODO(void) 84 | { 85 | PCU_FAIL("TODO"); 86 | } 87 | 88 | 89 | PCU_Suite *#{suite_name}_suite(void) 90 | { 91 | static PCU_Test tests[] = { 92 | #include "#{suite_name}#{pcutests_ext}" 93 | }; 94 | static PCU_Suite suite = { 95 | "#{suite_name}", tests, sizeof tests / sizeof tests[0], 96 | setup, 97 | teardown, 98 | initialize, 99 | cleanup, 100 | }; 101 | return &suite; 102 | } 103 | 104 | EOB 105 | file.close 106 | 107 | File.open(OPTS[:d] + suite_name + pcutests_ext, "w").close 108 | end 109 | 110 | def create_alltests() 111 | file = File.open(OPTS[:d] + OPTS[:m], "w") 112 | file.print <<-"EOB" 113 | #include "PCUnit/PCUnit.h" 114 | #include 115 | 116 | 117 | int main(int argc, char *argv[]) 118 | { 119 | const PCU_SuiteMethod suites[] = { 120 | }; 121 | int i; 122 | int console_mode = 0; 123 | PCU_set_putchar(putchar); 124 | PCU_set_getchar(getchar); 125 | PCU_enable_color(); 126 | for (i = 1; i < argc; i++) { 127 | if (argv[i][0] == '-') { 128 | switch (argv[i][1]) { 129 | case 'c': 130 | console_mode = 1; 131 | break; 132 | case 'v': 133 | PCU_set_verbose(1); 134 | break; 135 | case 'd': 136 | PCU_disable_color(); 137 | break; 138 | default: 139 | break; 140 | } 141 | } 142 | } 143 | if (console_mode) { 144 | return PCU_console_run(suites, sizeof suites / sizeof suites[0]); 145 | } 146 | return PCU_run(suites, sizeof suites / sizeof suites[0]); 147 | } 148 | 149 | EOB 150 | end 151 | 152 | def create_makefile(objs) 153 | cc = OPTS[:p] == ".c" ? "gcc" : "g++" 154 | ext = OPTS[:p] 155 | file = File.open(OPTS[:d] + OPTS[:M], "w") 156 | file.print <<-"EOB" 157 | PCUNITDIR = PCUnit 158 | 159 | CC = #{cc} 160 | CFLAGS = -Wall -g 161 | CFLAGS += -I$(PCUNITDIR)/.. 162 | LFLAGS = -L$(PCUNITDIR) -lpcunit 163 | LIBPCUNIT = $(PCUNITDIR)/libpcunit.a 164 | 165 | VPATH = 166 | 167 | TARGET = alltests 168 | OBJS = main.o 169 | #{objs} 170 | 171 | .PHONY: all clean pcunit_register test xml 172 | 173 | all: pcunit_register $(TARGET) 174 | 175 | pcunit_register: 176 | -ruby $(PCUNITDIR)/pcunit_register.rb 177 | 178 | .SUFFIXES: #{ext} .o 179 | 180 | #{ext}.o: 181 | $(CC) $(CFLAGS) -c $< 182 | 183 | $(LIBPCUNIT): 184 | cd $(PCUNITDIR) && $(MAKE) 185 | 186 | $(TARGET): $(LIBPCUNIT) $(OBJS) 187 | $(CC) $(CFLAGS) $(OBJS) -o $@ $(LFLAGS) 188 | 189 | test: all 190 | ./$(TARGET) 191 | 192 | xml: all 193 | ./$(TARGET) -v | ruby $(PCUNITDIR)/pcunit_xml_output.rb $(OUTPUT) 194 | 195 | clean: 196 | cd $(PCUNITDIR) && $(MAKE) clean 197 | rm -f *.o $(TARGET) 198 | 199 | EOB 200 | end 201 | 202 | def create_makefile_installed(objs) 203 | cc = OPTS[:p] == ".c" ? "gcc" : "g++" 204 | ext = OPTS[:p] 205 | file = File.open(OPTS[:d] + OPTS[:M], "w") 206 | file.print <<-"EOB" 207 | INSTALLDIR = /usr/local 208 | 209 | CC = #{cc} 210 | CFLAGS = -Wall -g 211 | CFLAGS += -I$(INSTALLDIR)/include 212 | LFLAGS = -L$(INSTALLDIR)/lib -lpcunit 213 | 214 | VPATH = 215 | 216 | TARGET = alltests 217 | OBJS = main.o 218 | #{objs} 219 | 220 | .PHONY: all clean pcunit_register test xml 221 | 222 | all: pcunit_register $(TARGET) 223 | 224 | pcunit_register: 225 | -ruby $(INSTALLDIR)/bin/pcunit_register.rb 226 | 227 | .SUFFIXES: #{ext} .o 228 | 229 | #{ext}.o: 230 | $(CC) $(CFLAGS) -c $< 231 | 232 | $(TARGET): $(OBJS) 233 | $(CC) $(CFLAGS) $(OBJS) -o $@ $(LFLAGS) 234 | 235 | test: all 236 | ./$(TARGET) 237 | 238 | xml: all 239 | ./$(TARGET) -v | ruby $(INSTALLDIR)/bin/pcunit_xml_output.rb $(OUTPUT) 240 | 241 | clean: 242 | rm -f *.o $(TARGET) 243 | 244 | EOB 245 | end 246 | 247 | makefile_objs = "" 248 | ARGV.each {|name| 249 | if OPTS[:o] || !File.exist?(OPTS[:d] + name + OPTS[:p]) 250 | create_test(name) 251 | end 252 | makefile_objs += "OBJS += #{name}.o\n" 253 | } 254 | 255 | if OPTS[:m] 256 | if OPTS[:o] || !File.exist?(OPTS[:d] + OPTS[:m]) 257 | create_alltests() 258 | end 259 | end 260 | 261 | if OPTS[:M] 262 | if OPTS[:o] || !File.exist?(OPTS[:d] + OPTS[:M]) 263 | if OPTS[:i] 264 | create_makefile_installed(makefile_objs) 265 | else 266 | create_makefile(makefile_objs) 267 | end 268 | end 269 | end 270 | 271 | -------------------------------------------------------------------------------- /test/assert_test/AssertMemoryTest.c: -------------------------------------------------------------------------------- 1 | #include "../../PCUnit/PCUnit.h" 2 | #include 3 | 4 | static int initialize(void) 5 | { 6 | return 0; 7 | } 8 | 9 | static int cleanup(void) 10 | { 11 | return 0; 12 | } 13 | 14 | static int setup(void) 15 | { 16 | return 0; 17 | } 18 | 19 | static int teardown(void) 20 | { 21 | return 0; 22 | } 23 | 24 | typedef struct STRUCT_t { 25 | int x; 26 | char y; 27 | } STRUCT_t; 28 | 29 | static void test_assert_mem_equal_OK(void) 30 | { 31 | STRUCT_t a[2] = {{0}}; 32 | STRUCT_t b[2] = {{0}}; 33 | 34 | a[0].x = 1; a[0].y = 2; a[1].x = 3; a[1].y = 4; 35 | b[0].x = 1; b[0].y = 2; b[1].x = 3; b[1].y = 4; 36 | PCU_ASSERT_MEMORY_EQUAL(&a[0], &b[0], sizeof a, 1); 37 | PCU_ASSERT_MEMORY_EQUAL(&a[0], &b[0], sizeof a[0], 2); 38 | } 39 | 40 | static void test_assert_mem_char_equal_OK(void) 41 | { 42 | const char *a, *b; 43 | a = "hoge"; 44 | b = "hogehoge"; 45 | PCU_ASSERT_MEMORY_EQUAL("hoge", a, 4, 1); 46 | PCU_ASSERT_MEMORY_EQUAL(a, b, 4, 1); 47 | PCU_ASSERT_MEMORY_EQUAL(a, b, 3, 1); 48 | PCU_ASSERT_MEMORY_EQUAL(a, b, 0, 1); 49 | } 50 | 51 | static void test_assert_mem_equal_FAIL(void) 52 | { 53 | STRUCT_t a[2] = {{0}}; 54 | STRUCT_t b[2] = {{0}}; 55 | 56 | a[0].x = 1; a[0].y = 2; a[1].x = 3; a[1].y = 4; 57 | b[0].x = 1; b[0].y = 2; b[1].x = 3; b[1].y = 5; 58 | PCU_ASSERT_MEMORY_EQUAL(&a[0], &b[0], sizeof a[0], 2); 59 | printf("NOT REACHED\n"); 60 | } 61 | 62 | static void test_assert_mem_equal_MSG(void) 63 | { 64 | STRUCT_t a[2] = {{0}}; 65 | STRUCT_t b[2] = {{0}}; 66 | 67 | a[0].x = 1; a[0].y = 2; a[1].x = 3; a[1].y = 4; 68 | b[0].x = 1; b[0].y = 2; b[1].x = 3; b[1].y = 5; 69 | PCU_ASSERT_MEMORY_EQUAL_MESSAGE(&a[0], &b[0], sizeof a[0], 1, PCU_format("%d, %d", a[0].x, b[0].y)); 70 | PCU_ASSERT_MEMORY_EQUAL_MESSAGE(&a[0], &b[0], sizeof a[0], 2, PCU_format("%d, %d", a[1].x, b[1].y)); 71 | } 72 | 73 | static void test_assert_mem_equal_FAIL_expect_null(void) 74 | { 75 | STRUCT_t a[2] = {{0}}; 76 | STRUCT_t b[2] = {{0}}; 77 | 78 | a[0].x = 1; a[0].y = 2; a[1].x = 3; a[1].y = 4; 79 | b[0].x = 1; b[0].y = 2; b[1].x = 3; b[1].y = 5; 80 | PCU_ASSERT_MEMORY_EQUAL(NULL, &b[0], sizeof a[0], 1); 81 | } 82 | 83 | static void test_assert_mem_equal_FAIL_actual_null(void) 84 | { 85 | STRUCT_t a[2] = {{0}}; 86 | STRUCT_t b[2] = {{0}}; 87 | 88 | a[0].x = 1; a[0].y = 2; a[1].x = 3; a[1].y = 4; 89 | b[0].x = 1; b[0].y = 2; b[1].x = 3; b[1].y = 5; 90 | PCU_ASSERT_MEMORY_EQUAL(&a[0], NULL, sizeof a[0], 1); 91 | } 92 | 93 | static void test_assert_mem_equal_OK_null_null(void) 94 | { 95 | PCU_ASSERT_MEMORY_EQUAL(NULL, NULL, 4, 2); 96 | } 97 | 98 | 99 | 100 | 101 | static void test_assert_mem_not_equal_OK(void) 102 | { 103 | STRUCT_t a[2] = {{0}}; 104 | STRUCT_t b[2] = {{0}}; 105 | 106 | a[0].x = 1; a[0].y = 2; a[1].x = 3; a[1].y = 4; 107 | b[0].x = 1; b[0].y = 2; b[1].x = 3; b[1].y = 5; 108 | PCU_ASSERT_MEMORY_NOT_EQUAL(&a[0], &b[0], sizeof a, 1); 109 | PCU_ASSERT_MEMORY_NOT_EQUAL(&a[0], &b[0], sizeof a[0], 2); 110 | } 111 | 112 | static void test_assert_mem_char_not_equal_OK(void) 113 | { 114 | const char *a, *b; 115 | a = "hogu"; 116 | b = "hogehoge"; 117 | PCU_ASSERT_MEMORY_NOT_EQUAL("hoge", a, 4, 1); 118 | PCU_ASSERT_MEMORY_NOT_EQUAL(a, b, 4, 1); 119 | PCU_ASSERT_MEMORY_NOT_EQUAL(a, b, 5, 1); 120 | } 121 | 122 | static void test_assert_mem_not_equal_FAIL(void) 123 | { 124 | STRUCT_t a[2] = {{0}}; 125 | STRUCT_t b[2] = {{0}}; 126 | 127 | a[0].x = 1; a[0].y = 2; a[1].x = 3; a[1].y = 4; 128 | b[0].x = 1; b[0].y = 2; b[1].x = 3; b[1].y = 4; 129 | PCU_ASSERT_MEMORY_NOT_EQUAL(&a[0], &b[0], sizeof a[0], 2); 130 | printf("NOT REACHED\n"); 131 | } 132 | 133 | static void test_assert_mem_not_equal_MSG(void) 134 | { 135 | STRUCT_t a[2] = {{0}}; 136 | STRUCT_t b[2] = {{0}}; 137 | 138 | a[0].x = 1; a[0].y = 2; a[1].x = 3; a[1].y = 4; 139 | b[0].x = 1; b[0].y = 2; b[1].x = 3; b[1].y = 4; 140 | PCU_ASSERT_MEMORY_NOT_EQUAL_MESSAGE(&a[0], &b[0], sizeof a[0], 1, PCU_format("%d, %d", a[0].x, b[0].y)); 141 | PCU_ASSERT_MEMORY_NOT_EQUAL_MESSAGE(&a[0], &b[0], sizeof a[0], 2, PCU_format("%d, %d", a[1].x, b[1].y)); 142 | } 143 | 144 | static void test_assert_mem_not_equal_OK_expect_null(void) 145 | { 146 | STRUCT_t a[2] = {{0}}; 147 | STRUCT_t b[2] = {{0}}; 148 | 149 | a[0].x = 1; a[0].y = 2; a[1].x = 3; a[1].y = 4; 150 | b[0].x = 1; b[0].y = 2; b[1].x = 3; b[1].y = 5; 151 | PCU_ASSERT_MEMORY_NOT_EQUAL(NULL, &b[0], sizeof a[0], 1); 152 | } 153 | 154 | static void test_assert_mem_not_equal_OK_actual_null(void) 155 | { 156 | STRUCT_t a[2] = {{0}}; 157 | STRUCT_t b[2] = {{0}}; 158 | 159 | a[0].x = 1; a[0].y = 2; a[1].x = 3; a[1].y = 4; 160 | b[0].x = 1; b[0].y = 2; b[1].x = 3; b[1].y = 5; 161 | PCU_ASSERT_MEMORY_NOT_EQUAL(&a[0], NULL, sizeof a[0], 1); 162 | } 163 | 164 | static void test_assert_mem_not_equal_FAIL_null_null(void) 165 | { 166 | PCU_ASSERT_MEMORY_NOT_EQUAL(NULL, NULL, 1, 4); 167 | } 168 | 169 | 170 | 171 | static PCU_Test tests[] = { 172 | PCU_TEST(test_assert_mem_equal_OK), 173 | PCU_TEST(test_assert_mem_char_equal_OK), 174 | PCU_TEST(test_assert_mem_equal_FAIL), 175 | PCU_TEST(test_assert_mem_equal_MSG), 176 | PCU_TEST(test_assert_mem_equal_FAIL_expect_null), 177 | PCU_TEST(test_assert_mem_equal_FAIL_actual_null), 178 | PCU_TEST(test_assert_mem_equal_OK_null_null), 179 | PCU_TEST(test_assert_mem_not_equal_OK), 180 | PCU_TEST(test_assert_mem_char_not_equal_OK), 181 | PCU_TEST(test_assert_mem_not_equal_FAIL), 182 | PCU_TEST(test_assert_mem_not_equal_MSG), 183 | PCU_TEST(test_assert_mem_not_equal_OK_expect_null), 184 | PCU_TEST(test_assert_mem_not_equal_OK_actual_null), 185 | PCU_TEST(test_assert_mem_not_equal_FAIL_null_null), 186 | }; 187 | 188 | PCU_Suite *AssertMemoryTest_suite(void) 189 | { 190 | static PCU_Suite suite = { 191 | "AssertMemoryTest", tests, sizeof tests / sizeof tests[0], setup, teardown, initialize, cleanup 192 | }; 193 | return &suite; 194 | } 195 | 196 | -------------------------------------------------------------------------------- /PCUnit/pcunit_xml_output.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/ruby 2 | 3 | require 'optparse' 4 | require 'rexml/document' 5 | 6 | opt = OptionParser.new 7 | 8 | output_file_name = "test_results.xml" 9 | no_stdout = false 10 | exit_code_flag = false 11 | 12 | opt.on('-e') {|v| exit_code_flag = v } 13 | opt.on('-n') {|v| no_stdout = v } 14 | opt.on('-h', '--help') { 15 | print <<-"EOB" 16 | Usage: pcunit_xml_output.rb [output_file] [-e] [-n] 17 | -e return non-zero exit code if tests failed 18 | -n no stdout flag 19 | 20 | EOB 21 | exit 22 | } 23 | 24 | opt.parse!(ARGV) 25 | 26 | $exit_code = 0 27 | doc = REXML::Document.new 28 | doc.add(REXML::XMLDecl.new(version="1.0", encoding="UTF-8")) 29 | $testsuites = REXML::Element.new("testsuites") 30 | doc.add_element($testsuites) 31 | $testsuites.add_attribute("tests", "0") 32 | $testsuites.add_attribute("failures", "0") 33 | $testsuites.add_attribute("errors", "0") 34 | $testsuites.add_attribute("time", "0") 35 | $testsuites.add_attribute("name", "") 36 | 37 | $failure_message = "" 38 | $testsuite = nil 39 | $testcase = nil 40 | $exists_testcase = false 41 | 42 | def parse_line(line) 43 | line.chomp! 44 | if line =~ /(\033\[\d*m)/ 45 | line[$1] = "" 46 | end 47 | if line =~ /^Suite: (.*)/ 48 | if $testsuite 49 | $testsuites.attributes["tests"] = ($testsuites.attributes["tests"].to_i + $testsuite.attributes["tests"].to_i).to_s 50 | $testsuites.attributes["failures"] = ($testsuites.attributes["failures"].to_i + $testsuite.attributes["failures"].to_i).to_s 51 | $testsuites.attributes["errors"] = ($testsuites.attributes["errors"].to_i + $testsuite.attributes["errors"].to_i).to_s 52 | end 53 | $failure_message = "" 54 | $testcase = nil 55 | $testsuite = REXML::Element.new("testsuite") 56 | $testsuite.add_attribute("name", $1) 57 | $testsuite.add_attribute("tests", "0") 58 | $testsuite.add_attribute("failures", "0") 59 | $testsuite.add_attribute("skipped", "0") 60 | $testsuite.add_attribute("errors", "0") 61 | $testsuite.add_attribute("time", "0") 62 | $testsuites.add_element($testsuite) 63 | elsif line =~ /^Test: (.*)/ 64 | $testcase = REXML::Element.new("testcase") 65 | $testcase.add_attribute("name", $1) 66 | $testcase.add_attribute("classname", $testsuite.attributes["name"]) 67 | $testcase.add_attribute("time", "0") 68 | $testsuite.add_element($testcase) 69 | $exists_testcase = true 70 | elsif line =~ /^ \[(.*)\]/ 71 | if $1 == "PASSED" 72 | elsif $1 == "SKIPPED" 73 | skipped = REXML::Element.new("skipped") 74 | $testcase.add_element(skipped) 75 | elsif $1 == "FAILED" 76 | failure = REXML::Element.new("failure") 77 | failure.add_attribute("message", $failure_message) 78 | failure.add_attribute("type", "") 79 | $testcase.add_element(failure) 80 | end 81 | $failure_message = "" 82 | $testcase = nil 83 | elsif line =~ /^(\d+) Tests, (\d+) Failures, (\d+) Skipped/ 84 | tests = $1.to_i 85 | failures = $2.to_i 86 | skipped = $3.to_i 87 | $testsuite.attributes["tests"] = ($testsuite.attributes["tests"].to_i + tests).to_s 88 | $testsuite.attributes["failures"] = ($testsuite.attributes["failures"].to_i + failures).to_s 89 | $testsuite.attributes["skipped"] = ($testsuite.attributes["skipped"].to_i + skipped).to_s 90 | if failures > 0 91 | $exit_code = 1 92 | end 93 | elsif line =~ /^(INITIALIZE|CLEANUP) FAILED : (.*)/ 94 | $testcase = REXML::Element.new("testcase") 95 | $testcase.add_attribute("name", $1 + " FAILED") 96 | $testcase.add_attribute("classname", $testsuite.attributes["name"]) 97 | $testcase.add_attribute("time", "0") 98 | failure = REXML::Element.new("error") 99 | failure.add_attribute("message", $2) 100 | failure.add_attribute("type", "") 101 | $testcase.add_element(failure) 102 | $testsuite.add_element($testcase) 103 | $testsuite.attributes["errors"] = ($testsuite.attributes["errors"].to_i + 1).to_s 104 | $exit_code = 1 105 | elsif line == "OK" 106 | elsif line == "" 107 | if $testcase 108 | if $failure_message =~ /(PCU_ASSERT|PCU_FAIL|SETUP FAILED|TEARDOWN FAILED)/ 109 | failure = REXML::Element.new("failure") 110 | failure.add_attribute("message", $failure_message) 111 | failure.add_attribute("type", "") 112 | $testcase.add_element(failure) 113 | end 114 | $failure_message = "" 115 | $testcase = nil 116 | end 117 | else 118 | $failure_message += line + "#x0A;\n" 119 | end 120 | end 121 | 122 | while s = STDIN.gets 123 | if !no_stdout 124 | puts s 125 | end 126 | if RUBY_VERSION >= '1.9' 127 | s = s.encode("UTF-8") 128 | end 129 | parse_line s 130 | end 131 | $testsuites.attributes["tests"] = ($testsuites.attributes["tests"].to_i + $testsuite.attributes["tests"].to_i).to_s 132 | $testsuites.attributes["failures"] = ($testsuites.attributes["failures"].to_i + $testsuite.attributes["failures"].to_i).to_s 133 | $testsuites.attributes["errors"] = ($testsuites.attributes["errors"].to_i + $testsuite.attributes["errors"].to_i).to_s 134 | if !$exists_testcase 135 | # dummy 136 | $testsuite = REXML::Element.new("testsuite") 137 | $testsuite.add_attribute("name", "") 138 | $testsuite.add_attribute("tests", "0") 139 | $testsuite.add_attribute("failures", "0") 140 | $testsuite.add_attribute("skipped", "0") 141 | $testsuite.add_attribute("errors", "0") 142 | $testsuite.add_attribute("time", "0") 143 | $testsuites.add_element($testsuite) 144 | $testcase = REXML::Element.new("testcase") 145 | $testcase.add_attribute("name", "") 146 | $testcase.add_attribute("classname", "") 147 | $testcase.add_attribute("time", "0") 148 | $testsuite.add_element($testcase) 149 | end 150 | 151 | str = "" 152 | doc.write(str, 2) 153 | str.gsub!(/#x0A;/, ' ') 154 | str.gsub!(/message='/, "message='\n") 155 | str += "\n" 156 | if ARGV[0] 157 | output_file_name = ARGV[0] 158 | end 159 | File.open(output_file_name, "w") { |f| 160 | f.write(str) 161 | } 162 | 163 | if exit_code_flag 164 | exit $exit_code 165 | end 166 | -------------------------------------------------------------------------------- /test/pcunit_mock_test/MockTest.c: -------------------------------------------------------------------------------- 1 | #include "PCUnit/PCUnit.h" 2 | #include "mock_target.h" 3 | #include 4 | 5 | static int setup(void) 6 | { 7 | mock_target_init(); 8 | return 0; 9 | } 10 | 11 | static int teardown(void) 12 | { 13 | mock_target_verify(); 14 | return 0; 15 | } 16 | 17 | 18 | static void test_f_int_args(void) 19 | { 20 | f_int_args_Expectation e[1] = {{0}}; 21 | e[0].expected.a = 1; 22 | e[0].expected.b = 2; 23 | e[0].expected.c = 3; 24 | e[0].expected.d = 4; 25 | e[0].retval = 5; 26 | f_int_args_expect(e, sizeof e / sizeof e[0]); 27 | PCU_ASSERT_EQUAL(5, f_int_args(1, 2, 3, 4)); 28 | } 29 | 30 | static void test_f_int_args_all_params_ignored(void) 31 | { 32 | f_int_args_Expectation e[1] = {{0}}; 33 | memset(&e[0].ignored, 0xFF, sizeof e[0].ignored); 34 | e[0].retval = 5; 35 | f_int_args_expect(e, sizeof e / sizeof e[0]); 36 | PCU_ASSERT_EQUAL(5, f_int_args(1, 2, 3, 4)); 37 | } 38 | 39 | static void test_f_int_args_param_ignored(void) 40 | { 41 | f_int_args_Expectation e[1] = {{0}}; 42 | e[0].expected.a = 1; 43 | e[0].ignored.b = 1; 44 | e[0].expected.c = 3; 45 | e[0].ignored.d = 1; 46 | e[0].retval = 5; 47 | f_int_args_expect(e, sizeof e / sizeof e[0]); 48 | PCU_ASSERT_EQUAL(5, f_int_args(1, 1000, 3, 1000)); 49 | } 50 | 51 | static void test_f_int_args_2times(void) 52 | { 53 | f_int_args_Expectation e[2] = {{0}}; 54 | e[0].expected.a = 1; 55 | e[0].expected.b = 2; 56 | e[0].expected.c = 3; 57 | e[0].expected.d = 4; 58 | e[0].retval = 5; 59 | e[1].expected.a = 10; 60 | e[1].expected.b = 20; 61 | e[1].expected.c = 30; 62 | e[1].expected.d = 40; 63 | e[1].retval = 50; 64 | f_int_args_expect(e, sizeof e / sizeof e[0]); 65 | PCU_ASSERT_EQUAL(5, f_int_args(1, 2, 3, 4)); 66 | PCU_ASSERT_EQUAL(50, f_int_args(10, 20, 30, 40)); 67 | } 68 | 69 | static void test_f_const_char_ptr(void) 70 | { 71 | f_const_char_ptr_Expectation e[1] = {{0}}; 72 | e[0].expected.a = "hoge"; 73 | e[0].retval = "foo"; 74 | f_const_char_ptr_expect(e, sizeof e / sizeof e[0]); 75 | PCU_ASSERT_STRING_EQUAL("foo", f_const_char_ptr("hoge")); 76 | } 77 | 78 | static void test_f_void(void) 79 | { 80 | f_void_omitted_Expectation e[1] = {{0}}; 81 | f_void_omitted_expect(e, sizeof e / sizeof e[0]); 82 | f_void_omitted(); 83 | } 84 | 85 | static void test_f_STRUCT_t_ptr(void) 86 | { 87 | STRUCT_t st1 = {100}; 88 | STRUCT_t st2 = {10}; 89 | STRUCT_t st3 = {10}; 90 | f_STRUCT_t_ptr_Expectation e[1] = {{0}}; 91 | e[0].expected.a = &st1; 92 | e[0].retval = &st2; 93 | f_STRUCT_t_ptr_expect(e, sizeof e / sizeof e[0]); 94 | PCU_ASSERT_MEMORY_EQUAL(&st3, f_STRUCT_t_ptr(&st1), sizeof(STRUCT_t), 1); 95 | } 96 | 97 | 98 | static int f_int_args_callback(int a, int b, int c, int d) 99 | { 100 | const int expected_a[] = {1, 10, 100, 1000}; 101 | const int expected_b[] = {2, 20, 200, 2000}; 102 | const int expected_c[] = {3, 30, 300, 3000}; 103 | const int expected_d[] = {4, 40, 400, 4000}; 104 | const int retval[] = {5, 50, 500, 5000}; 105 | PCU_ASSERT_EQUAL(expected_a[f_int_args_num_calls()], a); 106 | PCU_ASSERT_EQUAL(expected_b[f_int_args_num_calls()], b); 107 | PCU_ASSERT_EQUAL(expected_c[f_int_args_num_calls()], c); 108 | PCU_ASSERT_EQUAL(expected_d[f_int_args_num_calls()], d); 109 | return retval[f_int_args_num_calls()]; 110 | } 111 | 112 | static void test_f_int_args_callback(void) 113 | { 114 | f_int_args_set_callback(f_int_args_callback, 4); 115 | PCU_ASSERT_EQUAL(5, f_int_args(1, 2, 3, 4)); 116 | PCU_ASSERT_EQUAL(50, f_int_args(10, 20, 30, 40)); 117 | PCU_ASSERT_EQUAL(500, f_int_args(100, 200, 300, 400)); 118 | PCU_ASSERT_EQUAL(5000, f_int_args(1000, 2000, 3000, 4000)); 119 | } 120 | 121 | static int *f_int_ptr_callback(int *a) 122 | { 123 | const int ret_a[] = {1, 10, 100, 1000}; 124 | PCU_ASSERT_PTR_NOT_NULL(a); 125 | *a = ret_a[f_int_ptr_num_calls()]; 126 | return 0; 127 | } 128 | 129 | static void test_f_int_ptr_return_by_param_ptr(void) 130 | { 131 | int a = 0; 132 | f_int_ptr_set_callback(f_int_ptr_callback, 4); 133 | f_int_ptr(&a); 134 | PCU_ASSERT_EQUAL(1, a); 135 | a = 0; 136 | f_int_ptr(&a); 137 | PCU_ASSERT_EQUAL(10, a); 138 | a = 0; 139 | f_int_ptr(&a); 140 | PCU_ASSERT_EQUAL(100, a); 141 | a = 0; 142 | f_int_ptr(&a); 143 | PCU_ASSERT_EQUAL(1000, a); 144 | } 145 | 146 | static void f_int_varg_callback(int *a, va_list ap) 147 | { 148 | if (f_int_varg_num_calls() == 0) { 149 | PCU_ASSERT_EQUAL(1, va_arg(ap, int)); 150 | PCU_ASSERT_EQUAL(2, va_arg(ap, int)); 151 | PCU_ASSERT_EQUAL(3, va_arg(ap, int)); 152 | } else { 153 | PCU_ASSERT_EQUAL(10, va_arg(ap, int)); 154 | PCU_ASSERT_EQUAL(20, va_arg(ap, int)); 155 | PCU_ASSERT_EQUAL(30, va_arg(ap, int)); 156 | PCU_ASSERT_STRING_EQUAL("hoge", va_arg(ap, const char *)); 157 | } 158 | } 159 | 160 | static void test_f_int_varg_callback(void) 161 | { 162 | f_int_varg_set_callback(f_int_varg_callback, 2); 163 | f_int_varg(NULL, 1, 2, 3); 164 | f_int_varg(NULL, 10, 20, 30, "hoge"); 165 | } 166 | 167 | static int f_int_args_callback_many_times(int a, int b, int c, int d) 168 | { 169 | PCU_ASSERT_EQUAL(1, a); 170 | PCU_ASSERT_EQUAL(2, b); 171 | PCU_ASSERT_EQUAL(3, c); 172 | PCU_ASSERT_EQUAL(4, d); 173 | return 5; 174 | } 175 | 176 | static void test_f_int_args_callback_many_times(void) 177 | { 178 | int i; 179 | f_int_args_set_callback(f_int_args_callback_many_times, -1); 180 | for (i = 0; i < 10000; i++) { 181 | PCU_ASSERT_EQUAL(5, f_int_args(1, 2, 3, 4)); 182 | } 183 | } 184 | 185 | 186 | PCU_Suite *MockTest_suite(void) 187 | { 188 | static PCU_Test tests[] = { 189 | PCU_TEST(test_f_int_args), 190 | PCU_TEST(test_f_int_args_all_params_ignored), 191 | PCU_TEST(test_f_int_args_param_ignored), 192 | PCU_TEST(test_f_int_args_2times), 193 | PCU_TEST(test_f_const_char_ptr), 194 | PCU_TEST(test_f_void), 195 | PCU_TEST(test_f_STRUCT_t_ptr), 196 | PCU_TEST(test_f_int_args_callback), 197 | PCU_TEST(test_f_int_ptr_return_by_param_ptr), 198 | PCU_TEST(test_f_int_varg_callback), 199 | PCU_TEST(test_f_int_args_callback_many_times), 200 | }; 201 | static PCU_Suite suite = { 202 | "MockTest", tests, sizeof tests / sizeof tests[0], setup, teardown 203 | }; 204 | return &suite; 205 | } 206 | 207 | -------------------------------------------------------------------------------- /test/assert_test/AssertStringTest.c: -------------------------------------------------------------------------------- 1 | #include "../../PCUnit/PCUnit.h" 2 | #include 3 | 4 | static int initialize(void) 5 | { 6 | return 0; 7 | } 8 | 9 | static int cleanup(void) 10 | { 11 | return 0; 12 | } 13 | 14 | static int setup(void) 15 | { 16 | return 0; 17 | } 18 | 19 | static int teardown(void) 20 | { 21 | return 0; 22 | } 23 | 24 | 25 | static void test_assert_str_equal_OK(void) 26 | { 27 | const char *a, *b; 28 | a = b = "hoge"; 29 | PCU_ASSERT_STRING_EQUAL("hoge", a); 30 | PCU_ASSERT_STRING_EQUAL(a, b); 31 | } 32 | 33 | static void test_assert_str_equal_FAIL(void) 34 | { 35 | const char *a, *b; 36 | a = "hoge"; 37 | b = "piyo"; 38 | PCU_ASSERT_STRING_EQUAL(a, b); 39 | printf("NOT REACHED\n"); 40 | } 41 | 42 | static void test_assert_str_equal_MSG(void) 43 | { 44 | const char *a, *b; 45 | a = b = "hoge"; 46 | PCU_ASSERT_STRING_EQUAL_MESSAGE(a, b, PCU_format("%s, %s", a, b)); 47 | b = "piyo"; 48 | PCU_ASSERT_STRING_EQUAL_MESSAGE(a, b, PCU_format("%s, %s", a, b)); 49 | } 50 | 51 | static void test_assert_str_equal_FAIL_expect_null(void) 52 | { 53 | const char *a; 54 | a = "hoge"; 55 | PCU_ASSERT_STRING_EQUAL(NULL, a); 56 | } 57 | 58 | static void test_assert_str_equal_FAIL_actual_null(void) 59 | { 60 | const char *a; 61 | a = "hoge"; 62 | PCU_ASSERT_STRING_EQUAL(a, NULL); 63 | } 64 | 65 | static void test_assert_str_equal_OK_null_null(void) 66 | { 67 | PCU_ASSERT_STRING_EQUAL(NULL, NULL); 68 | } 69 | 70 | 71 | 72 | static void test_assert_str_not_equal_OK(void) 73 | { 74 | const char *a, *b; 75 | a = "hoge"; 76 | b = "piyo"; 77 | PCU_ASSERT_STRING_NOT_EQUAL(a, b); 78 | } 79 | 80 | static void test_assert_str_not_equal_FAIL(void) 81 | { 82 | const char *a, *b; 83 | a = b = "hoge"; 84 | PCU_ASSERT_STRING_NOT_EQUAL(a, b); 85 | printf("NOT REACHED\n"); 86 | } 87 | 88 | static void test_assert_str_not_equal_MSG(void) 89 | { 90 | const char *a, *b; 91 | a = "hoge"; 92 | b = "piyo"; 93 | PCU_ASSERT_STRING_NOT_EQUAL_MESSAGE(a, b, PCU_format("%s, %s", a, b)); 94 | b = "hoge"; 95 | PCU_ASSERT_STRING_NOT_EQUAL_MESSAGE(a, b, PCU_format("%s, %s", a, b)); 96 | } 97 | 98 | static void test_assert_str_not_equal_OK_expect_null(void) 99 | { 100 | const char *a; 101 | a = "hoge"; 102 | PCU_ASSERT_STRING_NOT_EQUAL(NULL, a); 103 | } 104 | 105 | static void test_assert_str_not_equal_OK_actual_null(void) 106 | { 107 | const char *a; 108 | a = "hoge"; 109 | PCU_ASSERT_STRING_NOT_EQUAL(a, NULL); 110 | } 111 | 112 | static void test_assert_str_not_equal_FAIL_null_null(void) 113 | { 114 | PCU_ASSERT_STRING_NOT_EQUAL(NULL, NULL); 115 | } 116 | 117 | 118 | 119 | 120 | 121 | static void test_assert_nstr_equal_OK(void) 122 | { 123 | const char *a, *b; 124 | a = "hoge"; 125 | b = "hogehoge"; 126 | PCU_ASSERT_NSTRING_EQUAL("hoge", a, 4); 127 | PCU_ASSERT_NSTRING_EQUAL(a, b, 4); 128 | PCU_ASSERT_NSTRING_EQUAL(a, b, 3); 129 | PCU_ASSERT_NSTRING_EQUAL(a, b, 0); 130 | } 131 | 132 | static void test_assert_nstr_equal_FAIL(void) 133 | { 134 | const char *a, *b; 135 | a = "hogu"; 136 | b = "hogehoge"; 137 | PCU_ASSERT_NSTRING_EQUAL(a, b, 4); 138 | printf("NOT REACHED\n"); 139 | } 140 | 141 | static void test_assert_nstr_equal_MSG(void) 142 | { 143 | const char *a, *b; 144 | a = "hogu"; 145 | b = "hogehoge"; 146 | PCU_ASSERT_NSTRING_EQUAL_MESSAGE(a, b, 3, PCU_format("%s, %s", a, b)); 147 | PCU_ASSERT_NSTRING_EQUAL_MESSAGE(a, b, 4, PCU_format("%s, %s", a, b)); 148 | } 149 | 150 | static void test_assert_nstr_equal_FAIL_expect_null(void) 151 | { 152 | const char *a; 153 | a = "hogu"; 154 | PCU_ASSERT_NSTRING_EQUAL(NULL, a, 1); 155 | } 156 | 157 | static void test_assert_nstr_equal_FAIL_actual_null(void) 158 | { 159 | const char *a; 160 | a = "hogu"; 161 | PCU_ASSERT_NSTRING_EQUAL(a, NULL, 1); 162 | } 163 | 164 | static void test_assert_nstr_equal_OK_null_null(void) 165 | { 166 | PCU_ASSERT_NSTRING_EQUAL(NULL, NULL, 1); 167 | } 168 | 169 | 170 | 171 | 172 | static void test_assert_nstr_not_equal_OK(void) 173 | { 174 | const char *a, *b; 175 | a = "hogu"; 176 | b = "hogehoge"; 177 | PCU_ASSERT_NSTRING_NOT_EQUAL("hoge", a, 4); 178 | PCU_ASSERT_NSTRING_NOT_EQUAL(a, b, 4); 179 | PCU_ASSERT_NSTRING_NOT_EQUAL(a, b, 5); 180 | } 181 | 182 | static void test_assert_nstr_not_equal_FAIL(void) 183 | { 184 | const char *a, *b; 185 | a = "hoge"; 186 | b = "hogehoge"; 187 | PCU_ASSERT_NSTRING_NOT_EQUAL(a, b, 4); 188 | printf("NOT REACHED\n"); 189 | } 190 | 191 | static void test_assert_nstr_not_equal_MSG(void) 192 | { 193 | const char *a, *b; 194 | a = "hogu"; 195 | b = "hogehoge"; 196 | PCU_ASSERT_NSTRING_NOT_EQUAL_MESSAGE(a, b, 4, PCU_format("%s, %s", a, b)); 197 | PCU_ASSERT_NSTRING_NOT_EQUAL_MESSAGE(a, b, 3, PCU_format("%s, %s", a, b)); 198 | } 199 | 200 | static void test_assert_nstr_not_equal_OK_expect_null(void) 201 | { 202 | const char *a; 203 | a = "hogu"; 204 | PCU_ASSERT_NSTRING_NOT_EQUAL(NULL, a, 1); 205 | } 206 | 207 | static void test_assert_nstr_not_equal_OK_actual_null(void) 208 | { 209 | const char *a; 210 | a = "hogu"; 211 | PCU_ASSERT_NSTRING_NOT_EQUAL(a, NULL, 1); 212 | } 213 | 214 | static void test_assert_nstr_not_equal_FAIL_null_null(void) 215 | { 216 | PCU_ASSERT_NSTRING_NOT_EQUAL(NULL, NULL, 1); 217 | } 218 | 219 | 220 | 221 | static PCU_Test tests[] = { 222 | PCU_TEST(test_assert_str_equal_OK), 223 | PCU_TEST(test_assert_str_equal_FAIL), 224 | PCU_TEST(test_assert_str_equal_MSG), 225 | PCU_TEST(test_assert_str_equal_FAIL_expect_null), 226 | PCU_TEST(test_assert_str_equal_FAIL_actual_null), 227 | PCU_TEST(test_assert_str_equal_OK_null_null), 228 | PCU_TEST(test_assert_str_not_equal_OK), 229 | PCU_TEST(test_assert_str_not_equal_FAIL), 230 | PCU_TEST(test_assert_str_not_equal_MSG), 231 | PCU_TEST(test_assert_str_not_equal_OK_expect_null), 232 | PCU_TEST(test_assert_str_not_equal_OK_actual_null), 233 | PCU_TEST(test_assert_str_not_equal_FAIL_null_null), 234 | PCU_TEST(test_assert_nstr_equal_OK), 235 | PCU_TEST(test_assert_nstr_equal_FAIL), 236 | PCU_TEST(test_assert_nstr_equal_MSG), 237 | PCU_TEST(test_assert_nstr_equal_FAIL_expect_null), 238 | PCU_TEST(test_assert_nstr_equal_FAIL_actual_null), 239 | PCU_TEST(test_assert_nstr_equal_OK_null_null), 240 | PCU_TEST(test_assert_nstr_not_equal_OK), 241 | PCU_TEST(test_assert_nstr_not_equal_FAIL), 242 | PCU_TEST(test_assert_nstr_not_equal_MSG), 243 | PCU_TEST(test_assert_nstr_not_equal_OK_expect_null), 244 | PCU_TEST(test_assert_nstr_not_equal_OK_actual_null), 245 | PCU_TEST(test_assert_nstr_not_equal_FAIL_null_null), 246 | }; 247 | 248 | PCU_Suite *AssertStringTest_suite(void) 249 | { 250 | static PCU_Suite suite = { 251 | "AssertStringTest", tests, sizeof tests / sizeof tests[0], setup, teardown, initialize, cleanup 252 | }; 253 | return &suite; 254 | } 255 | 256 | -------------------------------------------------------------------------------- /test/assert_test/AssertStringWTest.c: -------------------------------------------------------------------------------- 1 | #include "../../PCUnit/PCUnit.h" 2 | #include 3 | 4 | static int initialize(void) 5 | { 6 | return 0; 7 | } 8 | 9 | static int cleanup(void) 10 | { 11 | return 0; 12 | } 13 | 14 | static int setup(void) 15 | { 16 | return 0; 17 | } 18 | 19 | static int teardown(void) 20 | { 21 | return 0; 22 | } 23 | 24 | 25 | static void test_assert_strw_equal_OK(void) 26 | { 27 | const wchar_t *a, *b; 28 | a = b = L"hoge"; 29 | PCU_ASSERT_STRINGW_EQUAL(L"hoge", a); 30 | PCU_ASSERT_STRINGW_EQUAL(a, b); 31 | } 32 | 33 | static void test_assert_strw_equal_FAIL(void) 34 | { 35 | const wchar_t *a, *b; 36 | a = L"hoge"; 37 | b = L"piyo"; 38 | PCU_ASSERT_STRINGW_EQUAL(a, b); 39 | printf("NOT REACHED\n"); 40 | } 41 | 42 | static void test_assert_strw_equal_MSG(void) 43 | { 44 | const wchar_t *a, *b; 45 | a = b = L"hoge"; 46 | PCU_ASSERT_STRINGW_EQUAL_MESSAGE(a, b, PCU_formatW(L"%ls, %ls", a, b)); 47 | b = L"piyo"; 48 | PCU_ASSERT_STRINGW_EQUAL_MESSAGE(a, b, PCU_formatW(L"%ls, %ls", a, b)); 49 | } 50 | 51 | static void test_assert_strw_equal_FAIL_expect_null(void) 52 | { 53 | const wchar_t *a; 54 | a = L"hoge"; 55 | PCU_ASSERT_STRINGW_EQUAL(NULL, a); 56 | } 57 | 58 | static void test_assert_strw_equal_FAIL_actual_null(void) 59 | { 60 | const wchar_t *a; 61 | a = L"hoge"; 62 | PCU_ASSERT_STRINGW_EQUAL(a, NULL); 63 | } 64 | 65 | static void test_assert_strw_equal_OK_null_null(void) 66 | { 67 | PCU_ASSERT_STRINGW_EQUAL(NULL, NULL); 68 | } 69 | 70 | 71 | 72 | static void test_assert_strw_not_equal_OK(void) 73 | { 74 | const wchar_t *a, *b; 75 | a = L"hoge"; 76 | b = L"piyo"; 77 | PCU_ASSERT_STRINGW_NOT_EQUAL(a, b); 78 | } 79 | 80 | static void test_assert_strw_not_equal_FAIL(void) 81 | { 82 | const wchar_t *a, *b; 83 | a = b = L"hoge"; 84 | PCU_ASSERT_STRINGW_NOT_EQUAL(a, b); 85 | printf("NOT REACHED\n"); 86 | } 87 | 88 | static void test_assert_strw_not_equal_MSG(void) 89 | { 90 | const wchar_t *a, *b; 91 | a = L"hoge"; 92 | b = L"piyo"; 93 | PCU_ASSERT_STRINGW_NOT_EQUAL_MESSAGE(a, b, PCU_formatW(L"%ls, %ls", a, b)); 94 | b = L"hoge"; 95 | PCU_ASSERT_STRINGW_NOT_EQUAL_MESSAGE(a, b, PCU_formatW(L"%ls, %ls", a, b)); 96 | } 97 | 98 | static void test_assert_strw_not_equal_OK_expect_null(void) 99 | { 100 | const wchar_t *a; 101 | a = L"hoge"; 102 | PCU_ASSERT_STRINGW_NOT_EQUAL(NULL, a); 103 | } 104 | 105 | static void test_assert_strw_not_equal_OK_actual_null(void) 106 | { 107 | const wchar_t *a; 108 | a = L"hoge"; 109 | PCU_ASSERT_STRINGW_NOT_EQUAL(a, NULL); 110 | } 111 | 112 | static void test_assert_strw_not_equal_FAIL_null_null(void) 113 | { 114 | PCU_ASSERT_STRINGW_NOT_EQUAL(NULL, NULL); 115 | } 116 | 117 | 118 | 119 | 120 | 121 | static void test_assert_nstrw_equal_OK(void) 122 | { 123 | const wchar_t *a, *b; 124 | a = L"hoge"; 125 | b = L"hogehoge"; 126 | PCU_ASSERT_NSTRINGW_EQUAL(L"hoge", a, 4); 127 | PCU_ASSERT_NSTRINGW_EQUAL(a, b, 4); 128 | PCU_ASSERT_NSTRINGW_EQUAL(a, b, 3); 129 | PCU_ASSERT_NSTRINGW_EQUAL(a, b, 0); 130 | } 131 | 132 | static void test_assert_nstrw_equal_FAIL(void) 133 | { 134 | const wchar_t *a, *b; 135 | a = L"hogu"; 136 | b = L"hogehoge"; 137 | PCU_ASSERT_NSTRINGW_EQUAL(a, b, 4); 138 | printf("NOT REACHED\n"); 139 | } 140 | 141 | static void test_assert_nstrw_equal_MSG(void) 142 | { 143 | const wchar_t *a, *b; 144 | a = L"hogu"; 145 | b = L"hogehoge"; 146 | PCU_ASSERT_NSTRINGW_EQUAL_MESSAGE(a, b, 3, PCU_formatW(L"%ls, %ls", a, b)); 147 | PCU_ASSERT_NSTRINGW_EQUAL_MESSAGE(a, b, 4, PCU_formatW(L"%ls, %ls", a, b)); 148 | } 149 | 150 | static void test_assert_nstrw_equal_FAIL_expect_null(void) 151 | { 152 | const wchar_t *a; 153 | a = L"hogu"; 154 | PCU_ASSERT_NSTRINGW_EQUAL(NULL, a, 1); 155 | } 156 | 157 | static void test_assert_nstrw_equal_FAIL_actual_null(void) 158 | { 159 | const wchar_t *a; 160 | a = L"hogu"; 161 | PCU_ASSERT_NSTRINGW_EQUAL(a, NULL, 1); 162 | } 163 | 164 | static void test_assert_nstrw_equal_OK_null_null(void) 165 | { 166 | PCU_ASSERT_NSTRINGW_EQUAL(NULL, NULL, 1); 167 | } 168 | 169 | 170 | 171 | 172 | static void test_assert_nstrw_not_equal_OK(void) 173 | { 174 | const wchar_t *a, *b; 175 | a = L"hogu"; 176 | b = L"hogehoge"; 177 | PCU_ASSERT_NSTRINGW_NOT_EQUAL(L"hoge", a, 4); 178 | PCU_ASSERT_NSTRINGW_NOT_EQUAL(a, b, 4); 179 | PCU_ASSERT_NSTRINGW_NOT_EQUAL(a, b, 5); 180 | } 181 | 182 | static void test_assert_nstrw_not_equal_FAIL(void) 183 | { 184 | const wchar_t *a, *b; 185 | a = L"hoge"; 186 | b = L"hogehoge"; 187 | PCU_ASSERT_NSTRINGW_NOT_EQUAL(a, b, 4); 188 | printf("NOT REACHED\n"); 189 | } 190 | 191 | static void test_assert_nstrw_not_equal_MSG(void) 192 | { 193 | const wchar_t *a, *b; 194 | a = L"hogu"; 195 | b = L"hogehoge"; 196 | PCU_ASSERT_NSTRINGW_NOT_EQUAL_MESSAGE(a, b, 4, PCU_formatW(L"%ls, %ls", a, b)); 197 | PCU_ASSERT_NSTRINGW_NOT_EQUAL_MESSAGE(a, b, 3, PCU_formatW(L"%ls, %ls", a, b)); 198 | } 199 | 200 | static void test_assert_nstrw_not_equal_OK_expect_null(void) 201 | { 202 | const wchar_t *a; 203 | a = L"hogu"; 204 | PCU_ASSERT_NSTRINGW_NOT_EQUAL(NULL, a, 1); 205 | } 206 | 207 | static void test_assert_nstrw_not_equal_OK_actual_null(void) 208 | { 209 | const wchar_t *a; 210 | a = L"hogu"; 211 | PCU_ASSERT_NSTRINGW_NOT_EQUAL(a, NULL, 1); 212 | } 213 | 214 | static void test_assert_nstrw_not_equal_FAIL_null_null(void) 215 | { 216 | PCU_ASSERT_NSTRINGW_NOT_EQUAL(NULL, NULL, 1); 217 | } 218 | 219 | 220 | 221 | static PCU_Test tests[] = { 222 | PCU_TEST(test_assert_strw_equal_OK), 223 | PCU_TEST(test_assert_strw_equal_FAIL), 224 | PCU_TEST(test_assert_strw_equal_MSG), 225 | PCU_TEST(test_assert_strw_equal_FAIL_expect_null), 226 | PCU_TEST(test_assert_strw_equal_FAIL_actual_null), 227 | PCU_TEST(test_assert_strw_equal_OK_null_null), 228 | PCU_TEST(test_assert_strw_not_equal_OK), 229 | PCU_TEST(test_assert_strw_not_equal_FAIL), 230 | PCU_TEST(test_assert_strw_not_equal_MSG), 231 | PCU_TEST(test_assert_strw_not_equal_OK_expect_null), 232 | PCU_TEST(test_assert_strw_not_equal_OK_actual_null), 233 | PCU_TEST(test_assert_strw_not_equal_FAIL_null_null), 234 | PCU_TEST(test_assert_nstrw_equal_OK), 235 | PCU_TEST(test_assert_nstrw_equal_FAIL), 236 | PCU_TEST(test_assert_nstrw_equal_MSG), 237 | PCU_TEST(test_assert_nstrw_equal_FAIL_expect_null), 238 | PCU_TEST(test_assert_nstrw_equal_FAIL_actual_null), 239 | PCU_TEST(test_assert_nstrw_equal_OK_null_null), 240 | PCU_TEST(test_assert_nstrw_not_equal_OK), 241 | PCU_TEST(test_assert_nstrw_not_equal_FAIL), 242 | PCU_TEST(test_assert_nstrw_not_equal_MSG), 243 | PCU_TEST(test_assert_nstrw_not_equal_OK_expect_null), 244 | PCU_TEST(test_assert_nstrw_not_equal_OK_actual_null), 245 | PCU_TEST(test_assert_nstrw_not_equal_FAIL_null_null), 246 | }; 247 | 248 | PCU_Suite *AssertStringWTest_suite(void) 249 | { 250 | static PCU_Suite suite = { 251 | "AssertStringWTest", tests, sizeof tests / sizeof tests[0], setup, teardown, initialize, cleanup 252 | }; 253 | return &suite; 254 | } 255 | 256 | -------------------------------------------------------------------------------- /test/pcunit_mock_test/create_header.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/ruby 2 | 3 | 4 | File.open("target.h", "w") {|f| 5 | f.print <<-"EOB" 6 | #ifndef TARGET_H_INCLUDED 7 | #define TARGET_H_INCLUDED 8 | 9 | #include 10 | #include 11 | 12 | #define IGNORE \\ 13 | void ignore(void);\\ 14 | void ignore(void); 15 | 16 | typedef struct STRUCT_t { 17 | int a; 18 | int (*b)(int, int); 19 | struct { 20 | int a; 21 | int (*b)(int, int); 22 | } c; 23 | } STRUCT_t; 24 | 25 | typedef union UNION_t { 26 | unsigned int a; 27 | double b; 28 | struct { 29 | unsigned int a:4; 30 | unsigned int b:1; 31 | unsigned int :3; 32 | } c; 33 | } UNION_t; 34 | 35 | typedef enum ENUM_t { 36 | E_000, 37 | E_001 38 | } ENUM_t; 39 | 40 | EOB 41 | 42 | types = [ 43 | "char", 44 | "signed char", 45 | "unsigned char", 46 | "const char", 47 | "const signed char", 48 | "const unsigned char", 49 | "int", 50 | "signed int", 51 | "unsigned int", 52 | "signed", 53 | "unsigned", 54 | "const int", 55 | "const signed int", 56 | "const unsigned int", 57 | "const signed", 58 | "const unsigned", 59 | "short int", 60 | "signed short int", 61 | "unsigned short int", 62 | "const short int", 63 | "const signed short int", 64 | "const unsigned short int", 65 | "short", 66 | "signed short", 67 | "unsigned short", 68 | "const short", 69 | "const signed short", 70 | "const unsigned short", 71 | "long int", 72 | "signed long int", 73 | "unsigned long int", 74 | "const long int", 75 | "const signed long int", 76 | "const unsigned long int", 77 | "long", 78 | "signed long", 79 | "unsigned long", 80 | "const long", 81 | "const signed long", 82 | "const unsigned long", 83 | "long long int", 84 | "signed long long int", 85 | "unsigned long long int", 86 | "const long long int", 87 | "const signed long long int", 88 | "const unsigned long long int", 89 | "long long", 90 | "signed long long", 91 | "unsigned long long", 92 | "const long long", 93 | "const signed long long", 94 | "const unsigned long long", 95 | # "__int64", 96 | # "signed __int64", 97 | # "unsigned __int64", 98 | # "const __int64", 99 | # "const signed __int64", 100 | # "const unsigned __int64", 101 | "uint32_t", 102 | "const uint32_t", 103 | "size_t", 104 | "const size_t", 105 | "ptrdiff_t", 106 | "const ptrdiff_t", 107 | "wchar_t", 108 | "const wchar_t", 109 | # "TCHAR", 110 | # "const TCHAR", 111 | # "LPCTSTR", 112 | # "LPTSTR", 113 | "float", 114 | "const float", 115 | "double", 116 | "const double", 117 | "long double", 118 | "const long double", 119 | "struct STRUCT_t", 120 | "const struct STRUCT_t", 121 | "STRUCT_t", 122 | "const STRUCT_t", 123 | "union UNION_t", 124 | "const union UNION_t", 125 | "UNION_t", 126 | "const UNION_t", 127 | "enum ENUM_t", 128 | "const enum ENUM_t", 129 | "ENUM_t", 130 | "const ENUM_t", 131 | "void", 132 | "const void", 133 | "", 134 | ] 135 | 136 | types.each {|t| 137 | count = 0 138 | name = t.gsub(/\s/, '_') 139 | if t == "" 140 | f.puts "void f_none();" 141 | next 142 | end 143 | t2 = t.sub(/const /, '') 144 | if !(t =~ /void/) 145 | f.puts "#{t2} f_#{name}_arg(#{t} a);" 146 | f.puts "void f_#{name}_#{count += 1}(#{t}\ne);" 147 | f.puts "#{t2} f_#{name}_args(#{t} a, #{t} b, #{t} c, #{t} d);" 148 | end 149 | f.puts "#{t} *f_#{name}_ptr(#{t} *a);" 150 | f.puts "void f_#{name}_varg(#{t}* a, ...);" 151 | f.puts "#{t}* f_#{name}_#{count += 1}(#{t} * ret);" 152 | f.puts "#{t}* f_#{name}_#{count += 1}(#{t} * const a);" 153 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t}*a);" 154 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t} *a, #{t} *b,\n #{t} *c);" 155 | f.puts "#{t} **f_#{name}_#{count += 1}(#{t} **a);" 156 | f.puts "#{t}** f_#{name}_#{count += 1}(#{t}** a);" 157 | f.puts "#{t} ** f_#{name}_#{count += 1}(#{t} ** a);" 158 | f.puts "#{t}**f_#{name}_#{count += 1}(#{t}**a);" 159 | if !(t =~ /void/) 160 | f.puts "#{t} *f_#{name}_ary(#{t} a[1]);" 161 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t} a[]);" 162 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t} a []);" 163 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t} a[], #{t} b[]);" 164 | end 165 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t} *a[]);" 166 | f.puts "#{t}* f_#{name}_#{count += 1}(#{t}* a[]);" 167 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t} * a[]);" 168 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t} * a []);" 169 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t}*a[]);" 170 | if t != "const void" 171 | f.puts "#{t2} f_#{name}_omitted(#{t});" 172 | end 173 | if !(t =~ /void/) 174 | f.puts "#{t2} f_#{name}_#{count += 1}(#{t}, #{t});" 175 | end 176 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t} *,... );" 177 | f.puts "#{t}* f_#{name}_#{count += 1}(#{t}*);" 178 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t} * const);" 179 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t} *, #{t} *, #{t} *);" 180 | f.puts "#{t} **f_#{name}_#{count += 1}(#{t} **);" 181 | f.puts "#{t}**f_#{name}_#{count += 1}(#{t}**);" 182 | if !(t =~ /void/) 183 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t} [1]);" 184 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t} []);" 185 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t}[]);" 186 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t} [], #{t} [], #{t} [], #{t} []);" 187 | end 188 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t} *[]);" 189 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t}* []);" 190 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t}*[]);" 191 | f.puts "#{t} *f_#{name}_#{count += 1}(void);" 192 | f.puts "#{t} *f_#{name}_#{count += 1}();" 193 | 194 | if !(t =~ /void/) 195 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t2} (*)(#{t}));" 196 | f.puts "#{t} *f_#{name}_#{count += 1}(void (*)(#{t}),\n #{t2} (*)(#{t}),\n #{t2} (*)(#{t}));" 197 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t2}(*)(#{t}, #{t}));" 198 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t}*(*)(#{t}, #{t}, #{t}));" 199 | f.puts "#{t} *f_#{name}_fptr(#{t2} (*a)(#{t} A));" 200 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t2}(*a)(#{t} A, #{t} B));" 201 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t2}(*a)(#{t} A, #{t} B), #{t2}(*b)(#{t} A, #{t} B));" 202 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t}*(*a)(#{t} A, #{t} B, #{t} C));" 203 | elsif t == "const void" 204 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t2} (*)(#{t} *));" 205 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t}*(*)(#{t} *, #{t} *));" 206 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t2} (*a)(#{t} *));" 207 | f.puts "#{t} *f_#{name}_fptr(#{t}*(*a)(#{t} *A, #{t} *B));" 208 | f.puts "#{t} *f_#{name}_#{count += 1}(void (*a)(#{t} *A, #{t} *B), #{t}*(*b)(#{t} *A, #{t} *B));" 209 | else 210 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t2} (*)(#{t}));" 211 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t2} (*)(#{t}),\n #{t2} (*)(#{t}),\n #{t2} (*)(#{t}));" 212 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t}*(*)(#{t} *, #{t} *));" 213 | f.puts "#{t} *f_#{name}_#{count += 1}(#{t2} (*a)(#{t}));" 214 | f.puts "#{t} *f_#{name}_fptr(#{t}*(*a)(#{t} *A, #{t} *B));" 215 | f.puts "#{t} *f_#{name}_#{count += 1}(void (*a)(#{t} *A, #{t} *B), #{t}*(*b)(#{t} *A, #{t} *B));" 216 | end 217 | f.puts 218 | } 219 | 220 | f.print <<-"EOB" 221 | 222 | #endif /* TARGET_H_INCLUDED */ 223 | EOB 224 | } 225 | -------------------------------------------------------------------------------- /PCUnit/pcunit_register.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/ruby 2 | 3 | if RUBY_VERSION >= '1.9' 4 | Encoding.default_external = "ASCII-8BIT" 5 | end 6 | 7 | require 'optparse' 8 | 9 | opt = OptionParser.new 10 | OPTS = {} 11 | 12 | src_dirs = Array.new 13 | excluded = Array.new 14 | 15 | opt.on('-d VAL') {|v| src_dirs.push v } 16 | opt.on('-e VAL') {|v| excluded.push v } 17 | opt.on('-n') {|v| OPTS[:n] = v } 18 | opt.on('-h', '--help') { 19 | print <<-"EOB" 20 | Usage: pcunit_register.rb [-d DIR] [-e PATTERN] [-n] 21 | -d DIR source code directory 22 | -e PATTERN excluded file pattern 23 | -n no backup flag 24 | 25 | EOB 26 | exit 27 | } 28 | 29 | opt.parse!(ARGV) 30 | 31 | if src_dirs.empty? 32 | src_dirs.push "." 33 | end 34 | 35 | $suite_methods = [] 36 | $main_file = nil 37 | 38 | def comment_proc(line, normal_comment_flag, prep_comment_flags) 39 | line.sub!(/\/\/.*$/, "") 40 | line.gsub!(/\/\*.*?\*\//, "") 41 | if line =~ /#\s*if\b/ 42 | if line =~ /#\s*if\s+0/ 43 | prep_comment_flags.push(true) 44 | else 45 | prep_comment_flags.push(false) 46 | end 47 | elsif line =~ /#\s*else/ 48 | if prep_comment_flags.empty? 49 | elsif prep_comment_flags.last 50 | prep_comment_flags.pop 51 | prep_comment_flags.push(false) 52 | else 53 | prep_comment_flags.pop 54 | prep_comment_flags.push(true) 55 | end 56 | elsif line =~ /#\s*endif/ 57 | if prep_comment_flags.empty? 58 | else 59 | prep_comment_flags.pop 60 | end 61 | end 62 | if prep_comment_flags.include?(true) 63 | line = "" 64 | else 65 | if line["/*"] 66 | line[/\/\*.*/] = "" 67 | normal_comment_flag = true 68 | elsif normal_comment_flag 69 | if line["*/"] 70 | line[/.*\*\//] = "" 71 | normal_comment_flag = false 72 | else 73 | line = "" 74 | end 75 | end 76 | end 77 | return line, normal_comment_flag 78 | end 79 | 80 | def read_pcutests(pcutests_file, registered_testfuncs, pcu_test_lines) 81 | if !File.exist?(pcutests_file) 82 | return 83 | end 84 | File.open(pcutests_file, "r") { |f| 85 | while line = f.gets 86 | if line =~ /(,|\()\s*(test[^\s"\{\}\(\),]*)/ 87 | registered_testfuncs.push($2) 88 | pcu_test_lines.push(String.new(line)) 89 | end 90 | end 91 | } 92 | end 93 | 94 | def update_pcutests(pcutests_file, pcu_test_lines, testfuncs, added_testfuncs, nl) 95 | File.open(pcutests_file, "w") { |file| 96 | testfuncs.each {|e| 97 | pcu_test_lines.each {|v| 98 | if v =~ /\b#{e}\b/ 99 | file << v 100 | end 101 | } 102 | if added_testfuncs.include?(e) 103 | file << "PCU_TEST(#{added_testfuncs[added_testfuncs.index(e)]}),#{nl}" 104 | end 105 | } 106 | } 107 | end 108 | 109 | def update_test_file(file_name, lines, pcu_test_area_idx, pcu_test_lines, testfuncs, added_testfuncs, indent, nl) 110 | if !OPTS[:n] 111 | File.rename(file_name, file_name + ".bak") 112 | end 113 | file = File.open(file_name, "w") 114 | idx = 0 115 | pcu_test_area_end = false 116 | lines.each {|line| 117 | if pcu_test_area_idx < idx && !pcu_test_area_end 118 | testfuncs.each {|e| 119 | pcu_test_lines.each {|v| 120 | if v =~ /\b#{e}\b/ 121 | file << v 122 | end 123 | } 124 | if added_testfuncs.include?(e) 125 | file << "#{indent}PCU_TEST(#{added_testfuncs[added_testfuncs.index(e)]}),#{nl}" 126 | end 127 | } 128 | pcu_test_area_end = true 129 | file << line 130 | else 131 | file << line 132 | end 133 | idx += 1 134 | } 135 | file.close 136 | end 137 | 138 | def register_tests(file_name) 139 | file = File.open(file_name, "r") 140 | lines = [] 141 | pcu_test_lines = [] 142 | testfuncs = [] 143 | registered_testfuncs = [] 144 | idx = 0 145 | pcu_test_area = false 146 | prep_comment_flags = Array.new 147 | normal_comment_flag = false 148 | while line = file.gets 149 | lines.push(String.new(line)) 150 | 151 | line, normal_comment_flag = comment_proc(line, normal_comment_flag, prep_comment_flags) 152 | 153 | if line =~ /void\s+(test[^\s]*)\s*\(\s*(void|)\s*\)/ 154 | testfuncs.push($1) 155 | end 156 | if pcu_test_area 157 | if line =~ /(,|\()\s*(test[^\s"\{\}\(\),]*)/ 158 | registered_testfuncs.push($2) 159 | pcu_test_lines.push(String.new(line)) 160 | lines.pop 161 | elsif line =~ /#\s*include\s*"(.*)"/ 162 | pcutests_file = $1 163 | read_pcutests(pcutests_file, registered_testfuncs, pcu_test_lines) 164 | elsif line =~ /\};/ 165 | pcu_test_area = false 166 | end 167 | end 168 | if line =~ /PCU_Test\s+.*\[\]/ 169 | pcu_test_area = true 170 | tmp = line.slice(/^\s*/) 171 | indent = tmp == "" ? "\t" : tmp * 2 172 | pcu_test_area_idx = idx 173 | end 174 | if line =~ /PCU_Suite\s*\*\s*([^\s]+)\s*\(\s*(void|)\s*\)\s*[^;]*\s*$/ 175 | $suite_methods.push($1) 176 | end 177 | if !$main_file && line =~ /PCU_SuiteMethod\s+.*\[\s*\]/ 178 | $main_file = File.expand_path(file_name) 179 | end 180 | idx += 1 181 | end 182 | file.close 183 | undefined_testfuncs = [] 184 | registered_testfuncs.each {|func| 185 | if !testfuncs.include?(func) 186 | undefined_testfuncs.push(func) 187 | end 188 | } 189 | added_testfuncs = testfuncs - registered_testfuncs 190 | if (undefined_testfuncs.empty? && added_testfuncs.empty?) || !pcu_test_area_idx 191 | return 192 | end 193 | if lines[0] =~ /\r\n$/ 194 | nl = "\r\n" 195 | else 196 | nl = "\n" 197 | end 198 | if pcutests_file 199 | update_pcutests(pcutests_file, pcu_test_lines, testfuncs, added_testfuncs, nl) 200 | else 201 | update_test_file(file_name, lines, pcu_test_area_idx, pcu_test_lines, testfuncs, added_testfuncs, indent, nl) 202 | end 203 | end 204 | 205 | def register_suite_methods(file_name) 206 | $suite_methods.uniq! 207 | file = File.open(file_name, "r") 208 | lines = [] 209 | registered_suite_methods1 = [] 210 | registered_suite_methods2 = [] 211 | idx = 0 212 | mark = false 213 | insert_idx_decl = nil 214 | while line = file.gets 215 | if line =~ /PCU_Suite\s*\*\s*([^\s]+)\s*\(\s*(void|)\s*\)\s*;\s*$/ 216 | registered_suite_methods1.push($1) 217 | next 218 | end 219 | if mark && line =~ /([^\s,]+)\s*,/ 220 | registered_suite_methods2.push($1) 221 | next 222 | end 223 | lines.push(line) 224 | if line =~ /PCU_SuiteMethod\s+.*\[\s*\]/ 225 | mark = true 226 | indent = line.slice(/^\s*/) * 2 227 | end 228 | if mark && line =~ /\}\s*;/ 229 | insert_idx_init = idx 230 | mark = false 231 | end 232 | if !insert_idx_decl && line =~ /^\s*\{/ 233 | insert_idx_decl = idx - 2 234 | elsif !insert_idx_decl && line =~ /\)\s*\{/ 235 | insert_idx_decl = idx - 1 236 | end 237 | idx += 1 238 | end 239 | file.close 240 | diff1 = $suite_methods - registered_suite_methods1 241 | diff2 = $suite_methods - registered_suite_methods2 242 | if (diff1.empty? && diff2.empty?) || !insert_idx_init || !insert_idx_decl 243 | return 244 | end 245 | if lines[0] =~ /\r\n$/ 246 | nl = "\r\n" 247 | else 248 | nl = "\n" 249 | end 250 | $suite_methods.each {|method| 251 | lines.insert(insert_idx_decl, "PCU_Suite *#{method}(void);#{nl}") 252 | insert_idx_decl += 1 253 | } 254 | insert_idx_init += $suite_methods.size 255 | $suite_methods.each {|method| 256 | lines.insert(insert_idx_init, "#{indent}#{method},#{nl}") 257 | insert_idx_init += 1 258 | } 259 | if !OPTS[:n] 260 | File.rename(file_name, file_name + ".bak") 261 | end 262 | file = File.open(file_name, "w") 263 | lines.each {|line| 264 | file << line 265 | } 266 | file.close 267 | end 268 | 269 | src_dirs.each {|d| 270 | current_dir = Dir.pwd 271 | Dir.chdir(d) 272 | Dir.glob("**/*.{c{,pp,c,xx},C{,PP,C,XX}}") {|fname| 273 | excluded_flag = false 274 | excluded.each {|ex| 275 | if fname =~ Regexp.new(ex) 276 | excluded_flag = true 277 | break 278 | end 279 | } 280 | if !excluded_flag 281 | register_tests(fname) 282 | end 283 | } 284 | Dir.chdir(current_dir) 285 | } 286 | if $main_file 287 | register_suite_methods($main_file) 288 | end 289 | 290 | -------------------------------------------------------------------------------- /test/PCU_Libc_test/test_format_no_stdarg.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | #include "../../PCUnit/PCUnit.h" 7 | #define PCU_FORMAT_BUFSIZE 256 8 | 9 | 10 | void test_format(void) 11 | { 12 | const char *bufp = 0; 13 | char sp_buf[PCU_FORMAT_BUFSIZE]; 14 | int n; 15 | 16 | snprintf(sp_buf, sizeof sp_buf, "hogehoge"); 17 | bufp = PCU_format4( "hogehoge", 0, 0, 0, 0); 18 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 19 | 20 | snprintf(sp_buf, sizeof sp_buf, "%s", "piyopiyo"); 21 | bufp = PCU_format4( "%s", "piyopiyo", 0, 0, 0); 22 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 23 | 24 | snprintf(sp_buf, sizeof sp_buf, "foo%%bar%s", "hoge"); 25 | bufp = PCU_format4( "foo%%bar%s", "hoge", 0, 0, 0); 26 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 27 | 28 | snprintf(sp_buf, sizeof sp_buf, "%d, %d, %d, \"%8d\"", 9999, 0, -1, -1234); 29 | bufp = PCU_format4( "%d, %d, %d, \"%8d\"", 9999, 0, -1, -1234); 30 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 31 | 32 | snprintf(sp_buf, sizeof sp_buf, "%hd, %ld, %ld, \"%8ld\"", 9999, 0L, -1L, -1234L); 33 | bufp = PCU_format4( "%hd, %ld, %ld, \"%8ld\"", 9999, 0L, -1L, -1234L); 34 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 35 | 36 | snprintf(sp_buf, sizeof sp_buf, "%u, %u, %-d, \"%-8d\"", 12345, 0, -123, -111); 37 | bufp = PCU_format4( "%u, %u, %-d, \"%-8d\"", 12345, 0, -123, -111); 38 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 39 | 40 | snprintf(sp_buf, sizeof sp_buf, "\"%d\", \"%8d\", \"%-8d\", \"%s\"", 123456789, 123456, 789, "abcd"); 41 | bufp = PCU_format4( "\"%d\", \"%8d\", \"%-8d\", \"%s\"", 123456789, 123456, 789, "abcd"); 42 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 43 | 44 | snprintf(sp_buf, sizeof sp_buf, "\"%s\", \"%9d\", \"%s\", \"%s\"", "foo", 1234567890, "bar", "abcd"); 45 | bufp = PCU_format4( "\"%s\", \"%9d\", \"%s\", \"%s\"", "foo", 1234567890, "bar", "abcd"); 46 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 47 | 48 | snprintf(sp_buf, sizeof sp_buf, "%x, \"%8x\", \"%08X\", \"%10d\"", 0x1234, 0x5678, 0xABCD, 12345); 49 | bufp = PCU_format4( "%x, \"%8x\", \"%08X\", \"%10d\"", 0x1234, 0x5678, 0xABCD, 12345); 50 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 51 | 52 | snprintf(sp_buf, sizeof sp_buf, "%#x, \"%#8x\", \"%#08X\", \"%#-10x\"", 0x1234, 0x5678, 0xABCD, 0x12345); 53 | bufp = PCU_format4( "%#x, \"%#8x\", \"%#08X\", \"%#-10x\"", 0x1234, 0x5678, 0xABCD, 0x12345); 54 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 55 | 56 | snprintf(sp_buf, sizeof sp_buf, "%#x, \"%#8x\", \"%#08X\", \"%#010X\"", 0, 0x5678, 0xABCD, 0x12345); 57 | bufp = PCU_format4( "%#x, \"%#8x\", \"%#08X\", \"%#010X\"", 0, 0x5678, 0xABCD, 0x12345); 58 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 59 | 60 | snprintf(sp_buf, sizeof sp_buf, "%x, \"%8x\", \"%-8X\", \"%-10d\"", 0x0, 0x5678, 0xABCD, 12345); 61 | bufp = PCU_format4( "%x, \"%8x\", \"%-8X\", \"%-10d\"", 0x0, 0x5678, 0xABCD, 12345); 62 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 63 | 64 | snprintf(sp_buf, sizeof sp_buf, "%+d, \"%+8d\", \"%-+8d\", \"%+010d\"", 0, 0, -123, -1); 65 | bufp = PCU_format4( "%+d, \"%+8d\", \"%-+8d\", \"%+010d\"", 0, 0, -123, -1); 66 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 67 | 68 | snprintf(sp_buf, sizeof sp_buf, "%+d, \"%+8d\", \"%+-8d\", \"%+10d\"", 1234, 5678, 9876, 12345); 69 | bufp = PCU_format4( "%+d, \"%+8d\", \"%+-8d\", \"%+10d\"", 1234, 5678, 9876, 12345); 70 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 71 | 72 | snprintf(sp_buf, sizeof sp_buf, "% d, \"% 8d\", \"%- 8d\", \"% 010d\", \"% d\"", 0, 0, -123, -1, -2); 73 | bufp = PCU_format5( "% d, \"% 8d\", \"%- 8d\", \"% 010d\", \"% d\"", 0, 0, -123, -1, -2); 74 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 75 | 76 | snprintf(sp_buf, sizeof sp_buf, "% d, \"% 8d\", \"% -8d\", \"% 10d\"", 1234, 5678, 9876, 12345); 77 | bufp = PCU_format4( "% d, \"% 8d\", \"% -8d\", \"% 10d\"", 1234, 5678, 9876, 12345); 78 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 79 | 80 | n = 8; 81 | snprintf(sp_buf, sizeof sp_buf, "\"%*d\", \"%*X\"", n, 5678, -n, 0xABCD); 82 | bufp = PCU_format4( "\"%*d\", \"%*X\"", n, 5678, -n, 0xABCD); 83 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 84 | 85 | n = 0; 86 | snprintf(sp_buf, sizeof sp_buf, "\"%*d\", \"%*X\"", n, 1234, -n, 0xABCD); 87 | bufp = PCU_format4( "\"%*d\", \"%*X\"", n, 1234, -n, 0xABCD); 88 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 89 | 90 | snprintf(sp_buf, sizeof sp_buf, "%c, %c, %c, %c", 'a', '#', '\\', '9'); 91 | bufp = PCU_format4( "%c, %c, %c, %c", 'a', '#', '\\', '9'); 92 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 93 | 94 | 95 | snprintf(sp_buf, sizeof sp_buf, "%p, %p, %p, %p", (void *)1, (void *)bufp, (void *)sp_buf, (void *)1); 96 | bufp = PCU_format4( "%p, %p, %p, %p", 1, bufp, sp_buf, 1); 97 | PCU_MESSAGE(sp_buf); 98 | PCU_MESSAGE(bufp); 99 | 100 | snprintf(sp_buf, sizeof sp_buf, "%d, %d, %d, %d", CHAR_MAX, CHAR_MIN, SCHAR_MAX, SCHAR_MIN); 101 | bufp = PCU_format4( "%d, %d, %d, %d", CHAR_MAX, CHAR_MIN, SCHAR_MAX, SCHAR_MIN); 102 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 103 | 104 | snprintf(sp_buf, sizeof sp_buf, "%d, %u, %d, %d", UCHAR_MAX, UCHAR_MAX, 0, 0); 105 | bufp = PCU_format4( "%d, %u, %d, %d", UCHAR_MAX, UCHAR_MAX, 0, 0); 106 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 107 | 108 | snprintf(sp_buf, sizeof sp_buf, "%d, %d, %d, %u", SHRT_MAX, SHRT_MIN, USHRT_MAX, USHRT_MAX); 109 | bufp = PCU_format4( "%d, %d, %d, %u", SHRT_MAX, SHRT_MIN, USHRT_MAX, USHRT_MAX); 110 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 111 | 112 | snprintf(sp_buf, sizeof sp_buf, "%d, %d, %d, %u", INT_MAX, INT_MIN, UINT_MAX, UINT_MAX); 113 | bufp = PCU_format4( "%d, %d, %d, %u", INT_MAX, INT_MIN, UINT_MAX, UINT_MAX); 114 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 115 | 116 | snprintf(sp_buf, sizeof sp_buf, "%ld, %ld, %ld, %lu", LONG_MAX, LONG_MIN, ULONG_MAX, ULONG_MAX); 117 | bufp = PCU_format4( "%ld, %ld, %ld, %lu", LONG_MAX, LONG_MIN, ULONG_MAX, ULONG_MAX); 118 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 119 | 120 | snprintf(sp_buf, sizeof sp_buf, "%lld, %lld, %lld, %llu", LLONG_MAX, LLONG_MIN, ULLONG_MAX, ULLONG_MAX); 121 | bufp = PCU_format4( "%lld, %lld, %lld, %llu", LLONG_MAX, LLONG_MIN, ULLONG_MAX, ULLONG_MAX); 122 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 123 | 124 | } 125 | 126 | void test_format_shorten(void) 127 | { 128 | const char *bufp = 0; 129 | char sp_buf[PCU_FORMAT_BUFSIZE]; 130 | #define STR "0123456789abcdef"\ 131 | "1123456789abcdef"\ 132 | "2123456789abcdef"\ 133 | "3123456789abcdef"\ 134 | "4123456789abcdef"\ 135 | "5123456789abcdef"\ 136 | "6123456789abcdef"\ 137 | "7123456789abcdef"\ 138 | "8123456789abcdef"\ 139 | "9123456789abcdef"\ 140 | "a123456789abcdef"\ 141 | "b123456789abcdef"\ 142 | "c123456789abcdef"\ 143 | "d123456789abcdef"\ 144 | "e123456789abcdef" 145 | 146 | #define STR_0 STR "f123456789abcd01" 147 | #define STR_S STR "f123456789abcd%s" 148 | #define STR_D STR "f123456789abcd%d" 149 | #define STR_X STR "f123456789abcd%x" 150 | 151 | PCU_ASSERT_EQUAL(256, PCU_FORMAT_BUFSIZE); 152 | 153 | snprintf(sp_buf, sizeof sp_buf, STR_0); 154 | bufp = PCU_format4(STR_0, 0, 0, 0, 0); 155 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 156 | 157 | snprintf(sp_buf, sizeof sp_buf, STR_S, "xy"); 158 | bufp = PCU_format4(STR_S, "xy", 0, 0, 0); 159 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 160 | 161 | snprintf(sp_buf, sizeof sp_buf, STR_D, 12); 162 | bufp = PCU_format4(STR_D, 12, 0, 0, 0); 163 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 164 | 165 | snprintf(sp_buf, sizeof sp_buf, STR_X, 0xab); 166 | bufp = PCU_format4(STR_X, 0xab, 0, 0, 0); 167 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 168 | 169 | } 170 | 171 | 172 | PCU_Suite *FormatNoStdargTest_suite(void) 173 | { 174 | static PCU_Test tests[] = { 175 | PCU_TEST(test_format), 176 | PCU_TEST(test_format_shorten), 177 | }; 178 | static PCU_Suite suite = { "FormatNoStdargTest", tests, sizeof tests / sizeof tests[0] }; 179 | return &suite; 180 | } 181 | -------------------------------------------------------------------------------- /test/PCU_format_test/test_format.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | #include "../../PCUnit/PCUnit.h" 7 | #define PCU_FORMAT_BUFSIZE 256 8 | #ifdef __cplusplus 9 | extern "C" { 10 | #endif 11 | const char *PCU_format_test(const char *format, ...); 12 | #ifdef __cplusplus 13 | } 14 | #endif 15 | 16 | 17 | void test_format(void) 18 | { 19 | const char *bufp = 0; 20 | char sp_buf[PCU_FORMAT_BUFSIZE]; 21 | int n; 22 | 23 | snprintf(sp_buf, sizeof sp_buf, "hogehoge"); 24 | bufp = PCU_format_test( "hogehoge"); 25 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 26 | 27 | snprintf(sp_buf, sizeof sp_buf, "%s", "piyopiyo"); 28 | bufp = PCU_format_test( "%s", "piyopiyo"); 29 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 30 | 31 | snprintf(sp_buf, sizeof sp_buf, "foo%%bar%s", "hoge"); 32 | bufp = PCU_format_test( "foo%%bar%s", "hoge"); 33 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 34 | 35 | snprintf(sp_buf, sizeof sp_buf, "%d, %d, %d, \"%8d\"", 9999, 0, -1, -1234); 36 | bufp = PCU_format_test( "%d, %d, %d, \"%8d\"", 9999, 0, -1, -1234); 37 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 38 | 39 | snprintf(sp_buf, sizeof sp_buf, "%hd, %ld, %ld, \"%8ld\"", 9999, 0L, -1L, -1234L); 40 | bufp = PCU_format_test( "%hd, %ld, %ld, \"%8ld\"", 9999, 0L, -1L, -1234L); 41 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 42 | 43 | snprintf(sp_buf, sizeof sp_buf, "%lld, %lld, %lld, \"%8lld\"", 9999LL, 0LL, -1LL, -1234LL); 44 | bufp = PCU_format_test( "%lld, %lld, %lld, \"%8lld\"", 9999LL, 0LL, -1LL, -1234LL); 45 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 46 | 47 | snprintf(sp_buf, sizeof sp_buf, "%u, %u, %-d, \"%-8d\"", 12345, 0, -123, -111); 48 | bufp = PCU_format_test( "%u, %u, %-d, \"%-8d\"", 12345, 0, -123, -111); 49 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 50 | 51 | snprintf(sp_buf, sizeof sp_buf, "\"%d\", \"%8d\", \"%-8d\", \"%s\"", 123456789, 123456, 789, "abcd"); 52 | bufp = PCU_format_test( "\"%d\", \"%8d\", \"%-8d\", \"%s\"", 123456789, 123456, 789, "abcd"); 53 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 54 | 55 | snprintf(sp_buf, sizeof sp_buf, "\"%s\", \"%9d\", \"%s\", \"%s\"", "foo", 1234567890, "bar", "abcd"); 56 | bufp = PCU_format_test( "\"%s\", \"%9d\", \"%s\", \"%s\"", "foo", 1234567890, "bar", "abcd"); 57 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 58 | 59 | snprintf(sp_buf, sizeof sp_buf, "%x, \"%8x\", \"%08X\", \"%10d\"", 0x1234, 0x5678, 0xABCD, 12345); 60 | bufp = PCU_format_test( "%x, \"%8x\", \"%08X\", \"%10d\"", 0x1234, 0x5678, 0xABCD, 12345); 61 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 62 | 63 | snprintf(sp_buf, sizeof sp_buf, "%#x, \"%#8x\", \"%#08X\", \"%#-10x\"", 0x1234, 0x5678, 0xABCD, 0x12345); 64 | bufp = PCU_format_test( "%#x, \"%#8x\", \"%#08X\", \"%#-10x\"", 0x1234, 0x5678, 0xABCD, 0x12345); 65 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 66 | 67 | snprintf(sp_buf, sizeof sp_buf, "%#x, \"%#8x\", \"%#08X\", \"%#010X\"", 0, 0x5678, 0xABCD, 0x12345); 68 | bufp = PCU_format_test( "%#x, \"%#8x\", \"%#08X\", \"%#010X\"", 0, 0x5678, 0xABCD, 0x12345); 69 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 70 | 71 | snprintf(sp_buf, sizeof sp_buf, "%x, \"%8x\", \"%-8X\", \"%-10d\"", 0x0, 0x5678, 0xABCD, 12345); 72 | bufp = PCU_format_test( "%x, \"%8x\", \"%-8X\", \"%-10d\"", 0x0, 0x5678, 0xABCD, 12345); 73 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 74 | 75 | snprintf(sp_buf, sizeof sp_buf, "%lx, \"%8lx\", \"%-8lX\", \"%-10lx\"", 0x0L, 0x5678L, 0xABCDL, ULONG_MAX); 76 | bufp = PCU_format_test( "%lx, \"%8lx\", \"%-8lX\", \"%-10lx\"", 0x0L, 0x5678L, 0xABCDL, ULONG_MAX); 77 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 78 | 79 | snprintf(sp_buf, sizeof sp_buf, "%llx, \"%8llx\", \"%-8llX\", \"%-10llx\"", 0x0LL, 0x5678LL, 0xABCDLL, ULLONG_MAX); 80 | bufp = PCU_format_test( "%llx, \"%8llx\", \"%-8llX\", \"%-10llx\"", 0x0LL, 0x5678LL, 0xABCDLL, ULLONG_MAX); 81 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 82 | 83 | snprintf(sp_buf, sizeof sp_buf, "%+d, \"%+8d\", \"%-+8d\", \"%+010d\"", 0, 0, -123, -1); 84 | bufp = PCU_format_test( "%+d, \"%+8d\", \"%-+8d\", \"%+010d\"", 0, 0, -123, -1); 85 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 86 | 87 | snprintf(sp_buf, sizeof sp_buf, "%+d, \"%+8d\", \"%+-8d\", \"%+10d\"", 1234, 5678, 9876, 12345); 88 | bufp = PCU_format_test( "%+d, \"%+8d\", \"%+-8d\", \"%+10d\"", 1234, 5678, 9876, 12345); 89 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 90 | 91 | snprintf(sp_buf, sizeof sp_buf, "% d, \"% 8d\", \"%- 8d\", \"% 010d\", \"% d\"", 0, 0, -123, -1, -2); 92 | bufp = PCU_format_test( "% d, \"% 8d\", \"%- 8d\", \"% 010d\", \"% d\"", 0, 0, -123, -1, -2); 93 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 94 | 95 | snprintf(sp_buf, sizeof sp_buf, "% d, \"% 8d\", \"% -8d\", \"% 10d\"", 1234, 5678, 9876, 12345); 96 | bufp = PCU_format_test( "% d, \"% 8d\", \"% -8d\", \"% 10d\"", 1234, 5678, 9876, 12345); 97 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 98 | 99 | n = 8; 100 | snprintf(sp_buf, sizeof sp_buf, "\"%*d\", \"%*X\"", n, 5678, -n, 0xABCD); 101 | bufp = PCU_format_test( "\"%*d\", \"%*X\"", n, 5678, -n, 0xABCD); 102 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 103 | 104 | n = 0; 105 | snprintf(sp_buf, sizeof sp_buf, "\"%*d\", \"%*X\"", n, 1234, -n, 0xABCD); 106 | bufp = PCU_format_test( "\"%*d\", \"%*X\"", n, 1234, -n, 0xABCD); 107 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 108 | 109 | snprintf(sp_buf, sizeof sp_buf, "%c, %c, %c, %c", 'a', '#', '\\', '9'); 110 | bufp = PCU_format_test( "%c, %c, %c, %c", 'a', '#', '\\', '9'); 111 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 112 | 113 | 114 | snprintf(sp_buf, sizeof sp_buf, "%p, %p, %p, %p", (void *)1, (void *)bufp, (void *)sp_buf, (void *)1); 115 | bufp = PCU_format_test( "%p, %p, %p, %p", 1, bufp, sp_buf, 1); 116 | PCU_MESSAGE(sp_buf); 117 | PCU_MESSAGE(bufp); 118 | 119 | snprintf(sp_buf, sizeof sp_buf, "%d, %d, %d, %d, %d, %u", CHAR_MAX, CHAR_MIN, SCHAR_MAX, SCHAR_MIN, UCHAR_MAX, UCHAR_MAX); 120 | bufp = PCU_format_test( "%d, %d, %d, %d, %d, %u", CHAR_MAX, CHAR_MIN, SCHAR_MAX, SCHAR_MIN, UCHAR_MAX, UCHAR_MAX); 121 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 122 | 123 | snprintf(sp_buf, sizeof sp_buf, "%d, %d, %d, %u", SHRT_MAX, SHRT_MIN, USHRT_MAX, USHRT_MAX); 124 | bufp = PCU_format_test( "%d, %d, %d, %u", SHRT_MAX, SHRT_MIN, USHRT_MAX, USHRT_MAX); 125 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 126 | 127 | snprintf(sp_buf, sizeof sp_buf, "%d, %d, %d, %u", INT_MAX, INT_MIN, UINT_MAX, UINT_MAX); 128 | bufp = PCU_format_test( "%d, %d, %d, %u", INT_MAX, INT_MIN, UINT_MAX, UINT_MAX); 129 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 130 | 131 | snprintf(sp_buf, sizeof sp_buf, "%ld, %ld, %ld, %lu", LONG_MAX, LONG_MIN, ULONG_MAX, ULONG_MAX); 132 | bufp = PCU_format_test( "%ld, %ld, %ld, %lu", LONG_MAX, LONG_MIN, ULONG_MAX, ULONG_MAX); 133 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 134 | 135 | snprintf(sp_buf, sizeof sp_buf, "%lld, %lld, %lld, %llu", LLONG_MAX, LLONG_MIN, ULLONG_MAX, ULLONG_MAX); 136 | bufp = PCU_format_test( "%lld, %lld, %lld, %llu", LLONG_MAX, LLONG_MIN, ULLONG_MAX, ULLONG_MAX); 137 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 138 | 139 | } 140 | 141 | void test_format_shorten(void) 142 | { 143 | const char *bufp = 0; 144 | char sp_buf[PCU_FORMAT_BUFSIZE]; 145 | #define STR "0123456789abcdef"\ 146 | "1123456789abcdef"\ 147 | "2123456789abcdef"\ 148 | "3123456789abcdef"\ 149 | "4123456789abcdef"\ 150 | "5123456789abcdef"\ 151 | "6123456789abcdef"\ 152 | "7123456789abcdef"\ 153 | "8123456789abcdef"\ 154 | "9123456789abcdef"\ 155 | "a123456789abcdef"\ 156 | "b123456789abcdef"\ 157 | "c123456789abcdef"\ 158 | "d123456789abcdef"\ 159 | "e123456789abcdef" 160 | 161 | #define STR_0 STR "f123456789abcd01" 162 | #define STR_S STR "f123456789abcd%s" 163 | #define STR_D STR "f123456789abcd%d" 164 | #define STR_X STR "f123456789abcd%x" 165 | 166 | snprintf(sp_buf, sizeof sp_buf, STR_0); 167 | bufp = PCU_format_test(STR_0); 168 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 169 | 170 | snprintf(sp_buf, sizeof sp_buf, STR_S, "xy"); 171 | bufp = PCU_format_test(STR_S, "xy"); 172 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 173 | 174 | snprintf(sp_buf, sizeof sp_buf, STR_D, 12); 175 | bufp = PCU_format_test(STR_D, 12); 176 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 177 | 178 | snprintf(sp_buf, sizeof sp_buf, STR_X, 0xab); 179 | bufp = PCU_format_test(STR_X, 0xab); 180 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 181 | 182 | } 183 | 184 | 185 | PCU_Suite *FormatTest_suite(void) 186 | { 187 | static PCU_Test tests[] = { 188 | PCU_TEST(test_format), 189 | PCU_TEST(test_format_shorten), 190 | }; 191 | static PCU_Suite suite = { "FormatTest", tests, sizeof tests / sizeof tests[0] }; 192 | return &suite; 193 | } 194 | -------------------------------------------------------------------------------- /test/PCU_format_test/test_formatW.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | #include "../../PCUnit/PCUnit.h" 8 | #define PCU_FORMAT_BUFSIZE 256 9 | 10 | static int initialize(void) 11 | { 12 | setlocale(LC_CTYPE, "ja_JP.UTF-8"); 13 | return 0; 14 | } 15 | 16 | void test_formatW(void) 17 | { 18 | const char *bufp = 0; 19 | char sp_buf[PCU_FORMAT_BUFSIZE]; 20 | int n; 21 | 22 | snprintf(sp_buf, sizeof sp_buf, "hogehoge"); 23 | bufp = PCU_formatW( L"hogehoge"); 24 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 25 | 26 | snprintf(sp_buf, sizeof sp_buf, "%s", "piyopiyo"); 27 | bufp = PCU_formatW( L"%ls", L"piyopiyo"); 28 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 29 | 30 | snprintf(sp_buf, sizeof sp_buf, "foo%%bar%s", "hoge"); 31 | bufp = PCU_formatW( L"foo%%bar%ls", L"hoge"); 32 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 33 | 34 | snprintf(sp_buf, sizeof sp_buf, "%d, %d, %d, \"%8d\"", 9999, 0, -1, -1234); 35 | bufp = PCU_formatW( L"%d, %d, %d, \"%8d\"", 9999, 0, -1, -1234); 36 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 37 | 38 | snprintf(sp_buf, sizeof sp_buf, "%hd, %ld, %ld, \"%8ld\"", 9999, 0L, -1L, -1234L); 39 | bufp = PCU_formatW( L"%hd, %ld, %ld, \"%8ld\"", 9999, 0L, -1L, -1234L); 40 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 41 | 42 | snprintf(sp_buf, sizeof sp_buf, "%u, %u, %-d, \"%-8d\"", 12345, 0, -123, -111); 43 | bufp = PCU_formatW( L"%u, %u, %-d, \"%-8d\"", 12345, 0, -123, -111); 44 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 45 | 46 | snprintf(sp_buf, sizeof sp_buf, "\"%d\", \"%8d\", \"%-8d\", \"%s\"", 123456789, 123456, 789, "abcd"); 47 | bufp = PCU_formatW( L"\"%d\", \"%8d\", \"%-8d\", \"%s\"", 123456789, 123456, 789, "abcd"); 48 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 49 | 50 | snprintf(sp_buf, sizeof sp_buf, "\"%s\", \"%9d\", \"%s\", \"%s\"", "foo", 1234567890, "bar", "abcd"); 51 | bufp = PCU_formatW( L"\"%s\", \"%9d\", \"%s\", \"%s\"", "foo", 1234567890, "bar", "abcd"); 52 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 53 | 54 | snprintf(sp_buf, sizeof sp_buf, "%x, \"%8x\", \"%08X\", \"%10d\"", 0x1234, 0x5678, 0xABCD, 12345); 55 | bufp = PCU_formatW( L"%x, \"%8x\", \"%08X\", \"%10d\"", 0x1234, 0x5678, 0xABCD, 12345); 56 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 57 | 58 | snprintf(sp_buf, sizeof sp_buf, "%#x, \"%#8x\", \"%#08X\", \"%#-10x\"", 0x1234, 0x5678, 0xABCD, 0x12345); 59 | bufp = PCU_formatW( L"%#x, \"%#8x\", \"%#08X\", \"%#-10x\"", 0x1234, 0x5678, 0xABCD, 0x12345); 60 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 61 | 62 | snprintf(sp_buf, sizeof sp_buf, "%#x, \"%#8x\", \"%#08X\", \"%#010X\"", 0, 0x5678, 0xABCD, 0x12345); 63 | bufp = PCU_formatW( L"%#x, \"%#8x\", \"%#08X\", \"%#010X\"", 0, 0x5678, 0xABCD, 0x12345); 64 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 65 | 66 | snprintf(sp_buf, sizeof sp_buf, "%x, \"%8x\", \"%-8X\", \"%-10d\"", 0x0, 0x5678, 0xABCD, 12345); 67 | bufp = PCU_formatW( L"%x, \"%8x\", \"%-8X\", \"%-10d\"", 0x0, 0x5678, 0xABCD, 12345); 68 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 69 | 70 | snprintf(sp_buf, sizeof sp_buf, "%+d, \"%+8d\", \"%-+8d\", \"%+010d\"", 0, 0, -123, -1); 71 | bufp = PCU_formatW( L"%+d, \"%+8d\", \"%-+8d\", \"%+010d\"", 0, 0, -123, -1); 72 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 73 | 74 | snprintf(sp_buf, sizeof sp_buf, "%+d, \"%+8d\", \"%+-8d\", \"%+10d\"", 1234, 5678, 9876, 12345); 75 | bufp = PCU_formatW( L"%+d, \"%+8d\", \"%+-8d\", \"%+10d\"", 1234, 5678, 9876, 12345); 76 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 77 | 78 | snprintf(sp_buf, sizeof sp_buf, "% d, \"% 8d\", \"%- 8d\", \"% 010d\", \"% d\"", 0, 0, -123, -1, -2); 79 | bufp = PCU_formatW( L"% d, \"% 8d\", \"%- 8d\", \"% 010d\", \"% d\"", 0, 0, -123, -1, -2); 80 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 81 | 82 | snprintf(sp_buf, sizeof sp_buf, "% d, \"% 8d\", \"% -8d\", \"% 10d\"", 1234, 5678, 9876, 12345); 83 | bufp = PCU_formatW( L"% d, \"% 8d\", \"% -8d\", \"% 10d\"", 1234, 5678, 9876, 12345); 84 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 85 | 86 | n = 8; 87 | snprintf(sp_buf, sizeof sp_buf, "\"%*d\", \"%*X\"", n, 5678, -n, 0xABCD); 88 | bufp = PCU_formatW( L"\"%*d\", \"%*X\"", n, 5678, -n, 0xABCD); 89 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 90 | 91 | n = 0; 92 | snprintf(sp_buf, sizeof sp_buf, "\"%*d\", \"%*X\"", n, 1234, -n, 0xABCD); 93 | bufp = PCU_formatW( L"\"%*d\", \"%*X\"", n, 1234, -n, 0xABCD); 94 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 95 | 96 | snprintf(sp_buf, sizeof sp_buf, "%c, %c, %c, %c", 'a', '#', '\\', '9'); 97 | bufp = PCU_formatW( L"%c, %c, %c, %c", 'a', '#', '\\', '9'); 98 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 99 | 100 | 101 | snprintf(sp_buf, sizeof sp_buf, "%p, %p, %p, %p", (void *)1, (void *)bufp, (void *)sp_buf, (void *)1); 102 | bufp = PCU_formatW( L"%p, %p, %p, %p", 1, bufp, sp_buf, 1); 103 | PCU_MESSAGE(sp_buf); 104 | PCU_MESSAGE(bufp); 105 | 106 | snprintf(sp_buf, sizeof sp_buf, "あいうえお%s", "かきくけこ"); 107 | bufp = PCU_formatW( L"あいうえお%ls", L"かきくけこ"); 108 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 109 | 110 | snprintf(sp_buf, sizeof sp_buf, "%d, %d, %d, %d, %d, %u", CHAR_MAX, CHAR_MIN, SCHAR_MAX, SCHAR_MIN, UCHAR_MAX, UCHAR_MAX); 111 | bufp = PCU_formatW( L"%d, %d, %d, %d, %d, %u", CHAR_MAX, CHAR_MIN, SCHAR_MAX, SCHAR_MIN, UCHAR_MAX, UCHAR_MAX); 112 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 113 | 114 | snprintf(sp_buf, sizeof sp_buf, "%d, %d, %d, %u", SHRT_MAX, SHRT_MIN, USHRT_MAX, USHRT_MAX); 115 | bufp = PCU_formatW( L"%d, %d, %d, %u", SHRT_MAX, SHRT_MIN, USHRT_MAX, USHRT_MAX); 116 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 117 | 118 | snprintf(sp_buf, sizeof sp_buf, "%d, %d, %d, %u", INT_MAX, INT_MIN, UINT_MAX, UINT_MAX); 119 | bufp = PCU_formatW( L"%d, %d, %d, %u", INT_MAX, INT_MIN, UINT_MAX, UINT_MAX); 120 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 121 | 122 | snprintf(sp_buf, sizeof sp_buf, "%ld, %ld, %ld, %lu", LONG_MAX, LONG_MIN, ULONG_MAX, ULONG_MAX); 123 | bufp = PCU_formatW( L"%ld, %ld, %ld, %lu", LONG_MAX, LONG_MIN, ULONG_MAX, ULONG_MAX); 124 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 125 | 126 | snprintf(sp_buf, sizeof sp_buf, "%lld, %lld, %lld, %llu", LLONG_MAX, LLONG_MIN, ULLONG_MAX, ULLONG_MAX); 127 | bufp = PCU_formatW( L"%lld, %lld, %lld, %llu", LLONG_MAX, LLONG_MIN, ULLONG_MAX, ULLONG_MAX); 128 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 129 | 130 | } 131 | 132 | void test_formatW_shorten(void) 133 | { 134 | const char *bufp = 0; 135 | char sp_buf[PCU_FORMAT_BUFSIZE]; 136 | #define STR "0123456789abcdef"\ 137 | "1123456789abcdef"\ 138 | "2123456789abcdef"\ 139 | "3123456789abcdef"\ 140 | "4123456789abcdef"\ 141 | "5123456789abcdef"\ 142 | "6123456789abcdef"\ 143 | "7123456789abcdef"\ 144 | "8123456789abcdef"\ 145 | "9123456789abcdef"\ 146 | "a123456789abcdef"\ 147 | "b123456789abcdef"\ 148 | "c123456789abcdef"\ 149 | "d123456789abcdef"\ 150 | "e123456789abcdef" 151 | 152 | #define STR_0 STR "f123456789abcd01" 153 | #define STR_S STR "f123456789abcd%s" 154 | #define STR_D STR "f123456789abcd%d" 155 | #define STR_X STR "f123456789abcd%x" 156 | 157 | #define LSTR L"0123456789abcdef"\ 158 | L"1123456789abcdef"\ 159 | L"2123456789abcdef"\ 160 | L"3123456789abcdef"\ 161 | L"4123456789abcdef"\ 162 | L"5123456789abcdef"\ 163 | L"6123456789abcdef"\ 164 | L"7123456789abcdef"\ 165 | L"8123456789abcdef"\ 166 | L"9123456789abcdef"\ 167 | L"a123456789abcdef"\ 168 | L"b123456789abcdef"\ 169 | L"c123456789abcdef"\ 170 | L"d123456789abcdef"\ 171 | L"e123456789abcdef" 172 | 173 | #define LSTR_0 LSTR L"f123456789abcd01" 174 | #define LSTR_S LSTR L"f123456789abcd%s" 175 | #define LSTR_D LSTR L"f123456789abcd%d" 176 | #define LSTR_X LSTR L"f123456789abcd%x" 177 | 178 | snprintf(sp_buf, sizeof sp_buf, STR_0); 179 | bufp = PCU_formatW(LSTR_0); 180 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 181 | 182 | snprintf(sp_buf, sizeof sp_buf, STR_S, "xy"); 183 | bufp = PCU_formatW(LSTR_S, "xy"); 184 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 185 | 186 | snprintf(sp_buf, sizeof sp_buf, STR_D, 12); 187 | bufp = PCU_formatW(LSTR_D, 12); 188 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 189 | 190 | snprintf(sp_buf, sizeof sp_buf, STR_X, 0xab); 191 | bufp = PCU_formatW(LSTR_X, 0xab); 192 | PCU_ASSERT_STRING_EQUAL(sp_buf, bufp); 193 | 194 | } 195 | 196 | 197 | PCU_Suite *FormatWTest_suite(void) 198 | { 199 | static PCU_Test tests[] = { 200 | PCU_TEST(test_formatW), 201 | PCU_TEST(test_formatW_shorten), 202 | }; 203 | static PCU_Suite suite = { "FormatWTest", tests, sizeof tests / sizeof tests[0], 0, 0, initialize, 0 }; 204 | return &suite; 205 | } 206 | -------------------------------------------------------------------------------- /PCUnit/PCUnit.c: -------------------------------------------------------------------------------- 1 | #include "PCUnit.h" 2 | #include "PCU_Suite.h" 3 | #include "PCU_Test.h" 4 | #include "PCU_Libc.h" 5 | 6 | static int enable_color; 7 | 8 | typedef struct { 9 | int failed; 10 | } PCU_Result; 11 | static PCU_Result result; 12 | 13 | static void reset(const PCU_SuiteMethod *suite_methods, int num) 14 | { 15 | int i; 16 | const PCU_SuiteMethod *method = suite_methods; 17 | PCU_MEMSET(&result, 0, sizeof(result)); 18 | for (i = 0; i < num; i++, method++) { 19 | PCU_Suite *p = (*method)(); 20 | PCU_Suite_reset(p); 21 | } 22 | } 23 | 24 | void PCU_enable_color(void) 25 | { 26 | enable_color = 1; 27 | } 28 | 29 | void PCU_disable_color(void) 30 | { 31 | enable_color = 0; 32 | } 33 | 34 | enum { 35 | COLOR_GREEN, 36 | COLOR_RED 37 | }; 38 | #if defined(_WIN32) && !defined(_WIN32_WCE) 39 | #include 40 | static CONSOLE_SCREEN_BUFFER_INFO csbi; 41 | static int csbi_init_flag = 0; 42 | #endif 43 | static void set_color(int color) 44 | { 45 | #if defined(_WIN32) && !defined(_WIN32_WCE) 46 | HANDLE h; 47 | WORD attr; 48 | if (!enable_color) return; 49 | h = GetStdHandle(STD_OUTPUT_HANDLE); 50 | if (!csbi_init_flag) { 51 | GetConsoleScreenBufferInfo(h, &csbi); 52 | csbi_init_flag = 1; 53 | } 54 | switch (color) { 55 | case COLOR_GREEN: 56 | attr = FOREGROUND_GREEN; 57 | break; 58 | case COLOR_RED: 59 | attr = FOREGROUND_RED; 60 | break; 61 | default: 62 | attr = csbi.wAttributes; 63 | break; 64 | } 65 | SetConsoleTextAttribute(h, attr); 66 | #else 67 | if (!enable_color) return; 68 | switch (color) { 69 | case COLOR_GREEN: 70 | PCU_puts("\033[32m"); 71 | break; 72 | case COLOR_RED: 73 | PCU_puts("\033[31m"); 74 | break; 75 | default: 76 | break; 77 | } 78 | #endif 79 | } 80 | static void reset_color(void) 81 | { 82 | #if defined(_WIN32) && !defined(_WIN32_WCE) 83 | HANDLE h; 84 | if (!enable_color) return; 85 | if (!csbi_init_flag) return; 86 | h = GetStdHandle(STD_OUTPUT_HANDLE); 87 | SetConsoleTextAttribute(h, csbi.wAttributes); 88 | #else 89 | if (!enable_color) return; 90 | PCU_puts("\033[m"); 91 | #endif 92 | } 93 | 94 | static void print_before_test(const PCU_Suite *suite) 95 | { 96 | PCU_puts("\n"); 97 | PCU_puts("Suite: "); 98 | PCU_puts(suite->name); 99 | PCU_puts("\n"); 100 | } 101 | 102 | static void print_initialize_error(const PCU_Suite *suite) 103 | { 104 | set_color(COLOR_RED); 105 | PCU_PRINTF1("INITIALIZE FAILED : %d\n", suite->result.initialize_error); 106 | reset_color(); 107 | PCU_puts("\n"); 108 | } 109 | 110 | static void print_cleanup_error(const PCU_Suite *suite) 111 | { 112 | set_color(COLOR_RED); 113 | PCU_PRINTF1("CLEANUP FAILED : %d\n", suite->result.cleanup_error); 114 | reset_color(); 115 | PCU_puts("\n"); 116 | } 117 | 118 | static void print_after_test(const PCU_Suite *suite) 119 | { 120 | if (suite->result.initialize_error) { 121 | print_initialize_error(suite); 122 | return; 123 | } 124 | if (suite->result.num_tests_failed == 0) { 125 | set_color(COLOR_GREEN); 126 | } else { 127 | set_color(COLOR_RED); 128 | } 129 | PCU_PRINTF3("%d Tests, %d Failures, %d Skipped\n", 130 | suite->result.num_tests, suite->result.num_tests_failed, 131 | suite->result.num_tests - suite->result.num_tests_ran); 132 | if (suite->result.num_tests_failed == 0) { 133 | PCU_puts("OK\n"); 134 | } 135 | reset_color(); 136 | PCU_puts("\n"); 137 | if (suite->result.cleanup_error) { 138 | print_cleanup_error(suite); 139 | } 140 | } 141 | 142 | static void set_result(const PCU_Suite *suite) 143 | { 144 | if (suite->result.num_tests_failed || 145 | suite->result.initialize_error || suite->result.cleanup_error) { 146 | result.failed = 1; 147 | } 148 | } 149 | 150 | static void run_all(const PCU_SuiteMethod *suite_methods, int num) 151 | { 152 | int i; 153 | const PCU_SuiteMethod *method = suite_methods; 154 | reset(suite_methods, num); 155 | for (i = 0; i < num; i++, method++) { 156 | PCU_Suite *p = (*method)(); 157 | print_before_test(p); 158 | if (!PCU_Suite_initialize(p)) { 159 | PCU_Suite_run(p); 160 | PCU_Suite_cleanup(p); 161 | } 162 | set_result(p); 163 | PCU_puts("\n"); 164 | print_after_test(p); 165 | } 166 | } 167 | 168 | int PCU_run(const PCU_SuiteMethod *suite_methods, int num) 169 | { 170 | run_all(suite_methods, num); 171 | return result.failed; 172 | } 173 | 174 | #ifndef PCU_NO_CONSOLE_RUN 175 | static char input_buf[64]; 176 | 177 | static void print_result_selected(const PCU_Suite *suite, int idx) 178 | { 179 | PCU_Test *test = suite->tests + idx; 180 | PCU_puts("\n"); 181 | if (PCU_Test_is_failed(test)) { 182 | set_color(COLOR_RED); 183 | PCU_puts("FAILED ("); 184 | } else { 185 | set_color(COLOR_GREEN); 186 | if (PCU_Test_is_skipped(test)) { 187 | PCU_puts("Skipped ("); 188 | } else { 189 | PCU_puts("OK ("); 190 | } 191 | } 192 | PCU_puts(test->name); 193 | PCU_puts(")\n"); 194 | reset_color(); 195 | PCU_puts("\n"); 196 | } 197 | 198 | static void run_selected_suite(PCU_Suite *suite) 199 | { 200 | PCU_Suite_reset(suite); 201 | print_before_test(suite); 202 | PCU_Suite_run(suite); 203 | PCU_puts("\n"); 204 | print_after_test(suite); 205 | set_result(suite); 206 | } 207 | 208 | static void run_selected_test(PCU_Suite *suite, int idx) 209 | { 210 | PCU_Suite_reset(suite); 211 | PCU_Suite_run_selected(suite, idx); 212 | print_result_selected(suite, idx); 213 | set_result(suite); 214 | } 215 | 216 | static void show_list_tests(const PCU_Test *tests, int num) 217 | { 218 | int i; 219 | const PCU_Test *p; 220 | PCU_puts("List of Tests\n"); 221 | PCU_puts(" Number Name\n"); 222 | for (i = 0, p = tests; i < num; i++, p++) { 223 | PCU_PRINTF1(" %-6d ", i + 1); 224 | PCU_puts(p->name); 225 | PCU_puts("\n"); 226 | } 227 | PCU_puts("\n"); 228 | } 229 | 230 | static void show_list_suites(const PCU_SuiteMethod *suite_methods, int num) 231 | { 232 | int i; 233 | const PCU_SuiteMethod *method = suite_methods; 234 | PCU_puts("List of Suites\n"); 235 | PCU_puts(" Number Name\n"); 236 | for (i = 0; i < num; i++, method++) { 237 | const PCU_Suite *p = (*method)(); 238 | PCU_PRINTF1(" %-6d ", i + 1); 239 | PCU_puts(p->name); 240 | PCU_puts("\n"); 241 | } 242 | PCU_puts("\n"); 243 | } 244 | 245 | static int find_test_name(const PCU_Test *tests, int num, const char *input_str) 246 | { 247 | int i; 248 | const PCU_Test *p; 249 | for (i = 0, p = tests; i < num; i++, p++) { 250 | if (PCU_STRCMP(p->name, input_str) == 0) { 251 | return i; 252 | } 253 | } 254 | return -1; 255 | } 256 | 257 | static int find_number(int num, const char *input_str) 258 | { 259 | int n; 260 | n = PCU_ATOI(input_str); 261 | if (n <= 0 || num + 1 <= n) { 262 | return -1; 263 | } 264 | return n - 1; 265 | } 266 | 267 | static void get_line(char *buf, int size) 268 | { 269 | int c; 270 | int i = 0; 271 | static int prev = 0; 272 | if (size <= 0) return; 273 | while (i < size - 1) { 274 | c = PCU_getchar(); 275 | if (c == '\r') { 276 | prev = c; 277 | break; 278 | } else if (c == '\n') { 279 | if (prev == '\r') { 280 | prev = 0; 281 | } else { 282 | prev = c; 283 | break; 284 | } 285 | } else { 286 | prev = c; 287 | buf[i++] = (char) c; 288 | } 289 | } 290 | buf[i] = '\0'; 291 | } 292 | 293 | static void select_test(PCU_Suite *suite) 294 | { 295 | int idx; 296 | PCU_puts("Enter Number or Name of Test: "); 297 | get_line(input_buf, sizeof input_buf); 298 | 299 | idx = find_number(suite->ntests, input_buf); 300 | if (idx == -1) { 301 | idx = find_test_name(suite->tests, suite->ntests, input_buf); 302 | if (idx == -1) { 303 | PCU_puts("\nTest not found.\n"); 304 | return; 305 | } 306 | } 307 | PCU_puts("\n"); 308 | 309 | run_selected_test(suite, idx); 310 | } 311 | 312 | static int find_suite_name(const PCU_SuiteMethod *suite_methods, int num, const char *input_str) 313 | { 314 | int i; 315 | const PCU_SuiteMethod *method = suite_methods; 316 | for (i = 0; i < num; i++, method++) { 317 | const PCU_Suite *p = (*method)(); 318 | if (PCU_STRCMP(p->name, input_str) == 0) { 319 | return i; 320 | } 321 | } 322 | return -1; 323 | } 324 | 325 | static int select_suite(const PCU_SuiteMethod *suite_methods, int num) 326 | { 327 | int ret = 0; 328 | int idx; 329 | PCU_Suite *selected_suite; 330 | PCU_puts("Enter Number or Name of Suite: "); 331 | get_line(input_buf, sizeof input_buf); 332 | 333 | idx = find_number(num, input_buf); 334 | if (idx == -1) { 335 | idx = find_suite_name(suite_methods, num, input_buf); 336 | if (idx == -1) { 337 | PCU_puts("\nSuite not found.\n"); 338 | return 0; 339 | } 340 | } 341 | 342 | selected_suite = (suite_methods[idx])(); 343 | if (PCU_Suite_initialize(selected_suite)) { 344 | print_before_test(selected_suite); 345 | PCU_puts("\n"); 346 | print_initialize_error(selected_suite); 347 | return 0; 348 | } 349 | 350 | PCU_puts("\n"); 351 | while (1) { 352 | PCU_puts("============== Suite: "); 353 | PCU_puts(selected_suite->name); 354 | PCU_puts(" ==============\n"); 355 | PCU_puts("(R)un Suite, (S)elect Test, (L)ist of Tests, (M)ove up, (Q)uit\n"); 356 | PCU_puts("Enter Command: "); 357 | get_line(input_buf, sizeof input_buf); 358 | PCU_puts("\n"); 359 | switch (input_buf[0]) { 360 | case 'r': 361 | case 'R': 362 | run_selected_suite(selected_suite); 363 | break; 364 | case 's': 365 | case 'S': 366 | show_list_tests(selected_suite->tests, selected_suite->ntests); 367 | select_test(selected_suite); 368 | break; 369 | case 'l': 370 | case 'L': 371 | show_list_tests(selected_suite->tests, selected_suite->ntests); 372 | break; 373 | case 'm': 374 | case 'M': 375 | ret = 0; 376 | goto end; 377 | break; 378 | case 'q': 379 | case 'Q': 380 | ret = 1; 381 | goto end; 382 | break; 383 | default: 384 | break; 385 | } 386 | PCU_puts("\n"); 387 | } 388 | end: 389 | if (PCU_Suite_cleanup(selected_suite)) { 390 | print_before_test(selected_suite); 391 | PCU_puts("\n"); 392 | print_cleanup_error(selected_suite); 393 | } 394 | return ret; 395 | } 396 | 397 | int PCU_console_run(const PCU_SuiteMethod *suite_methods, int num) 398 | { 399 | int PCU_is_verbose(void); 400 | reset(suite_methods, num); 401 | while (1) { 402 | int quit; 403 | PCU_puts("************** PCUnit Console **************\n"); 404 | PCU_puts("(R)un all, (S)elect Suite, (L)ist of Suites, "); 405 | if (PCU_is_verbose()) { 406 | PCU_puts("(N)ormal"); 407 | } else { 408 | PCU_puts("(V)erbose"); 409 | } 410 | PCU_puts(" mode, "); 411 | if (enable_color) { 412 | PCU_puts("(D)is"); 413 | } else { 414 | PCU_puts("(E)n"); 415 | } 416 | PCU_puts("able color, (Q)uit\n"); 417 | PCU_puts("Enter Command: "); 418 | get_line(input_buf, sizeof input_buf); 419 | PCU_puts("\n"); 420 | switch (input_buf[0]) { 421 | case 'r': 422 | case 'R': 423 | run_all(suite_methods, num); 424 | break; 425 | case 's': 426 | case 'S': 427 | show_list_suites(suite_methods, num); 428 | quit = select_suite(suite_methods, num); 429 | if (quit) goto end; 430 | break; 431 | case 'l': 432 | case 'L': 433 | show_list_suites(suite_methods, num); 434 | break; 435 | case 'n': 436 | case 'N': 437 | PCU_set_verbose(0); 438 | break; 439 | case 'v': 440 | case 'V': 441 | PCU_set_verbose(1); 442 | break; 443 | case 'e': 444 | case 'E': 445 | PCU_enable_color(); 446 | break; 447 | case 'd': 448 | case 'D': 449 | PCU_disable_color(); 450 | break; 451 | case 'q': 452 | case 'Q': 453 | goto end; 454 | default: 455 | break; 456 | } 457 | PCU_puts("\n"); 458 | } 459 | end: 460 | return result.failed; 461 | } 462 | #endif 463 | -------------------------------------------------------------------------------- /test/assert_output_test/assert_output_expected.txt: -------------------------------------------------------------------------------- 1 | 2 | Suite: AssertDoubleTest 3 | 4 | Test: test_assert_dbl_equal_FAIL 5 | AssertDoubleTest.c:XXX: PCU_ASSERT_DOUBLE_EQUAL(a, b, delta) 6 | expected : |value1 - value2| <= |delta| 7 | value1 : 100 8 | value2 : 100.1 9 | delta : 0.0999 10 | 11 | Test: test_assert_dbl_equal_MSG 12 | AssertDoubleTest.c:XXX: PCU_ASSERT_DOUBLE_EQUAL(a, b, delta) 13 | expected : |value1 - value2| <= |delta| 14 | value1 : 100 15 | value2 : 100.1 16 | delta : 0.0999 17 | 100, 100.1 18 | 19 | Test: test_assert_dbl_not_equal_FAIL 20 | AssertDoubleTest.c:XXX: PCU_ASSERT_DOUBLE_NOT_EQUAL(a, b, delta) 21 | expected : |value1 - value2| > |delta| 22 | value1 : 100 23 | value2 : 100.1 24 | delta : 0.1 25 | 26 | Test: test_assert_dbl_not_equal_MSG 27 | AssertDoubleTest.c:XXX: PCU_ASSERT_DOUBLE_NOT_EQUAL(a, b, delta) 28 | expected : |value1 - value2| > |delta| 29 | value1 : 100 30 | value2 : 100.1 31 | delta : 0.1 32 | 100, 100.1 33 | 34 | 6 Tests, 4 Failures, 0 Skipped 35 | 36 | 37 | Suite: AssertEqualTest 38 | 39 | Test: test_assert_equal_FAIL 40 | AssertEqualTest.c:XXX: PCU_ASSERT_EQUAL(a, b) 41 | expected : 0x00000064 (100) 'd' 42 | actual : 0x00000063 (99) 'c' 43 | 44 | Test: test_assert_equal_MSG 45 | AssertEqualTest.c:XXX: PCU_ASSERT_EQUAL(a, b) 46 | expected : 0x00000064 (100) 'd' 47 | actual : 0x00000065 (101) 'e' 48 | 100, 101 49 | 50 | Test: test_assert_equal_char_FAIL 51 | AssertEqualTest.c:XXX: PCU_ASSERT_EQUAL(a, b) 52 | expected : 0x0000000000000064 (100) 'd' 53 | actual : 0xffffffffffffffff (-1) 54 | 55 | Test: test_assert_equal_short_FAIL 56 | AssertEqualTest.c:XXX: PCU_ASSERT_EQUAL(a, b) 57 | expected : 0x0000000000000064 (100) 'd' 58 | actual : 0xffffffffffffffff (-1) 59 | 60 | Test: test_assert_equal_long_FAIL 61 | AssertEqualTest.c:XXX: PCU_ASSERT_EQUAL(a, b) 62 | expected : 0x0000000000000064 (100) 'd' 63 | actual : 0xffffffffffffffff (-1) 64 | 65 | Test: test_assert_equal_longlong_FAIL 66 | AssertEqualTest.c:XXX: PCU_ASSERT_EQUAL(a, b) 67 | expected : 0x0000000000000064 (100) 'd' 68 | actual : 0xffffffffffffffff (-1) 69 | 70 | Test: test_assert_not_equal_FAIL 71 | AssertEqualTest.c:XXX: PCU_ASSERT_NOT_EQUAL(a, b) 72 | value1 : 0x00000064 (100) 'd' 73 | value2 : 0x00000064 (100) 'd' 74 | 75 | Test: test_assert_not_equal_MSG 76 | AssertEqualTest.c:XXX: PCU_ASSERT_NOT_EQUAL(a, b) 77 | value1 : 0x00000064 (100) 'd' 78 | value2 : 0x00000064 (100) 'd' 79 | 100, 100 80 | 81 | 10 Tests, 8 Failures, 0 Skipped 82 | 83 | 84 | Suite: AssertMemoryTest 85 | 86 | Test: test_assert_mem_equal_FAIL 87 | AssertMemoryTest.c:XXX: PCU_ASSERT_MEMORY_EQUAL(&a[0], &b[0], sizeof a[0], 2) 88 | nth : 1 89 | expected : 03 00 00 00 04 00 00 00 (XXXXXXXX) 90 | actual : 03 00 00 00 05 00 00 00 (XXXXXXXX) 91 | size : 8 92 | 93 | Test: test_assert_mem_equal_MSG 94 | AssertMemoryTest.c:XXX: PCU_ASSERT_MEMORY_EQUAL(&a[0], &b[0], sizeof a[0], 2) 95 | nth : 1 96 | expected : 03 00 00 00 04 00 00 00 (XXXXXXXX) 97 | actual : 03 00 00 00 05 00 00 00 (XXXXXXXX) 98 | size : 8 99 | 3, 5 100 | 101 | Test: test_assert_mem_equal_FAIL_expect_null 102 | AssertMemoryTest.c:XXX: PCU_ASSERT_MEMORY_EQUAL(NULL, &b[0], sizeof a[0], 1) 103 | expected : NULL 104 | actual : 01 00 00 00 02 00 00 00 (XXXXXXXX) 105 | size : 8 106 | 107 | Test: test_assert_mem_equal_FAIL_actual_null 108 | AssertMemoryTest.c:XXX: PCU_ASSERT_MEMORY_EQUAL(&a[0], NULL, sizeof a[0], 1) 109 | expected : 01 00 00 00 02 00 00 00 (XXXXXXXX) 110 | actual : NULL 111 | size : 8 112 | 113 | Test: test_assert_mem_not_equal_FAIL 114 | AssertMemoryTest.c:XXX: PCU_ASSERT_MEMORY_NOT_EQUAL(&a[0], &b[0], sizeof a[0], 2) 115 | nth : 0 116 | value1 : 01 00 00 00 02 00 00 00 (XXXXXXXX) 117 | value2 : 01 00 00 00 02 00 00 00 (XXXXXXXX) 118 | size : 8 119 | 120 | Test: test_assert_mem_not_equal_MSG 121 | AssertMemoryTest.c:XXX: PCU_ASSERT_MEMORY_NOT_EQUAL(&a[0], &b[0], sizeof a[0], 1) 122 | value1 : 01 00 00 00 02 00 00 00 (XXXXXXXX) 123 | value2 : 01 00 00 00 02 00 00 00 (XXXXXXXX) 124 | size : 8 125 | 1, 2 126 | 127 | Test: test_assert_mem_not_equal_FAIL_null_null 128 | AssertMemoryTest.c:XXX: PCU_ASSERT_MEMORY_NOT_EQUAL(NULL, NULL, 1, 4) 129 | nth : 0 130 | value1 : NULL 131 | value2 : NULL 132 | size : 1 133 | 134 | 14 Tests, 7 Failures, 0 Skipped 135 | 136 | 137 | Suite: AssertOperatorTest 138 | 139 | Test: test_assert_operator_FAIL1 140 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR((-1) < (1)) 141 | value1 : 0xffffffffffffffff (-1) 142 | value2 : 0x0000000000000001 (1) 143 | 144 | Test: test_assert_operator_FAIL2 145 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR((a) ^ (b)) 146 | value1 : 0x00000100 (256) 147 | value2 : 0x00000100 (256) 148 | 149 | Test: test_assert_operator_FAIL3 150 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR((a) & (~b)) 151 | value1 : 0x00000100 (256) 152 | value2 : 0xfffffeff (4294967039) 153 | 154 | Test: test_assert_operator_FAIL4 155 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR((a) == (b)) 156 | value1 : 0x00000100 (256) 157 | value2 : 0x00000101 (257) 158 | 159 | Test: test_assert_operator_FAIL5 160 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR((0x10 <= a) && (a < 0x100)) 161 | value1 : 0x00000001 (1) 162 | value2 : 0x00000000 (0) 163 | 164 | Test: test_assert_operator_FAIL6 165 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR((a < 0x10) || (0x100 < a)) 166 | value1 : 0x00000000 (0) 167 | value2 : 0x00000000 (0) 168 | 169 | Test: test_assert_operator_MSG 170 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR((a) == (b)) 171 | value1 : 0x00000100 (256) 172 | value2 : 0x00000000 (0) 173 | 256, 0 174 | 175 | Test: test_assert_operator_int_FAIL1 176 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR_INT((-1) > (1)) 177 | value1 : 0xffffffffffffffff (-1) 178 | value2 : 0x0000000000000001 (1) 179 | 180 | Test: test_assert_operator_int_FAIL2 181 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR_INT((a) ^ (b)) 182 | value1 : 0x00000100 (256) 183 | value2 : 0x00000100 (256) 184 | 185 | Test: test_assert_operator_int_FAIL3 186 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR_INT((a) & (~b)) 187 | value1 : 0x0000000000000100 (256) 188 | value2 : 0xfffffffffffffeff (-257) 189 | 190 | Test: test_assert_operator_int_FAIL4 191 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR_INT((a) == (b)) 192 | value1 : 0x00000100 (256) 193 | value2 : 0x00000101 (257) 194 | 195 | Test: test_assert_operator_int_FAIL5 196 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR_INT((0x10 <= a) && (a < 0x100)) 197 | value1 : 0x00000001 (1) 198 | value2 : 0x00000000 (0) 199 | 200 | Test: test_assert_operator_int_FAIL6 201 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR_INT((a < 0x10) || (0x100 < a)) 202 | value1 : 0x00000000 (0) 203 | value2 : 0x00000000 (0) 204 | 205 | Test: test_assert_operator_int_MSG 206 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR_INT((a) == (b)) 207 | value1 : 0x00000100 (256) 208 | value2 : 0x00000000 (0) 209 | 256, 0 210 | 211 | Test: test_assert_operator_dbl_FAIL1 212 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR_DOUBLE((0) > (1)) 213 | value1 : 0 214 | value2 : 1 215 | 216 | Test: test_assert_operator_dbl_FAIL2 217 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR_DOUBLE((a) < (b)) 218 | value1 : 100 219 | value2 : 100 220 | 221 | Test: test_assert_operator_dbl_FAIL3 222 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR_DOUBLE((a) == (b)) 223 | value1 : 100 224 | value2 : 100.1 225 | 226 | 20 Tests, 17 Failures, 0 Skipped 227 | 228 | 229 | Suite: AssertPtrTest 230 | 231 | Test: test_assert_ptr_equal_FAIL 232 | AssertPtrTest.c:XXX: PCU_ASSERT_PTR_EQUAL(&a, &b) 233 | expected : 0xXXXXXXXX 234 | actual : 0xXXXXXXXX 235 | 236 | Test: test_assert_ptr_equal_MSG 237 | AssertPtrTest.c:XXX: PCU_ASSERT_PTR_EQUAL(&a, &b) 238 | expected : 0xXXXXXXXX 239 | actual : 0xXXXXXXXX 240 | 0xXXXXXXXX, 0xXXXXXXXX 241 | 242 | Test: test_assert_ptr_not_equal_FAIL 243 | AssertPtrTest.c:XXX: PCU_ASSERT_PTR_NOT_EQUAL(&a, &a) 244 | value1 : 0xXXXXXXXX 245 | value2 : 0xXXXXXXXX 246 | 247 | Test: test_assert_ptr_not_equal_MSG 248 | AssertPtrTest.c:XXX: PCU_ASSERT_PTR_NOT_EQUAL(&a, &a) 249 | value1 : 0xXXXXXXXX 250 | value2 : 0xXXXXXXXX 251 | 0xXXXXXXXX, 0xXXXXXXXX 252 | 253 | Test: test_assert_ptr_null_FAIL 254 | AssertPtrTest.c:XXX: PCU_ASSERT_PTR_NULL(p) 255 | expected : NULL 256 | actual : 0xXXXXXXXX 257 | 258 | Test: test_assert_ptr_null_MSG 259 | AssertPtrTest.c:XXX: PCU_ASSERT_PTR_NULL(p) 260 | expected : NULL 261 | actual : 0xXXXXXXXX 262 | 0xXXXXXXXX 263 | 264 | Test: test_assert_ptr_not_null_FAIL 265 | AssertPtrTest.c:XXX: PCU_ASSERT_PTR_NOT_NULL(p) 266 | expected : non-NULL 267 | actual : NULL 268 | 269 | Test: test_assert_ptr_not_null_MSG 270 | AssertPtrTest.c:XXX: PCU_ASSERT_PTR_NOT_NULL(p) 271 | expected : non-NULL 272 | actual : NULL 273 | 0x0 274 | 275 | 12 Tests, 8 Failures, 0 Skipped 276 | 277 | 278 | Suite: AssertStringTest 279 | 280 | Test: test_assert_str_equal_FAIL 281 | AssertStringTest.c:XXX: PCU_ASSERT_STRING_EQUAL(a, b) 282 | expected : "hoge" (0xXXXXXXXX) 283 | actual : "piyo" (0xXXXXXXXX) 284 | 285 | Test: test_assert_str_equal_MSG 286 | AssertStringTest.c:XXX: PCU_ASSERT_STRING_EQUAL(a, b) 287 | expected : "hoge" (0xXXXXXXXX) 288 | actual : "piyo" (0xXXXXXXXX) 289 | hoge, piyo 290 | 291 | Test: test_assert_str_equal_FAIL_expect_null 292 | AssertStringTest.c:XXX: PCU_ASSERT_STRING_EQUAL(NULL, a) 293 | expected : NULL 294 | actual : "hoge" (0xXXXXXXXX) 295 | 296 | Test: test_assert_str_equal_FAIL_actual_null 297 | AssertStringTest.c:XXX: PCU_ASSERT_STRING_EQUAL(a, NULL) 298 | expected : "hoge" (0xXXXXXXXX) 299 | actual : NULL 300 | 301 | Test: test_assert_str_not_equal_FAIL 302 | AssertStringTest.c:XXX: PCU_ASSERT_STRING_NOT_EQUAL(a, b) 303 | value1 : "hoge" (0xXXXXXXXX) 304 | value2 : "hoge" (0xXXXXXXXX) 305 | 306 | Test: test_assert_str_not_equal_MSG 307 | AssertStringTest.c:XXX: PCU_ASSERT_STRING_NOT_EQUAL(a, b) 308 | value1 : "hoge" (0xXXXXXXXX) 309 | value2 : "hoge" (0xXXXXXXXX) 310 | hoge, hoge 311 | 312 | Test: test_assert_str_not_equal_FAIL_null_null 313 | AssertStringTest.c:XXX: PCU_ASSERT_STRING_NOT_EQUAL(NULL, NULL) 314 | value1 : NULL 315 | value2 : NULL 316 | 317 | Test: test_assert_nstr_equal_FAIL 318 | AssertStringTest.c:XXX: PCU_ASSERT_NSTRING_EQUAL(a, b, 4) 319 | expected : "hogu" (0xXXXXXXXX) 320 | actual : "hoge" (0xXXXXXXXX) 321 | length : 4 322 | 323 | Test: test_assert_nstr_equal_MSG 324 | AssertStringTest.c:XXX: PCU_ASSERT_NSTRING_EQUAL(a, b, 4) 325 | expected : "hogu" (0xXXXXXXXX) 326 | actual : "hoge" (0xXXXXXXXX) 327 | length : 4 328 | hogu, hogehoge 329 | 330 | Test: test_assert_nstr_equal_FAIL_expect_null 331 | AssertStringTest.c:XXX: PCU_ASSERT_NSTRING_EQUAL(NULL, a, 1) 332 | expected : NULL 333 | actual : "h" (0xXXXXXXXX) 334 | length : 1 335 | 336 | Test: test_assert_nstr_equal_FAIL_actual_null 337 | AssertStringTest.c:XXX: PCU_ASSERT_NSTRING_EQUAL(a, NULL, 1) 338 | expected : "h" (0xXXXXXXXX) 339 | actual : NULL 340 | length : 1 341 | 342 | Test: test_assert_nstr_not_equal_FAIL 343 | AssertStringTest.c:XXX: PCU_ASSERT_NSTRING_NOT_EQUAL(a, b, 4) 344 | value1 : "hoge" (0xXXXXXXXX) 345 | value2 : "hoge" (0xXXXXXXXX) 346 | length : 4 347 | 348 | Test: test_assert_nstr_not_equal_MSG 349 | AssertStringTest.c:XXX: PCU_ASSERT_NSTRING_NOT_EQUAL(a, b, 3) 350 | value1 : "hog" (0xXXXXXXXX) 351 | value2 : "hog" (0xXXXXXXXX) 352 | length : 3 353 | hogu, hogehoge 354 | 355 | Test: test_assert_nstr_not_equal_FAIL_null_null 356 | AssertStringTest.c:XXX: PCU_ASSERT_NSTRING_NOT_EQUAL(NULL, NULL, 1) 357 | value1 : NULL 358 | value2 : NULL 359 | length : 1 360 | 361 | 24 Tests, 14 Failures, 0 Skipped 362 | 363 | 364 | Suite: AssertStringWTest 365 | 366 | Test: test_assert_strw_equal_FAIL 367 | AssertStringWTest.c:XXX: PCU_ASSERT_STRINGW_EQUAL(a, b) 368 | expected : L"hoge" (0xXXXXXXXX) 369 | actual : L"piyo" (0xXXXXXXXX) 370 | 371 | Test: test_assert_strw_equal_MSG 372 | AssertStringWTest.c:XXX: PCU_ASSERT_STRINGW_EQUAL(a, b) 373 | expected : L"hoge" (0xXXXXXXXX) 374 | actual : L"piyo" (0xXXXXXXXX) 375 | hoge, piyo 376 | 377 | Test: test_assert_strw_equal_FAIL_expect_null 378 | AssertStringWTest.c:XXX: PCU_ASSERT_STRINGW_EQUAL(NULL, a) 379 | expected : NULL 380 | actual : L"hoge" (0xXXXXXXXX) 381 | 382 | Test: test_assert_strw_equal_FAIL_actual_null 383 | AssertStringWTest.c:XXX: PCU_ASSERT_STRINGW_EQUAL(a, NULL) 384 | expected : L"hoge" (0xXXXXXXXX) 385 | actual : NULL 386 | 387 | Test: test_assert_strw_not_equal_FAIL 388 | AssertStringWTest.c:XXX: PCU_ASSERT_STRINGW_NOT_EQUAL(a, b) 389 | value1 : L"hoge" (0xXXXXXXXX) 390 | value2 : L"hoge" (0xXXXXXXXX) 391 | 392 | Test: test_assert_strw_not_equal_MSG 393 | AssertStringWTest.c:XXX: PCU_ASSERT_STRINGW_NOT_EQUAL(a, b) 394 | value1 : L"hoge" (0xXXXXXXXX) 395 | value2 : L"hoge" (0xXXXXXXXX) 396 | hoge, hoge 397 | 398 | Test: test_assert_strw_not_equal_FAIL_null_null 399 | AssertStringWTest.c:XXX: PCU_ASSERT_STRINGW_NOT_EQUAL(NULL, NULL) 400 | value1 : NULL 401 | value2 : NULL 402 | 403 | Test: test_assert_nstrw_equal_FAIL 404 | AssertStringWTest.c:XXX: PCU_ASSERT_NSTRINGW_EQUAL(a, b, 4) 405 | expected : L"hogu" (0xXXXXXXXX) 406 | actual : L"hoge" (0xXXXXXXXX) 407 | length : 4 408 | 409 | Test: test_assert_nstrw_equal_MSG 410 | AssertStringWTest.c:XXX: PCU_ASSERT_NSTRINGW_EQUAL(a, b, 4) 411 | expected : L"hogu" (0xXXXXXXXX) 412 | actual : L"hoge" (0xXXXXXXXX) 413 | length : 4 414 | hogu, hogehoge 415 | 416 | Test: test_assert_nstrw_equal_FAIL_expect_null 417 | AssertStringWTest.c:XXX: PCU_ASSERT_NSTRINGW_EQUAL(NULL, a, 1) 418 | expected : NULL 419 | actual : L"h" (0xXXXXXXXX) 420 | length : 1 421 | 422 | Test: test_assert_nstrw_equal_FAIL_actual_null 423 | AssertStringWTest.c:XXX: PCU_ASSERT_NSTRINGW_EQUAL(a, NULL, 1) 424 | expected : L"h" (0xXXXXXXXX) 425 | actual : NULL 426 | length : 1 427 | 428 | Test: test_assert_nstrw_not_equal_FAIL 429 | AssertStringWTest.c:XXX: PCU_ASSERT_NSTRINGW_NOT_EQUAL(a, b, 4) 430 | value1 : L"hoge" (0xXXXXXXXX) 431 | value2 : L"hoge" (0xXXXXXXXX) 432 | length : 4 433 | 434 | Test: test_assert_nstrw_not_equal_MSG 435 | AssertStringWTest.c:XXX: PCU_ASSERT_NSTRINGW_NOT_EQUAL(a, b, 3) 436 | value1 : L"hog" (0xXXXXXXXX) 437 | value2 : L"hog" (0xXXXXXXXX) 438 | length : 3 439 | hogu, hogehoge 440 | 441 | Test: test_assert_nstrw_not_equal_FAIL_null_null 442 | AssertStringWTest.c:XXX: PCU_ASSERT_NSTRINGW_NOT_EQUAL(NULL, NULL, 1) 443 | value1 : NULL 444 | value2 : NULL 445 | length : 1 446 | 447 | 24 Tests, 14 Failures, 0 Skipped 448 | 449 | 450 | Suite: AssertTest 451 | 452 | Test: test_assert_FAIL 453 | AssertTest.c:XXX: PCU_ASSERT(0) 454 | expected : TRUE 455 | actual : FALSE (0) 456 | 457 | Test: test_assert_MSG 458 | AssertTest.c:XXX: PCU_ASSERT(a) 459 | expected : TRUE 460 | actual : FALSE (0) 461 | 0 462 | 463 | Test: test_assert_true_FAIL 464 | AssertTest.c:XXX: PCU_ASSERT_TRUE(a) 465 | expected : TRUE 466 | actual : FALSE (0) 467 | 468 | Test: test_assert_true_MSG 469 | AssertTest.c:XXX: PCU_ASSERT_TRUE(a) 470 | expected : TRUE 471 | actual : FALSE (0) 472 | 0 473 | 474 | Test: test_assert_false_FAIL 475 | AssertTest.c:XXX: PCU_ASSERT_FALSE(a) 476 | expected : FALSE 477 | actual : TRUE (1) 478 | 479 | Test: test_assert_false_MSG 480 | AssertTest.c:XXX: PCU_ASSERT_FALSE(a) 481 | expected : FALSE 482 | actual : TRUE (1) 483 | 1 484 | 485 | 9 Tests, 6 Failures, 0 Skipped 486 | 487 | 488 | Suite: CleanupTest 489 | 490 | 1 Tests, 0 Failures, 0 Skipped 491 | OK 492 | 493 | CLEANUP FAILED : -1 494 | 495 | 496 | Suite: FailTest 497 | 498 | Test: test_fail1 499 | FailTest.c:XXX: PCU_FAIL 500 | test_fail 501 | 502 | Test: test_fail2 503 | FailTest.c:XXX: PCU_FAIL 504 | test_fail: 1,0x2, 3, 0004, 5, 0x00000006, +7, 8 ,-9, 10 505 | 506 | Test: test_message1 507 | FailTest.c:XXX: PCU_MESSAGE 508 | test_message 509 | 510 | Test: test_message2 511 | FailTest.c:XXX: PCU_MESSAGE 512 | test_message: 1,0x2, 3, 0004, 5, 0x00000006, +7, 8 ,-9, 10 513 | 514 | Test: test_message_fail 515 | FailTest.c:XXX: PCU_MESSAGE 516 | test_message 517 | FailTest.c:XXX: PCU_FAIL 518 | test_fail 519 | 520 | 5 Tests, 3 Failures, 0 Skipped 521 | 522 | 523 | Suite: InitializeTest 524 | 525 | INITIALIZE FAILED : -1 526 | 527 | 528 | Suite: SetupTest 529 | 530 | Test: test_assert_setup_err 531 | test_assert_setup_err: SETUP FAILED 532 | return : -1 533 | 534 | Test: test_assert_teardown_err 535 | test_assert_teardown_err: TEARDOWN FAILED 536 | return : -2 537 | 538 | Test: test_repeated 539 | SetupTest.c:XXX: PCU_ASSERT_EQUAL(-1, PCU_repeat_counter()) 540 | expected : 0xffffffffffffffff (-1) 541 | actual : 0x0000000000000000 (0) 542 | repeat : 0 543 | SetupTest.c:XXX: PCU_ASSERT_EQUAL(-1, PCU_repeat_counter()) 544 | expected : 0xffffffffffffffff (-1) 545 | actual : 0x0000000000000001 (1) 546 | repeat : 1 547 | SetupTest.c:XXX: PCU_ASSERT_EQUAL(-1, PCU_repeat_counter()) 548 | expected : 0xffffffffffffffff (-1) 549 | actual : 0x0000000000000002 (2) 550 | repeat : 2 551 | SetupTest.c:XXX: PCU_ASSERT_EQUAL(-1, PCU_repeat_counter()) 552 | expected : 0xffffffffffffffff (-1) 553 | actual : 0x0000000000000003 (3) 554 | repeat : 3 555 | SetupTest.c:XXX: PCU_ASSERT_EQUAL(-1, PCU_repeat_counter()) 556 | expected : 0xffffffffffffffff (-1) 557 | actual : 0x0000000000000004 (4) 558 | repeat : 4 559 | 560 | 4 Tests, 3 Failures, 1 Skipped 561 | 562 | -------------------------------------------------------------------------------- /test/assert_output_test/assert_not_supported_expected.txt: -------------------------------------------------------------------------------- 1 | 2 | Suite: AssertDoubleTest 3 | 4 | Test: test_assert_dbl_equal_OK 5 | AssertDoubleTest.c:XXX: PCU_ASSERT_DOUBLE_EQUAL(a, b, delta) 6 | NOT SUPPORTED 7 | 8 | Test: test_assert_dbl_equal_FAIL 9 | AssertDoubleTest.c:XXX: PCU_ASSERT_DOUBLE_EQUAL(a, b, delta) 10 | NOT SUPPORTED 11 | 12 | Test: test_assert_dbl_equal_MSG 13 | AssertDoubleTest.c:XXX: PCU_ASSERT_DOUBLE_EQUAL(a, b, delta) 14 | NOT SUPPORTED 15 | 100, 100.1 16 | 17 | Test: test_assert_dbl_not_equal_OK 18 | AssertDoubleTest.c:XXX: PCU_ASSERT_DOUBLE_NOT_EQUAL(a, b, delta) 19 | NOT SUPPORTED 20 | 21 | Test: test_assert_dbl_not_equal_FAIL 22 | AssertDoubleTest.c:XXX: PCU_ASSERT_DOUBLE_NOT_EQUAL(a, b, delta) 23 | NOT SUPPORTED 24 | 25 | Test: test_assert_dbl_not_equal_MSG 26 | AssertDoubleTest.c:XXX: PCU_ASSERT_DOUBLE_NOT_EQUAL(a, b, delta) 27 | NOT SUPPORTED 28 | 100, 100.1 29 | 30 | 6 Tests, 6 Failures, 0 Skipped 31 | 32 | 33 | Suite: AssertEqualTest 34 | 35 | Test: test_assert_equal_FAIL 36 | AssertEqualTest.c:XXX: PCU_ASSERT_EQUAL(a, b) 37 | expected : 0x00000064 (100) 'd' 38 | actual : 0x00000063 (99) 'c' 39 | 40 | Test: test_assert_equal_MSG 41 | AssertEqualTest.c:XXX: PCU_ASSERT_EQUAL(a, b) 42 | expected : 0x00000064 (100) 'd' 43 | actual : 0x00000065 (101) 'e' 44 | 100, 101 45 | 46 | Test: test_assert_equal_char_FAIL 47 | AssertEqualTest.c:XXX: PCU_ASSERT_EQUAL(a, b) 48 | expected : 0x0000000000000064 (100) 'd' 49 | actual : 0xffffffffffffffff (-1) 50 | 51 | Test: test_assert_equal_short_FAIL 52 | AssertEqualTest.c:XXX: PCU_ASSERT_EQUAL(a, b) 53 | expected : 0x0000000000000064 (100) 'd' 54 | actual : 0xffffffffffffffff (-1) 55 | 56 | Test: test_assert_equal_long_FAIL 57 | AssertEqualTest.c:XXX: PCU_ASSERT_EQUAL(a, b) 58 | expected : 0x0000000000000064 (100) 'd' 59 | actual : 0xffffffffffffffff (-1) 60 | 61 | Test: test_assert_equal_longlong_FAIL 62 | AssertEqualTest.c:XXX: PCU_ASSERT_EQUAL(a, b) 63 | expected : 0x0000000000000064 (100) 'd' 64 | actual : 0xffffffffffffffff (-1) 65 | 66 | Test: test_assert_not_equal_FAIL 67 | AssertEqualTest.c:XXX: PCU_ASSERT_NOT_EQUAL(a, b) 68 | value1 : 0x00000064 (100) 'd' 69 | value2 : 0x00000064 (100) 'd' 70 | 71 | Test: test_assert_not_equal_MSG 72 | AssertEqualTest.c:XXX: PCU_ASSERT_NOT_EQUAL(a, b) 73 | value1 : 0x00000064 (100) 'd' 74 | value2 : 0x00000064 (100) 'd' 75 | 100, 100 76 | 77 | 10 Tests, 8 Failures, 0 Skipped 78 | 79 | 80 | Suite: AssertMemoryTest 81 | 82 | Test: test_assert_mem_equal_FAIL 83 | AssertMemoryTest.c:XXX: PCU_ASSERT_MEMORY_EQUAL(&a[0], &b[0], sizeof a[0], 2) 84 | nth : 1 85 | expected : 03 00 00 00 04 00 00 00 (XXXXXXXX) 86 | actual : 03 00 00 00 05 00 00 00 (XXXXXXXX) 87 | size : 8 88 | 89 | Test: test_assert_mem_equal_MSG 90 | AssertMemoryTest.c:XXX: PCU_ASSERT_MEMORY_EQUAL(&a[0], &b[0], sizeof a[0], 2) 91 | nth : 1 92 | expected : 03 00 00 00 04 00 00 00 (XXXXXXXX) 93 | actual : 03 00 00 00 05 00 00 00 (XXXXXXXX) 94 | size : 8 95 | 3, 5 96 | 97 | Test: test_assert_mem_equal_FAIL_expect_null 98 | AssertMemoryTest.c:XXX: PCU_ASSERT_MEMORY_EQUAL(NULL, &b[0], sizeof a[0], 1) 99 | expected : NULL 100 | actual : 01 00 00 00 02 00 00 00 (XXXXXXXX) 101 | size : 8 102 | 103 | Test: test_assert_mem_equal_FAIL_actual_null 104 | AssertMemoryTest.c:XXX: PCU_ASSERT_MEMORY_EQUAL(&a[0], NULL, sizeof a[0], 1) 105 | expected : 01 00 00 00 02 00 00 00 (XXXXXXXX) 106 | actual : NULL 107 | size : 8 108 | 109 | Test: test_assert_mem_not_equal_FAIL 110 | AssertMemoryTest.c:XXX: PCU_ASSERT_MEMORY_NOT_EQUAL(&a[0], &b[0], sizeof a[0], 2) 111 | nth : 0 112 | value1 : 01 00 00 00 02 00 00 00 (XXXXXXXX) 113 | value2 : 01 00 00 00 02 00 00 00 (XXXXXXXX) 114 | size : 8 115 | 116 | Test: test_assert_mem_not_equal_MSG 117 | AssertMemoryTest.c:XXX: PCU_ASSERT_MEMORY_NOT_EQUAL(&a[0], &b[0], sizeof a[0], 1) 118 | value1 : 01 00 00 00 02 00 00 00 (XXXXXXXX) 119 | value2 : 01 00 00 00 02 00 00 00 (XXXXXXXX) 120 | size : 8 121 | 1, 2 122 | 123 | Test: test_assert_mem_not_equal_FAIL_null_null 124 | AssertMemoryTest.c:XXX: PCU_ASSERT_MEMORY_NOT_EQUAL(NULL, NULL, 1, 4) 125 | nth : 0 126 | value1 : NULL 127 | value2 : NULL 128 | size : 1 129 | 130 | 14 Tests, 7 Failures, 0 Skipped 131 | 132 | 133 | Suite: AssertOperatorTest 134 | 135 | Test: test_assert_operator_FAIL1 136 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR((-1) < (1)) 137 | value1 : 0xffffffffffffffff (-1) 138 | value2 : 0x0000000000000001 (1) 139 | 140 | Test: test_assert_operator_FAIL2 141 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR((a) ^ (b)) 142 | value1 : 0x00000100 (256) 143 | value2 : 0x00000100 (256) 144 | 145 | Test: test_assert_operator_FAIL3 146 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR((a) & (~b)) 147 | value1 : 0x00000100 (256) 148 | value2 : 0xfffffeff (4294967039) 149 | 150 | Test: test_assert_operator_FAIL4 151 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR((a) == (b)) 152 | value1 : 0x00000100 (256) 153 | value2 : 0x00000101 (257) 154 | 155 | Test: test_assert_operator_FAIL5 156 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR((0x10 <= a) && (a < 0x100)) 157 | value1 : 0x00000001 (1) 158 | value2 : 0x00000000 (0) 159 | 160 | Test: test_assert_operator_FAIL6 161 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR((a < 0x10) || (0x100 < a)) 162 | value1 : 0x00000000 (0) 163 | value2 : 0x00000000 (0) 164 | 165 | Test: test_assert_operator_MSG 166 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR((a) == (b)) 167 | value1 : 0x00000100 (256) 168 | value2 : 0x00000000 (0) 169 | 256, 0 170 | 171 | Test: test_assert_operator_int_FAIL1 172 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR_INT((-1) > (1)) 173 | value1 : 0xffffffffffffffff (-1) 174 | value2 : 0x0000000000000001 (1) 175 | 176 | Test: test_assert_operator_int_FAIL2 177 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR_INT((a) ^ (b)) 178 | value1 : 0x00000100 (256) 179 | value2 : 0x00000100 (256) 180 | 181 | Test: test_assert_operator_int_FAIL3 182 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR_INT((a) & (~b)) 183 | value1 : 0x0000000000000100 (256) 184 | value2 : 0xfffffffffffffeff (-257) 185 | 186 | Test: test_assert_operator_int_FAIL4 187 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR_INT((a) == (b)) 188 | value1 : 0x00000100 (256) 189 | value2 : 0x00000101 (257) 190 | 191 | Test: test_assert_operator_int_FAIL5 192 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR_INT((0x10 <= a) && (a < 0x100)) 193 | value1 : 0x00000001 (1) 194 | value2 : 0x00000000 (0) 195 | 196 | Test: test_assert_operator_int_FAIL6 197 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR_INT((a < 0x10) || (0x100 < a)) 198 | value1 : 0x00000000 (0) 199 | value2 : 0x00000000 (0) 200 | 201 | Test: test_assert_operator_int_MSG 202 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR_INT((a) == (b)) 203 | value1 : 0x00000100 (256) 204 | value2 : 0x00000000 (0) 205 | 256, 0 206 | 207 | Test: test_assert_operator_dbl_FAIL1 208 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR_DOUBLE((0) > (1)) 209 | NOT SUPPORTED 210 | 211 | Test: test_assert_operator_dbl_FAIL2 212 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR_DOUBLE((a) < (b)) 213 | NOT SUPPORTED 214 | 215 | Test: test_assert_operator_dbl_FAIL3 216 | AssertOperatorTest.c:XXX: PCU_ASSERT_OPERATOR_DOUBLE((a) == (b)) 217 | NOT SUPPORTED 218 | 219 | 20 Tests, 17 Failures, 0 Skipped 220 | 221 | 222 | Suite: AssertPtrTest 223 | 224 | Test: test_assert_ptr_equal_FAIL 225 | AssertPtrTest.c:XXX: PCU_ASSERT_PTR_EQUAL(&a, &b) 226 | expected : 0xXXXXXXXX 227 | actual : 0xXXXXXXXX 228 | 229 | Test: test_assert_ptr_equal_MSG 230 | AssertPtrTest.c:XXX: PCU_ASSERT_PTR_EQUAL(&a, &b) 231 | expected : 0xXXXXXXXX 232 | actual : 0xXXXXXXXX 233 | 0xXXXXXXXX, 0xXXXXXXXX 234 | 235 | Test: test_assert_ptr_not_equal_FAIL 236 | AssertPtrTest.c:XXX: PCU_ASSERT_PTR_NOT_EQUAL(&a, &a) 237 | value1 : 0xXXXXXXXX 238 | value2 : 0xXXXXXXXX 239 | 240 | Test: test_assert_ptr_not_equal_MSG 241 | AssertPtrTest.c:XXX: PCU_ASSERT_PTR_NOT_EQUAL(&a, &a) 242 | value1 : 0xXXXXXXXX 243 | value2 : 0xXXXXXXXX 244 | 0xXXXXXXXX, 0xXXXXXXXX 245 | 246 | Test: test_assert_ptr_null_FAIL 247 | AssertPtrTest.c:XXX: PCU_ASSERT_PTR_NULL(p) 248 | expected : NULL 249 | actual : 0xXXXXXXXX 250 | 251 | Test: test_assert_ptr_null_MSG 252 | AssertPtrTest.c:XXX: PCU_ASSERT_PTR_NULL(p) 253 | expected : NULL 254 | actual : 0xXXXXXXXX 255 | 0xXXXXXXXX 256 | 257 | Test: test_assert_ptr_not_null_FAIL 258 | AssertPtrTest.c:XXX: PCU_ASSERT_PTR_NOT_NULL(p) 259 | expected : non-NULL 260 | actual : NULL 261 | 262 | Test: test_assert_ptr_not_null_MSG 263 | AssertPtrTest.c:XXX: PCU_ASSERT_PTR_NOT_NULL(p) 264 | expected : non-NULL 265 | actual : NULL 266 | 0x0 267 | 268 | 12 Tests, 8 Failures, 0 Skipped 269 | 270 | 271 | Suite: AssertStringTest 272 | 273 | Test: test_assert_str_equal_FAIL 274 | AssertStringTest.c:XXX: PCU_ASSERT_STRING_EQUAL(a, b) 275 | expected : "hoge" (0xXXXXXXXX) 276 | actual : "piyo" (0xXXXXXXXX) 277 | 278 | Test: test_assert_str_equal_MSG 279 | AssertStringTest.c:XXX: PCU_ASSERT_STRING_EQUAL(a, b) 280 | expected : "hoge" (0xXXXXXXXX) 281 | actual : "piyo" (0xXXXXXXXX) 282 | hoge, piyo 283 | 284 | Test: test_assert_str_equal_FAIL_expect_null 285 | AssertStringTest.c:XXX: PCU_ASSERT_STRING_EQUAL(NULL, a) 286 | expected : NULL 287 | actual : "hoge" (0xXXXXXXXX) 288 | 289 | Test: test_assert_str_equal_FAIL_actual_null 290 | AssertStringTest.c:XXX: PCU_ASSERT_STRING_EQUAL(a, NULL) 291 | expected : "hoge" (0xXXXXXXXX) 292 | actual : NULL 293 | 294 | Test: test_assert_str_not_equal_FAIL 295 | AssertStringTest.c:XXX: PCU_ASSERT_STRING_NOT_EQUAL(a, b) 296 | value1 : "hoge" (0xXXXXXXXX) 297 | value2 : "hoge" (0xXXXXXXXX) 298 | 299 | Test: test_assert_str_not_equal_MSG 300 | AssertStringTest.c:XXX: PCU_ASSERT_STRING_NOT_EQUAL(a, b) 301 | value1 : "hoge" (0xXXXXXXXX) 302 | value2 : "hoge" (0xXXXXXXXX) 303 | hoge, hoge 304 | 305 | Test: test_assert_str_not_equal_FAIL_null_null 306 | AssertStringTest.c:XXX: PCU_ASSERT_STRING_NOT_EQUAL(NULL, NULL) 307 | value1 : NULL 308 | value2 : NULL 309 | 310 | Test: test_assert_nstr_equal_FAIL 311 | AssertStringTest.c:XXX: PCU_ASSERT_NSTRING_EQUAL(a, b, 4) 312 | expected : "hogu" (0xXXXXXXXX) 313 | actual : "hoge" (0xXXXXXXXX) 314 | length : 4 315 | 316 | Test: test_assert_nstr_equal_MSG 317 | AssertStringTest.c:XXX: PCU_ASSERT_NSTRING_EQUAL(a, b, 4) 318 | expected : "hogu" (0xXXXXXXXX) 319 | actual : "hoge" (0xXXXXXXXX) 320 | length : 4 321 | hogu, hogehoge 322 | 323 | Test: test_assert_nstr_equal_FAIL_expect_null 324 | AssertStringTest.c:XXX: PCU_ASSERT_NSTRING_EQUAL(NULL, a, 1) 325 | expected : NULL 326 | actual : "h" (0xXXXXXXXX) 327 | length : 1 328 | 329 | Test: test_assert_nstr_equal_FAIL_actual_null 330 | AssertStringTest.c:XXX: PCU_ASSERT_NSTRING_EQUAL(a, NULL, 1) 331 | expected : "h" (0xXXXXXXXX) 332 | actual : NULL 333 | length : 1 334 | 335 | Test: test_assert_nstr_not_equal_FAIL 336 | AssertStringTest.c:XXX: PCU_ASSERT_NSTRING_NOT_EQUAL(a, b, 4) 337 | value1 : "hoge" (0xXXXXXXXX) 338 | value2 : "hoge" (0xXXXXXXXX) 339 | length : 4 340 | 341 | Test: test_assert_nstr_not_equal_MSG 342 | AssertStringTest.c:XXX: PCU_ASSERT_NSTRING_NOT_EQUAL(a, b, 3) 343 | value1 : "hog" (0xXXXXXXXX) 344 | value2 : "hog" (0xXXXXXXXX) 345 | length : 3 346 | hogu, hogehoge 347 | 348 | Test: test_assert_nstr_not_equal_FAIL_null_null 349 | AssertStringTest.c:XXX: PCU_ASSERT_NSTRING_NOT_EQUAL(NULL, NULL, 1) 350 | value1 : NULL 351 | value2 : NULL 352 | length : 1 353 | 354 | 24 Tests, 14 Failures, 0 Skipped 355 | 356 | 357 | Suite: AssertStringWTest 358 | 359 | Test: test_assert_strw_equal_OK 360 | AssertStringWTest.c:XXX: PCU_ASSERT_STRINGW_EQUAL(L"hoge", a) 361 | NOT SUPPORTED 362 | 363 | Test: test_assert_strw_equal_FAIL 364 | AssertStringWTest.c:XXX: PCU_ASSERT_STRINGW_EQUAL(a, b) 365 | NOT SUPPORTED 366 | 367 | Test: test_assert_strw_equal_MSG 368 | AssertStringWTest.c:XXX: PCU_ASSERT_STRINGW_EQUAL(a, b) 369 | NOT SUPPORTED 370 | 371 | 372 | Test: test_assert_strw_equal_FAIL_expect_null 373 | AssertStringWTest.c:XXX: PCU_ASSERT_STRINGW_EQUAL(NULL, a) 374 | NOT SUPPORTED 375 | 376 | Test: test_assert_strw_equal_FAIL_actual_null 377 | AssertStringWTest.c:XXX: PCU_ASSERT_STRINGW_EQUAL(a, NULL) 378 | NOT SUPPORTED 379 | 380 | Test: test_assert_strw_equal_OK_null_null 381 | AssertStringWTest.c:XXX: PCU_ASSERT_STRINGW_EQUAL(NULL, NULL) 382 | NOT SUPPORTED 383 | 384 | Test: test_assert_strw_not_equal_OK 385 | AssertStringWTest.c:XXX: PCU_ASSERT_STRINGW_NOT_EQUAL(a, b) 386 | NOT SUPPORTED 387 | 388 | Test: test_assert_strw_not_equal_FAIL 389 | AssertStringWTest.c:XXX: PCU_ASSERT_STRINGW_NOT_EQUAL(a, b) 390 | NOT SUPPORTED 391 | 392 | Test: test_assert_strw_not_equal_MSG 393 | AssertStringWTest.c:XXX: PCU_ASSERT_STRINGW_NOT_EQUAL(a, b) 394 | NOT SUPPORTED 395 | 396 | 397 | Test: test_assert_strw_not_equal_OK_expect_null 398 | AssertStringWTest.c:XXX: PCU_ASSERT_STRINGW_NOT_EQUAL(NULL, a) 399 | NOT SUPPORTED 400 | 401 | Test: test_assert_strw_not_equal_OK_actual_null 402 | AssertStringWTest.c:XXX: PCU_ASSERT_STRINGW_NOT_EQUAL(a, NULL) 403 | NOT SUPPORTED 404 | 405 | Test: test_assert_strw_not_equal_FAIL_null_null 406 | AssertStringWTest.c:XXX: PCU_ASSERT_STRINGW_NOT_EQUAL(NULL, NULL) 407 | NOT SUPPORTED 408 | 409 | Test: test_assert_nstrw_equal_OK 410 | AssertStringWTest.c:XXX: PCU_ASSERT_NSTRINGW_EQUAL(L"hoge", a, 4) 411 | NOT SUPPORTED 412 | 413 | Test: test_assert_nstrw_equal_FAIL 414 | AssertStringWTest.c:XXX: PCU_ASSERT_NSTRINGW_EQUAL(a, b, 4) 415 | NOT SUPPORTED 416 | 417 | Test: test_assert_nstrw_equal_MSG 418 | AssertStringWTest.c:XXX: PCU_ASSERT_NSTRINGW_EQUAL(a, b, 3) 419 | NOT SUPPORTED 420 | 421 | 422 | Test: test_assert_nstrw_equal_FAIL_expect_null 423 | AssertStringWTest.c:XXX: PCU_ASSERT_NSTRINGW_EQUAL(NULL, a, 1) 424 | NOT SUPPORTED 425 | 426 | Test: test_assert_nstrw_equal_FAIL_actual_null 427 | AssertStringWTest.c:XXX: PCU_ASSERT_NSTRINGW_EQUAL(a, NULL, 1) 428 | NOT SUPPORTED 429 | 430 | Test: test_assert_nstrw_equal_OK_null_null 431 | AssertStringWTest.c:XXX: PCU_ASSERT_NSTRINGW_EQUAL(NULL, NULL, 1) 432 | NOT SUPPORTED 433 | 434 | Test: test_assert_nstrw_not_equal_OK 435 | AssertStringWTest.c:XXX: PCU_ASSERT_NSTRINGW_NOT_EQUAL(L"hoge", a, 4) 436 | NOT SUPPORTED 437 | 438 | Test: test_assert_nstrw_not_equal_FAIL 439 | AssertStringWTest.c:XXX: PCU_ASSERT_NSTRINGW_NOT_EQUAL(a, b, 4) 440 | NOT SUPPORTED 441 | 442 | Test: test_assert_nstrw_not_equal_MSG 443 | AssertStringWTest.c:XXX: PCU_ASSERT_NSTRINGW_NOT_EQUAL(a, b, 4) 444 | NOT SUPPORTED 445 | 446 | 447 | Test: test_assert_nstrw_not_equal_OK_expect_null 448 | AssertStringWTest.c:XXX: PCU_ASSERT_NSTRINGW_NOT_EQUAL(NULL, a, 1) 449 | NOT SUPPORTED 450 | 451 | Test: test_assert_nstrw_not_equal_OK_actual_null 452 | AssertStringWTest.c:XXX: PCU_ASSERT_NSTRINGW_NOT_EQUAL(a, NULL, 1) 453 | NOT SUPPORTED 454 | 455 | Test: test_assert_nstrw_not_equal_FAIL_null_null 456 | AssertStringWTest.c:XXX: PCU_ASSERT_NSTRINGW_NOT_EQUAL(NULL, NULL, 1) 457 | NOT SUPPORTED 458 | 459 | 24 Tests, 24 Failures, 0 Skipped 460 | 461 | 462 | Suite: AssertTest 463 | 464 | Test: test_assert_FAIL 465 | AssertTest.c:XXX: PCU_ASSERT(0) 466 | expected : TRUE 467 | actual : FALSE (0) 468 | 469 | Test: test_assert_MSG 470 | AssertTest.c:XXX: PCU_ASSERT(a) 471 | expected : TRUE 472 | actual : FALSE (0) 473 | 0 474 | 475 | Test: test_assert_true_FAIL 476 | AssertTest.c:XXX: PCU_ASSERT_TRUE(a) 477 | expected : TRUE 478 | actual : FALSE (0) 479 | 480 | Test: test_assert_true_MSG 481 | AssertTest.c:XXX: PCU_ASSERT_TRUE(a) 482 | expected : TRUE 483 | actual : FALSE (0) 484 | 0 485 | 486 | Test: test_assert_false_FAIL 487 | AssertTest.c:XXX: PCU_ASSERT_FALSE(a) 488 | expected : FALSE 489 | actual : TRUE (1) 490 | 491 | Test: test_assert_false_MSG 492 | AssertTest.c:XXX: PCU_ASSERT_FALSE(a) 493 | expected : FALSE 494 | actual : TRUE (1) 495 | 1 496 | 497 | 9 Tests, 6 Failures, 0 Skipped 498 | 499 | 500 | Suite: CleanupTest 501 | 502 | 1 Tests, 0 Failures, 0 Skipped 503 | OK 504 | 505 | CLEANUP FAILED : -1 506 | 507 | 508 | Suite: FailTest 509 | 510 | Test: test_fail1 511 | FailTest.c:XXX: PCU_FAIL 512 | test_fail 513 | 514 | Test: test_fail2 515 | FailTest.c:XXX: PCU_FAIL 516 | test_fail: 1,0x2, 3, 0004, 5, 0x00000006, +7, 8 ,-9, 10 517 | 518 | Test: test_message1 519 | FailTest.c:XXX: PCU_MESSAGE 520 | test_message 521 | 522 | Test: test_message2 523 | FailTest.c:XXX: PCU_MESSAGE 524 | test_message: 1,0x2, 3, 0004, 5, 0x00000006, +7, 8 ,-9, 10 525 | 526 | Test: test_message_fail 527 | FailTest.c:XXX: PCU_MESSAGE 528 | test_message 529 | FailTest.c:XXX: PCU_FAIL 530 | test_fail 531 | 532 | 5 Tests, 3 Failures, 0 Skipped 533 | 534 | 535 | Suite: InitializeTest 536 | 537 | INITIALIZE FAILED : -1 538 | 539 | 540 | Suite: SetupTest 541 | 542 | Test: test_assert_setup_err 543 | test_assert_setup_err: SETUP FAILED 544 | return : -1 545 | 546 | Test: test_assert_teardown_err 547 | test_assert_teardown_err: TEARDOWN FAILED 548 | return : -2 549 | 550 | Test: test_repeated 551 | SetupTest.c:XXX: PCU_ASSERT_EQUAL(-1, PCU_repeat_counter()) 552 | expected : 0xffffffffffffffff (-1) 553 | actual : 0x0000000000000000 (0) 554 | repeat : 0 555 | SetupTest.c:XXX: PCU_ASSERT_EQUAL(-1, PCU_repeat_counter()) 556 | expected : 0xffffffffffffffff (-1) 557 | actual : 0x0000000000000001 (1) 558 | repeat : 1 559 | SetupTest.c:XXX: PCU_ASSERT_EQUAL(-1, PCU_repeat_counter()) 560 | expected : 0xffffffffffffffff (-1) 561 | actual : 0x0000000000000002 (2) 562 | repeat : 2 563 | SetupTest.c:XXX: PCU_ASSERT_EQUAL(-1, PCU_repeat_counter()) 564 | expected : 0xffffffffffffffff (-1) 565 | actual : 0x0000000000000003 (3) 566 | repeat : 3 567 | SetupTest.c:XXX: PCU_ASSERT_EQUAL(-1, PCU_repeat_counter()) 568 | expected : 0xffffffffffffffff (-1) 569 | actual : 0x0000000000000004 (4) 570 | repeat : 4 571 | 572 | 4 Tests, 3 Failures, 1 Skipped 573 | 574 | -------------------------------------------------------------------------------- /PCUnit/PCU_Test.c: -------------------------------------------------------------------------------- 1 | #ifdef _WIN32 2 | #define _CRT_SECURE_NO_WARNINGS 3 | #endif 4 | 5 | #include "PCU_Suite.h" 6 | #include "PCU_Test.h" 7 | #include "PCU_Libc.h" 8 | 9 | static PCU_Test *current_test; 10 | static int repeat_counter; 11 | static PCU_jmp_buf fatal_jmp; 12 | static int last_assertion; 13 | static int leave_is_enabled; 14 | static int is_verbose; 15 | static int assert_not_flag; 16 | static struct { 17 | size_t n; 18 | } assert_nstr; 19 | static struct { 20 | size_t size; 21 | size_t n; 22 | size_t idx; 23 | } assert_mem; 24 | 25 | static void print_test_name(void); 26 | static void print_result(const char *str); 27 | static void print_file_line_assert(enum PCU_Type type, const char *str_assert, const char *file, unsigned int line); 28 | static void print_repeat(enum PCU_Type type, int repeat); 29 | static void print_params(enum PCU_Type type, PCU_size_t expected, PCU_size_t actual); 30 | static void print_params_double(enum PCU_Type type, double expected, double actual, double delta); 31 | 32 | static void PCU_Test_clear_result(PCU_Test *self) 33 | { 34 | PCU_MEMSET(&self->result, 0, sizeof(self->result)); 35 | } 36 | 37 | void PCU_Test_reset(PCU_Test *self) 38 | { 39 | PCU_Test_clear_result(self); 40 | } 41 | 42 | void PCU_Test_run(PCU_Test *self) 43 | { 44 | volatile int repeat; 45 | current_test = self; 46 | 47 | if (is_verbose) { 48 | print_test_name(); 49 | } 50 | repeat = (self->ntimes != 0) ? self->ntimes : 1; 51 | for (repeat_counter = 0; repeat_counter < repeat; repeat_counter++) { 52 | int err; 53 | leave_is_enabled = 0; 54 | err = PCU_Suite_setup(); 55 | if (err) { 56 | self->result.num_errors++; 57 | print_file_line_assert(PCU_TYPE_SETUP, "SETUP FAILED", "", (unsigned int) -1); 58 | print_params(PCU_TYPE_SETUP, 0, (PCU_size_t) err); 59 | print_repeat(PCU_TYPE_SETUP, repeat_counter); 60 | continue; 61 | } 62 | leave_is_enabled = 1; 63 | if (PCU_SETJMP(fatal_jmp) == 0) { 64 | self->test(); 65 | } 66 | leave_is_enabled = 0; 67 | err = PCU_Suite_teardown(); 68 | if (err) { 69 | self->result.num_errors++; 70 | print_file_line_assert(PCU_TYPE_SETUP, "TEARDOWN FAILED", "", (unsigned int) -1); 71 | print_params(PCU_TYPE_SETUP, 0, (PCU_size_t) err); 72 | print_repeat(PCU_TYPE_SETUP, repeat_counter); 73 | continue; 74 | } 75 | } 76 | if (is_verbose) { 77 | if (repeat < 0) { 78 | print_result("SKIPPED"); 79 | } else if (PCU_Test_is_failed(self)) { 80 | print_result("FAILED"); 81 | } else { 82 | print_result("PASSED"); 83 | } 84 | } 85 | } 86 | 87 | int PCU_Test_is_skipped(const PCU_Test *self) 88 | { 89 | return (self->ntimes < 0); 90 | } 91 | 92 | int PCU_Test_is_failed(const PCU_Test *self) 93 | { 94 | return (self->result.num_asserts_failed > 0 || self->result.num_errors > 0); 95 | } 96 | 97 | int PCU_test_has_failed(void) 98 | { 99 | return PCU_Test_is_failed(current_test); 100 | } 101 | 102 | void PCU_leave_test_func(void) 103 | { 104 | PCU_LONGJMP(fatal_jmp, 1); 105 | } 106 | 107 | void PCU_assert_impl(int passed_flag, PCU_size_t expected, PCU_size_t actual, 108 | enum PCU_Type type, const char *str_assert, const char *file, unsigned int line) 109 | { 110 | if (passed_flag) { 111 | last_assertion = 1; 112 | return; 113 | } 114 | 115 | last_assertion = 0; 116 | current_test->result.num_asserts_failed++; 117 | 118 | print_file_line_assert(type, str_assert, file, line); 119 | print_params(type, expected, actual); 120 | print_repeat(type, repeat_counter); 121 | } 122 | 123 | void PCU_assert_num_impl(PCU_size_t expected, PCU_size_t actual, 124 | enum PCU_Type type, int not_flag, const char *str_assert, const char *file, unsigned int line) 125 | { 126 | assert_not_flag = not_flag; 127 | PCU_assert_impl(not_flag ? (expected != actual) : (expected == actual), 128 | expected, actual, type, str_assert, file, line); 129 | } 130 | 131 | void PCU_assert_str_impl(const void *expected, const void *actual, size_t n, 132 | enum PCU_Type type, int not_flag, const char *str_assert, const char *file, unsigned int line) 133 | { 134 | int cmp = 0; 135 | assert_not_flag = not_flag; 136 | assert_nstr.n = n; 137 | if (expected == 0 || actual == 0) { 138 | cmp = (expected != actual); 139 | } else if (type == PCU_TYPE_STR) { 140 | cmp = PCU_STRCMP((const char *) expected, (const char *) actual); 141 | } else if (type == PCU_TYPE_NSTR) { 142 | cmp = PCU_STRNCMP((const char *) expected, (const char *) actual, n); 143 | } 144 | #ifdef PCU_USE_WCHAR 145 | else if (type == PCU_TYPE_STRW) { 146 | cmp = PCU_WCSCMP((const wchar_t *) expected, (const wchar_t *) actual); 147 | } else { 148 | cmp = PCU_WCSNCMP((const wchar_t *) expected, (const wchar_t *) actual, n); 149 | } 150 | #else 151 | if (type == PCU_TYPE_STRW || type == PCU_TYPE_NSTRW) { 152 | cmp = !not_flag; 153 | } 154 | #endif 155 | PCU_assert_impl(not_flag ? (cmp != 0) : (cmp == 0), 156 | (PCU_size_t)(size_t) expected, (PCU_size_t)(size_t) actual, type, str_assert, file, line); 157 | } 158 | 159 | static size_t mem_compare(const void *m1, const void *m2, size_t size, size_t n) 160 | { 161 | const unsigned char *p1 = (const unsigned char *) m1; 162 | const unsigned char *p2 = (const unsigned char *) m2; 163 | size_t len = size * n; 164 | size_t s = size; 165 | size_t idx = 0; 166 | if (len) { 167 | do { 168 | if (*p1 != *p2) { 169 | return idx; 170 | } 171 | p1++; 172 | p2++; 173 | len--; 174 | s--; 175 | if (s == 0) { 176 | idx++; 177 | s = size; 178 | } 179 | } while (len); 180 | } 181 | return (size_t) -1; 182 | } 183 | 184 | void PCU_assert_mem_impl(const void *expected, const void *actual, size_t size, size_t n, 185 | enum PCU_Type type, int not_flag, const char *str_assert, const char *file, unsigned int line) 186 | { 187 | int cmp; 188 | assert_not_flag = not_flag; 189 | assert_mem.size = size; 190 | assert_mem.n = n; 191 | assert_mem.idx = 0; 192 | if (expected == 0 || actual == 0) { 193 | cmp = (expected != actual); 194 | } else { 195 | size_t idx; 196 | idx = mem_compare(expected, actual, size, n); 197 | if (idx == (size_t) -1) { 198 | cmp = 0; 199 | } else { 200 | cmp = 1; 201 | assert_mem.idx = idx; 202 | } 203 | } 204 | PCU_assert_impl(not_flag ? (cmp != 0) : (cmp == 0), 205 | (PCU_size_t)(size_t) expected, (PCU_size_t)(size_t) actual, type, str_assert, file, line); 206 | } 207 | 208 | void PCU_assert_double_impl(double expected, double actual, double delta, 209 | enum PCU_Type type, int not_flag, const char *str_assert, const char *file, unsigned int line) 210 | { 211 | #ifndef PCU_NO_FLOATINGPOINT 212 | double dlt = delta; 213 | assert_not_flag = not_flag; 214 | if (dlt < 0) { 215 | dlt = -dlt; 216 | } 217 | 218 | if (expected == actual) { 219 | if (!not_flag) { 220 | last_assertion = 1; 221 | return; 222 | } 223 | } else { 224 | double d = (expected < actual) ? actual - expected : expected - actual; 225 | if (!not_flag && d <= dlt) { 226 | last_assertion = 1; 227 | return; 228 | } else if (not_flag && d > dlt) { 229 | last_assertion = 1; 230 | return; 231 | } 232 | } 233 | #else 234 | (void) not_flag; 235 | #endif 236 | 237 | last_assertion = 0; 238 | current_test->result.num_asserts_failed++; 239 | 240 | print_file_line_assert(type, str_assert, file, line); 241 | print_params_double(type, expected, actual, delta); 242 | print_repeat(type, repeat_counter); 243 | } 244 | 245 | void PCU_assert_op_double_impl(int passed_flag, double expected, double actual, 246 | enum PCU_Type type, const char *str_assert, const char *file, unsigned int line) 247 | { 248 | if (passed_flag) { 249 | last_assertion = 1; 250 | return; 251 | } 252 | 253 | last_assertion = 0; 254 | current_test->result.num_asserts_failed++; 255 | 256 | print_file_line_assert(type, str_assert, file, line); 257 | print_params_double(type, expected, actual, 0.0); 258 | print_repeat(type, repeat_counter); 259 | } 260 | 261 | void PCU_msg_impl(const char *msg, 262 | enum PCU_Type type, const char *str_assert, const char *file, unsigned int line) 263 | { 264 | current_test->result.num_msgs++; 265 | print_file_line_assert(type, str_assert, file, line); 266 | print_params(type, (PCU_size_t)(size_t) msg, 0); 267 | print_repeat(type, repeat_counter); 268 | } 269 | 270 | int PCU_repeat_counter(void) 271 | { 272 | return repeat_counter; 273 | } 274 | 275 | const char *PCU_test_name(void) 276 | { 277 | return current_test->name; 278 | } 279 | 280 | int PCU_last_assertion(void) 281 | { 282 | return last_assertion; 283 | } 284 | 285 | int PCU_leave_is_enabled(void) 286 | { 287 | return leave_is_enabled; 288 | } 289 | 290 | void PCU_set_verbose(int verbose_flag) 291 | { 292 | is_verbose = verbose_flag; 293 | } 294 | 295 | static int is_first_print(const PCU_Test *self) 296 | { 297 | if (self->result.num_asserts_failed == 1 && self->result.num_msgs == 0 && 298 | self->result.num_errors == 0) { 299 | return 1; 300 | } else if (self->result.num_asserts_failed == 0 && self->result.num_msgs == 1 && 301 | self->result.num_errors == 0) { 302 | return 1; 303 | } else if (self->result.num_asserts_failed == 0 && self->result.num_msgs == 0 && 304 | self->result.num_errors == 1) { 305 | return 1; 306 | } 307 | return 0; 308 | } 309 | 310 | static void print_test_name(void) 311 | { 312 | PCU_puts("\nTest: "); 313 | PCU_puts(PCU_test_name()); 314 | PCU_puts("\n"); 315 | } 316 | 317 | static void print_result(const char *str) 318 | { 319 | PCU_puts(" ["); 320 | PCU_puts(str); 321 | PCU_puts("]\n"); 322 | } 323 | 324 | static void print_file_line_assert(enum PCU_Type type, const char *str_assert, const char *file, unsigned int line) 325 | { 326 | if (!is_verbose && is_first_print(current_test)) { 327 | print_test_name(); 328 | } 329 | 330 | if (type == PCU_TYPE_SETUP) { 331 | PCU_puts(" "); 332 | PCU_puts(PCU_test_name()); 333 | PCU_puts(": "); 334 | PCU_puts(str_assert); 335 | PCU_puts("\n"); 336 | } else if (type != PCU_TYPE_ADDMSG) { 337 | PCU_puts(" "); 338 | PCU_puts(file); 339 | #ifdef _MSC_VER 340 | PCU_PRINTF1("(%u) : ", line); 341 | #else 342 | PCU_PRINTF1(":%u: ", line); 343 | #endif 344 | PCU_puts(str_assert); 345 | PCU_puts("\n"); 346 | } 347 | } 348 | 349 | static int is_repeated_test(const PCU_Test *self) 350 | { 351 | return (self->ntimes > 1); 352 | } 353 | 354 | static void print_repeat(enum PCU_Type type, int repeat) 355 | { 356 | if (is_repeated_test(current_test) && type != PCU_TYPE_ADDMSG) { 357 | PCU_PRINTF1(" repeat : %d\n", repeat); 358 | } 359 | } 360 | 361 | #define IS_ASCII(c) (' ' == 0x20 && 0x20 <= (c) && (c) <= 0x7e) 362 | 363 | #ifdef PCU_DEFINED_LLONG 364 | #define PCU_LX_LD " : 0x%0*llx (%lld)" 365 | #define PCU_LD " (%lld)" 366 | #define PCU_LD_LU " (signed:%lld unsigned:%llu)" 367 | #elif defined(PCU_DEFINED_WIN32_I64) 368 | #define PCU_LX_LD " : 0x%0*I64x (%I64d)" 369 | #define PCU_LD " (%I64d)" 370 | #define PCU_LD_LU " (signed:%I64d unsigned:%I64u)" 371 | #else 372 | #define PCU_LX_LD " : 0x%0*lx (%ld)" 373 | #define PCU_LD " (%ld)" 374 | #define PCU_LD_LU " (signed:%ld unsigned:%lu)" 375 | #endif 376 | 377 | static void print_type_num(const char *str, PCU_size_t value, int is_64bit_width) 378 | { 379 | const int width = (int) ((is_64bit_width ? sizeof(PCU_size_t) : sizeof(size_t)) * 2); 380 | PCU_puts(" "); 381 | PCU_puts(str); 382 | PCU_PRINTF3(PCU_LX_LD, width, value, value); 383 | if (IS_ASCII(value)) { 384 | PCU_PRINTF1(" '%c'\n", (int) value); 385 | } else { 386 | PCU_puts("\n"); 387 | } 388 | } 389 | 390 | #if (defined(PCU_NO_VSPRINTF) || defined(PCU_NO_LIBC)) && defined(PCU_NO_DIV32) 391 | static void print_type_num_no_div32(const char *str, PCU_size_t value) 392 | { 393 | PCU_puts(" "); 394 | PCU_puts(str); 395 | PCU_PRINTF2(" : 0x%0*x\n", sizeof(size_t) * 2, value); 396 | } 397 | 398 | static void print_expected_actual_no_div32(const char *expected_str, const char *actual_str, 399 | PCU_size_t expected, PCU_size_t actual) 400 | { 401 | if (expected > 0xFFFF || actual > 0xFFFF) { 402 | print_type_num_no_div32(expected_str, expected); 403 | print_type_num_no_div32(actual_str , actual); 404 | } else { 405 | print_type_num(expected_str, expected, 0); 406 | print_type_num(actual_str , actual , 0); 407 | } 408 | } 409 | 410 | #else 411 | static void print_expected_actual(const char *expected_str, const char *actual_str, 412 | PCU_size_t expected, PCU_size_t actual) 413 | { 414 | int is_64bit_width = (expected > (PCU_size_t) 0xFFFFFFFF || 415 | actual > (PCU_size_t) 0xFFFFFFFF); 416 | print_type_num(expected_str, expected, is_64bit_width); 417 | print_type_num(actual_str , actual , is_64bit_width); 418 | } 419 | 420 | #endif 421 | 422 | static void print_null(const char *str) 423 | { 424 | PCU_puts(" "); 425 | PCU_puts(str); 426 | PCU_puts(" : NULL\n"); 427 | } 428 | 429 | static void print_p(const void *value) 430 | { 431 | #ifdef PCU_NO_STDARG 432 | PCU_PRINTF1("%p", (size_t) value); 433 | #else 434 | PCU_PRINTF1("%p", value); 435 | #endif 436 | } 437 | 438 | static void print_type_ptr(const char *str, const void *value) 439 | { 440 | if (value) { 441 | PCU_puts(" "); 442 | PCU_puts(str); 443 | PCU_puts(" : "); 444 | print_p(value); 445 | PCU_puts("\n"); 446 | } else { 447 | print_null(str); 448 | } 449 | } 450 | 451 | static void print_type_str(const char *str, const char *value) 452 | { 453 | if (value) { 454 | PCU_puts(" "); 455 | PCU_puts(str); 456 | PCU_puts(" : \""); 457 | PCU_puts(value); 458 | PCU_puts("\" ("); 459 | print_p(value); 460 | PCU_puts(")\n"); 461 | } else { 462 | print_null(str); 463 | } 464 | } 465 | 466 | static void print_type_nstr(const char *str, const char *value, size_t len) 467 | { 468 | if (value) { 469 | size_t i; 470 | PCU_puts(" "); 471 | PCU_puts(str); 472 | PCU_puts(" : \""); 473 | for (i = 0; i < len; i++) { 474 | PCU_PRINTF1("%c", value[i]); 475 | } 476 | PCU_puts("\" ("); 477 | print_p(value); 478 | PCU_puts(")\n"); 479 | } else { 480 | print_null(str); 481 | } 482 | } 483 | 484 | #ifdef PCU_USE_WCHAR 485 | static void print_type_nstrw(const char *str, const wchar_t *value, size_t len) 486 | { 487 | if (value) { 488 | size_t i; 489 | PCU_puts(" "); 490 | PCU_puts(str); 491 | PCU_puts(" : L\""); 492 | for (i = 0; i < len; i++) { 493 | PCU_PRINTF1("%lc", value[i]); 494 | } 495 | PCU_puts("\" ("); 496 | print_p(value); 497 | PCU_puts(")\n"); 498 | } else { 499 | print_null(str); 500 | } 501 | } 502 | 503 | #endif 504 | 505 | #if !defined(PCU_USE_WCHAR) || defined(PCU_NO_FLOATINGPOINT) 506 | static void print_not_supported(void) 507 | { 508 | PCU_puts(" NOT SUPPORTED\n"); 509 | } 510 | #endif 511 | 512 | static void print_hex(const void *buf, size_t size) 513 | { 514 | size_t i; 515 | const unsigned char *p = (const unsigned char *) buf; 516 | for (i = 0; i < size; i++, p++) { 517 | PCU_PRINTF1("%02x ", *p); 518 | } 519 | } 520 | 521 | static void print_type_mem(const char *str, const unsigned char *value, size_t size, size_t idx) 522 | { 523 | if (value) { 524 | const void *p = value + size * idx; 525 | PCU_puts(" "); 526 | PCU_puts(str); 527 | PCU_puts(" : "); 528 | print_hex(p, size); 529 | do { 530 | PCU_ssize_t s_val; 531 | PCU_size_t u_val; 532 | if (size == sizeof(char)) { 533 | s_val = (PCU_ssize_t) *(const signed char *)p; 534 | u_val = (PCU_size_t ) *(const unsigned char *)p; 535 | } else if (size == sizeof(short)) { 536 | s_val = (PCU_ssize_t) *(const short *)p; 537 | u_val = (PCU_size_t ) *(const unsigned short *)p; 538 | } else if (size == sizeof(int)) { 539 | s_val = (PCU_ssize_t) *(const int *)p; 540 | u_val = (PCU_size_t ) *(const unsigned int *)p; 541 | #if !((defined(PCU_NO_VSPRINTF) || defined(PCU_NO_LIBC)) && defined(PCU_NO_DIV32)) 542 | } else if (size == sizeof(long)) { 543 | s_val = (PCU_ssize_t) *(const long *)p; 544 | u_val = (PCU_size_t ) *(const unsigned long *)p; 545 | } else if (size == sizeof(PCU_size_t)) { 546 | s_val = (PCU_ssize_t) *(const PCU_ssize_t *)p; 547 | u_val = (PCU_size_t ) *(const PCU_size_t *)p; 548 | #endif 549 | } else { 550 | break; 551 | } 552 | if (s_val < 0) { 553 | PCU_PRINTF2(PCU_LD_LU, s_val, u_val); 554 | } else { 555 | PCU_PRINTF1(PCU_LD, s_val); 556 | } 557 | } while (0); 558 | PCU_puts("\n"); 559 | } else { 560 | print_null(str); 561 | } 562 | } 563 | 564 | static void print_params(enum PCU_Type type, PCU_size_t expected, PCU_size_t actual) 565 | { 566 | const char * const expected_str = "expected"; 567 | const char * const actual_str = "actual "; 568 | const char * const value1_str = "value1 "; 569 | const char * const value2_str = "value2 "; 570 | const char * s1 = expected_str; 571 | const char * s2 = actual_str; 572 | 573 | if (assert_not_flag) { 574 | s1 = value1_str; 575 | s2 = value2_str; 576 | } 577 | switch (type) { 578 | case PCU_TYPE_BOOL: 579 | PCU_PRINTF1(" expected : %s\n", assert_not_flag ? "TRUE" : "FALSE"); 580 | PCU_PRINTF1(" actual : %s", assert_not_flag ? "FALSE" : "TRUE"); 581 | #if !((defined(PCU_NO_VSPRINTF) || defined(PCU_NO_LIBC)) && defined(PCU_NO_DIV32)) 582 | PCU_PRINTF1(PCU_LD, actual); 583 | #endif 584 | PCU_puts("\n"); 585 | break; 586 | case PCU_TYPE_NUM: 587 | #if (defined(PCU_NO_VSPRINTF) || defined(PCU_NO_LIBC)) && defined(PCU_NO_DIV32) 588 | print_expected_actual_no_div32(s1, s2, expected, actual); 589 | #else 590 | print_expected_actual(s1, s2, expected, actual); 591 | #endif 592 | break; 593 | case PCU_TYPE_OP: 594 | case PCU_TYPE_OP_INT: 595 | #if (defined(PCU_NO_VSPRINTF) || defined(PCU_NO_LIBC)) && defined(PCU_NO_DIV32) 596 | print_expected_actual_no_div32(value1_str, value2_str, expected, actual); 597 | #else 598 | print_expected_actual(value1_str, value2_str, expected, actual); 599 | #endif 600 | break; 601 | case PCU_TYPE_PTR: 602 | print_type_ptr(s1, (const void *)(size_t) expected); 603 | print_type_ptr(s2 , (const void *)(size_t) actual); 604 | break; 605 | case PCU_TYPE_PTR_NULL: 606 | PCU_PRINTF1(" expected : %sNULL\n", assert_not_flag ? "non-" : ""); 607 | print_type_ptr(actual_str, (const void *)(size_t) actual); 608 | break; 609 | case PCU_TYPE_STR: 610 | print_type_str(s1, (const char *)(size_t) expected); 611 | print_type_str(s2 , (const char *)(size_t) actual); 612 | break; 613 | case PCU_TYPE_MEM: 614 | if (assert_mem.n > 1) { 615 | PCU_PRINTF1(" nth : %u\n", (unsigned int) assert_mem.idx); 616 | } 617 | print_type_mem(s1, (const unsigned char *)(size_t) expected, assert_mem.size, assert_mem.idx); 618 | print_type_mem(s2, (const unsigned char *)(size_t) actual, assert_mem.size, assert_mem.idx); 619 | PCU_PRINTF1(" size : %u\n", (unsigned int) assert_mem.size); 620 | break; 621 | case PCU_TYPE_NSTR: 622 | print_type_nstr(s1, (const char *)(size_t) expected, assert_nstr.n); 623 | print_type_nstr(s2 , (const char *)(size_t) actual, assert_nstr.n); 624 | PCU_PRINTF1(" length : %u\n", (unsigned int) assert_nstr.n); 625 | break; 626 | #ifdef PCU_USE_WCHAR 627 | case PCU_TYPE_STRW: 628 | print_type_nstrw(s1, (const wchar_t *)(size_t) expected, 629 | expected ? PCU_WCSLEN((const wchar_t *)(size_t) expected) : 0); 630 | print_type_nstrw(s2 , (const wchar_t *)(size_t) actual, 631 | actual ? PCU_WCSLEN((const wchar_t *)(size_t) actual) : 0); 632 | break; 633 | case PCU_TYPE_NSTRW: 634 | print_type_nstrw(s1, (const wchar_t *)(size_t) expected, assert_nstr.n); 635 | print_type_nstrw(s2 , (const wchar_t *)(size_t) actual, assert_nstr.n); 636 | PCU_PRINTF1(" length : %u\n", (unsigned int) assert_nstr.n); 637 | break; 638 | #else 639 | case PCU_TYPE_STRW: 640 | case PCU_TYPE_NSTRW: 641 | print_not_supported(); 642 | break; 643 | #endif 644 | case PCU_TYPE_MSG: 645 | case PCU_TYPE_ADDMSG: 646 | case PCU_TYPE_FAIL: 647 | PCU_puts(" "); 648 | PCU_puts((const char *)(size_t) expected); 649 | PCU_puts("\n"); 650 | break; 651 | case PCU_TYPE_SETUP: 652 | PCU_PRINTF1(" return : %d\n", (int) actual); 653 | break; 654 | default: 655 | break; 656 | } 657 | } 658 | 659 | static void print_params_double(enum PCU_Type type, double expected, double actual, double delta) 660 | { 661 | #ifndef PCU_NO_FLOATINGPOINT 662 | switch (type) { 663 | case PCU_TYPE_DBL: 664 | #if !defined(PCU_NO_VSPRINTF) && !defined(PCU_NO_LIBC) 665 | PCU_PRINTF1(" expected : |value1 - value2| %s |delta|\n", assert_not_flag ? ">" : "<="); 666 | PCU_PRINTF1(" value1 : %g\n", expected); 667 | PCU_PRINTF1(" value2 : %g\n", actual); 668 | PCU_PRINTF1(" delta : %g\n", delta); 669 | #else 670 | (void) expected; 671 | (void) actual; 672 | (void) delta; 673 | #endif 674 | break; 675 | case PCU_TYPE_OP_DBL: 676 | #if !defined(PCU_NO_VSPRINTF) && !defined(PCU_NO_LIBC) 677 | PCU_PRINTF1(" value1 : %g\n", expected); 678 | PCU_PRINTF1(" value2 : %g\n", actual); 679 | #endif 680 | break; 681 | default: 682 | break; 683 | } 684 | #else 685 | (void) type; 686 | (void) expected; 687 | (void) actual; 688 | (void) delta; 689 | print_not_supported(); 690 | #endif 691 | } 692 | 693 | #ifndef PCU_NO_CONSOLE_RUN 694 | int PCU_is_verbose(void) 695 | { 696 | return is_verbose; 697 | } 698 | #endif 699 | 700 | --------------------------------------------------------------------------------