IsDBCSLeadByteEx.c File Reference

#include "precomp.h"

Include dependency graph for IsDBCSLeadByteEx.c:

Go to the source code of this file.

Classes
struct	RANGE
struct	ENTRY

Macros
#define	MAX_RANGE   4

Typedefs
typedef struct RANGE	RANGE
typedef struct ENTRY	ENTRY

Functions
	START_TEST (IsDBCSLeadByteEx)

Macro Definition Documentation

MAX_RANGE

#define MAX_RANGE   4

Definition at line 10 of file IsDBCSLeadByteEx.c.

Typedef Documentation

ENTRY

typedef struct ENTRY ENTRY

RANGE

typedef struct RANGE RANGE

Function Documentation

START_TEST()

START_TEST

(

IsDBCSLeadByteEx

)

Definition at line 26 of file IsDBCSLeadByteEx.c.

{
    static const ENTRY Entries[] =
    {
        {
            "English", 437,
            0
        },
        {
            "ChineseSimpilified", 936,
            1,
            {
                { 0x81, 0xFE }
            }
        },
        {
            "ChineseTraditional", 950,
            1,
            {
                { 0x81, 0xFE }
            }
        },
        {
            "Japanese", 932,
            2,
            {
                { 0x81, 0x9F }, { 0xE0, 0xFC }
            }
        },
        {
            "Korean", 949,
            1,
            {
                { 0x81, 0xFE }
            }
        }
    };
    int i;
 
    for (i = 0; i < _countof(Entries); ++i)
    {
        int Index, iRange;
        int CodePage = Entries[i].CodePage, StartIndex = 0, RangeCount = 0;
        BOOL InRange = FALSE;
        RANGE Ranges[MAX_RANGE];
        const char *Name = Entries[i].Name;
 
        ZeroMemory(&Ranges, sizeof(Ranges));
 
        for (Index = 0; Index < 256; ++Index)
        {
            if (InRange)
            {
                if (!IsDBCSLeadByteEx(CodePage, Index))
                {
                    Ranges[RangeCount].StartIndex = StartIndex;
                    Ranges[RangeCount].EndIndex = Index - 1;
                    ++RangeCount;
                    InRange = FALSE;
                }
            }
            else
            {
                if (IsDBCSLeadByteEx(CodePage, Index))
                {
                    StartIndex = Index;
                    InRange = TRUE;
                }
            }
        }
        if (InRange)
        {
            Ranges[RangeCount].StartIndex = StartIndex;
            Ranges[RangeCount].EndIndex = Index - 1;
            ++RangeCount;
        }
 
        ok(RangeCount == Entries[i].RangeCount,
           "%s: RangeCount expected %d, was %d\n",
           Name, Entries[i].RangeCount, RangeCount);
        for (iRange = 0; iRange < Entries[i].RangeCount; ++iRange)
        {
            const RANGE *pRange = &Entries[i].Ranges[iRange];
            int iStart = Ranges[iRange].StartIndex;
            int iEnd = Ranges[iRange].EndIndex;
            ok(iStart == pRange->StartIndex,
               "%s: Ranges[%d].StartIndex expected: 0x%02X, was: 0x%02X\n",
               Name, iRange, pRange->StartIndex, iStart);
            ok(iEnd == pRange->EndIndex,
               "%s: Ranges[%d].EndIndex was expected: 0x%02X, was: 0x%02X\n",
               Name, iRange, pRange->EndIndex, iEnd);
        }
    }
}