;
; 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);
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
;
; 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);
;
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:
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
;
; 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...
;
; 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);
;
L9: tya ; get low byte of counter, hi's all set
rts
-
;
; Ullrich von Bassewitz, 31.05.1998
+; Christian Krueger: 12-Aug-2013, minor optimizations
;
; char* strncat (char* dest, const char* src, size_t n);
;
.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
;
; 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
;
; Ullrich von Bassewitz, 25.10.2000
+; Christian Krueger, 02-Mar-2017, some bytes saved
;
; CC65 runtime: Convert int in ax into a long
;
; 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
-
-
+++ /dev/null
-/*
- !!DESCRIPTION!! A small test for atoi. Assumes twos complement
- !!ORIGIN!!
- !!LICENCE!!
- !!AUTHOR!!
-*/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <limits.h>
-#include <errno.h>
-
-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;
-}
--- /dev/null
+/*
+ !!DESCRIPTION!! A small test for atoi. Assumes twos complement
+ !!ORIGIN!!
+ !!LICENCE!!
+ !!AUTHOR!!
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
+
+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;
+}
--- /dev/null
+#include <string.h>
+#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
+
+
--- /dev/null
+#include <string.h>
+#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
--- /dev/null
+#include <string.h>
+#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
--- /dev/null
+#include <string.h>
+#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
+
+
--- /dev/null
+#include <string.h>
+#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
+
+
--- /dev/null
+/*
+ !!DESCRIPTION!! A small test for atoi/strtol. Assumes twos complement
+ !!ORIGIN!!
+ !!LICENCE!!
+ !!AUTHOR!!
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
+
+#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;
+}
--- /dev/null
+#include <string.h>
+#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
+
+
--- /dev/null
+#include <string.h>
+#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
--- /dev/null
+/*
+ !!DESCRIPTION!! A small test for strtuol. Assumes twos complement
+ !!ORIGIN!!
+ !!LICENCE!!
+ !!AUTHOR!!
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
+
+#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;
+}
+++ /dev/null
-/*
- !!DESCRIPTION!! A small test for atoi/strtol. Assumes twos complement
- !!ORIGIN!!
- !!LICENCE!!
- !!AUTHOR!!
-*/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <limits.h>
-#include <errno.h>
-
-#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;
-}
+++ /dev/null
-/*
- !!DESCRIPTION!! A small test for strtuol. Assumes twos complement
- !!ORIGIN!!
- !!LICENCE!!
- !!AUTHOR!!
-*/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <limits.h>
-#include <errno.h>
-
-#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;
-}
--- /dev/null
+/*****************************************************************************/
+/* */
+/* 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 <stdio.h>
+#include <stdlib.h>
+
+#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
+
+
+
+
+++ /dev/null
-#include <string.h>
-#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
-
-
+++ /dev/null
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-
-
-/* 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;
-}
-
-
-
+++ /dev/null
-#include <string.h>
-#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
-
-
+++ /dev/null
-/*****************************************************************************/
-/* */
-/* 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 <stdio.h>
-#include <stdlib.h>
-
-#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
-
-
-
-
projects / cc65 / commitdiff