788 lines
25 KiB
C
788 lines
25 KiB
C
|
|
#include <gint/display.h>
|
|
#include <gint/keyboard.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <gint/gint.h>
|
|
#include <fxlibc/printf.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
#include <stdint.h>
|
|
#include <stdbool.h>
|
|
|
|
|
|
#define ASSERTFP( a, value, eps ) ((a)>((value)+(eps)) ? false : (a)<((value)-(eps)) ? false : true )
|
|
|
|
|
|
// global return values and character read so far
|
|
int ret = -20;
|
|
int n = -20;
|
|
|
|
// char arrays to test %c and %s scanf() formats
|
|
char c[10] = ".........";
|
|
char str[25] = "........................";
|
|
char str2[25] = "........................";
|
|
|
|
// unsigned integers (various length to cover all hh/h/l/ll modifiers) to test %d %i %u %o %x %X scanf() formats
|
|
uint64_t ulli = 0;
|
|
uint32_t uli = 0;
|
|
uint32_t ui = 0;
|
|
uint16_t usi = 0;
|
|
uint8_t ussi = 0;
|
|
|
|
// signed integers (various length to cover all hh/h/l/ll modifiers) to test %d %i %u %o %x %X scanf() formats
|
|
int64_t slli = 0;
|
|
int32_t sli = 0;
|
|
int32_t si = 0;
|
|
int16_t ssi = 0;
|
|
int8_t sssi = 0;
|
|
|
|
float f1 = 0;
|
|
float f2 = 0;
|
|
double d1 = 0;
|
|
double d2 = 0;
|
|
long double ld1 = 0;
|
|
long double ld2 = 0;
|
|
|
|
|
|
int fscan_test( void )
|
|
{
|
|
int line=1;
|
|
FILE *fp = fopen("input.txt", "r");
|
|
|
|
if (fp == NULL) {
|
|
dprint( 1, line, C_BLACK, "Error: Failed to open file\n");
|
|
line+=10;
|
|
return 1;
|
|
}
|
|
|
|
// Test 1: Read an integer
|
|
int i;
|
|
fscanf(fp, "%d", &i);
|
|
dprint( 1, line, C_BLACK, "Test 1: Read integer: %d\n", i);
|
|
line+=10;
|
|
|
|
// Test 2: Read a floating-point number
|
|
float f;
|
|
fscanf(fp, "%f", &f);
|
|
dprint( 1, line, C_BLACK, "Test 2: Read floating-point number: %f\n", f);
|
|
line+=10;
|
|
|
|
// Test 3: Read a string with spaces
|
|
char s[20];
|
|
fscanf(fp, "%s", s);
|
|
dprint( 1, line, C_BLACK, "Test 3: Read string: %s\n", s);
|
|
line+=10;
|
|
|
|
// Test 4: Read a character
|
|
char cc;
|
|
fscanf(fp, "%*c%c", &cc);
|
|
dprint( 1, line, C_BLACK, "Test 4: Read character: %c\n", cc);
|
|
line+=10;
|
|
|
|
// Test 5: Read multiple values
|
|
int a, b, d;
|
|
float c1;
|
|
fscanf(fp, "%d%f%d", &a, &c1, &b);
|
|
dprint( 1, line, C_BLACK, "Test 5: Read multiple values: %d, %f, %d\n", a, c1, b);
|
|
line+=10;
|
|
|
|
// Test 6: Read a string with spaces using %[^\n]
|
|
char s1[50];
|
|
fscanf(fp, " %[^\n]", s1);
|
|
dprint( 1, line, C_BLACK, "Test 6: Read string with spaces: %s\n", s1);
|
|
line+=10;
|
|
|
|
// Test 7: Read until EOF
|
|
int num, count = 0;
|
|
while (fscanf(fp, "%d", &num) == 1) {
|
|
dprint( 1, line, C_BLACK, "Test 7: Read number: %d\n", num);
|
|
line+=10;
|
|
count++;
|
|
}
|
|
dprint( 1, line, C_BLACK, "Test 7: Total numbers read: %d\n", count);
|
|
line+=10;
|
|
|
|
// Test 8: Error handling - invalid input
|
|
int x;
|
|
int ret = fscanf(fp, "%d", &x);
|
|
if (ret == EOF) {
|
|
dprint( 1, line, C_BLACK, "Test 8: End of file reached\n");
|
|
line+=10;
|
|
}
|
|
else if (ret == 0) {
|
|
dprint( 1, line, C_BLACK, "Test 8: Invalid input\n");
|
|
line+=10;
|
|
}
|
|
else {
|
|
dprint( 1, line, C_BLACK, "Test 8: Read number: %d\n", x);
|
|
line+=10;
|
|
}
|
|
|
|
|
|
// Test 9: Error handling - end of file
|
|
int y;
|
|
ret = fscanf(fp, "%d", &y);
|
|
if (ret == EOF) {
|
|
dprint( 1, line, C_BLACK, "Test 9: End of file reached\n");
|
|
line+=10;
|
|
}
|
|
else {
|
|
dprint( 1, line, C_BLACK, "Test 9: Read number: %d\n", y);
|
|
line+=10;
|
|
}
|
|
|
|
fclose(fp);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
void clear( void )
|
|
{
|
|
|
|
ret = -20;
|
|
n = -20;
|
|
|
|
strcpy( c, "........." );
|
|
strcpy( str, "........................" );
|
|
strcpy( str2, "........................" );
|
|
|
|
ulli = 0;
|
|
uli = 0;
|
|
ui = 0;
|
|
usi = 0;
|
|
ussi = 0;
|
|
|
|
slli = 0;
|
|
sli = 0;
|
|
si = 0;
|
|
ssi = 0;
|
|
sssi = 0;
|
|
|
|
f1 = 0;
|
|
f2 = 0;
|
|
|
|
d1 = 0;
|
|
d2 = 0;
|
|
|
|
ld1 = 0;
|
|
ld2 = 0;
|
|
}
|
|
|
|
main(void)
|
|
{
|
|
__printf_enable_fp();
|
|
|
|
|
|
dclear(C_WHITE);
|
|
|
|
// results as per glic/sscanf are given in comments after the corresponding dprint()
|
|
|
|
/******************************/
|
|
/* TESTS ON CHARS AND STRINGS */
|
|
/******************************/
|
|
|
|
clear();
|
|
ret = sscanf( "abcdefghij", "%c%n", &c[0], &n );
|
|
assert( c[0]=='a' && n==1 && ret==1 );
|
|
dprint( 1, 10, C_BLACK, "#1 : rd 1c : [%c] cn=%d rt=%d", c[0], n, ret );
|
|
dupdate();
|
|
// #1 : rd 1c : [a] cn=1 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "abcdefghij", "%c%*c%c%n", &c[0], &c[2], &n );
|
|
assert( c[0]=='a' && c[1]=='.' && c[2]=='c' && n==3 && ret==2 );
|
|
dprint( 1, 20, C_BLACK, "#2 : rd 1c + skp 1c + rd 1c : [%c][%c][%c] cn=%d rt=%d", c[0], c[1], c[2], n, ret );
|
|
dupdate();
|
|
// #2 : rd 1c + skp 1c + rd 1c : [a][.][c] cn=3 rt=2
|
|
|
|
clear();
|
|
ret = sscanf( "abcdefghij", "%3c%n", &c, &n );
|
|
assert( c[0]=='a' && c[1]=='b' && c[2]=='c' && n==3 && ret==1 );
|
|
dprint( 1, 30, C_BLACK, "#3 : rd 3c (w 3c) : [%c][%c][%c] cn=%d rt=%d", c[0], c[1], c[2], n, ret );
|
|
dupdate();
|
|
// #3 : rd 3c (w 3c) : [a][b][c] cn=3 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "abcdefghij", "%*5c%3c%n", &c, &n );
|
|
assert( c[0]=='f' && c[1]=='g' && c[2]=='h' && n==8 && ret==1 );
|
|
dprint( 1, 40, C_BLACK, "#4 : skp 5c + rd 3c (w 3c) : [%c][%c][%c] cn=%d rt=%d", c[0], c[1], c[2], n, ret );
|
|
dupdate();
|
|
// #4 : skp 5c + rd 3c (w 3c) : [f][g][h] cn=8 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "abcdefghij", "%n", &n );
|
|
assert( n==0 && ret==0 );
|
|
dprint( 1, 50, C_BLACK, "#5 : no char : cn=%d rt=%d", n, ret );
|
|
dupdate();
|
|
// #5 : no char : cn=0 rt=0
|
|
|
|
clear();
|
|
ret = sscanf( "abcdefghij", "%s%n", str, &n );
|
|
assert( strcmp(str, "abcdefghij")==0 && n==10 && ret==1 );
|
|
dprint( 1, 60, C_BLACK, "#6 : rd 1s : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #6 : rd 1s : [abcdefghij] cn=10 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "abcde ghij", "%s%n", str, &n );
|
|
assert( strcmp(str, "abcde")==0 && n==5 && ret==1 );
|
|
dprint( 1, 70, C_BLACK, "#7 : rd 1s with space : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #7 : rd 1s with space : [abcde] cn=5 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "abcdefghij", "%*5c%s%n", str, &n );
|
|
assert( strcmp(str, "fghij")==0 && n==10 && ret==1 );
|
|
dprint( 1, 80, C_BLACK, "#8 : skp 5c + rd 1str : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #8 : skp 5c + rd 1str : [fghij] cn=10 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "", "%*5c%s%n", str, &n );
|
|
assert( strcmp(str, "........................" )==0 && n==-20 && ret==-1 );
|
|
dprint( 1, 90, C_BLACK, "#9 : empty str tst1 : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #9 : empty str tst1 : [........................] cn=-20 rt=-1
|
|
|
|
clear();
|
|
ret = sscanf( "", "%c%s%n", &c[0], str, &n );
|
|
assert( c[0]=='.' && strcmp(str, "........................" )==0 && n==-20 && ret==-1 );
|
|
dprint( 1, 100, C_BLACK, "#10 : empty str tst2 : [%c][%s] cn=%d rt=%d", c[0], str, n, ret );
|
|
dupdate();
|
|
// #10 : empty str tst2 : [.][........................] cn=-20 rt=-1
|
|
|
|
clear();
|
|
ret = sscanf( "abcdef ghijkl", "%s%s%n", str, str2, &n );
|
|
assert( strcmp( str, "abcdef")==0 && strcmp(str2, "ghijkl" )==0 && n==13 && ret==2 );
|
|
dprint( 1, 110, C_BLACK, "#11 : rd 1s + 1s : [%s][%s] cn=%d rt=%d", str, str2, n, ret );
|
|
dupdate();
|
|
// #11 : rd 1s + rd 1s : [abcdef][ghijkl] cn=13 rt=2
|
|
|
|
clear();
|
|
ret = sscanf( "abcdef ghijkl", "%s%c%s%n", str, &c[0], str2, &n );
|
|
assert( strcmp( str, "abcdef")==0 && c[0]==' ' && strcmp(str2, "ghijkl" )==0 && n==13 && ret==3 );
|
|
dprint( 1, 120, C_BLACK, "#12 : rd 1s + 1c + 1s : [%s][%c][%s] cn=%d rt=%d", str, c[0], str2, n, ret );
|
|
dupdate();
|
|
// #12 : rd 1s + rd 1c + rd 1s : [abcdef][ ][ghijkl] cn=13 rt=3
|
|
|
|
getkey();
|
|
|
|
/******************************/
|
|
/* TESTS ON INTEGER NUMBERS */
|
|
/******************************/
|
|
|
|
dclear( C_WHITE );
|
|
|
|
clear();
|
|
ret = sscanf( "1234567890", "%d%n", &si, &n );
|
|
assert( si==1234567890 && n==10 && ret==1 );
|
|
dprint( 1, 10, C_BLACK, "#13 : rd 1d : [%d] cn=%d rt=%d", si, n, ret );
|
|
dupdate();
|
|
// #13 : rd 1d : [1234567890] cn=10 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "1234567890", "%d%n", &ui, &n );
|
|
assert( ui==1234567890 && n==10 && ret==1 );
|
|
dprint( 1, 20, C_BLACK, "#14 : rd 1d : [%d] cn=%d rt=%d", ui, n, ret );
|
|
dupdate();
|
|
// #14 : rd 1d : [1234567890] cn=10 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "-1234567890", "%d%n", &si, &n );
|
|
assert( si==-1234567890 && n==11 && ret==1 );
|
|
dprint( 1, 30, C_BLACK, "#15 : rd 1d : [%d] cn=%d rt=%d", si, n, ret );
|
|
dupdate();
|
|
// #15 : rd 1d : [-1234567890] cn=11 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "-1234567890", "%d%n", &ui, &n );
|
|
assert( ui==-1234567890 && n==11 && ret==1 );
|
|
dprint( 1, 40, C_BLACK, "#16 : rd 1d : [%d] cn=%d rt=%d", ui, n, ret );
|
|
dupdate();
|
|
// #16 : rd 1d : [-1234567890] cn=11 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "1234567890", "%hd%n", &ssi, &n );
|
|
//assert( ssi==722 && n==10 && ret==1 );
|
|
dprint( 1, 50, C_BLACK, "#17 : rd 1hd : [%hd] cn=%d rt=%d", ssi, n, ret );
|
|
dupdate();
|
|
// #17 : rd 1hd : [722] cn=10 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "1234567890", "%hhd%n", &sssi, &n );
|
|
//assert( sssi==-46 && n==10 && ret==1 );
|
|
dprint( 1, 60, C_BLACK, "#18 : rd 1hhd : [%hhd] cn=%d rt=%d", sssi, n, ret );
|
|
dupdate();
|
|
// #18 : rd 1hhd : [-46] cn=10 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "1234567890", "%ld%n", &sli, &n );
|
|
assert( sli==1234567890 && n==10 && ret==1 );
|
|
dprint( 1, 70, C_BLACK, "#19 : rd 1ld : [%ld] cn=%d rt=%d", sli, n, ret );
|
|
dupdate();
|
|
// #19 : rd 1ld : [1234567890] cn=10 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "1234567890", "%lld%n", &slli, &n );
|
|
assert( slli==1234567890 && n==10 && ret==1 );
|
|
dprint( 1, 80, C_BLACK, "#20 : rd 1lld : [%lld] cn=%d rt=%d", slli, n, ret );
|
|
dupdate();
|
|
// #20 : rd 1lld : [1234567890] cn=10 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "-1234567890", "%hd%n", &ssi, &n );
|
|
assert( ssi==-722 && n==11 && ret==1 );
|
|
dprint( 1, 90, C_BLACK, "#21 : rd 1hd : [%hd] cn=%d rt=%d", ssi, n, ret );
|
|
dupdate();
|
|
// #21 : rd 1hd : [-722] cn=11 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "-1234567890", "%hhd%n", &sssi, &n );
|
|
assert( sssi==46 && n==11 && ret==1 );
|
|
dprint( 1, 100, C_BLACK, "#22 : rd 1hhd : [%hhd] cn=%d rt=%d", sssi, n, ret );
|
|
dupdate();
|
|
// #22 : rd 1hhd : [46] cn=11 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "-1234567890", "%ld%n", &sli, &n );
|
|
assert( sli==-1234567890 && n==11 && ret==1 );
|
|
dprint( 1, 110, C_BLACK, "#23 : rd 1ld : [%ld] cn=%d rt=%d", sli, n, ret );
|
|
dupdate();
|
|
// #23 : rd 1lld : [-1234567890] cn=11 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "-1234567890", "%lld%n", &slli, &n );
|
|
assert( slli==-1234567890 && n==11 && ret==1 );
|
|
dprint( 1, 120, C_BLACK, "#24 : rd 1lld : [%lld] cn=%d rt=%d", slli, n, ret );
|
|
dupdate();
|
|
// #24 : rd 1lld : [-1234567890] cn=11 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "1234567890", "%u%n", &ui, &n );
|
|
assert( ui==1234567890 && n==10 && ret==1 );
|
|
dprint( 1, 130, C_BLACK, "#25 : rd 1u : [%u] cn=%d rt=%d", ui, n, ret );
|
|
dupdate();
|
|
// #25 : rd 1u : [1234567890] cn=10 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "1234567890", "%hhu%n", &ussi, &n );
|
|
assert( ussi==210 && n==10 && ret==1 );
|
|
dprint( 1, 140, C_BLACK, "#26 : rd 1hhu : [%hhu] cn=%d rt=%d", ussi, n, ret );
|
|
dupdate();
|
|
// #26 : rd 1hhu : [210] cn=10 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "-1234567890", "%lu%n", &uli, &n );
|
|
assert( uli==3060399406 && n==11 && ret==1 );
|
|
dprint( 1, 150, C_BLACK, "#27 : rd 1lu : [%lu] cn=%d rt=%d", uli, n, ret );
|
|
dupdate();
|
|
// #27 : rd 1lu : [3060399406] cn=11 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "-1234567890", "%llu%n", &ulli, &n );
|
|
assert( ulli==18446744072474983726 && n==11 && ret==1 );
|
|
dprint( 1, 160, C_BLACK, "#28 : rd 1llu : [%llu] cn=%d rt=%d", ulli, n, ret );
|
|
dupdate();
|
|
// #28 : rd 1llu : [18446744072474983726] cn=11 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "1234567890", "%3i%2c%4i%c%n", &ui, &c[0], &si, &c[3], &n );
|
|
assert( ui==123 && c[0]=='4' && c[1]=='5' && si==6789 && c[3]=='0' && n==10 && ret==4 );
|
|
dprint( 1, 170, C_BLACK, "#29 : rd 1i+2c+4i+c : [%i][%c][%c][%i][%c] cn=%d rt=%d", ui, c[0], c[1], si, c[3], n, ret );
|
|
dupdate();
|
|
// #29 : rd 1i+2c+4i+c : [123][4][5][6789][0] cn=10 rt=4
|
|
|
|
clear();
|
|
ret = sscanf( "123", "%i%n", &ui, &n );
|
|
assert( ui==123 && n==3 && ret==1 );
|
|
dprint( 1, 180, C_BLACK, "#30 : rd 1i from decimal : [%i] cn=%d rt=%d", ui, n, ret );
|
|
dupdate();
|
|
// #30 : rd 1i from decimal : [123] cn=3 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "0123", "%i%n", &ui, &n );
|
|
assert( ui==83 && n==4 && ret==1 );
|
|
dprint( 1, 190, C_BLACK, "#31 : rd 1i from octal : [%i] cn=%d rt=%d", ui, n, ret );
|
|
dupdate();
|
|
// #31 : rd 1i from octal : [83] cn=4 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "0x123", "%i%n", &ui, &n );
|
|
assert( ui==291 && n==5 && ret==1 );
|
|
dprint( 1, 200, C_BLACK, "#32 : rd 1i from hexadecimal : [%i] cn=%d rt=%d", ui, n, ret );
|
|
dupdate();
|
|
// #32 : rd 1i from hexadecimal : [291] cn=5 rt=1
|
|
|
|
getkey();
|
|
|
|
|
|
/********************************************/
|
|
/* TESTS ON HEXADECIMAL AND OCTAL NUMBERS */
|
|
/********************************************/
|
|
|
|
dclear( C_WHITE );
|
|
|
|
clear();
|
|
ret = sscanf( "0123", "%o%n", &ui, &n );
|
|
assert( ui==83 && n==4 && ret==1 );
|
|
dprint( 1, 10, C_BLACK, "#33 : rd 1o from decimal : [%i] cn=%d rt=%d", ui, n, ret );
|
|
dupdate();
|
|
// #33 : rd 1o from decimal : [83] cn=4 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "0x123", "%x%n", &ui, &n );
|
|
assert( ui==291 && n==5 && ret==1 );
|
|
dprint( 1, 20, C_BLACK, "#34 : rd 1x from hexadecimal : [%i] cn=%d rt=%d", ui, n, ret );
|
|
dupdate();
|
|
// #34 : rd 1x from hexadecimal : [291] cn=5 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "0X123", "%x%n", &ui, &n );
|
|
assert( ui==291 && n==5 && ret==1 );
|
|
dprint( 1, 30, C_BLACK, "#35 : rd 1x from hexadecimal : [%i] cn=%d rt=%d", ui, n, ret );
|
|
dupdate();
|
|
// #35 : rd 1x from hexadecimal : [291] cn=5 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "0x123", "%X%n", &ui, &n );
|
|
assert( ui==291 && n==5 && ret==1 );
|
|
dprint( 1, 40, C_BLACK, "#36 : rd 1X from hexadecimal : [%i] cn=%d rt=%d", ui, n, ret );
|
|
dupdate();
|
|
// #36 : rd 1X from hexadecimal : [291] cn=5 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "0X123", "%X%n", &ui, &n );
|
|
assert( ui==291 && n==5 && ret==1 );
|
|
dprint( 1, 50, C_BLACK, "#37 : rd 1X from hexadecimal : [%i] cn=%d rt=%d", ui, n, ret );
|
|
dupdate();
|
|
// #37 : rd 1X from hexadecimal : [291] cn=5 rt=1
|
|
|
|
|
|
/*************************************/
|
|
/* TESTS ON FLOATING POINT NUMBERS */
|
|
/*************************************/
|
|
|
|
// read %a%e%f%g%A%E%F%G
|
|
|
|
clear();
|
|
ret = sscanf( "0.123 -0.456", "%a%A%n", &f1, &f2, &n );
|
|
assert( ASSERTFP(f1,0.123,1E-3) && ASSERTFP(f2,-0.456,1E-3) && n==12 && ret==2 );
|
|
dprint( 1, 60, C_BLACK, "#38 : rd 1a+1A: [%.3f][%.3f] cn=%d rt=%d", f1, f2, n, ret );
|
|
dupdate();
|
|
// #38 : rd 1a+1A: [0.123][-0.456] cn=12 rt=2
|
|
|
|
clear();
|
|
ret = sscanf( "0.0123E+1 -45.6E-2", "%f%F%n", &f1, &f2, &n );
|
|
assert( ASSERTFP(f1,0.123,1E-3) && ASSERTFP(f2,-0.456,1E-3) && n==18 && ret==2 );
|
|
dprint( 1, 70, C_BLACK, "#39 : rd 1f+1F: [%.3f][%.3f] cn=%d rt=%d", f1, f2, n, ret );
|
|
dupdate();
|
|
// #39 : rd 1f+1F: [0.123][-0.456] cn=18 rt=2
|
|
|
|
clear();
|
|
ret = sscanf( "0.123 -0.456", "%g%G%n", &f1, &f2, &n );
|
|
assert( ASSERTFP(f1,0.123,1E-3) && ASSERTFP(f2,-0.456,1E-3) && n==12 && ret==2 );
|
|
dprint( 1, 80, C_BLACK, "#40 : rd 1g+1G: [%.3f][%.3f] cn=%d rt=%d", f1, f2, n, ret );
|
|
dupdate();
|
|
// #40 : rd 1g+1G: [0.123][-0.456] cn=12 rt=2
|
|
|
|
clear();
|
|
ret = sscanf( "0.0123E+1 -45.6E-2", "%e%E%n", &f1, &f2, &n );
|
|
assert( ASSERTFP(f1,0.123,1E-3) && ASSERTFP(f2,-0.456,1E-3) && n==18 && ret==2 );
|
|
dprint( 1, 90, C_BLACK, "#41 : rd 1e+1E: [%.3f][%.3f] cn=%d rt=%d", f1, f2, n, ret );
|
|
dupdate();
|
|
// #41 : rd 1e+1E: [0.123][-0.456] cn=18 rt=2
|
|
|
|
clear();
|
|
ret = sscanf( "0.123 -0.456", "%la%lA%n", &d1, &d2, &n );
|
|
assert( ASSERTFP(d1,0.123,1E-3) && ASSERTFP(d2,-0.456,1E-3) && n==12 && ret==2 );
|
|
dprint( 1, 100, C_BLACK, "#42 : rd 1la+1lA: [%.3lf][%.3lf] cn=%d rt=%d", d1, d2, n, ret );
|
|
dupdate();
|
|
// #42 : rd 1la+1lA: [0.123][-0.456] cn=12 rt=2
|
|
|
|
clear();
|
|
ret = sscanf( "0.0123E+1 -45.6E-2", "%lf%lF%n", &d1, &d2, &n );
|
|
assert( ASSERTFP(d1,0.123,1E-3) && ASSERTFP(d2,-0.456,1E-3) && n==18 && ret==2 );
|
|
dprint( 1, 110, C_BLACK, "#43 : rd 1lf+1lF: [%.3lf][%.3lf] cn=%d rt=%d", d1, d2, n, ret );
|
|
dupdate();
|
|
// #43 : rd 1lf+1lF: [0.123][-0.456] cn=18 rt=2
|
|
|
|
clear();
|
|
ret = sscanf( "0.123 -0.456", "%La%LA%n", &ld1, &ld2, &n );
|
|
assert( ASSERTFP(ld1,0.123,1E-3) && ASSERTFP(ld2,-0.456,1E-3) && n==12 && ret==2 );
|
|
dprint( 1, 120, C_BLACK, "#44 : rd 1La+1LA: [%.3Lf][%.3Lf] cn=%d rt=%d", ld1, ld2, n, ret );
|
|
dupdate();
|
|
// #44 : rd 1La+1LA: [0.123][-0.456] cn=12 rt=2
|
|
|
|
clear();
|
|
ret = sscanf( "0.0123E+1 -45.6E-2", "%Lf%LF%n", &ld1, &ld2, &n );
|
|
assert( ASSERTFP(ld1,0.123,1E-3) && ASSERTFP(ld2,-0.456,1E-3) && n==18 && ret==2 );
|
|
dprint( 1, 130, C_BLACK, "#45 : rd 1Lf+1LF: [%.3Lf][%.3Lf] cn=%d rt=%d", ld1, ld2, n, ret );
|
|
dupdate();
|
|
// #45 : rd 1Lf+1LF: [0.123][-0.456] cn=18 rt
|
|
|
|
/***********************/
|
|
/* TESTS ON POINTERS */
|
|
/***********************/
|
|
|
|
int val = 123;
|
|
char buf[100];
|
|
sprintf( buf, "%p", (void*)&val);
|
|
void *ptr;
|
|
sscanf(buf, "%p", &ptr);
|
|
int *iPtr = ptr;
|
|
assert( iPtr == &val && (void*)&val == ptr );
|
|
dprint( 1, 140, C_BLACK,"#46 : rd 1p : [in:%p][out:%p]", (void*)&val, ptr);
|
|
dupdate();
|
|
// #46 : rd 1p : [in:0x.........][out:0x.........]
|
|
// Note : address changes at each run
|
|
|
|
|
|
getkey();
|
|
|
|
/**************************/
|
|
/* TESTS ON SET OF CHAR */
|
|
/**************************/
|
|
|
|
|
|
|
|
dclear( C_WHITE );
|
|
|
|
clear();
|
|
ret = sscanf( "abcdefghij", "%[abdr-v0-9A-F]%n", str, &n );
|
|
assert( strcmp(str, "ab")==0 && n==2 && ret==1 );
|
|
dprint( 1, 10, C_BLACK, "#47 : rd 1[] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #47 : rd 1[] : [ab] cn=2 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "bcdefghij", "%[abdr-v0-9A-F]%n", str, &n );
|
|
assert( strcmp(str, "b")==0 && n==1 && ret==1 );
|
|
dprint( 1, 20, C_BLACK, "#48 : rd 1[] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #48 : rd 1[] : [b] cn=1 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "1abcdefghij", "%[abdr-v0-9A-F]%n", str, &n );
|
|
assert( strcmp(str, "1ab")==0 && n==3 && ret==1 );
|
|
dprint( 1, 30, C_BLACK, "#49 : rd 1[] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #49 : rd 1[] : [1ab] cn=3 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "Gabcdefghij", "%[abdr-v0-9A-F]%n", str, &n );
|
|
assert( strcmp(str, "........................")==0 && n==-20 && ret==0 );
|
|
dprint( 1, 40, C_BLACK, "#50 : rd 1[] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #50 : rd 1[] : [........................] cn=-20 rt=0
|
|
|
|
clear();
|
|
ret = sscanf( "6abcdefghij", "%[abdr-v0-5A-F]%n", str, &n );
|
|
assert( strcmp(str, "........................")==0 && n==-20 && ret==0 );
|
|
dprint( 1, 50, C_BLACK, "#51 : rd 1[] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #51 : rd 1[] : [........................] cn=-20 rt=0
|
|
|
|
clear();
|
|
ret = sscanf( "uabcdefghij", "%[abdr-v0-9A-F]%n", str, &n );
|
|
assert( strcmp(str, "uab")==0 && n==3 && ret==1 );
|
|
dprint( 1, 60, C_BLACK, "#52 : rd 1[] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #52 : rd 1[] : [uab] cn=3 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "-abcdefghij", "%[abdr-v0-9A-F]%n", str, &n );
|
|
assert( strcmp(str, "........................")==0 && n==-20 && ret==0 );
|
|
dprint( 1, 70, C_BLACK, "#53 : rd 1[] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #53 : rd 1[] : [........................] cn=-20 rt=0
|
|
|
|
clear();
|
|
ret = sscanf( "-abcdefghij", "%[abdr-v0-5A-F-]%n", str, &n );
|
|
assert( strcmp(str, "-ab")==0 && n==3 && ret==1 );
|
|
dprint( 1, 80, C_BLACK, "#54 : rd 1[] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #54 : rd 1[] : [-ab] cn=3 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "Gabcdefghij", "%[abdr-v0-9A-F-]%n", str, &n );
|
|
assert( strcmp(str, "........................")==0 && n==-20 && ret==0 );
|
|
dprint( 1, 90, C_BLACK, "#55 : rd 1[] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #55 : rd 1[] : [........................] cn=-20 rt=0
|
|
|
|
clear();
|
|
ret = sscanf( "]abcdefghij", "%[abdr-v0-9A-F-]%n", str, &n );
|
|
assert( strcmp(str, "........................")==0 && n==-20 && ret==0 );
|
|
dprint( 1, 100, C_BLACK, "#56 : rd 1[] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #56 : rd 1[] : [........................] cn=-20 rt=0
|
|
|
|
clear();
|
|
ret = sscanf( "]abcdefghij", "%3[]abdr-v0-9A-F-]%n", str, &n );
|
|
assert( strcmp(str, "]ab")==0 && n==3 && ret==1 );
|
|
dprint( 1, 110, C_BLACK, "#57 : rd 1[] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #57 : rd 1[] : []ab] cn=3 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "Gabcdefghij", "%2[abdr-v0-9A-F-]%n", str, &n );
|
|
assert( strcmp(str, "........................")==0 && n==-20 && ret==0 );
|
|
dprint( 1, 120, C_BLACK, "#58 : rd 1[] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #58 : rd 1[] : [........................] cn=-20 rt=0
|
|
|
|
clear();
|
|
ret = sscanf( "]abcdefghij", "%4[abdr-v0-9A-F-]%n", str, &n );
|
|
assert( strcmp(str, "........................")==0 && n==-20 && ret==0 );
|
|
dprint( 1, 130, C_BLACK, "#59 : rd 1[] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #59 : rd 1[] : [........................] cn=-20 rt=0
|
|
|
|
clear();
|
|
ret = sscanf( "]abcdefghij", "%5[]a-z0-9A-Z-]%n", str, &n );
|
|
assert( strcmp(str, "]abcd")==0 && n==5 && ret==1 );
|
|
dprint( 1, 140, C_BLACK, "#60 : rd 1[] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #60 : rd 1[] : []abcd] cn=5 rt=1
|
|
|
|
getkey();
|
|
|
|
|
|
dclear( C_WHITE );
|
|
|
|
|
|
|
|
clear();
|
|
ret = sscanf( "abcdefghij", "%[^abdr-v0-9A-F]%n", str, &n );
|
|
assert( strcmp(str, "........................")==0 && n==-20 && ret==0 );
|
|
dprint( 1, 10, C_BLACK, "#61 : rd 1[^] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #61 : rd 1[^] : [........................] cn=-20 rt=0
|
|
|
|
clear();
|
|
ret = sscanf( "bcdefghij", "%[^abdr-v0-9A-F]%n", str, &n );
|
|
assert( strcmp(str, "........................")==0 && n==-20 && ret==0 );
|
|
dprint( 1, 20, C_BLACK, "#62 : rd 1[^] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #62 : rd 1[^] : [........................] cn=-20 rt=0
|
|
|
|
clear();
|
|
ret = sscanf( "1abcdefghij", "%[^abdr-v0-9A-F]%n", str, &n );
|
|
assert( strcmp(str, "........................")==0 && n==-20 && ret==0 );
|
|
dprint( 1, 30, C_BLACK, "#63 : rd 1[^] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #63 : rd 1[^] : [........................] cn=-20 rt=0
|
|
|
|
clear();
|
|
ret = sscanf( "Gabcdefghij", "%[^abdr-v0-9A-F]%n", str, &n );
|
|
assert( strcmp(str, "G")==0 && n==1 && ret==1 );
|
|
dprint( 1, 40, C_BLACK, "#64 : rd 1[^] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #64 : rd 1[^] : [G] cn=1 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "6abcdefghij", "%[^abdr-v0-5A-F]%n", str, &n );
|
|
assert( strcmp(str, "6")==0 && n==1 && ret==1 );
|
|
dprint( 1, 50, C_BLACK, "#65 : rd 1[^] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #65 : rd 1[^] : [6] cn=1 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "uabcdefghij", "%[^abdr-v0-9A-F]%n", str, &n );
|
|
assert( strcmp(str, "........................")==0 && n==-20 && ret==0 );
|
|
dprint( 1, 60, C_BLACK, "#66 : rd 1[^] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #66 : rd 1[^] : [........................] cn=-20 rt=0
|
|
|
|
clear();
|
|
ret = sscanf( "-abcdefghij", "%[^abdr-v0-9A-F]%n", str, &n );
|
|
assert( strcmp(str, "-")==0 && n==1 && ret==1 );
|
|
dprint( 1, 70, C_BLACK, "#67 : rd 1[^] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #67 : rd 1[^] : [-] cn=1 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "-abcdefghij", "%[^abdr-v0-5A-F-]%n", str, &n );
|
|
assert( strcmp(str, "........................")==0 && n==-20 && ret==0 );
|
|
dprint( 1, 80, C_BLACK, "#68 : rd 1[^] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #68 : rd 1[^] : [........................] cn=-20 rt=0
|
|
|
|
clear();
|
|
ret = sscanf( "Gabcdefghij", "%[^abdr-v0-9A-F-]%n", str, &n );
|
|
assert( strcmp(str, "G")==0 && n==1 && ret==1 );
|
|
dprint( 1, 90, C_BLACK, "#69 : rd 1[^] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #69 : rd 1[^] : [G] cn=1 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "]GHIJabcdefghij", "%[^abdr-v0-9A-F-]%n", str, &n );
|
|
assert( strcmp(str, "]GHIJ")==0 && n==5 && ret==1 );
|
|
dprint( 1, 100, C_BLACK, "#70 : rd 1[^] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #70 : rd 1[^] : []GHIJ] cn=5 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "]abcdefghij", "%3[^]abdr-v0-9A-F-]%n", str, &n );
|
|
assert( strcmp(str, "........................")==0 && n==-20 && ret==0 );
|
|
dprint( 1, 110, C_BLACK, "#71 : rd 1[^] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #71 : rd 1[^] : [........................] cn=-20 rt=0
|
|
|
|
clear();
|
|
ret = sscanf( "Gabcdefghij", "%2[^abdr-v0-9A-F-]%n", str, &n );
|
|
assert( strcmp(str, "G")==0 && n==1 && ret==1 );
|
|
dprint( 1, 120, C_BLACK, "#72 : rd 1[^] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #72 : rd 1[^] : [G] cn=1 rt=1
|
|
|
|
clear();
|
|
ret = sscanf( "]abcdefghij", "%4[^abdr-v0-9A-F-]%n", str, &n );
|
|
assert( strcmp(str, "]")==0 && n==1 && ret==1 );
|
|
dprint( 1, 130, C_BLACK, "#73 : rd 1[^] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #73 : rd 1[^] : []] cn=1 rt=1
|
|
|
|
clear();
|
|
|
|
ret = sscanf( "]abcdefghij", "%5[^]a-z0-9A-Z-]%n", str, &n );
|
|
assert( strcmp(str, "........................")==0 && n==-20 && ret==0 );
|
|
dprint( 1, 140, C_BLACK, "#74 : rd 1[^] : [%s] cn=%d rt=%d", str, n, ret );
|
|
dupdate();
|
|
// #74 : rd 1[^] : [........................] cn=-20 rt=0
|
|
|
|
clear();
|
|
char str3[50] = "................................................";
|
|
ret = sscanf( "Any combi: You can to use any combi.\n", "%*[^:]%*2c%[^\n]%n", str3, &n );
|
|
assert( strcmp(str3, "You can to use any combi.")==0 && n==36 && ret==1 );
|
|
dprint( 1, 150, C_BLACK, "#75 : rd 1[^] : [%s] cn=%d rt=%d", str3, n, ret );
|
|
dupdate();
|
|
// #75 : rd 1[^] : [You can to use any combi.] cn=36 rt=1
|
|
|
|
clear();
|
|
char str4[50] = "................................................";
|
|
ret = sscanf( " This is a line with spaces.\n", " %[^\n]%n", str4, &n );
|
|
assert( strcmp(str4, "This is a line with spaces.")==0 && n==33 && ret==1 );
|
|
dprint( 1, 160, C_BLACK, "#76 : rd 1 [^] : [%s] cn=%d rt=%d", str4, n, ret );
|
|
dupdate();
|
|
// #76 : rd 1[^] : [This is a line with spaces.] cn=33 rt=1
|
|
|
|
getkey();
|
|
|
|
|
|
dclear( C_WHITE );
|
|
|
|
gint_world_switch( GINT_CALL( fscan_test ));
|
|
|
|
dupdate();
|
|
|
|
getkey();
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
|
} |