bslathi19/cc65
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Merge pull request #389 from IrgendwerA8/stringimprovements

Browse Source 
Optimization of string functions (size & speed).
This commit is contained in:
Oliver Schmidt
2017-04-04 15:39:37 +02:00
committed by GitHub
parent 4e856546c1 371e8efb79
commit 233dd5062a
20 changed files with 607 additions and 267 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
libsrc/common/memmove.s
View File

@@ -1,6 +1,6 @@
; ;
; 2003-08-20, Ullrich von Bassewitz ; 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 ; 2015-10-23, Greg King
; ;
; void* __fastcall__ memmove (void* dest, const void* src, size_t size); ; 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 ptr1+1 ; adjust base...
dec ptr2+1 dec ptr2+1
dey ; in entry case: 0 -> FF 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: @copyBytes:
.repeat 2 ; Unroll this a bit to make it faster... .repeat 3 ; unroll this a bit to make it faster...
lda (ptr1),y lda (ptr1),y ; important: unrolling three times gives a nice
sta (ptr2),y sta (ptr2),y ; 255/3 = 85 loop which ends at 0
dey dey
.endrepeat .endrepeat
@copyEntry: ; in entry case: 0 -> FF @copyEntry: ; in entry case: 0 -> FF

70
libsrc/common/strcat.s
View File

@@ -1,5 +1,6 @@
; ;
; Ullrich von Bassewitz, 31.05.1998 ; Ullrich von Bassewitz, 31.05.1998
; Christian Krueger: 2013-Jul-24, minor optimizations
; ;
; char* strcat (char* dest, const char* src); ; char* strcat (char* dest, const char* src);
; ;
@@ -7,49 +8,44 @@
.export _strcat .export _strcat
.import popax .import popax
.importzp ptr1, ptr2, tmp3 .importzp ptr1, ptr2, tmp3
.macpack cpu
_strcat: _strcat:
sta ptr1 ; Save src sta ptr1 ; Save src
stx ptr1+1 stx ptr1+1
jsr popax ; Get dest jsr popax ; Get dest
sta ptr2 sta tmp3 ; Remember for function return
stx ptr2+1 tay
sta tmp3 ; Remember for function return .if (.cpu .bitand ::CPU_ISET_65SC02)
ldy #0 stz ptr2
.else
lda #0
sta ptr2 ; access from page start, y contains low byte
.endif
stx ptr2+1
; find end of dest findEndOfDest:
lda (ptr2),y
sc1: lda (ptr2),y beq endOfDestFound
beq sc2
iny iny
bne sc1 bne findEndOfDest
inc ptr2+1 inc ptr2+1
bne sc1 bne findEndOfDest
; end found, get offset in y into pointer endOfDestFound:
sty ptr2 ; advance pointer to last y position
ldy #0 ; reset new y-offset
sc2: tya copyByte:
clc lda (ptr1),y
adc ptr2 sta (ptr2),y
sta ptr2 beq done
bcc sc3
inc ptr2+1
; copy src
sc3: ldy #0
sc4: lda (ptr1),y
sta (ptr2),y
beq sc5
iny iny
bne sc4 bne copyByte
inc ptr1+1 inc ptr1+1
inc ptr2+1 inc ptr2+1
bne sc4 bne copyByte ; like bra here
; done, return pointer to dest ; return pointer to dest
done: lda tmp3 ; X does still contain high byte
sc5: lda tmp3 ; X does still contain high byte
rts rts

52
libsrc/common/strchr.s
View File

@@ -1,5 +1,6 @@
; ;
; Ullrich von Bassewitz, 31.05.1998 ; Ullrich von Bassewitz, 31.05.1998
; Christian Krueger, 2013-Aug-04, minor optimization
; ;
; const char* strchr (const char* s, int c); ; const char* strchr (const char* s, int c);
; ;
@@ -7,42 +8,45 @@
.export _strchr .export _strchr
.import popax .import popax
.importzp ptr1, tmp1 .importzp ptr1, tmp1
.macpack cpu
_strchr: _strchr:
sta tmp1 ; Save c sta tmp1 ; Save c
jsr popax ; get s jsr popax ; get s
sta ptr1 tay ; low byte of pointer to y
stx ptr1+1 stx ptr1+1
ldy #0 .if (.cpu .bitand ::CPU_ISET_65SC02)
stz ptr1
.else
lda #0
sta ptr1 ; access from page start, y contains low byte
.endif
Loop: lda (ptr1),y ; Get next char Loop: lda (ptr1),y ; Get next char
beq EOS ; Jump on end of string beq EOS ; Jump on end of string
cmp tmp1 ; Found? cmp tmp1 ; Found?
beq Found ; Jump if yes beq Found ; Jump if yes
iny iny
bne Loop bne Loop
inc ptr1+1 inc ptr1+1
bne Loop ; Branch always bne Loop ; Branch always
; End of string. Check if we're searching for the terminating zero ; End of string. Check if we're searching for the terminating zero
EOS: lda tmp1 ; Get the char we're searching for EOS:
bne NotFound ; Jump if not searching for terminator lda tmp1 ; Get the char we're searching for
bne NotFound ; Jump if not searching for terminator
; Found. Calculate pointer to c. ; Found. Set pointer to c.
Found: ldx ptr1+1 ; Load high byte of pointer Found:
tya ; Low byte offset ldx ptr1+1 ; Load high byte of pointer
clc tya ; low byte is in y
adc ptr1 rts
bcc Found1
inx
Found1: rts
; Not found, return NULL ; Not found, return NULL
NotFound: NotFound:
lda #0 lda #0
tax tax
rts rts

78
libsrc/common/strcspn.s
View File

@@ -1,54 +1,54 @@
; ;
; Ullrich von Bassewitz, 11.06.1998 ; Ullrich von Bassewitz, 11.06.1998
; Christian Krueger: 05-Aug-2013, optimization
; ;
; size_t strcspn (const char* s1, const char* s2); ; size_t strcspn (const char* s1, const char* s2);
; ;
.export _strcspn .export _strcspn
.import popax .import popax, _strlen
.importzp ptr1, ptr2, tmp1, tmp2, tmp3 .importzp ptr1, ptr2, tmp1, tmp2
_strcspn: _strcspn:
sta ptr2 ; Save s2 jsr _strlen ; get length in a/x and transfer s2 to ptr1
stx ptr2+1 ; Note: It does not make sense to
jsr popax ; Get s1 ; have more than 255 test chars, so
sta ptr1 ; we don't support a high byte here! (ptr1+1 is
stx ptr1+1 ; also unchanged in strlen then (important!))
ldx #0 ; low counter byte ; -> the original implementation also
stx tmp1 ; high counter byte ; ignored this case
ldy #$00
L1: lda (ptr1),y ; get next char from s1 sta tmp1 ; tmp1 = strlen of test chars
beq L6 ; jump if done jsr popax ; get and save s1
sta tmp2 ; save char 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 iny
bne L2 check: cpy tmp1 ; compare with length of test character string
inc ptr1+1 beq endOfTestChars
L2: sty tmp3 ; save index into s1 cmp (ptr1),y ; found matching char?
bne checkNext
ldy #0 ; get index into s2 leave: txa ; restore position of finding
L3: lda (ptr2),y ; ldx tmp2 ; and return
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
; 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
rts rts
endOfTestChars:
inx
bne loadChar
inc tmp2
bne loadChar ; like bra...

5
libsrc/common/strlen.s
View File

@@ -1,6 +1,10 @@
; ;
; Ullrich von Bassewitz, 31.05.1998 ; 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); ; int strlen (const char* s);
; ;
@@ -23,4 +27,3 @@ L1: lda (ptr1),y
L9: tya ; get low byte of counter, hi's all set L9: tya ; get low byte of counter, hi's all set
rts rts

99
libsrc/common/strncat.s
View File

@@ -1,5 +1,6 @@
; ;
; Ullrich von Bassewitz, 31.05.1998 ; Ullrich von Bassewitz, 31.05.1998
; Christian Krueger: 12-Aug-2013, minor optimizations
; ;
; char* strncat (char* dest, const char* src, size_t n); ; char* strncat (char* dest, const char* src, size_t n);
; ;
@@ -7,66 +8,68 @@
.export _strncat .export _strncat
.import popax .import popax
.importzp ptr1, ptr2, ptr3, tmp1, tmp2 .importzp ptr1, ptr2, ptr3, tmp1, tmp2
.macpack cpu
_strncat: _strncat:
eor #$FF ; one's complement to count upwards eor #$FF ; one's complement to count upwards
sta tmp1 sta tmp1
txa txa
eor #$FF eor #$FF
sta tmp2 sta tmp2
jsr popax ; get src
sta ptr1 jsr popax ; get src
stx ptr1+1 sta ptr1
jsr popax ; get dest stx ptr1+1
sta ptr2
stx ptr2+1 jsr popax ; get dest
sta ptr3 ; remember for function return sta ptr3 ; remember for function return
stx ptr3+1 stx ptr3+1
ldy #0 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
; find end of dest ; find end of dest
L1: lda (ptr2),y L1: lda (ptr2),y
beq L2 beq L2
iny iny
bne L1 bne L1
inc ptr2+1 inc ptr2+1
bne L1 bne L1
; end found, get offset in y into pointer ; end found, apply offset to dest ptr and reset y
L2: sty ptr2
L2: tya
clc
adc ptr2
sta ptr2
bcc L3
inc ptr2+1
; copy src. We've put the ones complement of the count into the counter, so ; 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 ; we'll increment the counter on top of the loop
L3: ldy #0 L3: ldy #0
ldx tmp1 ; low counter byte ldx tmp1 ; low counter byte
L4: inx L4: inx
bne L5 bne L5
inc tmp2 inc tmp2
beq L6 ; jump if done beq L6 ; jump if done
L5: lda (ptr1),y L5: lda (ptr1),y
sta (ptr2),y sta (ptr2),y
beq L7 beq L7
iny iny
bne L4 bne L4
inc ptr1+1 inc ptr1+1
inc ptr2+1 inc ptr2+1
bne L4 bne L4
; done, set the trailing zero and return pointer to dest ; done, set the trailing zero and return pointer to dest
L6: lda #0 L6: lda #0
sta (ptr2),y sta (ptr2),y
L7: lda ptr3 L7: lda ptr3
ldx ptr3+1 ldx ptr3+1
rts rts

58
libsrc/common/strrchr.s
View File

@@ -1,47 +1,41 @@
; ;
; Ullrich von Bassewitz, 31.05.1998 ; Ullrich von Bassewitz, 31.05.1998
; Christian Krueger: 2013-Aug-01, optimization
; ;
; char* strrchr (const char* s, int c); ; char* strrchr (const char* s, int c);
; ;
.export _strrchr .export _strrchr
.import popax .import popax
.importzp ptr1, ptr2, tmp1 .importzp ptr1, tmp1, tmp2
_strrchr: _strrchr:
sta tmp1 ; Save c sta tmp1 ; Save c
jsr popax ; get s jsr popax ; get s
sta ptr1 tay ; low byte to y
stx ptr1+1 stx ptr1+1
lda #0 ; function result = NULL ldx #0 ; default function result is NULL, X is high byte...
sta ptr2 stx tmp2 ; tmp2 is low-byte
sta ptr2+1 stx ptr1 ; low-byte of source string is in Y, so clear real one...
tay
testChar:
lda (ptr1),y ; get char
beq finished ; jump if end of string
cmp tmp1 ; found?
bne nextChar ; jump if no
L1: lda (ptr1),y ; get next char charFound:
beq L3 ; jump if end of string sty tmp2 ; y has low byte of location, save it
cmp tmp1 ; found? ldx ptr1+1 ; x holds high-byte of result
bne L2 ; jump if no
; Remember a pointer to the character nextChar:
iny
bne testChar
inc ptr1+1
bne testChar ; here like bra...
tya ; return the pointer to the last occurrence
clc
adc ptr1
sta ptr2
lda ptr1+1
adc #$00
sta ptr2+1
; Next char finished:
lda tmp2 ; high byte in X is already correct...
L2: iny
bne L1
inc ptr1+1
bne L1 ; jump always
; Return the pointer to the last occurrence
L3: lda ptr2
ldx ptr2+1
rts rts

80
libsrc/common/strspn.s
View File

@@ -1,56 +1,54 @@
; ;
; Ullrich von Bassewitz, 11.06.1998 ; Ullrich von Bassewitz, 11.06.1998
; Christian Krueger: 08-Aug-2013, optimization
; ;
; size_t strspn (const char* s1, const char* s2); ; size_t strspn (const char* s1, const char* s2);
; ;
.export _strspn .export _strspn
.import popax .import popax, _strlen
.importzp ptr1, ptr2, tmp1, tmp2, tmp3 .importzp ptr1, ptr2, tmp1, tmp2
_strspn: _strspn:
sta ptr2 ; Save s2 jsr _strlen ; get length in a/x and transfer s2 to ptr1
stx ptr2+1 ; Note: It does not make sense to
jsr popax ; get s1 ; have more than 255 test chars, so
sta ptr1 ; we don't support a high byte here! (ptr1+1 is
stx ptr1+1 ; also unchanged in strlen then (important!))
ldx #0 ; low counter byte ; -> the original implementation also
stx tmp1 ; high counter byte ; ignored this case
ldy #$00
L1: lda (ptr1),y ; get next char from s1 sta tmp1 ; tmp1 = strlen of test chars
beq L6 ; jump if done jsr popax ; get and save s1
sta tmp2 ; save char 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 iny
bne L2 check: cpy tmp1 ; compare with length of test character string
inc ptr1+1 beq leave
L2: sty tmp3 ; save index into s1 cmp (ptr1),y ; found matching char?
bne checkNext
ldy #0 ; get index into s2 foundTestChar:
L3: lda (ptr2),y ;
beq L6 ; jump if done
cmp tmp2
beq L4
iny
bne L3
; The character was found in s2. Increment the counter and start over
L4: ldy tmp3 ; reload index
inx inx
bne L1 bne loadChar
inc tmp1 inc tmp2
bne L1 bne loadChar ; like bra...
; The character was not found, or we reached the end of s1. Return count of leave: txa ; restore position of finding
; characters ldx tmp2 ; and return
L6: txa ; get low counter byte
ldx tmp1 ; get high counter byte
rts rts

16
libsrc/runtime/axlong.s
View File

@@ -1,5 +1,6 @@
; ;
; Ullrich von Bassewitz, 25.10.2000 ; Ullrich von Bassewitz, 25.10.2000
; Christian Krueger, 02-Mar-2017, some bytes saved
; ;
; CC65 runtime: Convert int in ax into a long ; CC65 runtime: Convert int in ax into a long
; ;
@@ -9,18 +10,13 @@
; Convert AX from int to long in EAX ; Convert AX from int to long in EAX
axlong: ldy #$ff
cpx #$80 ; Positive?
bcs store ; No, apply $FF
axulong: axulong:
ldy #0 ldy #0
sty sreg store: sty sreg
sty sreg+1 sty sreg+1
rts rts
axlong: cpx #$80 ; Positive?
bcc axulong ; Yes, handle like unsigned type
ldy #$ff
sty sreg
sty sreg+1
rts

0
test/val/atoi-test.c → test/val/lib_common_atoi.c
View File

65
test/val/lib_common_memmove.c Normal file
View File

@@ -0,0 +1,65 @@
// temporarily disable optimizations altogether until a fine grain control
// is implemented on Makefile level only disabling the compiler option -Os
#pragma optimize (off)
#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

58
test/val/lib_common_strcat.c Normal file
View File

@@ -0,0 +1,58 @@
// temporarily disable optimizations altogether until a fine grain control
// is implemented on Makefile level only disabling the compiler option -Os
#pragma optimize (off)
#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

39
testcode/lib/strchr-test.c → test/val/lib_common_strchr.c
View File

@@ -1,7 +1,5 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h> #include <string.h>
#include "unittest.h"
/* Test string. Must NOT have duplicate characters! */ /* Test string. Must NOT have duplicate characters! */
@@ -11,49 +9,34 @@ static char Found[256];
int main (void) TEST
{ {
unsigned Len; unsigned Len;
unsigned I; unsigned I;
char* P; char* P;
/* Print a header */
printf ("strchr(): ");
/* Get the length of the string */ /* Get the length of the string */
Len = strlen (S); Len = strlen (S);
/* Search for all characters in the string, including the terminator */ /* Search for all characters in the string, including the terminator */
for (I = 0; I < Len+1; ++I) { for (I = 0; I < Len+1; ++I)
{
/* Search for this char */ /* Search for this char */
P = strchr (S, S[I]); P = strchr (S, S[I]);
/* Check if we found it */ /* Check if we found it */
if (P == 0 || (P - S) != I) { 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);
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 */ /* Mark the char as checked */
Found[S[I]] = 1; Found[S[I]] = 1;
} }
/* Search for all other characters and make sure they aren't found */ /* Search for all other characters and make sure they aren't found */
for (I = 0; I < 256; ++I) { for (I = 0; I < 256; ++I)
if (Found[I] == 0) { {
if (strchr (S, (char)I) != 0) { if (Found[I] == 0)
printf ("Failed for code 0x%02X\n", I); {
exit (EXIT_FAILURE); ASSERT_IsFalse(strchr (S, (char)I), "Failed for code 0x%02X\n" COMMA I);
}
} }
} }
/* Test passed */
printf ("Passed\n");
return EXIT_SUCCESS;
} }
ENDTEST

30
test/val/lib_common_strcspn.c Normal file
View File

@@ -0,0 +1,30 @@
// temporarily disable optimizations altogether until a fine grain control
// is implemented on Makefile level only disabling the compiler option -Os
#pragma optimize (off)
#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

58
test/val/lib_common_strncat.c Normal file
View File

@@ -0,0 +1,58 @@
// temporarily disable optimizations altogether until a fine grain control
// is implemented on Makefile level only disabling the compiler option -Os
#pragma optimize (off)
#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

0
test/val/strtol-test.c → test/val/lib_common_strol.c
View File

38
test/val/lib_common_strrchr.c Normal file
View File

@@ -0,0 +1,38 @@
#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

28
test/val/lib_common_strspn.c Normal file
View File

@@ -0,0 +1,28 @@
// temporarily disable optimizations altogether until a fine grain control
// is implemented on Makefile level only disabling the compiler option -Os
#pragma optimize (off)
#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

0
test/val/strtoul-test.c → test/val/lib_common_strtoul.c
View File

89
test/val/unittest.h Normal file
View File

@@ -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 <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