mirror of
https://github.com/KolibriOS/kolibrios.git
synced 2024-12-17 20:32:35 +03:00
375 lines
13 KiB
C
375 lines
13 KiB
C
/****************************************************************************
|
|
*
|
|
* Open Watcom Project
|
|
*
|
|
* Portions Copyright (c) 1983-2002 Sybase, Inc. All Rights Reserved.
|
|
*
|
|
* ========================================================================
|
|
*
|
|
* This file contains Original Code and/or Modifications of Original
|
|
* Code as defined in and that are subject to the Sybase Open Watcom
|
|
* Public License version 1.0 (the 'License'). You may not use this file
|
|
* except in compliance with the License. BY USING THIS FILE YOU AGREE TO
|
|
* ALL TERMS AND CONDITIONS OF THE LICENSE. A copy of the License is
|
|
* provided with the Original Code and Modifications, and is also
|
|
* available at www.sybase.com/developer/opensource.
|
|
*
|
|
* The Original Code and all software distributed under the License are
|
|
* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
|
|
* EXPRESS OR IMPLIED, AND SYBASE AND ALL CONTRIBUTORS HEREBY DISCLAIM
|
|
* ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR
|
|
* NON-INFRINGEMENT. Please see the License for the specific language
|
|
* governing rights and limitations under the License.
|
|
*
|
|
* ========================================================================
|
|
*
|
|
* Description: Non-exhaustive test of ctype.h functions and macros.
|
|
* Note: Tests assume the C locale.
|
|
*
|
|
****************************************************************************/
|
|
|
|
|
|
#include <ctype.h>
|
|
#include <wctype.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
|
|
#define VERIFY( exp ) if( !(exp) ) { \
|
|
printf( "%s: ***FAILURE*** at line %d of %s.\n",\
|
|
ProgramName, __LINE__, \
|
|
strlwr(__FILE__) ); \
|
|
NumErrors++; \
|
|
}
|
|
|
|
#define TEST_ARRAY_SIZE 256
|
|
#define TEST_ARRAY_SIZE_WIDE 512
|
|
|
|
|
|
struct CtypeBits {
|
|
unsigned alnum : 1;
|
|
unsigned alpha : 1;
|
|
unsigned blank : 1;
|
|
unsigned cntrl : 1;
|
|
unsigned digit : 1;
|
|
unsigned graph : 1;
|
|
unsigned lower : 1;
|
|
unsigned print : 1;
|
|
unsigned punct : 1;
|
|
unsigned space : 1;
|
|
unsigned upper : 1;
|
|
unsigned xdigit : 1;
|
|
unsigned ascii : 1;
|
|
unsigned csym : 1;
|
|
unsigned csymf : 1;
|
|
};
|
|
|
|
struct CtypeBits MacroResults[TEST_ARRAY_SIZE];
|
|
struct CtypeBits FunctResults[TEST_ARRAY_SIZE];
|
|
struct CtypeBits WideMacroResults[TEST_ARRAY_SIZE_WIDE];
|
|
struct CtypeBits WideFunctResults[TEST_ARRAY_SIZE_WIDE];
|
|
|
|
char ProgramName[_MAX_PATH]; /* executable filename */
|
|
int NumErrors = 0; /* number of errors */
|
|
|
|
int far far_data = 0;
|
|
|
|
void TestClassifyMacro( void )
|
|
/****************************/
|
|
{
|
|
int i;
|
|
|
|
far_data++; // set ds outside DGROUP
|
|
|
|
MacroResults[0].alnum = isalnum( EOF );
|
|
MacroResults[0].alpha = isalpha( EOF );
|
|
MacroResults[0].blank = isblank( EOF );
|
|
MacroResults[0].cntrl = iscntrl( EOF );
|
|
MacroResults[0].digit = isdigit( EOF );
|
|
MacroResults[0].graph = isgraph( EOF );
|
|
MacroResults[0].lower = islower( EOF );
|
|
MacroResults[0].print = isprint( EOF );
|
|
MacroResults[0].punct = ispunct( EOF );
|
|
MacroResults[0].space = isspace( EOF );
|
|
MacroResults[0].upper = isupper( EOF );
|
|
MacroResults[0].xdigit = isxdigit( EOF );
|
|
MacroResults[0].ascii = isascii( EOF );
|
|
MacroResults[0].csym = __iscsym( EOF );
|
|
MacroResults[0].csymf = __iscsymf( EOF );
|
|
|
|
for( i = 1; i < TEST_ARRAY_SIZE; i++ ) {
|
|
MacroResults[i].alnum = isalnum( i );
|
|
MacroResults[i].alpha = isalpha( i );
|
|
MacroResults[i].blank = isblank( i );
|
|
MacroResults[i].cntrl = iscntrl( i );
|
|
MacroResults[i].digit = isdigit( i );
|
|
MacroResults[i].graph = isgraph( i );
|
|
MacroResults[i].lower = islower( i );
|
|
MacroResults[i].print = isprint( i );
|
|
MacroResults[i].punct = ispunct( i );
|
|
MacroResults[i].space = isspace( i );
|
|
MacroResults[i].upper = isupper( i );
|
|
MacroResults[i].xdigit = isxdigit( i );
|
|
MacroResults[i].ascii = isascii( i );
|
|
MacroResults[i].csym = __iscsym( i );
|
|
MacroResults[i].csymf = __iscsymf( i );
|
|
}
|
|
}
|
|
|
|
void TestClassifyFunct( void )
|
|
/****************************/
|
|
{
|
|
int i;
|
|
|
|
far_data++; // set ds outside DGROUP
|
|
|
|
FunctResults[0].alnum = (isalnum)( EOF );
|
|
FunctResults[0].alpha = (isalpha)( EOF );
|
|
FunctResults[0].blank = (isblank)( EOF );
|
|
FunctResults[0].cntrl = (iscntrl)( EOF );
|
|
FunctResults[0].digit = (isdigit)( EOF );
|
|
FunctResults[0].graph = (isgraph)( EOF );
|
|
FunctResults[0].lower = (islower)( EOF );
|
|
FunctResults[0].print = (isprint)( EOF );
|
|
FunctResults[0].punct = (ispunct)( EOF );
|
|
FunctResults[0].space = (isspace)( EOF );
|
|
FunctResults[0].upper = (isupper)( EOF );
|
|
FunctResults[0].xdigit = (isxdigit)( EOF );
|
|
FunctResults[0].ascii = (isascii)( EOF );
|
|
FunctResults[0].csym = (__iscsym)( EOF );
|
|
FunctResults[0].csymf = (__iscsymf)( EOF );
|
|
|
|
for( i = 1; i < TEST_ARRAY_SIZE; i++ ) {
|
|
FunctResults[i].alnum = (isalnum)( i );
|
|
FunctResults[i].alpha = (isalpha)( i );
|
|
FunctResults[i].blank = (isblank)( i );
|
|
FunctResults[i].cntrl = (iscntrl)( i );
|
|
FunctResults[i].digit = (isdigit)( i );
|
|
FunctResults[i].graph = (isgraph)( i );
|
|
FunctResults[i].lower = (islower)( i );
|
|
FunctResults[i].print = (isprint)( i );
|
|
FunctResults[i].punct = (ispunct)( i );
|
|
FunctResults[i].space = (isspace)( i );
|
|
FunctResults[i].upper = (isupper)( i );
|
|
FunctResults[i].xdigit = (isxdigit)( i );
|
|
FunctResults[i].ascii = (isascii)( i );
|
|
FunctResults[i].csym = (__iscsym)( i );
|
|
FunctResults[i].csymf = (__iscsymf)( i );
|
|
}
|
|
}
|
|
|
|
void TestClassifyWideMacro( void )
|
|
/********************************/
|
|
{
|
|
int i;
|
|
|
|
far_data++; // set ds outside DGROUP
|
|
|
|
WideMacroResults[0].alnum = iswalnum( WEOF );
|
|
WideMacroResults[0].alpha = iswalpha( WEOF );
|
|
WideMacroResults[0].blank = iswblank( WEOF );
|
|
WideMacroResults[0].cntrl = iswcntrl( WEOF );
|
|
WideMacroResults[0].digit = iswdigit( WEOF );
|
|
WideMacroResults[0].graph = iswgraph( WEOF );
|
|
WideMacroResults[0].lower = iswlower( WEOF );
|
|
WideMacroResults[0].print = iswprint( WEOF );
|
|
WideMacroResults[0].punct = iswpunct( WEOF );
|
|
WideMacroResults[0].space = iswspace( WEOF );
|
|
WideMacroResults[0].upper = iswupper( WEOF );
|
|
WideMacroResults[0].xdigit = iswxdigit( WEOF );
|
|
WideMacroResults[0].ascii = isascii( WEOF );
|
|
WideMacroResults[0].csym = __iscsym( WEOF );
|
|
WideMacroResults[0].csymf = __iscsymf( WEOF );
|
|
|
|
for( i = 1; i < TEST_ARRAY_SIZE_WIDE; i++ ) {
|
|
WideMacroResults[i].alnum = iswalnum( i );
|
|
WideMacroResults[i].alpha = iswalpha( i );
|
|
WideMacroResults[i].blank = iswblank( i );
|
|
WideMacroResults[i].cntrl = iswcntrl( i );
|
|
WideMacroResults[i].digit = iswdigit( i );
|
|
WideMacroResults[i].graph = iswgraph( i );
|
|
WideMacroResults[i].lower = iswlower( i );
|
|
WideMacroResults[i].print = iswprint( i );
|
|
WideMacroResults[i].punct = iswpunct( i );
|
|
WideMacroResults[i].space = iswspace( i );
|
|
WideMacroResults[i].upper = iswupper( i );
|
|
WideMacroResults[i].xdigit = iswxdigit( i );
|
|
WideMacroResults[i].ascii = isascii( i );
|
|
WideMacroResults[i].csym = __iscsym( i );
|
|
WideMacroResults[i].csymf = __iscsymf( i );
|
|
}
|
|
}
|
|
|
|
void TestClassifyWideFunct( void )
|
|
/********************************/
|
|
{
|
|
int i;
|
|
|
|
far_data++; // set ds outside DGROUP
|
|
|
|
WideFunctResults[0].alnum = (iswalnum)( WEOF );
|
|
WideFunctResults[0].alpha = (iswalpha)( WEOF );
|
|
WideFunctResults[0].blank = (iswblank)( WEOF );
|
|
WideFunctResults[0].cntrl = (iswcntrl)( WEOF );
|
|
WideFunctResults[0].digit = (iswdigit)( WEOF );
|
|
WideFunctResults[0].graph = (iswgraph)( WEOF );
|
|
WideFunctResults[0].lower = (iswlower)( WEOF );
|
|
WideFunctResults[0].print = (iswprint)( WEOF );
|
|
WideFunctResults[0].punct = (iswpunct)( WEOF );
|
|
WideFunctResults[0].space = (iswspace)( WEOF );
|
|
WideFunctResults[0].upper = (iswupper)( WEOF );
|
|
WideFunctResults[0].xdigit = (iswxdigit)( WEOF );
|
|
WideFunctResults[0].ascii = (isascii)( WEOF );
|
|
WideFunctResults[0].csym = (__iscsym)( WEOF );
|
|
WideFunctResults[0].csymf = (__iscsymf)( WEOF );
|
|
|
|
for( i = 1; i < TEST_ARRAY_SIZE_WIDE; i++ ) {
|
|
WideFunctResults[i].alnum = (iswalnum)( i );
|
|
WideFunctResults[i].alpha = (iswalpha)( i );
|
|
WideFunctResults[i].blank = (iswblank)( i );
|
|
WideFunctResults[i].cntrl = (iswcntrl)( i );
|
|
WideFunctResults[i].digit = (iswdigit)( i );
|
|
WideFunctResults[i].graph = (iswgraph)( i );
|
|
WideFunctResults[i].lower = (iswlower)( i );
|
|
WideFunctResults[i].print = (iswprint)( i );
|
|
WideFunctResults[i].punct = (iswpunct)( i );
|
|
WideFunctResults[i].space = (iswspace)( i );
|
|
WideFunctResults[i].upper = (iswupper)( i );
|
|
WideFunctResults[i].xdigit = (iswxdigit)( i );
|
|
WideFunctResults[i].ascii = (isascii)( i );
|
|
WideFunctResults[i].csym = (__iscsym)( i );
|
|
WideFunctResults[i].csymf = (__iscsymf)( i );
|
|
}
|
|
}
|
|
|
|
/* Helper function to print mismatches in human readable form */
|
|
void CheckResults( struct CtypeBits *s1, struct CtypeBits *s2, int count )
|
|
/************************************************************************/
|
|
{
|
|
int i;
|
|
|
|
far_data++; // set ds outside DGROUP
|
|
|
|
for( i = 0; i < TEST_ARRAY_SIZE; i++ ) {
|
|
if( s1[i].alnum != WideMacroResults[i].alnum )
|
|
printf( "Mismatch at %d (alnum)\n", i );
|
|
if( s1[i].alpha != s2[i].alpha )
|
|
printf( "Mismatch at %d (alpha)\n", i );
|
|
if( s1[i].blank != s2[i].blank )
|
|
printf( "Mismatch at %d (blank)\n", i );
|
|
if( s1[i].cntrl != s2[i].cntrl )
|
|
printf( "Mismatch at %d (cntrl)\n", i );
|
|
if( s1[i].digit != s2[i].digit )
|
|
printf( "Mismatch at %d (digit)\n", i );
|
|
if( s1[i].graph != s2[i].graph )
|
|
printf( "Mismatch at %d (graph)\n", i );
|
|
if( s1[i].lower != s2[i].lower )
|
|
printf( "Mismatch at %d (lower)\n", i );
|
|
if( s1[i].print != s2[i].print )
|
|
printf( "Mismatch at %d (print)\n", i );
|
|
if( s1[i].punct != s2[i].punct )
|
|
printf( "Mismatch at %d (punct)\n", i );
|
|
if( s1[i].space != s2[i].space )
|
|
printf( "Mismatch at %d (space)\n", i );
|
|
if( s1[i].upper != s2[i].upper )
|
|
printf( "Mismatch at %d (upper)\n", i );
|
|
if( s1[i].xdigit != s2[i].xdigit )
|
|
printf( "Mismatch at %d (xdigit)\n", i );
|
|
if( s1[i].ascii != s2[i].ascii )
|
|
printf( "Mismatch at %d (ascii)\n", i );
|
|
if( s1[i].csym != s2[i].csym )
|
|
printf( "Mismatch at %d (csym)\n", i );
|
|
if( s1[i].csymf != s2[i].csymf )
|
|
printf( "Mismatch at %d (csymf)\n", i );
|
|
}
|
|
}
|
|
|
|
void TestResults( void )
|
|
/**********************/
|
|
{
|
|
size_t len;
|
|
size_t wide_len;
|
|
|
|
far_data++; // set ds outside DGROUP
|
|
|
|
len = sizeof( MacroResults );
|
|
wide_len = sizeof( WideMacroResults );
|
|
|
|
CheckResults( MacroResults, FunctResults, TEST_ARRAY_SIZE );
|
|
VERIFY( !memcmp( MacroResults, FunctResults, len ) );
|
|
VERIFY( !memcmp( WideMacroResults, WideFunctResults, wide_len ) );
|
|
VERIFY( !memcmp( MacroResults, WideMacroResults, len ) );
|
|
VERIFY( !memcmp( MacroResults, WideFunctResults, len ) );
|
|
}
|
|
|
|
void TestConversion( void )
|
|
/*************************/
|
|
{
|
|
int c, c1, c2;
|
|
|
|
far_data++; // set ds outside DGROUP
|
|
|
|
for( c = 0; c < 256; c++ ) {
|
|
c1 = tolower( c );
|
|
c2 = toupper( c );
|
|
if( isalpha( c ) ) {
|
|
if( islower( c ) )
|
|
VERIFY( (c1 == c) && (c2 != c) );
|
|
if( isupper( c ) )
|
|
VERIFY( (c1 != c) && (c2 == c) );
|
|
} else {
|
|
VERIFY( !isalpha( c1 ) && !isalpha( c2 ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
void TestWideConversion( void )
|
|
/*****************************/
|
|
{
|
|
wchar_t c, c1, c2;
|
|
|
|
far_data++; // set ds outside DGROUP
|
|
|
|
for( c = 0; c < 1024; c++ ) {
|
|
c1 = towlower( c );
|
|
c2 = towupper( c );
|
|
if( iswalpha( c ) ) {
|
|
if( iswlower( c ) )
|
|
VERIFY( (c1 == c) && (c2 != c) );
|
|
if( iswupper( c ) )
|
|
VERIFY( (c1 != c) && (c2 == c) );
|
|
} else {
|
|
VERIFY( !iswalpha( c1 ) && !iswalpha( c2 ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
int main( int argc, char *argv[] )
|
|
/********************************/
|
|
{
|
|
far_data++; // set ds outside DGROUP
|
|
|
|
/*** Initialize ***/
|
|
strcpy( ProgramName, strlwr(argv[0]) );
|
|
|
|
/*** Test stuff ***/
|
|
TestClassifyMacro();
|
|
TestClassifyFunct();
|
|
TestClassifyWideMacro();
|
|
TestClassifyWideFunct();
|
|
TestResults();
|
|
TestConversion();
|
|
TestWideConversion();
|
|
|
|
/*** Print a pass/fail message and quit ***/
|
|
if( NumErrors == 0 ) {
|
|
printf( "%s: SUCCESS.\n", ProgramName );
|
|
return( EXIT_SUCCESS );
|
|
} else {
|
|
printf( "%s: FAILURE (%d errors).\n", ProgramName, NumErrors );
|
|
return( EXIT_FAILURE );
|
|
}
|
|
}
|