#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;


}