mbtest.c

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C语言 代码 · 共 1,019 行 · 第 1/2 页

    ptr = _mbsncat( bufA, "Fred!", 4 );
    VERIFY( ptr == bufA );
    VERIFY( _mbscmp(bufA,"BobFred") == 0 );

    ptr = _mbsnbcpy( bufA, "Bob", 30 );
    VERIFY( ptr == bufA );
    ptr = _mbsnbcat( bufA, "Fred!", 0 );
    VERIFY( ptr == bufA );
    VERIFY( _mbscmp(bufA,"Bob") == 0 );

    ptr = _mbsnbcat( bufA, "Fred!", 4 );
    VERIFY( ptr == bufA );
    VERIFY( _mbscmp(bufA,"BobFred") == 0 );

    strcat( bufA, "\x90" );     /* strcat, not _mbscat -- just one byte */
    ptr = _mbsnbcat( bufA, "Grok", 5 );
    VERIFY( ptr == bufA );
    #ifndef DUMMY_DBCS
        VERIFY( _mbscmp(bufA,"BobFredGrok") == 0 );
    #else
        VERIFY( _mbscmp(bufA,"BobFred""\x90""Grok") == 0 );
    #endif
}


void TestCopyM( void )
{
    unsigned char       bufA[80] = "";
    unsigned char       bufB[] = "Foo\x81\xFC"" Bar";
    unsigned char *     ptr;

    _mbsncpy( bufA, "!!!!!!!!\x90\x90""!!!!!!!", 20 );
    VERIFY( _mbscmp(bufA,"!!!!!!!!\x90\x90""!!!!!!!") == 0 );

    ptr = _mbsncpy( bufA, bufB, 10 );
    VERIFY( ptr == bufA );
    VERIFY( _mbscmp(bufA,bufB) == 0 );

    ptr = _mbsncpy( bufA, "Bob", 30 );
    VERIFY( ptr == bufA );
    ptr = _mbsncat( bufA, "Fred!\x81\xFC", 0 );
    VERIFY( ptr == bufA );
    VERIFY( _mbscmp(bufA,"Bob") == 0 );

    ptr = _mbsncat( bufA, "Fred\x81\xFC!", 5 );
    VERIFY( ptr == bufA );
    #ifndef DUMMY_DBCS
        VERIFY( _mbscmp(bufA,"BobFred\x81\xFC") == 0 );
    #else
        VERIFY( _mbscmp(bufA,"BobFred\x81") == 0 );
    #endif

    ptr = _mbsnbcpy( bufA, "Bob\x81\xFC", 6 );
    VERIFY( ptr == bufA );
    ptr = _mbsnbcat( bufA, "Fred!", 0 );
    VERIFY( ptr == bufA );
    VERIFY( _mbscmp(bufA,"Bob\x81\xFC") == 0 );

    ptr = _mbsnbcat( bufA, "Fred\x81\xFC!", 6 );
    VERIFY( ptr == bufA );
    VERIFY( _mbscmp(bufA,"Bob\x81\xFC""Fred\x81\xFC") == 0 );
}



/****
***** Test mbtowc() and mbstowcs().
****/

void TestToWide( void )
{
    wchar_t             wc = L'\0';
    wchar_t             wcs[20];
    int                 rc;

    rc = mbtowc( &wc, NULL, 1 );
    VERIFY( rc == 0 );

    rc = mbtowc( NULL, "!", 1 );
    VERIFY( rc == 1 );
    VERIFY( wc == L'\0' );

    rc = mbtowc( &wc, "", 1 );
    VERIFY( rc == 0 );

    rc = mbtowc( &wc, "", 0 );
    VERIFY( rc == -1 );

    rc = mbtowc( &wc, "foo", 0 );
    VERIFY( rc == -1 );

    rc = mbtowc( &wc, "foo", 1 );
    VERIFY( rc == 1 );
    VERIFY( wc == 'f' );

    rc = mbtowc( &wc, "\x81\xFC""foo", 2 );
    #ifndef DUMMY_DBCS
        VERIFY( rc == 2 );
    #else
        VERIFY( rc == 1 );
    #endif
    VERIFY( wc != 0 );

    rc = mbstowcs( wcs, "", 20 );
    VERIFY( rc == 0 );
    VERIFY( wcs[0] == L'\0' );

    rc = mbstowcs( wcs, "foo", 0 );
    VERIFY( rc == 0 );

    rc = mbstowcs( wcs, "\x81\xFC""foo", 0 );
    VERIFY( rc == 0 );

    rc = mbstowcs( wcs, "foo", 20 );
    VERIFY( rc == 3 );

    rc = mbstowcs( wcs, "\x81\xFC""foo", 20 );
    #ifndef DUMMY_DBCS
        VERIFY( rc == 4 );
        VERIFY( wcs[1] == 'f' );
        VERIFY( wcs[2] == 'o' );
        VERIFY( wcs[3] == 'o' );
        VERIFY( wcs[4] == '\0' );
    #else
        VERIFY( rc == 5 );
        VERIFY( wcs[2] == 'f' );
        VERIFY( wcs[3] == 'o' );
        VERIFY( wcs[4] == 'o' );
        VERIFY( wcs[5] == '\0' );
    #endif
    VERIFY( mbstowcs( NULL, "\x81\xFC""foo", 20 )  ==  rc );
}



/****
***** Test wctomb() and wcstombs().
****/

void TestFromWide( void )
{
    unsigned char       mbs[20];
    wchar_t             wc = L'\0';
    wchar_t             wcs[] = { 'H', 'e', 'l', 'l', 'o', '\0' };
    int                 len;

    len = wctomb( NULL, 0 );
    VERIFY( len == 0 );

    len = wctomb( mbs, L'\0' );
    VERIFY( len == 1 );
    VERIFY( mbs[0] == '\0' );

    len = wctomb( mbs, 'H' );
    VERIFY( len == 1 );
    VERIFY( mbs[0] == 'H' );

    len = wcstombs( mbs, wcs, 20 );
    VERIFY( len == 5 );
    VERIFY( !_mbscmp(mbs,"Hello") );
    VERIFY( wcstombs( NULL, wcs, 20 )  ==  len );

    len = wcstombs( mbs, &wc, 20 );
    VERIFY( len == 0 );
    VERIFY( mbs[0] == '\0' );
}



/****
***** Test _mbsset(), _mbsnset(), and _mbsnbset().
****/

void TestSet( void )
{
    unsigned char       buf[] = "abcdefghij";
    unsigned char *     ptr;
    unsigned int        mbc = '!';

    ptr = _mbsset( buf, mbc );
    VERIFY( ptr == buf );
    VERIFY( buf[0] == '!' );
    VERIFY( buf[9] == '!' );
    VERIFY( buf[10] == '\0' );

    _mbscpy( buf, "abcdefghij" );
    ptr = _mbsnset( buf, mbc, 5 );
    VERIFY( ptr == buf );
    VERIFY( buf[0] == '!' );
    VERIFY( buf[4] == '!' );
    VERIFY( buf[5] == 'f' );

    _mbscpy( buf, "abcdefghij" );
    ptr = _mbsnbset( buf, mbc, 5 );
    VERIFY( ptr == buf );
    VERIFY( buf[0] == '!' );
    VERIFY( buf[4] == '!' );
    VERIFY( buf[5] == 'f' );
}


void TestSetM( void )
{
    unsigned char       buf[] = "abcdefghij";
    unsigned char *     ptr;
    unsigned int        mbc;

    mbc = _mbsnextc( "\x81\xFC" );

    ptr = _mbsset( buf, mbc );
    VERIFY( ptr == buf );
    VERIFY( buf[0] == '\x81' );
    #ifndef DUMMY_DBCS
        VERIFY( buf[1] == '\xFC' );
    #else
        VERIFY( buf[1] == '\x81' );
    #endif

    _mbscpy( buf, "abcdefghij" );
    ptr = _mbsnset( buf, mbc, 4 );
    VERIFY( ptr == buf );
    VERIFY( buf[0] == '\x81' );
    #ifndef DUMMY_DBCS
        VERIFY( buf[1] == '\xFC' );
        VERIFY( buf[8] == 'i' );
    #else
        VERIFY( buf[1] == '\x81' );
        VERIFY( buf[4] == 'e' );
    #endif

    _mbscpy( buf, "abcdefghij" );
    ptr = _mbsnbset( buf, mbc, 5 );
    VERIFY( ptr == buf );
    VERIFY( buf[0] == '\x81' );
    #ifndef DUMMY_DBCS
        VERIFY( buf[4] == ' ' );
    #else
        VERIFY( buf[4] == '\x81' );
    #endif
    VERIFY( buf[5] == 'f' );
}



/****
***** Test _mbstok().
****/

void TestToken( void )
{
    unsigned char       buf[] = "F\x81\xFC""ind\x90\x90""all;the.tokens,";
    unsigned char *     ptr;

    ptr = _mbstok( buf, " ;.,!\x90\x90" );      /* find a token */
    VERIFY( !_mbscmp(ptr,"F\x81\xFC""ind") );

    ptr = _mbstok( NULL, " ;.,!" );             /* find a token */
    #ifndef DUMMY_DBCS
        VERIFY( !_mbscmp(ptr,"all") );
    #else
        VERIFY( !_mbscmp(ptr,"\x90""all") );
    #endif

    ptr = _mbstok( NULL, " ;.,!" );             /* find a token */
    VERIFY( !_mbscmp(ptr,"the") );

    ptr = _mbstok( NULL, " ;.,!" );             /* find a token */
    VERIFY( !_mbscmp(ptr,"tokens") );

    ptr = _mbstok( NULL, " '.,!" );             /* try to find another */
    VERIFY( ptr == NULL );
}



/****
***** Test mbtob(), sisinit(), mbrlen(), mbrtowc(), wcrtomb(), mbsrtowcs(),
***** wcsrtombs(), ie. all Normative Addendum functions.
****/

void TestAddendum( void )
{
    wchar_t             wc;
    wchar_t             wcs[10];
    wchar_t *           wcsPtr;
    int                 status;
    mbstate_t           state;
    unsigned char       mbc[MB_LEN_MAX];
    unsigned char       mbcs[10*MB_LEN_MAX+1];
    unsigned char *     mbcsPtr;

    status = wctob( L'!' );
    VERIFY( status == '!' );

    status = mbtowc( &wc, "\x90\x90", 2 );
    #ifndef DUMMY_DBCS
        VERIFY( status == 2 );
        status = wctob( wc );
        VERIFY( status == EOF );
    #else
        VERIFY( status == 1 );
        status = wctob( wc );
        VERIFY( status == 0x90 );
    #endif

    status = sisinit( NULL );
    VERIFY( status != 0 );

    state = 0;
    status = sisinit( &state );
    VERIFY( status == 0 );

    state = 123;
    status = sisinit( &state );
    VERIFY( status == 0 );

    status = mbrlen( "\0""!", 2, &state );
    VERIFY( status == 0 );

    status = mbrlen( "!", 2, &state );
    VERIFY( status == 1 );

    status = mbrlen( "\x90\x90""!", 1, &state );
    #ifndef DUMMY_DBCS
        VERIFY( status == -2 );
    #else
        VERIFY( status == 1 );
    #endif

    status = mbrtowc( NULL, NULL, 0, &state );
    VERIFY( status == 0 );

    status = mbrtowc( &wc, "!", 20, &state );
    VERIFY( status == 1 );
    VERIFY( wc == L'!' );

    status = wcrtomb( NULL, wc, &state );
    VERIFY( status == 0 );

    status = wcrtomb( mbc, wc, &state );
    VERIFY( status == 1 );
    VERIFY( *mbc == '!' );

    _mbscpy( mbcs, "Foo!\x90\x90" );
    mbcsPtr = mbcs;
    wcs[5] = wcs[6] = L'-';
    #ifndef DUMMY_DBCS
        status = mbsrtowcs( wcs, (const char**)(&mbcsPtr), 5, &state );
        VERIFY( status == 5 );
    #else
        status = mbsrtowcs( wcs, (const char**)(&mbcsPtr), 6, &state );
        VERIFY( status == 6 );
    #endif
    VERIFY( wcs[0] == L'F' );
    VERIFY( wcs[1] == L'o' );
    VERIFY( wcs[2] == L'o' );
    VERIFY( wcs[3] == L'!' );
    #ifndef DUMMY_DBCS
        VERIFY( wcs[4] & 0xFF00 );
        VERIFY( wcs[5] == L'-' );
        wcs[5] = L'\0';
    #else
        VERIFY( wcs[4] == 0x90 );
        VERIFY( wcs[5] == 0x90 );
        VERIFY( wcs[6] == L'-' );
        wcs[6] = L'\0';
    #endif

    mbcsPtr = mbcs;
    status = mbsrtowcs( NULL, (const char**)(&mbcsPtr), 1, &state );
    #ifdef DUMMY_DBCS
        VERIFY( status == 6 );  /* ignore len when dst==NULL */
    #else
        VERIFY( status == 5 );  /* ignore len when dst==NULL */
    #endif

    wcsPtr = wcs;
    _mbsset( mbcs, _mbsnextc("#") );
    status = wcsrtombs( mbcs, (const wchar_t**)(&wcsPtr), 6, &state );
    VERIFY( status == 6 );
    mbcs[status] = '\0';
    VERIFY( _mbscmp( mbcs, "Foo!\x90\x90" ) == 0 );

    wcsPtr = wcs;
    status = wcsrtombs( NULL, (const wchar_t**)(&wcsPtr), 20, &state );
    VERIFY( status == 6 );
}



/****
***** Test _mbsrev(), _mbslen(), _mbsninc(), _mbsnextc(), _mbsnbcnt(),
***** _mbsdec(), and _mbsnccnt().
****/

void TestMisc( void )
{
    unsigned char       buf[] = "abcde\x81\xFC""fghij";
    unsigned char       foo[] = "foo""\x82\x81\x81\xFC\x90\x90\x81\x81\x81\x81""bar";
    unsigned char *     ptr;
    int                 len;
    unsigned int        ch;
    char                mbc[MB_LEN_MAX+1];

    VERIFY( _mbsdec( foo, foo ) == NULL );
    VERIFY( _mbsdec( foo, foo-1 ) == NULL );
    VERIFY( _mbsdec( foo, foo+2 ) == foo+1 );
    VERIFY( _mbsdec( foo, foo+3 ) == foo+2 );
    VERIFY( _mbsdec( foo, foo+5 ) == foo+3 );
    VERIFY( _mbsdec( foo, foo+7 ) == foo+5 );
    VERIFY( _mbsdec( foo, foo+9 ) == foo+7 );
    VERIFY( _mbsdec( foo, foo+11 ) == foo+9 );
    VERIFY( _mbsdec( foo, foo+13 ) == foo+11 );

    len = _mbslen( buf );
    #ifndef DUMMY_DBCS
        VERIFY( len == 11 );
    #else
        VERIFY( len == 12 );
    #endif

    ptr = _mbsninc( buf, 4 );
    VERIFY( ptr == buf+4 );

    ptr = _mbsninc( buf, 6 );
    #ifndef DUMMY_DBCS
        VERIFY( ptr == buf+7 );
    #else
        VERIFY( ptr == buf+6 );
    #endif

    ch = _mbsnextc( ptr );
    _mbvtop( ch, mbc );
    mbc[_mbclen(mbc)] = '\0';
    VERIFY( _mbccmp(mbc,ptr) == 0 );

    len = _mbsnbcnt( buf, 30 );
    VERIFY( len == 12 );

    len = _mbsnbcnt( "a\x81\xFC""bc\x90\0", 30 );
    #ifndef DUMMY_DBCS
        VERIFY( len == 5 );
    #else
        VERIFY( len == 6 );
    #endif

    len = _mbsnbcnt( buf, 5 );
    VERIFY( len == 5 );

    len = _mbsnccnt( buf, 5 );
    VERIFY( len == 5 );

    len = _mbsnccnt( buf, 6 );
    #ifndef DUMMY_DBCS
        VERIFY( len == 5 );
    #else
        VERIFY( len == 6 );
    #endif

    len = _mbsnccnt( buf, 7 );
    #ifndef DUMMY_DBCS
        VERIFY( len == 6 );
    #else
        VERIFY( len == 7 );
    #endif

    ptr = _mbsninc( NULL, 10 );
    VERIFY( ptr == NULL );

    ptr = _mbsninc( buf, 6 );
    #ifndef DUMMY_DBCS
        VERIFY( ptr == buf+7 );
    #else
        VERIFY( ptr == buf+6 );
    #endif

    ptr = _mbsrev( buf );
    VERIFY( ptr == buf );
    #ifndef DUMMY_DBCS
        VERIFY( !_mbscmp(buf,"jihgf\x81\xFC""edcba") );
    #else
        VERIFY( !_mbscmp(buf,"jihgf\xFC\x81""edcba") );
    #endif
}



/****
***** Test a few lead_byte:null_byte situations.
****/

void TestInvalidDbcs( void )
{
    unsigned char       bufA[80] = "foo\x81";
    unsigned char       bufB[] = "abcde\x81\xFC""fghij";
    unsigned char *     ptr = "\x81";

    VERIFY( _mbslen( bufA ) == 3 );
    VERIFY( _mbclen( "\x81" ) == 2 );           /* for MS compatability */
    VERIFY( _mbsinc( ptr ) == ptr+1 );

    _mbsnbcat( bufA, bufB, 6 );
    VERIFY( _mbscmp( bufA, "fooabcde" ) == 0 );

    strset( bufA, '\0' );
    _mbsnbcpy( bufA, bufB, 6 );
    VERIFY( strcmp( bufA, "abcde" ) == 0 );
}