From: IrgendwerA8 Date: Sun, 5 Mar 2017 01:09:12 +0000 (+0100) Subject: Added further optimizations and unit tests. X-Git-Tag: V2.16~8^2~2 X-Git-Url: https://git.sur5r.net/?a=commitdiff_plain;h=81115aa82625f2b7e773b29844a3a7af589cdb95;p=cc65 Added further optimizations and unit tests. --- diff --git a/libsrc/common/memmove.s b/libsrc/common/memmove.s index 9c33124f1..666447cd8 100644 --- a/libsrc/common/memmove.s +++ b/libsrc/common/memmove.s @@ -1,6 +1,6 @@ ; ; 2003-08-20, Ullrich von Bassewitz -; 2009-09-13, Christian Krueger -- performance increase (about 20%) +; 2009-09-13, Christian Krueger -- performance increase (about 20%), 2013-07-25 improved unrolling ; 2015-10-23, Greg King ; ; void* __fastcall__ memmove (void* dest, const void* src, size_t size); @@ -61,13 +61,10 @@ PageSizeCopy: ; assert Y = 0 dec ptr1+1 ; adjust base... dec ptr2+1 dey ; in entry case: 0 -> FF - lda (ptr1),y ; need to copy this 'intro byte' - sta (ptr2),y ; to 'land' later on Y=0! (as a result of the '.repeat'-block!) - dey ; FF ->FE @copyBytes: - .repeat 2 ; Unroll this a bit to make it faster... - lda (ptr1),y - sta (ptr2),y + .repeat 3 ; unroll this a bit to make it faster... + lda (ptr1),y ; important: unrolling three times gives a nice + sta (ptr2),y ; 255/3 = 85 loop which ends at 0 dey .endrepeat @copyEntry: ; in entry case: 0 -> FF diff --git a/libsrc/common/strcat.s b/libsrc/common/strcat.s index 9be65386f..74fef0759 100644 --- a/libsrc/common/strcat.s +++ b/libsrc/common/strcat.s @@ -1,6 +1,6 @@ ; ; Ullrich von Bassewitz, 31.05.1998 -; Christian Krueger: 2013-Jul-24, minor optimization +; Christian Krueger: 2013-Jul-24, minor optimizations ; ; char* strcat (char* dest, const char* src); ; @@ -15,8 +15,12 @@ _strcat: jsr popax ; Get dest sta tmp3 ; Remember for function return tay +.if (.cpu .bitand ::CPU_ISET_65SC02) + stz ptr2 +.else lda #0 sta ptr2 ; access from page start, y contains low byte +.endif stx ptr2+1 findEndOfDest: diff --git a/libsrc/common/strchr.s b/libsrc/common/strchr.s index 0bd55d0e1..48bb8822b 100644 --- a/libsrc/common/strchr.s +++ b/libsrc/common/strchr.s @@ -14,8 +14,12 @@ _strchr: jsr popax ; get s tay ; low byte of pointer to y stx ptr1+1 +.if (.cpu .bitand ::CPU_ISET_65SC02) + stz ptr1 +.else lda #0 - sta ptr1 ; ptr access page wise + sta ptr1 ; access from page start, y contains low byte +.endif Loop: lda (ptr1),y ; Get next char beq EOS ; Jump on end of string diff --git a/libsrc/common/strcspn.s b/libsrc/common/strcspn.s index 8fd567ae4..3f7b42ed1 100644 --- a/libsrc/common/strcspn.s +++ b/libsrc/common/strcspn.s @@ -1,54 +1,54 @@ ; ; Ullrich von Bassewitz, 11.06.1998 +; Christian Krueger: 05-Aug-2013, optimization ; ; size_t strcspn (const char* s1, const char* s2); ; .export _strcspn - .import popax - .importzp ptr1, ptr2, tmp1, tmp2, tmp3 + .import popax, _strlen + .importzp ptr1, ptr2, tmp1, tmp2 _strcspn: - sta ptr2 ; Save s2 - stx ptr2+1 - jsr popax ; Get s1 - sta ptr1 - stx ptr1+1 - ldx #0 ; low counter byte - stx tmp1 ; high counter byte - ldy #$00 - -L1: lda (ptr1),y ; get next char from s1 - beq L6 ; jump if done - sta tmp2 ; save char + jsr _strlen ; get length in a/x and transfer s2 to ptr1 + ; Note: It does not make sense to + ; have more than 255 test chars, so + ; we don't support a high byte here! (ptr1+1 is + ; also unchanged in strlen then (important!)) + ; -> the original implementation also + ; ignored this case + + sta tmp1 ; tmp1 = strlen of test chars + jsr popax ; get and save s1 + sta ptr2 ; to ptr2 + stx ptr2+1 + ldx #0 ; low counter byte + stx tmp2 ; high counter byte + +loadChar: + ldy #0 + lda (ptr2),y ; get next char from s1 + beq leave ; handly byte of s1 +advance: + inc ptr2 ; advance string position to test + bne check + inc ptr2+1 + dey ; correct next iny (faster/shorter than bne...) + +checkNext: iny - bne L2 - inc ptr1+1 -L2: sty tmp3 ; save index into s1 - - ldy #0 ; get index into s2 -L3: lda (ptr2),y ; - beq L4 ; jump if done - cmp tmp2 - beq L6 - iny - bne L3 - -; The character was not found in s2. Increment the counter and start over - -L4: ldy tmp3 ; reload index - inx - bne L1 - inc tmp1 - bne L1 +check: cpy tmp1 ; compare with length of test character string + beq endOfTestChars + cmp (ptr1),y ; found matching char? + bne checkNext -; The character was found, or we reached the end of s1. Return count of -; characters - -L6: txa ; get low counter byte - ldx tmp1 ; get high counter byte +leave: txa ; restore position of finding + ldx tmp2 ; and return rts - - +endOfTestChars: + inx + bne loadChar + inc tmp2 + bne loadChar ; like bra... diff --git a/libsrc/common/strlen.s b/libsrc/common/strlen.s index b583eea50..1a51edb11 100644 --- a/libsrc/common/strlen.s +++ b/libsrc/common/strlen.s @@ -1,6 +1,10 @@ ; ; Ullrich von Bassewitz, 31.05.1998 ; +; Note: strspn & strcspn call internally this function and rely on +; the usage of only ptr1 here! Keep in mind when appling changes +; and check the other implementations too! +; ; int strlen (const char* s); ; @@ -23,4 +27,3 @@ L1: lda (ptr1),y L9: tya ; get low byte of counter, hi's all set rts - diff --git a/libsrc/common/strncat.s b/libsrc/common/strncat.s index b7bb04b2a..42717853f 100644 --- a/libsrc/common/strncat.s +++ b/libsrc/common/strncat.s @@ -1,5 +1,6 @@ ; ; Ullrich von Bassewitz, 31.05.1998 +; Christian Krueger: 12-Aug-2013, minor optimizations ; ; char* strncat (char* dest, const char* src, size_t n); ; @@ -9,64 +10,65 @@ .importzp ptr1, ptr2, ptr3, tmp1, tmp2 _strncat: - eor #$FF ; one's complement to count upwards - sta tmp1 - txa - eor #$FF - sta tmp2 - jsr popax ; get src - sta ptr1 - stx ptr1+1 - jsr popax ; get dest - sta ptr2 - stx ptr2+1 - sta ptr3 ; remember for function return - stx ptr3+1 - ldy #0 + eor #$FF ; one's complement to count upwards + sta tmp1 + txa + eor #$FF + sta tmp2 + + jsr popax ; get src + sta ptr1 + stx ptr1+1 -; find end of dest + jsr popax ; get dest + sta ptr3 ; remember for function return + stx ptr3+1 + stx ptr2+1 + tay ; low byte as offset in Y +.if (.cpu .bitand ::CPU_ISET_65SC02) + stz ptr2 +.else + ldx #0 + stx ptr2 ; destination on page boundary +.endif -L1: lda (ptr2),y - beq L2 - iny - bne L1 - inc ptr2+1 - bne L1 +; find end of dest -; end found, get offset in y into pointer +L1: lda (ptr2),y + beq L2 + iny + bne L1 + inc ptr2+1 + bne L1 -L2: tya - clc - adc ptr2 - sta ptr2 - bcc L3 - inc ptr2+1 +; end found, apply offset to dest ptr and reset y +L2: sty ptr2 ; copy src. We've put the ones complement of the count into the counter, so ; we'll increment the counter on top of the loop -L3: ldy #0 - ldx tmp1 ; low counter byte +L3: ldy #0 + ldx tmp1 ; low counter byte -L4: inx - bne L5 - inc tmp2 - beq L6 ; jump if done -L5: lda (ptr1),y - sta (ptr2),y - beq L7 - iny - bne L4 - inc ptr1+1 - inc ptr2+1 - bne L4 +L4: inx + bne L5 + inc tmp2 + beq L6 ; jump if done +L5: lda (ptr1),y + sta (ptr2),y + beq L7 + iny + bne L4 + inc ptr1+1 + inc ptr2+1 + bne L4 ; done, set the trailing zero and return pointer to dest -L6: lda #0 - sta (ptr2),y -L7: lda ptr3 - ldx ptr3+1 - rts +L6: lda #0 + sta (ptr2),y +L7: lda ptr3 + ldx ptr3+1 + rts diff --git a/libsrc/common/strspn.s b/libsrc/common/strspn.s index f8b8fff2a..3316f0dab 100644 --- a/libsrc/common/strspn.s +++ b/libsrc/common/strspn.s @@ -1,56 +1,54 @@ ; ; Ullrich von Bassewitz, 11.06.1998 +; Christian Krueger: 08-Aug-2013, optimization ; ; size_t strspn (const char* s1, const char* s2); ; .export _strspn - .import popax - .importzp ptr1, ptr2, tmp1, tmp2, tmp3 + .import popax, _strlen + .importzp ptr1, ptr2, tmp1, tmp2 _strspn: - sta ptr2 ; Save s2 - stx ptr2+1 - jsr popax ; get s1 - sta ptr1 - stx ptr1+1 - ldx #0 ; low counter byte - stx tmp1 ; high counter byte - ldy #$00 - -L1: lda (ptr1),y ; get next char from s1 - beq L6 ; jump if done - sta tmp2 ; save char - iny - bne L2 - inc ptr1+1 -L2: sty tmp3 ; save index into s1 - - ldy #0 ; get index into s2 -L3: lda (ptr2),y ; - beq L6 ; jump if done - cmp tmp2 - beq L4 + jsr _strlen ; get length in a/x and transfer s2 to ptr1 + ; Note: It does not make sense to + ; have more than 255 test chars, so + ; we don't support a high byte here! (ptr1+1 is + ; also unchanged in strlen then (important!)) + ; -> the original implementation also + ; ignored this case + + sta tmp1 ; tmp1 = strlen of test chars + jsr popax ; get and save s1 + sta ptr2 ; to ptr2 + stx ptr2+1 + ldx #0 ; low counter byte + stx tmp2 ; high counter byte + +loadChar: + ldy #0 + lda (ptr2),y ; get next char from s1 + beq leave ; handly byte of s1 +advance: + inc ptr2 ; advance string position to test + bne check + inc ptr2+1 + dey ; correct next iny (faster/shorter than bne...) + +checkNext: iny - bne L3 +check: cpy tmp1 ; compare with length of test character string + beq leave + cmp (ptr1),y ; found matching char? + bne checkNext -; The character was found in s2. Increment the counter and start over - -L4: ldy tmp3 ; reload index +foundTestChar: inx - bne L1 - inc tmp1 - bne L1 - -; The character was not found, or we reached the end of s1. Return count of -; characters + bne loadChar + inc tmp2 + bne loadChar ; like bra... -L6: txa ; get low counter byte - ldx tmp1 ; get high counter byte +leave: txa ; restore position of finding + ldx tmp2 ; and return rts - - - - - - + \ No newline at end of file diff --git a/libsrc/runtime/axlong.s b/libsrc/runtime/axlong.s index 6d97b5025..02d0a825c 100644 --- a/libsrc/runtime/axlong.s +++ b/libsrc/runtime/axlong.s @@ -1,5 +1,6 @@ ; ; Ullrich von Bassewitz, 25.10.2000 +; Christian Krueger, 02-Mar-2017, some bytes saved ; ; CC65 runtime: Convert int in ax into a long ; @@ -9,18 +10,13 @@ ; Convert AX from int to long in EAX +axlong: ldy #$ff + cpx #$80 ; Positive? + bcs store ; No, apply $FF + axulong: ldy #0 - sty sreg - sty sreg+1 - rts - -axlong: cpx #$80 ; Positive? - bcc axulong ; Yes, handle like unsigned type - ldy #$ff - sty sreg +store: sty sreg sty sreg+1 rts - - diff --git a/test/val/atoi-test.c b/test/val/atoi-test.c deleted file mode 100644 index 5f5fa65e7..000000000 --- a/test/val/atoi-test.c +++ /dev/null @@ -1,42 +0,0 @@ -/* - !!DESCRIPTION!! A small test for atoi. Assumes twos complement - !!ORIGIN!! - !!LICENCE!! - !!AUTHOR!! -*/ - -#include -#include -#include -#include -#include - -static unsigned int Failures = 0; - -static void CheckAtoi (const char* Str, int Val) -{ - int Res = atoi (Str); - if (Res != Val) { - printf ("atoi error in \"%s\":\n" - " result = %d, should be %d\n", Str, Res, Val); - ++Failures; - } -} - -int main (void) -{ - CheckAtoi ("\t +0A", 0); - CheckAtoi ("\t -0.123", 0); - CheckAtoi (" -32 ", -32); - CheckAtoi (" +32 ", 32); - CheckAtoi ("0377", 377); - CheckAtoi (" 0377 ", 377); - CheckAtoi (" +0377 ", 377); - CheckAtoi (" -0377 ", -377); - CheckAtoi ("0x7FFF", 0); - CheckAtoi (" +0x7FFF", 0); - CheckAtoi (" -0x7FFF", 0); - printf ("Failures: %u\n", Failures); - - return Failures; -} diff --git a/test/val/lib_common_atoi.c b/test/val/lib_common_atoi.c new file mode 100644 index 000000000..5f5fa65e7 --- /dev/null +++ b/test/val/lib_common_atoi.c @@ -0,0 +1,42 @@ +/* + !!DESCRIPTION!! A small test for atoi. Assumes twos complement + !!ORIGIN!! + !!LICENCE!! + !!AUTHOR!! +*/ + +#include +#include +#include +#include +#include + +static unsigned int Failures = 0; + +static void CheckAtoi (const char* Str, int Val) +{ + int Res = atoi (Str); + if (Res != Val) { + printf ("atoi error in \"%s\":\n" + " result = %d, should be %d\n", Str, Res, Val); + ++Failures; + } +} + +int main (void) +{ + CheckAtoi ("\t +0A", 0); + CheckAtoi ("\t -0.123", 0); + CheckAtoi (" -32 ", -32); + CheckAtoi (" +32 ", 32); + CheckAtoi ("0377", 377); + CheckAtoi (" 0377 ", 377); + CheckAtoi (" +0377 ", 377); + CheckAtoi (" -0377 ", -377); + CheckAtoi ("0x7FFF", 0); + CheckAtoi (" +0x7FFF", 0); + CheckAtoi (" -0x7FFF", 0); + printf ("Failures: %u\n", Failures); + + return Failures; +} diff --git a/test/val/lib_common_memmove.c b/test/val/lib_common_memmove.c new file mode 100644 index 000000000..dd5801569 --- /dev/null +++ b/test/val/lib_common_memmove.c @@ -0,0 +1,61 @@ +#include +#include "unittest.h" + +#define BufferSize 384 // test correct page passing (>256, multiple of 128 here) + +static char Buffer[BufferSize+3]; // +1 to move up (and down) + + + +TEST +{ + unsigned i, v; + char* p; + + for (i=0; i < BufferSize; ++i) + Buffer[i+1] = (i%128); + + Buffer[0] = 255; // to check if start position is untouched + Buffer[BufferSize+2] = 255; // to check if end position is untouched + + // copy upwards + p = memmove(Buffer+2, Buffer+1, BufferSize); + + // check buffer consistency before target + ASSERT_AreEqual(255, (unsigned)Buffer[0], "%u", "Unexpected value before range!"); + + // check buffer consistency at starting point + ASSERT_AreEqual(0, (unsigned)Buffer[1], "%u", "Unexpected value at range start!"); + + // check buffer consistency after range + ASSERT_AreEqual(255, (unsigned)Buffer[BufferSize+2], "%u", "Unexpected value after range!"); + + // check buffer values + for (i=0; i < BufferSize; ++i) + { + ASSERT_AreEqual(i%128, (unsigned)Buffer[i+2], "%u", "Unexpected value in buffer at position %u!" COMMA i+2); + } + + v = Buffer[BufferSize+1]; // rember value of first untouched end-byte + + // copy downwards + p = memmove(Buffer+1, Buffer+2, BufferSize); + + // check buffer consistency before target + ASSERT_AreEqual(255, (unsigned)Buffer[0], "%u", "Unexpected value before range!"); + + // check buffer consistency at end point + ASSERT_AreEqual(v, (unsigned)Buffer[BufferSize+1], "%u", "Unexpected value at range end!"); + + // check buffer consistency after range + ASSERT_AreEqual(255, (unsigned)Buffer[BufferSize+2], "%u", "Unexpected value after range!"); + + // check buffer values + for (i=0; i < BufferSize; ++i) + { + ASSERT_AreEqual(i%128, (unsigned)Buffer[i+1], "%u", "Unexpected value in buffer at position %u!" COMMA i+1); + } +} +ENDTEST + + diff --git a/test/val/lib_common_strcat.c b/test/val/lib_common_strcat.c new file mode 100644 index 000000000..1872053a4 --- /dev/null +++ b/test/val/lib_common_strcat.c @@ -0,0 +1,54 @@ +#include +#include "unittest.h" + +#define SourceStringSize 257 // test correct page passing (>256) + +static char SourceString[SourceStringSize+1]; // +1 room for terminating null +static char DestinationString[2*SourceStringSize+1]; // will contain two times the source buffer + + +TEST +{ + unsigned i,j; + char* p; + + for (i=0; i < SourceStringSize; ++i) + SourceString[i] = (i%128)+1; + + SourceString[i] = 0; + + ASSERT_AreEqual(SourceStringSize, strlen(SourceString), "%u", "Source string initialization or 'strlen()' problem!"); + + /* Ensure empty destination string */ + DestinationString[0] = 0; + + ASSERT_AreEqual(0, strlen(DestinationString), "%u", "Destination string initialization or 'strlen()' problem!"); + + /* Test concatenation to empty buffer */ + + strcat(DestinationString, SourceString); + + ASSERT_AreEqual(SourceStringSize, strlen(DestinationString), "%u", "Unexpected string length while string concatenation to empty buffer!"); + + /* Test concatenation to non empty buffer */ + + p = strcat(DestinationString, SourceString); + + ASSERT_AreEqual(2*SourceStringSize, strlen(DestinationString), "%u", "Unexpected string length while string concatenation to non-empty buffer!"); + + /* Test return value */ + + ASSERT_IsTrue(p == DestinationString,"Invalid return value!"); + + /* Test contents */ + + for(j=0; j <2; ++j) + for(i=0; i < SourceStringSize; ++i) + { + unsigned position = j*SourceStringSize+i; + unsigned current = DestinationString[position]; + unsigned expected = (i%128)+1; + ASSERT_AreEqual(expected, current, "%u", "Unexpected destination buffer contents at position %u!\n" COMMA position); + } +} +ENDTEST diff --git a/test/val/lib_common_strchr.c b/test/val/lib_common_strchr.c new file mode 100644 index 000000000..a48d287e5 --- /dev/null +++ b/test/val/lib_common_strchr.c @@ -0,0 +1,42 @@ +#include +#include "unittest.h" + + +/* Test string. Must NOT have duplicate characters! */ +static char S[] = "Helo wrd!\n"; + +static char Found[256]; + + + +TEST +{ + unsigned Len; + unsigned I; + char* P; + + /* Get the length of the string */ + Len = strlen (S); + + /* Search for all characters in the string, including the terminator */ + for (I = 0; I < Len+1; ++I) + { + /* Search for this char */ + P = strchr (S, S[I]); + + /* Check if we found it */ + ASSERT_IsFalse(P == 0 || (P - S) != I, "For code 0x%02X, offset %u!\nP = %04X offset = %04X\n" COMMA S[I] COMMA I COMMA P COMMA P-S); + /* Mark the char as checked */ + Found[S[I]] = 1; + } + + /* Search for all other characters and make sure they aren't found */ + for (I = 0; I < 256; ++I) + { + if (Found[I] == 0) + { + ASSERT_IsFalse(strchr (S, (char)I), "Failed for code 0x%02X\n" COMMA I); + } + } +} +ENDTEST diff --git a/test/val/lib_common_strcspn.c b/test/val/lib_common_strcspn.c new file mode 100644 index 000000000..10935a78e --- /dev/null +++ b/test/val/lib_common_strcspn.c @@ -0,0 +1,26 @@ +#include +#include "unittest.h" + +#define EstimatedStringSize 384 // test correct page passing (>256) + +static char EstimatedString[EstimatedStringSize+1]; // +1 room for terminating null +static char* EmptyTestChars=""; // strlen equivalent... +static char* TestChars="1234567890"; // we like to find numbers + +TEST +{ + unsigned i; + + for (i=0; i < EstimatedStringSize; ++i) + EstimatedString[i] = (i%26)+'A'; // put ABCD... into the string to be estimated + + ASSERT_AreEqual(strlen(EstimatedString), strcspn(EstimatedString, TestChars), "%u", "Unxpected position returned for non-participant case!"); + + EstimatedString[EstimatedStringSize/2] = TestChars[strlen(TestChars-1)]; + ASSERT_AreEqual(EstimatedStringSize/2, strcspn(EstimatedString, TestChars), "%u", "Unxpected position returned for participant case!"); + + ASSERT_AreEqual(strlen(EstimatedString), strcspn(EstimatedString, EmptyTestChars), "%u", "Unxpected position returned for empty test case!"); +} +ENDTEST + + diff --git a/test/val/lib_common_strncat.c b/test/val/lib_common_strncat.c new file mode 100644 index 000000000..dd6df9147 --- /dev/null +++ b/test/val/lib_common_strncat.c @@ -0,0 +1,54 @@ +#include +#include "unittest.h" + +#define SourceStringSize 384 // test correct page passing (>256, multiple of 128 here) + +static char SourceString[SourceStringSize+1]; // +1 room for terminating null +static char DestinationString[2*SourceStringSize+1]; // will contain two times the source buffer + + +TEST +{ + unsigned i; + char* p; + + for (i=0; i < SourceStringSize; ++i) + SourceString[i] = (i%128)+1; + + SourceString[i] = 0; + + ASSERT_AreEqual(SourceStringSize, strlen(SourceString), "%u", "Source string initialization or 'strlen()' problem!"); + + /* Ensure empty destination string */ + DestinationString[0] = 0; + + ASSERT_AreEqual(0, strlen(DestinationString), "%u", "Destination string initialization or 'strlen()' problem!"); + + /* Test "unlimted" concatenation to empty buffer */ + + strncat(DestinationString, SourceString, 1024); + + ASSERT_AreEqual(SourceStringSize, strlen(DestinationString), "%u", "Unexpected string length while string concatenation to empty buffer!"); + + /* Test limited concatenation to non empty buffer */ + + p = strncat(DestinationString, SourceString, 128); + + ASSERT_AreEqual(SourceStringSize+128, strlen(DestinationString), "%u", "Unexpected string length while string concatenation to non-empty buffer!"); + + /* Test return value */ + + ASSERT_IsTrue(p == DestinationString, "Invalid return value!"); + + /* Test contents */ + + for(i=0; i < strlen(DestinationString); ++i) + { + unsigned current = DestinationString[i]; + unsigned expected = (i%128)+1; + ASSERT_AreEqual(expected, current, "%u", "Unexpected destination buffer contents at position %u!\n" COMMA i); + } +} +ENDTEST + + diff --git a/test/val/lib_common_strol.c b/test/val/lib_common_strol.c new file mode 100644 index 000000000..76daef791 --- /dev/null +++ b/test/val/lib_common_strol.c @@ -0,0 +1,135 @@ +/* + !!DESCRIPTION!! A small test for atoi/strtol. Assumes twos complement + !!ORIGIN!! + !!LICENCE!! + !!AUTHOR!! +*/ + +#include +#include +#include +#include +#include + +#define ERROR 0 +#define OK 1 + +static unsigned int Failures = 0; + +static void IncStr (char* Buf) +/* Increment a number represented as a string by one. The string MUST not + * start with a '9', we cannot handle overflow in this case. + */ +{ + int Len = strlen (Buf); + + while (--Len >= 0) { + switch (Buf[Len]) { + case '9': + Buf[Len] = '0'; + break; + + default: + ++(Buf[Len]); + return; + } + } +} + +static void CheckStrToL (const char* Str, int Base, long Val, unsigned char Ok) +{ + char* EndPtr; + long Res = strtol (Str, &EndPtr, Base); + if (Ok) { + if (Res != Val) { + printf ("strtol error in \"%s\":\n" + " result = %ld, should be %ld, chars = %d\n", + Str, Res, Val, EndPtr - Str); + ++Failures; + } + } else { + if (errno != ERANGE) { + printf ("strtol error in \"%s\":\n" + " should not convert, but errno = %d\n", + Str, errno); + ++Failures; + } + if (Res != Val) { + printf ("strtol error in \"%s\":\n" + " result = %ld, should be %ld, chars = %d\n", + Str, Res, Val, EndPtr - Str); + ++Failures; + } + } +} + +int main (void) +{ + char Buf[80]; + + /* Prefixed allowed if base = 0 */ + CheckStrToL ("\t 0x10G ", 0, 16L, OK); + CheckStrToL ("\t 0X10G ", 0, 16L, OK); + CheckStrToL (" \t0377\t", 0, 255L, OK); + CheckStrToL (" 377", 0, 377L, OK); + + CheckStrToL ("\t -0x10G ", 0, -16L, OK); + CheckStrToL ("\t -0X10G ", 0, -16L, OK); + CheckStrToL (" \t-0377\t", 0, -255L, OK); + CheckStrToL (" -377", 0, -377L, OK); + + /* No prefixes if base = 10 */ + CheckStrToL ("\t 1234 ", 10, 1234L, OK); + CheckStrToL ("\t -1234 ", 10, -1234L, OK); + CheckStrToL ("\t -0x10G ", 10, 0L, OK); + CheckStrToL ("\t -0X10G ", 10, 0L, OK); + CheckStrToL (" \t-0377\t", 10, -377L, OK); + CheckStrToL (" 0377", 10, 377L, OK); + + /* 0x prefix is allowed if base = 16 */ + CheckStrToL ("\t 0x1234 ", 16, 0x1234L, OK); + CheckStrToL ("\t -0x1234 ", 16, -0x1234L, OK); + CheckStrToL ("\t -010G ", 16, -16L, OK); + CheckStrToL ("\t 10G ", 16, 16L, OK); + + /* Check LONG_MIN and LONG_MAX */ + sprintf (Buf, "%ld", LONG_MIN); + CheckStrToL (Buf, 0, LONG_MIN, OK); + sprintf (Buf, "%ld", LONG_MAX); + CheckStrToL (Buf, 0, LONG_MAX, OK); + + /* Check value one smaller */ + sprintf (Buf+1, "%ld", LONG_MIN); + Buf[1] = '0'; /* Overwrite '-' */ + IncStr (Buf+1); + if (Buf[1] == '0') { + Buf[1] = '-'; + Buf[0] = ' '; + } else { + Buf[0] = '-'; + } + CheckStrToL (Buf, 0, LONG_MIN, ERROR); + + /* Check value one larger */ + sprintf (Buf+1, "%ld", LONG_MAX); + Buf[0] = '0'; + IncStr (Buf); + if (Buf[0] == '0') { + Buf[0] = ' '; + } + CheckStrToL (Buf, 0, LONG_MAX, ERROR); + + /* Check numbers that are much too large or small */ + CheckStrToL ("-999999999999999999999999999999999999999999999999999999999", 0, LONG_MIN, ERROR); + CheckStrToL ("+999999999999999999999999999999999999999999999999999999999", 0, LONG_MAX, ERROR); + CheckStrToL (" 999999999999999999999999999999999999999999999999999999999", 0, LONG_MAX, ERROR); + + /* Check a few other bases */ + CheckStrToL ("aBcD", 36, 481261L, OK); + CheckStrToL ("zyaB", 35, 0L, ERROR); + CheckStrToL ("zyaB", 36, 1677395L, ERROR); + + printf ("Failures: %u\n", Failures); + + return Failures; +} diff --git a/test/val/lib_common_strrchr.c b/test/val/lib_common_strrchr.c new file mode 100644 index 000000000..a72c44db9 --- /dev/null +++ b/test/val/lib_common_strrchr.c @@ -0,0 +1,38 @@ +#include +#include "unittest.h" + +static char TestString[] = "01234567890123456789"; // two times the same string +static char Found[256]; + +TEST +{ + unsigned len; + unsigned i; + char* p; + + len = strlen(TestString)/2; // test only one half of the string, to find last appearance + + /* Search for all characters in the string, including the terminator */ + for (i = 0; i < len; ++i) + { + /* Search for this char */ + p = strrchr (TestString, TestString[i]); + ASSERT_AreEqual(i+len, p-TestString, "%u", "Unexpected location of character '%c' found!" COMMA TestString[i]); + + /* Mark the char as checked */ + Found[TestString[i]] = 1; + } + + /* Search for all other characters and make sure they aren't found */ + for (i = 0; i < 256; ++i) + { + if (!Found[i]) + { + p = strrchr (TestString, i); + ASSERT_IsFalse(p, "Unexpected location of character '%c' found!" COMMA TestString[i]); + } + } +} +ENDTEST + + diff --git a/test/val/lib_common_strspn.c b/test/val/lib_common_strspn.c new file mode 100644 index 000000000..96a006469 --- /dev/null +++ b/test/val/lib_common_strspn.c @@ -0,0 +1,24 @@ +#include +#include "unittest.h" + +#define EstimatedStringSize 384 // test correct page passing (>256) + +static char EstimatedString[EstimatedStringSize+1]; // +1 room for terminating null +static char* EmptyTestChars=""; // empty test case... +static char* TestChars="1234567890"; // we like to find numbers + +TEST +{ + unsigned i; + + for (i=0; i < EstimatedStringSize; ++i) + EstimatedString[i] = (i%10)+'0'; // put 0123... into the string to be estimated + + ASSERT_AreEqual(strlen(EstimatedString), strspn(EstimatedString, TestChars), "%u", "Unxpected position returned for all participant case!"); + + EstimatedString[EstimatedStringSize/2] = 'X'; + ASSERT_AreEqual(EstimatedStringSize/2, strspn(EstimatedString, TestChars), "%u", "Unxpected position returned for breaking case!"); + + ASSERT_AreEqual(0, strspn(EstimatedString, EmptyTestChars), "%u", "Unxpected position returned for empty test case!"); +} +ENDTEST diff --git a/test/val/lib_common_strtoul.c b/test/val/lib_common_strtoul.c new file mode 100644 index 000000000..803fd452c --- /dev/null +++ b/test/val/lib_common_strtoul.c @@ -0,0 +1,121 @@ +/* + !!DESCRIPTION!! A small test for strtuol. Assumes twos complement + !!ORIGIN!! + !!LICENCE!! + !!AUTHOR!! +*/ + +#include +#include +#include +#include +#include + +#define ERROR 0 +#define OK 1 + +static unsigned int Failures = 0; + +static void IncStr (char* Buf) +/* Increment a number represented as a string by one. The string MUST not + * start with a '9', we cannot handle overflow in this case. + */ +{ + int Len = strlen (Buf); + + while (--Len >= 0) { + switch (Buf[Len]) { + case '9': + Buf[Len] = '0'; + break; + + default: + ++(Buf[Len]); + return; + } + } +} + +static void CheckStrToUL (const char* Str, int Base, unsigned long Val, unsigned char Ok) +{ + char* EndPtr; + unsigned long Res = strtoul (Str, &EndPtr, Base); + if (Ok) { + if (Res != Val) { + printf ("strtol error in \"%s\":\n" + " result = %lu, should be %lu, chars = %d\n", + Str, Res, Val, EndPtr - Str); + ++Failures; + } + } else { + if (errno != ERANGE) { + printf ("strtol error in \"%s\":\n" + " should not convert, but errno = %d\n", + Str, errno); + ++Failures; + } + if (Res != Val) { + printf ("strtol error in \"%s\":\n" + " result = %lu, should be %lu, chars = %d\n", + Str, Res, Val, EndPtr - Str); + ++Failures; + } + } +} + +int main (void) +{ + char Buf[80]; + + /* Prefixed allowed if base = 0 */ + CheckStrToUL ("\t 0x10G ", 0, 16UL, OK); + CheckStrToUL ("\t 0X10G ", 0, 16UL, OK); + CheckStrToUL (" \t0377\t", 0, 255UL, OK); + CheckStrToUL (" 377", 0, 377UL, OK); + + CheckStrToUL ("\t -0x10G ", 0, (unsigned long) -16L, OK); + CheckStrToUL ("\t -0X10G ", 0, (unsigned long) -16L, OK); + CheckStrToUL (" \t-0377\t", 0, (unsigned long) -255L, OK); + CheckStrToUL (" -377", 0, (unsigned long) -377L, OK); + + /* No prefixes if base = 10 */ + CheckStrToUL ("\t 1234 ", 10, 1234UL, OK); + CheckStrToUL ("\t -1234 ", 10, (unsigned long) -1234L, OK); + CheckStrToUL ("\t -0x10G ", 10, 0UL, OK); + CheckStrToUL ("\t -0X10G ", 10, 0UL, OK); + CheckStrToUL (" \t-0377\t", 10, (unsigned long) -377L, OK); + CheckStrToUL (" 0377", 10, 377UL, OK); + + /* 0x prefix is allowed if base = 16 */ + CheckStrToUL ("\t 0x1234 ", 16, 0x1234UL, OK); + CheckStrToUL ("\t -0x1234 ", 16, (unsigned long) -0x1234L, OK); + CheckStrToUL ("\t -010G ", 16, (unsigned long) -16L, OK); + CheckStrToUL ("\t 10G ", 16, 16UL, OK); + + /* Check ULONG_MAX */ + sprintf (Buf, "%lu", ULONG_MAX); + CheckStrToUL (Buf, 0, ULONG_MAX, OK); + + /* Check value one larger */ + sprintf (Buf+1, "%lu", ULONG_MAX); + Buf[0] = '0'; + IncStr (Buf); + if (Buf[0] == '0') { + Buf[0] = ' '; + } + CheckStrToUL (Buf, 0, ULONG_MAX, ERROR); + + /* Check numbers that are much too large or small */ + CheckStrToUL ("-999999999999999999999999999999999999999999999999999999999", 0, ULONG_MAX, ERROR); + CheckStrToUL ("+999999999999999999999999999999999999999999999999999999999", 0, ULONG_MAX, ERROR); + CheckStrToUL (" 999999999999999999999999999999999999999999999999999999999", 0, ULONG_MAX, ERROR); + + /* Check a few other bases */ + CheckStrToUL ("aBcD", 36, 481261UL, OK); + CheckStrToUL ("zyaB", 35, 0UL, ERROR); + CheckStrToUL ("zyaB", 36, 1677395UL, ERROR); + + printf ("Failures: %u\n", Failures); + + return Failures; +} diff --git a/test/val/strtol-test.c b/test/val/strtol-test.c deleted file mode 100644 index 76daef791..000000000 --- a/test/val/strtol-test.c +++ /dev/null @@ -1,135 +0,0 @@ -/* - !!DESCRIPTION!! A small test for atoi/strtol. Assumes twos complement - !!ORIGIN!! - !!LICENCE!! - !!AUTHOR!! -*/ - -#include -#include -#include -#include -#include - -#define ERROR 0 -#define OK 1 - -static unsigned int Failures = 0; - -static void IncStr (char* Buf) -/* Increment a number represented as a string by one. The string MUST not - * start with a '9', we cannot handle overflow in this case. - */ -{ - int Len = strlen (Buf); - - while (--Len >= 0) { - switch (Buf[Len]) { - case '9': - Buf[Len] = '0'; - break; - - default: - ++(Buf[Len]); - return; - } - } -} - -static void CheckStrToL (const char* Str, int Base, long Val, unsigned char Ok) -{ - char* EndPtr; - long Res = strtol (Str, &EndPtr, Base); - if (Ok) { - if (Res != Val) { - printf ("strtol error in \"%s\":\n" - " result = %ld, should be %ld, chars = %d\n", - Str, Res, Val, EndPtr - Str); - ++Failures; - } - } else { - if (errno != ERANGE) { - printf ("strtol error in \"%s\":\n" - " should not convert, but errno = %d\n", - Str, errno); - ++Failures; - } - if (Res != Val) { - printf ("strtol error in \"%s\":\n" - " result = %ld, should be %ld, chars = %d\n", - Str, Res, Val, EndPtr - Str); - ++Failures; - } - } -} - -int main (void) -{ - char Buf[80]; - - /* Prefixed allowed if base = 0 */ - CheckStrToL ("\t 0x10G ", 0, 16L, OK); - CheckStrToL ("\t 0X10G ", 0, 16L, OK); - CheckStrToL (" \t0377\t", 0, 255L, OK); - CheckStrToL (" 377", 0, 377L, OK); - - CheckStrToL ("\t -0x10G ", 0, -16L, OK); - CheckStrToL ("\t -0X10G ", 0, -16L, OK); - CheckStrToL (" \t-0377\t", 0, -255L, OK); - CheckStrToL (" -377", 0, -377L, OK); - - /* No prefixes if base = 10 */ - CheckStrToL ("\t 1234 ", 10, 1234L, OK); - CheckStrToL ("\t -1234 ", 10, -1234L, OK); - CheckStrToL ("\t -0x10G ", 10, 0L, OK); - CheckStrToL ("\t -0X10G ", 10, 0L, OK); - CheckStrToL (" \t-0377\t", 10, -377L, OK); - CheckStrToL (" 0377", 10, 377L, OK); - - /* 0x prefix is allowed if base = 16 */ - CheckStrToL ("\t 0x1234 ", 16, 0x1234L, OK); - CheckStrToL ("\t -0x1234 ", 16, -0x1234L, OK); - CheckStrToL ("\t -010G ", 16, -16L, OK); - CheckStrToL ("\t 10G ", 16, 16L, OK); - - /* Check LONG_MIN and LONG_MAX */ - sprintf (Buf, "%ld", LONG_MIN); - CheckStrToL (Buf, 0, LONG_MIN, OK); - sprintf (Buf, "%ld", LONG_MAX); - CheckStrToL (Buf, 0, LONG_MAX, OK); - - /* Check value one smaller */ - sprintf (Buf+1, "%ld", LONG_MIN); - Buf[1] = '0'; /* Overwrite '-' */ - IncStr (Buf+1); - if (Buf[1] == '0') { - Buf[1] = '-'; - Buf[0] = ' '; - } else { - Buf[0] = '-'; - } - CheckStrToL (Buf, 0, LONG_MIN, ERROR); - - /* Check value one larger */ - sprintf (Buf+1, "%ld", LONG_MAX); - Buf[0] = '0'; - IncStr (Buf); - if (Buf[0] == '0') { - Buf[0] = ' '; - } - CheckStrToL (Buf, 0, LONG_MAX, ERROR); - - /* Check numbers that are much too large or small */ - CheckStrToL ("-999999999999999999999999999999999999999999999999999999999", 0, LONG_MIN, ERROR); - CheckStrToL ("+999999999999999999999999999999999999999999999999999999999", 0, LONG_MAX, ERROR); - CheckStrToL (" 999999999999999999999999999999999999999999999999999999999", 0, LONG_MAX, ERROR); - - /* Check a few other bases */ - CheckStrToL ("aBcD", 36, 481261L, OK); - CheckStrToL ("zyaB", 35, 0L, ERROR); - CheckStrToL ("zyaB", 36, 1677395L, ERROR); - - printf ("Failures: %u\n", Failures); - - return Failures; -} diff --git a/test/val/strtoul-test.c b/test/val/strtoul-test.c deleted file mode 100644 index 803fd452c..000000000 --- a/test/val/strtoul-test.c +++ /dev/null @@ -1,121 +0,0 @@ -/* - !!DESCRIPTION!! A small test for strtuol. Assumes twos complement - !!ORIGIN!! - !!LICENCE!! - !!AUTHOR!! -*/ - -#include -#include -#include -#include -#include - -#define ERROR 0 -#define OK 1 - -static unsigned int Failures = 0; - -static void IncStr (char* Buf) -/* Increment a number represented as a string by one. The string MUST not - * start with a '9', we cannot handle overflow in this case. - */ -{ - int Len = strlen (Buf); - - while (--Len >= 0) { - switch (Buf[Len]) { - case '9': - Buf[Len] = '0'; - break; - - default: - ++(Buf[Len]); - return; - } - } -} - -static void CheckStrToUL (const char* Str, int Base, unsigned long Val, unsigned char Ok) -{ - char* EndPtr; - unsigned long Res = strtoul (Str, &EndPtr, Base); - if (Ok) { - if (Res != Val) { - printf ("strtol error in \"%s\":\n" - " result = %lu, should be %lu, chars = %d\n", - Str, Res, Val, EndPtr - Str); - ++Failures; - } - } else { - if (errno != ERANGE) { - printf ("strtol error in \"%s\":\n" - " should not convert, but errno = %d\n", - Str, errno); - ++Failures; - } - if (Res != Val) { - printf ("strtol error in \"%s\":\n" - " result = %lu, should be %lu, chars = %d\n", - Str, Res, Val, EndPtr - Str); - ++Failures; - } - } -} - -int main (void) -{ - char Buf[80]; - - /* Prefixed allowed if base = 0 */ - CheckStrToUL ("\t 0x10G ", 0, 16UL, OK); - CheckStrToUL ("\t 0X10G ", 0, 16UL, OK); - CheckStrToUL (" \t0377\t", 0, 255UL, OK); - CheckStrToUL (" 377", 0, 377UL, OK); - - CheckStrToUL ("\t -0x10G ", 0, (unsigned long) -16L, OK); - CheckStrToUL ("\t -0X10G ", 0, (unsigned long) -16L, OK); - CheckStrToUL (" \t-0377\t", 0, (unsigned long) -255L, OK); - CheckStrToUL (" -377", 0, (unsigned long) -377L, OK); - - /* No prefixes if base = 10 */ - CheckStrToUL ("\t 1234 ", 10, 1234UL, OK); - CheckStrToUL ("\t -1234 ", 10, (unsigned long) -1234L, OK); - CheckStrToUL ("\t -0x10G ", 10, 0UL, OK); - CheckStrToUL ("\t -0X10G ", 10, 0UL, OK); - CheckStrToUL (" \t-0377\t", 10, (unsigned long) -377L, OK); - CheckStrToUL (" 0377", 10, 377UL, OK); - - /* 0x prefix is allowed if base = 16 */ - CheckStrToUL ("\t 0x1234 ", 16, 0x1234UL, OK); - CheckStrToUL ("\t -0x1234 ", 16, (unsigned long) -0x1234L, OK); - CheckStrToUL ("\t -010G ", 16, (unsigned long) -16L, OK); - CheckStrToUL ("\t 10G ", 16, 16UL, OK); - - /* Check ULONG_MAX */ - sprintf (Buf, "%lu", ULONG_MAX); - CheckStrToUL (Buf, 0, ULONG_MAX, OK); - - /* Check value one larger */ - sprintf (Buf+1, "%lu", ULONG_MAX); - Buf[0] = '0'; - IncStr (Buf); - if (Buf[0] == '0') { - Buf[0] = ' '; - } - CheckStrToUL (Buf, 0, ULONG_MAX, ERROR); - - /* Check numbers that are much too large or small */ - CheckStrToUL ("-999999999999999999999999999999999999999999999999999999999", 0, ULONG_MAX, ERROR); - CheckStrToUL ("+999999999999999999999999999999999999999999999999999999999", 0, ULONG_MAX, ERROR); - CheckStrToUL (" 999999999999999999999999999999999999999999999999999999999", 0, ULONG_MAX, ERROR); - - /* Check a few other bases */ - CheckStrToUL ("aBcD", 36, 481261UL, OK); - CheckStrToUL ("zyaB", 35, 0UL, ERROR); - CheckStrToUL ("zyaB", 36, 1677395UL, ERROR); - - printf ("Failures: %u\n", Failures); - - return Failures; -} diff --git a/test/val/unittest.h b/test/val/unittest.h new file mode 100644 index 000000000..bd355bb0c --- /dev/null +++ b/test/val/unittest.h @@ -0,0 +1,89 @@ +/*****************************************************************************/ +/* */ +/* unittest.h */ +/* */ +/* Unit test helper macros */ +/* */ +/* */ +/* */ +/* (C) 2017 Christian Krueger */ +/* */ +/* This software is provided 'as-is', without any expressed or implied */ +/* warranty. In no event will the authors be held liable for any damages */ +/* arising from the use of this software. */ +/* */ +/* Permission is granted to anyone to use this software for any purpose, */ +/* including commercial applications, and to alter it and redistribute it */ +/* freely, subject to the following restrictions: */ +/* */ +/* 1. The origin of this software must not be misrepresented; you must not */ +/* claim that you wrote the original software. If you use this software */ +/* in a product, an acknowledgment in the product documentation would be */ +/* appreciated but is not required. */ +/* 2. Altered source versions must be plainly marked as such, and must not */ +/* be misrepresented as being the original software. */ +/* 3. This notice may not be removed or altered from any source */ +/* distribution. */ +/* */ +/*****************************************************************************/ + +#ifndef _UNITTEST_H +#define _UNITTEST_H + +#include +#include + +#ifndef COMMA +#define COMMA , +#endif + +#define TEST int main(void) \ + {\ + printf("%s: ",__FILE__); + +#define ENDTEST printf("Passed\n"); \ + return EXIT_SUCCESS; \ + } + +#define ASSERT_IsTrue(a,b) if (!(a)) \ + {\ + printf("Fail at line %d:\n",__LINE__);\ + printf(b);\ + printf("\n");\ + printf("Expected status should be true but wasn't!\n");\ + exit(EXIT_FAILURE);\ + } + +#define ASSERT_IsFalse(a,b) if ((a)) \ + {\ + printf("Fail at line %d:\n",__LINE__);\ + printf(b);\ + printf("\n");\ + printf("Expected status should be false but wasn't!\n");\ + exit(EXIT_FAILURE);\ + } + +#define ASSERT_AreEqual(a,b,c,d) if ((a) != (b)) \ + {\ + printf("Fail at line %d:\n",__LINE__);\ + printf(d);\ + printf("\n");\ + printf("Expected value: "c", but is "c"!\n", (a), (b));\ + exit(EXIT_FAILURE);\ + } + +#define ASSERT_AreNotEqual(a,b,c,d) if ((a) == (b)) \ + {\ + printf("Fail at line %d:\n",__LINE__);\ + printf(d);\ + printf("\n");\ + printf("Expected value not: "c", but is "c"!\n", (a), (b));\ + exit(EXIT_FAILURE);\ + } + +/* End of unittest.h */ +#endif + + + + diff --git a/testcode/lib/strcat-test.c b/testcode/lib/strcat-test.c deleted file mode 100644 index 58119e27a..000000000 --- a/testcode/lib/strcat-test.c +++ /dev/null @@ -1,56 +0,0 @@ -#include -#include "unittest.h" - -#define SourceStringSize 257 // test correct page passing (>256) - -static char SourceString[SourceStringSize+1]; // +1 room for terminating null -static char DestinationString[2*SourceStringSize+1]; // will contain two times the source buffer - - -TEST -{ - unsigned i,j; - char* p; - - for (i=0; i < SourceStringSize; ++i) - SourceString[i] = (i%128)+1; - - SourceString[i] = 0; - - ASSERT_AreEqual(SourceStringSize, strlen(SourceString), "%u", "Source string initialization or 'strlen()' problem!"); - - /* Ensure empty destination string */ - DestinationString[0] = 0; - - ASSERT_AreEqual(0, strlen(DestinationString), "%u", "Destination string initialization or 'strlen()' problem!"); - - /* Test concatenation to empty buffer */ - - strcat(DestinationString, SourceString); - - ASSERT_AreEqual(SourceStringSize, strlen(DestinationString), "%u", "Unexpected string length while string concatenation to empty buffer!"); - - /* Test concatenation to non empty buffer */ - - p = strcat(DestinationString, SourceString); - - ASSERT_AreEqual(2*SourceStringSize, strlen(DestinationString), "%u", "Unexpected string length while string concatenation to non-empty buffer!"); - - /* Test return value */ - - ASSERT_IsTrue(p == DestinationString,"Invalid return value!"); - - /* Test contents */ - - for(j=0; j <2; ++j) - for(i=0; i < SourceStringSize; ++i) - { - unsigned position = j*SourceStringSize+i; - unsigned current = DestinationString[position]; - unsigned expected = (i%128)+1; - ASSERT_AreEqual(expected, current, "%u", "Unexpected destination buffer contents at position %u!\n" COMMA position); - } -} -ENDTEST - - diff --git a/testcode/lib/strchr-test.c b/testcode/lib/strchr-test.c deleted file mode 100644 index 7aba1de1e..000000000 --- a/testcode/lib/strchr-test.c +++ /dev/null @@ -1,59 +0,0 @@ -#include -#include -#include - - - -/* Test string. Must NOT have duplicate characters! */ -static char S[] = "Helo wrd!\n"; - -static char Found[256]; - - - -int main (void) -{ - unsigned Len; - unsigned I; - char* P; - - /* Print a header */ - printf ("strchr(): "); - - /* Get the length of the string */ - Len = strlen (S); - - /* Search for all characters in the string, including the terminator */ - for (I = 0; I < Len+1; ++I) { - - /* Search for this char */ - P = strchr (S, S[I]); - - /* Check if we found it */ - if (P == 0 || (P - S) != I) { - printf ("Failed for code 0x%02X, offset %u!\n", S[I], I); - printf ("P = %04X offset = %04X\n", P, P-S); - exit (EXIT_FAILURE); - } - - /* Mark the char as checked */ - Found[S[I]] = 1; - } - - /* Search for all other characters and make sure they aren't found */ - for (I = 0; I < 256; ++I) { - if (Found[I] == 0) { - if (strchr (S, (char)I) != 0) { - printf ("Failed for code 0x%02X\n", I); - exit (EXIT_FAILURE); - } - } - } - - /* Test passed */ - printf ("Passed\n"); - return EXIT_SUCCESS; -} - - - diff --git a/testcode/lib/strrchr-test.c b/testcode/lib/strrchr-test.c deleted file mode 100644 index a72c44db9..000000000 --- a/testcode/lib/strrchr-test.c +++ /dev/null @@ -1,38 +0,0 @@ -#include -#include "unittest.h" - -static char TestString[] = "01234567890123456789"; // two times the same string -static char Found[256]; - -TEST -{ - unsigned len; - unsigned i; - char* p; - - len = strlen(TestString)/2; // test only one half of the string, to find last appearance - - /* Search for all characters in the string, including the terminator */ - for (i = 0; i < len; ++i) - { - /* Search for this char */ - p = strrchr (TestString, TestString[i]); - ASSERT_AreEqual(i+len, p-TestString, "%u", "Unexpected location of character '%c' found!" COMMA TestString[i]); - - /* Mark the char as checked */ - Found[TestString[i]] = 1; - } - - /* Search for all other characters and make sure they aren't found */ - for (i = 0; i < 256; ++i) - { - if (!Found[i]) - { - p = strrchr (TestString, i); - ASSERT_IsFalse(p, "Unexpected location of character '%c' found!" COMMA TestString[i]); - } - } -} -ENDTEST - - diff --git a/testcode/lib/unittest.h b/testcode/lib/unittest.h deleted file mode 100644 index bd355bb0c..000000000 --- a/testcode/lib/unittest.h +++ /dev/null @@ -1,89 +0,0 @@ -/*****************************************************************************/ -/* */ -/* unittest.h */ -/* */ -/* Unit test helper macros */ -/* */ -/* */ -/* */ -/* (C) 2017 Christian Krueger */ -/* */ -/* This software is provided 'as-is', without any expressed or implied */ -/* warranty. In no event will the authors be held liable for any damages */ -/* arising from the use of this software. */ -/* */ -/* Permission is granted to anyone to use this software for any purpose, */ -/* including commercial applications, and to alter it and redistribute it */ -/* freely, subject to the following restrictions: */ -/* */ -/* 1. The origin of this software must not be misrepresented; you must not */ -/* claim that you wrote the original software. If you use this software */ -/* in a product, an acknowledgment in the product documentation would be */ -/* appreciated but is not required. */ -/* 2. Altered source versions must be plainly marked as such, and must not */ -/* be misrepresented as being the original software. */ -/* 3. This notice may not be removed or altered from any source */ -/* distribution. */ -/* */ -/*****************************************************************************/ - -#ifndef _UNITTEST_H -#define _UNITTEST_H - -#include -#include - -#ifndef COMMA -#define COMMA , -#endif - -#define TEST int main(void) \ - {\ - printf("%s: ",__FILE__); - -#define ENDTEST printf("Passed\n"); \ - return EXIT_SUCCESS; \ - } - -#define ASSERT_IsTrue(a,b) if (!(a)) \ - {\ - printf("Fail at line %d:\n",__LINE__);\ - printf(b);\ - printf("\n");\ - printf("Expected status should be true but wasn't!\n");\ - exit(EXIT_FAILURE);\ - } - -#define ASSERT_IsFalse(a,b) if ((a)) \ - {\ - printf("Fail at line %d:\n",__LINE__);\ - printf(b);\ - printf("\n");\ - printf("Expected status should be false but wasn't!\n");\ - exit(EXIT_FAILURE);\ - } - -#define ASSERT_AreEqual(a,b,c,d) if ((a) != (b)) \ - {\ - printf("Fail at line %d:\n",__LINE__);\ - printf(d);\ - printf("\n");\ - printf("Expected value: "c", but is "c"!\n", (a), (b));\ - exit(EXIT_FAILURE);\ - } - -#define ASSERT_AreNotEqual(a,b,c,d) if ((a) == (b)) \ - {\ - printf("Fail at line %d:\n",__LINE__);\ - printf(d);\ - printf("\n");\ - printf("Expected value not: "c", but is "c"!\n", (a), (b));\ - exit(EXIT_FAILURE);\ - } - -/* End of unittest.h */ -#endif - - - -