usp10.c File Reference

#include <assert.h>
#include <stdio.h>
#include <wine/test.h>
#include <windows.h>
#include <usp10.h>

Include dependency graph for usp10.c:

Go to the source code of this file.

Classes
struct	_itemTest
struct	_shapeTest_char
struct	_shapeTest_glyph
struct	_font_fingerprint
struct	tagRangeP
struct	enum_font_data
struct	logical_width_test

Macros
#define	test_items_ok(a, b, c, d, e, f, g, h)   (winetest_set_location(__FILE__,__LINE__), 0) ? 0 : _test_items_ok(a,b,c,d,e,f,g,h)
#define	MS_MAKE_TAG(_x1, _x2, _x3, _x4)
#define	latn_tag   MS_MAKE_TAG('l','a','t','n')
#define	arab_tag   MS_MAKE_TAG('a','r','a','b')
#define	thai_tag   MS_MAKE_TAG('t','h','a','i')
#define	hebr_tag   MS_MAKE_TAG('h','e','b','r')
#define	syrc_tag   MS_MAKE_TAG('s','y','r','c')
#define	thaa_tag   MS_MAKE_TAG('t','h','a','a')
#define	deva_tag   MS_MAKE_TAG('d','e','v','a')
#define	beng_tag   MS_MAKE_TAG('b','e','n','g')
#define	guru_tag   MS_MAKE_TAG('g','u','r','u')
#define	gujr_tag   MS_MAKE_TAG('g','u','j','r')
#define	orya_tag   MS_MAKE_TAG('o','r','y','a')
#define	taml_tag   MS_MAKE_TAG('t','a','m','l')
#define	telu_tag   MS_MAKE_TAG('t','e','l','u')
#define	knda_tag   MS_MAKE_TAG('k','n','d','a')
#define	mlym_tag   MS_MAKE_TAG('m','l','y','m')
#define	mymr_tag   MS_MAKE_TAG('m','y','m','r')
#define	tale_tag   MS_MAKE_TAG('t','a','l','e')
#define	talu_tag   MS_MAKE_TAG('t','a','l','u')
#define	khmr_tag   MS_MAKE_TAG('k','h','m','r')
#define	hani_tag   MS_MAKE_TAG('h','a','n','i')
#define	bopo_tag   MS_MAKE_TAG('b','o','p','o')
#define	kana_tag   MS_MAKE_TAG('k','a','n','a')
#define	hang_tag   MS_MAKE_TAG('h','a','n','g')
#define	yi_tag   MS_MAKE_TAG('y','i',' ',' ')
#define	ethi_tag   MS_MAKE_TAG('e','t','h','i')
#define	mong_tag   MS_MAKE_TAG('m','o','n','g')
#define	tfng_tag   MS_MAKE_TAG('t','f','n','g')
#define	nko_tag   MS_MAKE_TAG('n','k','o',' ')
#define	vai_tag   MS_MAKE_TAG('v','a','i',' ')
#define	cher_tag   MS_MAKE_TAG('c','h','e','r')
#define	cans_tag   MS_MAKE_TAG('c','a','n','s')
#define	ogam_tag   MS_MAKE_TAG('o','g','a','m')
#define	runr_tag   MS_MAKE_TAG('r','u','n','r')
#define	brai_tag   MS_MAKE_TAG('b','r','a','i')
#define	dsrt_tag   MS_MAKE_TAG('d','s','r','t')
#define	osma_tag   MS_MAKE_TAG('o','s','m','a')
#define	math_tag   MS_MAKE_TAG('m','a','t','h')
#define	test_shape_ok(a, b, c, d, e, f, g, h, i)   (winetest_set_location(__FILE__,__LINE__), 0) ? 0 : _test_shape_ok(1,a,b,c,d,e,f,g,h,i,NULL)
#define	test_shape_ok_valid(v, a, b, c, d, e, f, g, h, i)   (winetest_set_location(__FILE__,__LINE__), 0) ? 0 : _test_shape_ok(v,a,b,c,d,e,f,g,h,i,NULL)
#define	test_shape_ok_valid_props2(v, a, b, c, d, e, f, g, h, i, j)   (winetest_set_location(__FILE__,__LINE__), 0) ? 0 : _test_shape_ok(v,a,b,c,d,e,f,g,h,i,j)
#define	find_font_for_range(a, b, c, d, e, f, g)   (winetest_set_location(__FILE__,__LINE__), 0) ? 0 : _find_font_for_range(a,b,c,d,e,f,g)
#define	MAX_ENUM_FONTS   4096
#define	test_item_ScriptXtoX(a, b, c, d, e, f)   (winetest_set_location(__FILE__,__LINE__), 0) ? 0 : _test_item_ScriptXtoX(a,b,c,d,e,f)
#define	test_caret_item_ScriptXtoCP(a, b, c, d, e, f)   _test_caret_item_ScriptXtoCP(__LINE__,a,b,c,d,e,f)

Typedefs
typedef struct _itemTest	itemTest
typedef struct _shapeTest_char	shapeTest_char
typedef struct _shapeTest_glyph	shapeTest_glyph
typedef struct _font_fingerprint	font_fingerprint
typedef struct tagRangeP	fontEnumParam

Functions
static	HRESULT (WINAPI *pScriptItemizeOpenType)(const WCHAR *pwcInChars
static void	_test_items_ok (LPCWSTR string, DWORD cchString, SCRIPT_CONTROL *Control, SCRIPT_STATE *State, DWORD nItems, const itemTest *items, BOOL nItemsToDo, const INT nItemsBroken[2])
static void	test_ScriptItemize (void)
static void	make_surrogate (DWORD i, WORD out[2])
static void	test_ScriptItemize_surrogates (void)
static void	_test_shape_ok (int valid, HDC hdc, LPCWSTR string, DWORD cchString, SCRIPT_CONTROL *Control, SCRIPT_STATE *State, DWORD item, DWORD nGlyphs, const shapeTest_char *charItems, const shapeTest_glyph *glyphItems, const SCRIPT_GLYPHPROP *props2)
static int CALLBACK	enumFontProc (const LOGFONTA *lpelfe, const TEXTMETRICA *lpntme, DWORD FontType, LPARAM lParam)
static int	_find_font_for_range (HDC hdc, const CHAR *recommended, BYTE range, const WCHAR check, HFONT *hfont, HFONT *origFont, const font_fingerprint *fingerprint)
static void	test_ScriptShapeOpenType (HDC hdc)
static void	test_ScriptShape (HDC hdc)
static void	test_ScriptPlace (HDC hdc)
static void	test_ScriptItemIzeShapePlace (HDC hdc, unsigned short pwOutGlyphs[256])
static void	test_ScriptGetCMap (HDC hdc, unsigned short pwOutGlyphs[256])
static INT CALLBACK	enum_bitmap_font_proc (const LOGFONTA *lf, const TEXTMETRICA *ntm, DWORD type, LPARAM lParam)
static INT CALLBACK	enum_truetype_proc (const LOGFONTA *lf, const TEXTMETRICA *ntm, DWORD type, LPARAM lParam)
static void	test_ScriptGetFontProperties (HDC hdc)
static void	test_ScriptTextOut (HDC hdc)
static void	test_ScriptTextOut2 (HDC hdc)
static void	test_ScriptTextOut3 (HDC hdc)
static void	_test_item_ScriptXtoX (SCRIPT_ANALYSIS *psa, int cChars, int cGlyphs, const int *offsets, const WORD *pwLogClust, const int *piAdvance)
static void	_test_caret_item_ScriptXtoCP (int line, SCRIPT_ANALYSIS *psa, int cChars, int cGlyphs, const int *offsets, const WORD *pwLogClust, const int *piAdvance)
static void	test_ScriptXtoX (void)
static void	test_ScriptString (HDC hdc)
static void	test_ScriptStringXtoCP_CPtoX (HDC hdc)
static HWND	create_test_window (void)
static void	test_ScriptCacheGetHeight (HDC hdc)
static void	test_ScriptGetGlyphABCWidth (HDC hdc)
static void	test_ScriptLayout (void)
static BOOL CALLBACK	enum_proc (LGRPID group, LCID lcid, LPSTR locale, LONG_PTR lparam)
static void	test_digit_substitution (void)
static void	test_ScriptGetProperties (void)
static void	test_ScriptBreak (void)
static void	test_newlines (void)
static void	test_ScriptGetFontFunctions (HDC hdc)
static void	test_ScriptGetLogicalWidths (void)
static void	test_ScriptIsComplex (void)
static void	test_ScriptString_pSize (HDC hdc)
static void	test_script_cache_reuse (void)
static void	init_tests (void)
	START_TEST (usp10)

Variables
static int	cInChars
static int int	cMaxItems
static int int const SCRIPT_CONTROL *	psControl
static int int const SCRIPT_CONTROL const SCRIPT_STATE *	psState
static int int const SCRIPT_CONTROL const SCRIPT_STATE SCRIPT_ITEM *	pItems
static int int const SCRIPT_CONTROL const SCRIPT_STATE SCRIPT_ITEM ULONG *	pScriptTags
static int int const SCRIPT_CONTROL const SCRIPT_STATE SCRIPT_ITEM ULONG int *	pcItems
static SCRIPT_CACHE *	psc
static SCRIPT_CACHE SCRIPT_ANALYSIS *	psa
static SCRIPT_CACHE SCRIPT_ANALYSIS OPENTYPE_TAG	tagScript
static SCRIPT_CACHE SCRIPT_ANALYSIS OPENTYPE_TAG OPENTYPE_TAG	tagLangSys
static SCRIPT_CACHE SCRIPT_ANALYSIS OPENTYPE_TAG OPENTYPE_TAG int *	rcRangeChars
static SCRIPT_CACHE SCRIPT_ANALYSIS OPENTYPE_TAG OPENTYPE_TAG int TEXTRANGE_PROPERTIES **	rpRangeProperties
static SCRIPT_CACHE SCRIPT_ANALYSIS OPENTYPE_TAG OPENTYPE_TAG int TEXTRANGE_PROPERTIES int	cRanges
static SCRIPT_CACHE SCRIPT_ANALYSIS OPENTYPE_TAG OPENTYPE_TAG int TEXTRANGE_PROPERTIES int const WCHAR *	pwcChars
static SCRIPT_CACHE SCRIPT_ANALYSIS OPENTYPE_TAG OPENTYPE_TAG int TEXTRANGE_PROPERTIES int const WCHAR int	cChars
static SCRIPT_CACHE SCRIPT_ANALYSIS OPENTYPE_TAG OPENTYPE_TAG int TEXTRANGE_PROPERTIES int const WCHAR int int	cMaxGlyphs
static SCRIPT_CACHE SCRIPT_ANALYSIS OPENTYPE_TAG OPENTYPE_TAG int TEXTRANGE_PROPERTIES int const WCHAR int int WORD *	pwLogClust
static SCRIPT_CACHE SCRIPT_ANALYSIS OPENTYPE_TAG OPENTYPE_TAG int TEXTRANGE_PROPERTIES int const WCHAR int int WORD SCRIPT_CHARPROP *	pCharProps
static SCRIPT_CACHE SCRIPT_ANALYSIS OPENTYPE_TAG OPENTYPE_TAG int TEXTRANGE_PROPERTIES int const WCHAR int int WORD SCRIPT_CHARPROP WORD *	pwOutGlyphs
static SCRIPT_CACHE SCRIPT_ANALYSIS OPENTYPE_TAG OPENTYPE_TAG int TEXTRANGE_PROPERTIES int const WCHAR int int WORD SCRIPT_CHARPROP WORD SCRIPT_GLYPHPROP *	pOutGlyphProps
static SCRIPT_CACHE SCRIPT_ANALYSIS OPENTYPE_TAG OPENTYPE_TAG int TEXTRANGE_PROPERTIES int const WCHAR int int WORD SCRIPT_CHARPROP WORD SCRIPT_GLYPHPROP int *	pcGlyphs
static SCRIPT_CACHE SCRIPT_ANALYSIS int	cMaxTags
static SCRIPT_CACHE SCRIPT_ANALYSIS int OPENTYPE_TAG int *	pcTags
static SCRIPT_CACHE SCRIPT_ANALYSIS OPENTYPE_TAG int OPENTYPE_TAG *	pLangSysTags
static SCRIPT_CACHE SCRIPT_ANALYSIS OPENTYPE_TAG OPENTYPE_TAG int OPENTYPE_TAG *	pFeatureTags
static const struct logical_width_test	logical_width_tests []

Macro Definition Documentation

arab_tag

#define arab_tag   MS_MAKE_TAG('a','r','a','b')

Definition at line 143 of file usp10.c.

beng_tag

#define beng_tag   MS_MAKE_TAG('b','e','n','g')

Definition at line 149 of file usp10.c.

bopo_tag

#define bopo_tag   MS_MAKE_TAG('b','o','p','o')

Definition at line 162 of file usp10.c.

brai_tag

#define brai_tag   MS_MAKE_TAG('b','r','a','i')

Definition at line 175 of file usp10.c.

cans_tag

#define cans_tag   MS_MAKE_TAG('c','a','n','s')

Definition at line 172 of file usp10.c.

cher_tag

#define cher_tag   MS_MAKE_TAG('c','h','e','r')

Definition at line 171 of file usp10.c.

deva_tag

#define deva_tag   MS_MAKE_TAG('d','e','v','a')

Definition at line 148 of file usp10.c.

dsrt_tag

#define dsrt_tag   MS_MAKE_TAG('d','s','r','t')

Definition at line 176 of file usp10.c.

ethi_tag

#define ethi_tag   MS_MAKE_TAG('e','t','h','i')

Definition at line 166 of file usp10.c.

find_font_for_range

#define find_font_for_range	(		a,
			b,
			c,
			d,
			e,
			f,
			g
	)		(winetest_set_location(__FILE__,__LINE__), 0) ? 0 : _find_font_for_range(a,b,c,d,e,f,g)

Definition at line 1355 of file usp10.c.

gujr_tag

#define gujr_tag   MS_MAKE_TAG('g','u','j','r')

Definition at line 151 of file usp10.c.

guru_tag

#define guru_tag   MS_MAKE_TAG('g','u','r','u')

Definition at line 150 of file usp10.c.

hang_tag

#define hang_tag   MS_MAKE_TAG('h','a','n','g')

Definition at line 164 of file usp10.c.

hani_tag

#define hani_tag   MS_MAKE_TAG('h','a','n','i')

Definition at line 161 of file usp10.c.

hebr_tag

#define hebr_tag   MS_MAKE_TAG('h','e','b','r')

Definition at line 145 of file usp10.c.

kana_tag

#define kana_tag   MS_MAKE_TAG('k','a','n','a')

Definition at line 163 of file usp10.c.

khmr_tag

#define khmr_tag   MS_MAKE_TAG('k','h','m','r')

Definition at line 160 of file usp10.c.

knda_tag

#define knda_tag   MS_MAKE_TAG('k','n','d','a')

Definition at line 155 of file usp10.c.

latn_tag

#define latn_tag   MS_MAKE_TAG('l','a','t','n')

Definition at line 142 of file usp10.c.

math_tag

#define math_tag   MS_MAKE_TAG('m','a','t','h')

Definition at line 178 of file usp10.c.

MAX_ENUM_FONTS

#define MAX_ENUM_FONTS   4096

Definition at line 2467 of file usp10.c.

mlym_tag

#define mlym_tag   MS_MAKE_TAG('m','l','y','m')

Definition at line 156 of file usp10.c.

mong_tag

#define mong_tag   MS_MAKE_TAG('m','o','n','g')

Definition at line 167 of file usp10.c.

MS_MAKE_TAG

#define MS_MAKE_TAG	(		_x1,
			_x2,
			_x3,
			_x4
	)

Value:

( ( (ULONG)_x4 << 24 ) |     \
            ( (ULONG)_x3 << 16 ) |     \
            ( (ULONG)_x2 <<  8 ) |     \
              (ULONG)_x1         )

Definition at line 136 of file usp10.c.

mymr_tag

#define mymr_tag   MS_MAKE_TAG('m','y','m','r')

Definition at line 157 of file usp10.c.

nko_tag

#define nko_tag   MS_MAKE_TAG('n','k','o',' ')

Definition at line 169 of file usp10.c.

ogam_tag

#define ogam_tag   MS_MAKE_TAG('o','g','a','m')

Definition at line 173 of file usp10.c.

orya_tag

#define orya_tag   MS_MAKE_TAG('o','r','y','a')

Definition at line 152 of file usp10.c.

osma_tag

#define osma_tag   MS_MAKE_TAG('o','s','m','a')

Definition at line 177 of file usp10.c.

runr_tag

#define runr_tag   MS_MAKE_TAG('r','u','n','r')

Definition at line 174 of file usp10.c.

syrc_tag

#define syrc_tag   MS_MAKE_TAG('s','y','r','c')

Definition at line 146 of file usp10.c.

tale_tag

#define tale_tag   MS_MAKE_TAG('t','a','l','e')

Definition at line 158 of file usp10.c.

talu_tag

#define talu_tag   MS_MAKE_TAG('t','a','l','u')

Definition at line 159 of file usp10.c.

taml_tag

#define taml_tag   MS_MAKE_TAG('t','a','m','l')

Definition at line 153 of file usp10.c.

telu_tag

#define telu_tag   MS_MAKE_TAG('t','e','l','u')

Definition at line 154 of file usp10.c.

test_caret_item_ScriptXtoCP

#define test_caret_item_ScriptXtoCP	(		a,
			b,
			c,
			d,
			e,
			f
	)		_test_caret_item_ScriptXtoCP(__LINE__,a,b,c,d,e,f)

Definition at line 2973 of file usp10.c.

test_item_ScriptXtoX

#define test_item_ScriptXtoX	(		a,
			b,
			c,
			d,
			e,
			f
	)		(winetest_set_location(__FILE__,__LINE__), 0) ? 0 : _test_item_ScriptXtoX(a,b,c,d,e,f)

Definition at line 2901 of file usp10.c.

test_items_ok

#define test_items_ok	(		a,
			b,
			c,
			d,
			e,
			f,
			g,
			h
	)		(winetest_set_location(__FILE__,__LINE__), 0) ? 0 : _test_items_ok(a,b,c,d,e,f,g,h)

Definition at line 134 of file usp10.c.

test_shape_ok

#define test_shape_ok	(		a,
			b,
			c,
			d,
			e,
			f,
			g,
			h,
			i
	)		(winetest_set_location(__FILE__,__LINE__), 0) ? 0 : _test_shape_ok(1,a,b,c,d,e,f,g,h,i,NULL)

Definition at line 1230 of file usp10.c.

test_shape_ok_valid

#define test_shape_ok_valid	(		v,
			a,
			b,
			c,
			d,
			e,
			f,
			g,
			h,
			i
	)		(winetest_set_location(__FILE__,__LINE__), 0) ? 0 : _test_shape_ok(v,a,b,c,d,e,f,g,h,i,NULL)

Definition at line 1233 of file usp10.c.

test_shape_ok_valid_props2

#define test_shape_ok_valid_props2	(		v,
			a,
			b,
			c,
			d,
			e,
			f,
			g,
			h,
			i,
			j
	)		(winetest_set_location(__FILE__,__LINE__), 0) ? 0 : _test_shape_ok(v,a,b,c,d,e,f,g,h,i,j)

Definition at line 1236 of file usp10.c.

tfng_tag

#define tfng_tag   MS_MAKE_TAG('t','f','n','g')

Definition at line 168 of file usp10.c.

thaa_tag

#define thaa_tag   MS_MAKE_TAG('t','h','a','a')

Definition at line 147 of file usp10.c.

thai_tag

#define thai_tag   MS_MAKE_TAG('t','h','a','i')

Definition at line 144 of file usp10.c.

vai_tag

#define vai_tag   MS_MAKE_TAG('v','a','i',' ')

Definition at line 170 of file usp10.c.

yi_tag

#define yi_tag   MS_MAKE_TAG('y','i',' ',' ')

Definition at line 165 of file usp10.c.

Typedef Documentation

font_fingerprint

typedef struct _font_fingerprint font_fingerprint

fontEnumParam

typedef struct tagRangeP fontEnumParam

itemTest

typedef struct _itemTest itemTest

shapeTest_char

typedef struct _shapeTest_char shapeTest_char

shapeTest_glyph

typedef struct _shapeTest_glyph shapeTest_glyph

Function Documentation

_find_font_for_range()

static int _find_font_for_range ( HDC  hdc, const CHAR *  recommended, BYTE  range, const WCHAR  check, HFONT *  hfont, HFONT *  origFont, const font_fingerprint *  fingerprint  )

static

Definition at line 1274 of file usp10.c.

{
    int rc = 0;
    fontEnumParam lParam;

    lParam.range = range;
    memset(&lParam.lf,0,sizeof(LOGFONTA));
    *hfont = NULL;

    if (recommended)
    {
        lstrcpyA(lParam.lf.lfFaceName, recommended);
        if (!EnumFontFamiliesExA(hdc, &lParam.lf, enumFontProc, (LPARAM)&lParam, 0))
        {
            *hfont = CreateFontIndirectA(&lParam.lf);
            if (*hfont)
            {
                winetest_trace("using font %s\n",lParam.lf.lfFaceName);
                if (fingerprint)
                {
                    WORD output[10];
                    int i;

                    *origFont = SelectObject(hdc,*hfont);
                    if (GetGlyphIndicesW(hdc, fingerprint->check, 10, output, 0) != GDI_ERROR)
                    {
                        for (i=0; i < 10; i++)
                            if (output[i] != fingerprint->result[i])
                            {
                                winetest_trace("found font does not match fingerprint\n");
                                SelectObject(hdc,*origFont);
                                DeleteObject(*hfont);
                                *hfont = NULL;
                                break;
                            }
                        if (i == 10) rc = 1;
                    }
                    SelectObject(hdc, *origFont);
                }
                else rc = 1;
            }
        }
        if (!rc)
            winetest_skip("Font %s is not available.\n", recommended);
    }

    if (!*hfont)
    {
        memset(&lParam.lf,0,sizeof(LOGFONTA));
        lParam.lf.lfCharSet = DEFAULT_CHARSET;

        if (!EnumFontFamiliesExA(hdc, &lParam.lf, enumFontProc, (LPARAM)&lParam, 0) && lParam.lf.lfFaceName[0])
        {
            *hfont = CreateFontIndirectA(&lParam.lf);
            if (*hfont)
                winetest_trace("trying font %s: failures will only be warnings\n",lParam.lf.lfFaceName);
        }
    }

    if (*hfont)
    {
        WORD glyph = 0;

        *origFont = SelectObject(hdc,*hfont);
        if (GetGlyphIndicesW(hdc, &check, 1, &glyph, 0) == GDI_ERROR || glyph == 0)
        {
            winetest_trace("    Font fails to contain required glyphs\n");
            SelectObject(hdc,*origFont);
            DeleteObject(*hfont);
            *hfont=NULL;
            rc = 0;
        }
        else if (!rc)
            rc = -1;
    }
    else
        winetest_trace("Failed to find usable font\n");

    return rc;
}

_test_caret_item_ScriptXtoCP()

static void _test_caret_item_ScriptXtoCP ( int  line, SCRIPT_ANALYSIS *  psa, int  cChars, int  cGlyphs, const int *  offsets, const WORD *  pwLogClust, const int *  piAdvance  )

static

Definition at line 2975 of file usp10.c.

{
    int iX, iCP, i;
    int icChars, icGlyphs;
    int piCP;
    int clusterSize;
    HRESULT hr;
    SCRIPT_VISATTR psva[10];
    int piTrailing;
    int direction;

    memset(psva,0,sizeof(psva));
    direction = (psa->fRTL)?-1:+1;

    for(iX = -1, i = iCP = 0; i < cChars; i++)
    {
        if (offsets[i] != iX)
        {
            iX = offsets[i];
            iCP = i;
        }
        icChars = cChars;
        icGlyphs = cGlyphs;
        hr = ScriptXtoCP(iX, icChars, icGlyphs, pwLogClust, psva, piAdvance, psa, &piCP, &piTrailing);
        ok_(__FILE__,line)(hr == S_OK, "ScriptXtoCP: should return S_OK not %08x\n", hr);
        ok_(__FILE__,line)(piCP == iCP, "ScriptXtoCP: iX=%d should return piCP=%d not %d\n", iX, iCP, piCP);
        ok_(__FILE__,line)(piTrailing == 0, "ScriptXtoCP: iX=%d should return piTrailing=0 not %d\n", iX, piTrailing);
    }

    for(iX = -2, i = 0; i < cChars; i++)
    {
        if (offsets[i]+direction != iX)
        {
            iX = offsets[i] + direction;
            iCP = i;
        }
        icChars = cChars;
        icGlyphs = cGlyphs;
        hr = ScriptXtoCP(iX, icChars, icGlyphs, pwLogClust, psva, piAdvance, psa, &piCP, &piTrailing);
        ok_(__FILE__,line)(hr == S_OK, "ScriptXtoCP leading: should return S_OK not %08x\n", hr);
        ok_(__FILE__,line)(piCP == iCP, "ScriptXtoCP leading: iX=%d should return piCP=%d not %d\n", iX, iCP, piCP);
        ok_(__FILE__,line)(piTrailing == 0, "ScriptXtoCP leading: iX=%d should return piTrailing=0 not %d\n", iX, piTrailing);
    }

    for(clusterSize = 0, iCP = 0, iX = -2, i = 0; i < cChars; i++)
    {
        clusterSize++;
        if (offsets[i] != offsets[i+1])
        {
            iX = offsets[i+1]-direction;
            icChars = cChars;
            icGlyphs = cGlyphs;
            hr = ScriptXtoCP(iX, icChars, icGlyphs, pwLogClust, psva, piAdvance, psa, &piCP, &piTrailing);
            ok_(__FILE__,line)(hr == S_OK, "ScriptXtoCP trailing: should return S_OK not %08x\n", hr);
            ok_(__FILE__,line)(piCP == iCP, "ScriptXtoCP trailing: iX=%d should return piCP=%d not %d\n", iX, iCP, piCP);
            ok_(__FILE__,line)(piTrailing == clusterSize, "ScriptXtoCP trailing: iX=%d should return piTrailing=%d not %d\n", iX, clusterSize, piTrailing);
            iCP = i+1;
            clusterSize = 0;
        }
    }
}

_test_item_ScriptXtoX()

static void _test_item_ScriptXtoX ( SCRIPT_ANALYSIS *  psa, int  cChars, int  cGlyphs, const int *  offsets, const WORD *  pwLogClust, const int *  piAdvance  )

static

Definition at line 2903 of file usp10.c.

{
    int iX, iCP;
    int icChars, icGlyphs;
    int piCP, piX;
    HRESULT hr;
    SCRIPT_VISATTR psva[10];
    int piTrailing;
    BOOL fTrailing;
    int direction;

    memset(psva,0,sizeof(psva));
    direction = (psa->fRTL)?-1:+1;

    for(iCP = 0; iCP < cChars; iCP++)
    {
        iX = offsets[iCP];
        icChars = cChars;
        icGlyphs = cGlyphs;
        hr = ScriptXtoCP(iX, icChars, icGlyphs, pwLogClust, psva, piAdvance, psa, &piCP, &piTrailing);
        winetest_ok(hr == S_OK, "ScriptXtoCP: should return S_OK not %08x\n", hr);
        winetest_ok(piCP == iCP, "ScriptXtoCP: iX=%d should return piCP=%d not %d\n", iX, iCP, piCP);
        winetest_ok(piTrailing == 0, "ScriptXtoCP: iX=%d should return piTrailing=0 not %d\n", iX, piTrailing);
    }

    for(iCP = 0; iCP < cChars; iCP++)
    {
        iX = offsets[iCP]+direction;
        icChars = cChars;
        icGlyphs = cGlyphs;
        hr = ScriptXtoCP(iX, icChars, icGlyphs, pwLogClust, psva, piAdvance, psa, &piCP, &piTrailing);
        winetest_ok(hr == S_OK, "ScriptXtoCP leading: should return S_OK not %08x\n", hr);
        winetest_ok(piCP == iCP, "ScriptXtoCP leading: iX=%d should return piCP=%d not %d\n", iX, iCP, piCP);
        winetest_ok(piTrailing == 0, "ScriptXtoCP leading: iX=%d should return piTrailing=0 not %d\n", iX, piTrailing);
    }

    for(iCP = 0; iCP < cChars; iCP++)
    {
        iX = offsets[iCP+1]-direction;
        icChars = cChars;
        icGlyphs = cGlyphs;
        hr = ScriptXtoCP(iX, icChars, icGlyphs, pwLogClust, psva, piAdvance, psa, &piCP, &piTrailing);
        winetest_ok(hr == S_OK, "ScriptXtoCP trailing: should return S_OK not %08x\n", hr);
        winetest_ok(piCP == iCP, "ScriptXtoCP trailing: iX=%d should return piCP=%d not %d\n", iX, iCP, piCP);
        winetest_ok(piTrailing == 1, "ScriptXtoCP trailing: iX=%d should return piTrailing=1 not %d\n", iX, piTrailing);
    }

    for(iCP = 0; iCP <= cChars+1; iCP++)
    {
        fTrailing = FALSE;
        icChars = cChars;
        icGlyphs = cGlyphs;
        hr = ScriptCPtoX(iCP, fTrailing, icChars, icGlyphs, pwLogClust, psva, piAdvance, psa, &piX);
        winetest_ok(hr == S_OK, "ScriptCPtoX: should return S_OK not %08x\n", hr);
        winetest_ok(piX == offsets[iCP],
           "ScriptCPtoX: iCP=%d should return piX=%d not %d\n", iCP, offsets[iCP], piX);
    }

    for(iCP = 0; iCP <= cChars+1; iCP++)
    {
        fTrailing = TRUE;
        icChars = cChars;
        icGlyphs = cGlyphs;
        hr = ScriptCPtoX(iCP, fTrailing, icChars, icGlyphs, pwLogClust, psva, piAdvance, psa, &piX);
        winetest_ok(hr == S_OK, "ScriptCPtoX trailing: should return S_OK not %08x\n", hr);
        winetest_ok(piX == offsets[iCP+1],
           "ScriptCPtoX trailing: iCP=%d should return piX=%d not %d\n", iCP, offsets[iCP+1], piX);
    }
}

_test_items_ok()

static void _test_items_ok ( LPCWSTR  string, DWORD  cchString, SCRIPT_CONTROL *  Control, SCRIPT_STATE *  State, DWORD  nItems, const itemTest *  items, BOOL  nItemsToDo, const INT  nItemsBroken[2]  )

inlinestatic

Definition at line 70 of file usp10.c.

{
    HRESULT hr;
    int x, outnItems;
    SCRIPT_ITEM outpItems[15];
    ULONG tags[15] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};

    if (pScriptItemizeOpenType)
        hr = pScriptItemizeOpenType(string, cchString, 15, Control, State, outpItems, tags, &outnItems);
    else
        hr = ScriptItemize(string, cchString, 15, Control, State, outpItems, &outnItems);

    winetest_ok(hr == S_OK, "ScriptItemize should return S_OK not %08x\n", hr);
    if (nItemsBroken && (broken(nItemsBroken[0] == outnItems) || broken(nItemsBroken[1] == outnItems)))
    {
        winetest_win_skip("This test broken on this platform: nitems %d\n", outnItems);
        return;
    }
    todo_wine_if (nItemsToDo)
        winetest_ok(outnItems == nItems, "Wrong number of items (%u)\n", outnItems);
    outnItems = min(outnItems, nItems);
    for (x = 0; x <= outnItems; x++)
    {
        if (items[x].isBroken && broken(outpItems[x].iCharPos == items[x].broken_value[0]))
            winetest_win_skip("This test broken on this platform: item %d CharPos %d\n", x, outpItems[x].iCharPos);
        else todo_wine_if (items[x].todo_flag[0])
            winetest_ok(outpItems[x].iCharPos == items[x].iCharPos, "%i:Wrong CharPos (%i)\n",x,outpItems[x].iCharPos);

        if (items[x].isBroken && broken(outpItems[x].a.fRTL== items[x].broken_value[1]))
            winetest_win_skip("This test broken on this platform: item %d fRTL %d\n", x, outpItems[x].a.fRTL);
        else todo_wine_if (items[x].todo_flag[1])
            winetest_ok(outpItems[x].a.fRTL == items[x].fRTL, "%i:Wrong fRTL(%i)\n",x,outpItems[x].a.fRTL);

        if (items[x].isBroken && broken(outpItems[x].a.fLayoutRTL == items[x].broken_value[2]))
            winetest_win_skip("This test broken on this platform: item %d fLayoutRTL %d\n", x, outpItems[x].a.fLayoutRTL);
        else todo_wine_if (items[x].todo_flag[2])
            winetest_ok(outpItems[x].a.fLayoutRTL == items[x].fLayoutRTL, "%i:Wrong fLayoutRTL(%i)\n",x,outpItems[x].a.fLayoutRTL);

        if (items[x].isBroken && broken(outpItems[x].a.s.uBidiLevel == items[x].broken_value[3]))
            winetest_win_skip("This test broken on this platform: item %d BidiLevel %d\n", x, outpItems[x].a.s.uBidiLevel);
        else todo_wine_if (items[x].todo_flag[3])
            winetest_ok(outpItems[x].a.s.uBidiLevel == items[x].uBidiLevel, "%i:Wrong BidiLevel(%i)\n",x,outpItems[x].a.s.uBidiLevel);

        if (items[x].isBroken && broken(outpItems[x].a.s.fOverrideDirection == items[x].broken_value[4]))
            winetest_win_skip("This test broken on this platform: item %d fOverrideDirection %d\n", x, outpItems[x].a.s.fOverrideDirection);
        else todo_wine_if (items[x].todo_flag[4])
            winetest_ok(outpItems[x].a.s.fOverrideDirection == items[x].fOverrideDirection, "%i:Wrong fOverrideDirection(%i)\n",x,outpItems[x].a.s.fOverrideDirection);

        if (x != outnItems)
            winetest_ok(outpItems[x].a.eScript != SCRIPT_UNDEFINED, "%i: Undefined script\n",x);
        if (pScriptItemizeOpenType)
        {
            if (items[x].isBroken && broken(tags[x] == items[x].broken_value[5]))
                winetest_win_skip("This test broken on this platform: item %d Script Tag %x\n", x, tags[x]);
            else todo_wine_if (items[x].todo_flag[5])
                winetest_ok(tags[x] == items[x].scriptTag,"%i:Incorrect Script Tag %x != %x\n",x,tags[x],items[x].scriptTag);
        }

    }
}

_test_shape_ok()

static void _test_shape_ok ( int  valid, HDC  hdc, LPCWSTR  string, DWORD  cchString, SCRIPT_CONTROL *  Control, SCRIPT_STATE *  State, DWORD  item, DWORD  nGlyphs, const shapeTest_char *  charItems, const shapeTest_glyph *  glyphItems, const SCRIPT_GLYPHPROP *  props2  )

inlinestatic

Definition at line 966 of file usp10.c.

{
    HRESULT hr;
    int x, outnItems = 0, outnGlyphs = 0, outnGlyphs2 = 0;
    const SCRIPT_PROPERTIES **script_properties;
    SCRIPT_ITEM outpItems[15];
    SCRIPT_CACHE sc = NULL;
    WORD *glyphs, *glyphs2;
    WORD *logclust, *logclust2;
    int maxGlyphs = cchString * 1.5;
    SCRIPT_GLYPHPROP *glyphProp, *glyphProp2;
    SCRIPT_CHARPROP  *charProp, *charProp2;
    int script_count;
    WCHAR *string2;
    ULONG tags[15];

    hr = ScriptGetProperties(&script_properties, &script_count);
    winetest_ok(SUCCEEDED(hr), "Failed to get script properties, hr %#x.\n", hr);

    hr = pScriptItemizeOpenType(string, cchString, 15, Control, State, outpItems, tags, &outnItems);
    if (valid > 0)
        winetest_ok(hr == S_OK, "ScriptItemizeOpenType should return S_OK not %08x\n", hr);
    else if (hr != S_OK)
        winetest_trace("ScriptItemizeOpenType should return S_OK not %08x\n", hr);

    if (outnItems <= item)
    {
        if (valid > 0)
            winetest_win_skip("Did not get enough items\n");
        else
            winetest_trace("Did not get enough items\n");
        return;
    }

    logclust = HeapAlloc(GetProcessHeap(), 0, sizeof(WORD) * cchString);
    memset(logclust,'a',sizeof(WORD) * cchString);
    charProp = HeapAlloc(GetProcessHeap(), 0, sizeof(SCRIPT_CHARPROP) * cchString);
    memset(charProp,'a',sizeof(SCRIPT_CHARPROP) * cchString);
    glyphs = HeapAlloc(GetProcessHeap(), 0, sizeof(WORD) * maxGlyphs);
    memset(glyphs,'a',sizeof(WORD) * cchString);
    glyphProp = HeapAlloc(GetProcessHeap(), 0, sizeof(SCRIPT_GLYPHPROP) * maxGlyphs);
    memset(glyphProp,'a',sizeof(SCRIPT_GLYPHPROP) * cchString);

    string2 = HeapAlloc(GetProcessHeap(), 0, cchString * sizeof(*string2));
    logclust2 = HeapAlloc(GetProcessHeap(), 0, cchString * sizeof(*logclust2));
    memset(logclust2, 'a', cchString * sizeof(*logclust2));
    charProp2 = HeapAlloc(GetProcessHeap(), 0, cchString * sizeof(*charProp2));
    memset(charProp2, 'a', cchString * sizeof(*charProp2));
    glyphs2 = HeapAlloc(GetProcessHeap(), 0, maxGlyphs * sizeof(*glyphs2));
    memset(glyphs2, 'a', maxGlyphs * sizeof(*glyphs2));
    glyphProp2 = HeapAlloc(GetProcessHeap(), 0, maxGlyphs * sizeof(*glyphProp2));
    memset(glyphProp2, 'a', maxGlyphs * sizeof(*glyphProp2));

    winetest_ok(!outpItems[item].a.fLogicalOrder, "Got unexpected fLogicalOrder %#x.\n",
            outpItems[item].a.fLogicalOrder);
    hr = pScriptShapeOpenType(hdc, &sc, &outpItems[item].a, tags[item], 0x00000000, NULL, NULL, 0, string, cchString, maxGlyphs, logclust, charProp, glyphs, glyphProp, &outnGlyphs);
    if (valid > 0)
        winetest_ok(hr == S_OK, "ScriptShapeOpenType failed (%x)\n",hr);
    else if (hr != S_OK)
        winetest_trace("ScriptShapeOpenType failed (%x)\n",hr);
    if (FAILED(hr))
        goto cleanup;

    for (x = 0; x < cchString; x++)
    {
        if (valid > 0)
            winetest_ok(logclust[x] == charItems[x].wLogClust, "%i: invalid LogClust(%i)\n",x,logclust[x]);
        else if (logclust[x] != charItems[x].wLogClust)
            winetest_trace("%i: invalid LogClust(%i)\n",x,logclust[x]);
        if (valid > 0)
            winetest_ok(charProp[x].fCanGlyphAlone == charItems[x].CharProp.fCanGlyphAlone, "%i: invalid fCanGlyphAlone\n",x);
        else if (charProp[x].fCanGlyphAlone != charItems[x].CharProp.fCanGlyphAlone)
            winetest_trace("%i: invalid fCanGlyphAlone\n",x);
    }

    if (valid > 0)
        winetest_ok(nGlyphs == outnGlyphs, "got incorrect number of glyphs (%i)\n",outnGlyphs);
    else if (nGlyphs != outnGlyphs)
        winetest_trace("got incorrect number of glyphs (%i)\n",outnGlyphs);
    for (x = 0; x < outnGlyphs; x++)
    {
        if (glyphItems[x].Glyph)
        {
            if (valid > 0)
                winetest_ok(glyphs[x]!=0, "%i: Glyph not present when it should be\n",x);
            else if (glyphs[x]==0)
                winetest_trace("%i: Glyph not present when it should be\n",x);
        }
        else
        {
            if (valid > 0)
                winetest_ok(glyphs[x]==0, "%i: Glyph present when it should not be\n",x);
            else if (glyphs[x]!=0)
                winetest_trace("%i: Glyph present when it should not be\n",x);
        }
        if (valid > 0)
        {
            todo_wine_if(tags[item] == syrc_tag && !x)
                winetest_ok(glyphProp[x].sva.uJustification == glyphItems[x].GlyphProp.sva.uJustification ||
                            (props2 && glyphProp[x].sva.uJustification == props2[x].sva.uJustification),
                             "%i: uJustification incorrect (%i)\n",x,glyphProp[x].sva.uJustification);
        }
        else if (glyphProp[x].sva.uJustification != glyphItems[x].GlyphProp.sva.uJustification)
        {
            winetest_trace("%i: uJustification incorrect (%i)\n",x,glyphProp[x].sva.uJustification);
        }
        if (valid > 0)
            winetest_ok(glyphProp[x].sva.fClusterStart == glyphItems[x].GlyphProp.sva.fClusterStart ||
                        (props2 && glyphProp[x].sva.fClusterStart == props2[x].sva.fClusterStart),
                        "%i: fClusterStart incorrect (%i)\n",x,glyphProp[x].sva.fClusterStart);
        else if (glyphProp[x].sva.fClusterStart != glyphItems[x].GlyphProp.sva.fClusterStart)
            winetest_trace("%i: fClusterStart incorrect (%i)\n",x,glyphProp[x].sva.fClusterStart);
        if (valid > 0)
            winetest_ok(glyphProp[x].sva.fDiacritic == glyphItems[x].GlyphProp.sva.fDiacritic ||
                        (props2 && glyphProp[x].sva.fDiacritic == props2[x].sva.fDiacritic),
                        "%i: fDiacritic incorrect (%i)\n",x,glyphProp[x].sva.fDiacritic);
        else if (glyphProp[x].sva.fDiacritic != glyphItems[x].GlyphProp.sva.fDiacritic)
            winetest_trace("%i: fDiacritic incorrect (%i)\n",x,glyphProp[x].sva.fDiacritic);
        if (valid > 0)
            winetest_ok(glyphProp[x].sva.fZeroWidth == glyphItems[x].GlyphProp.sva.fZeroWidth ||
                        (props2 && glyphProp[x].sva.fZeroWidth == props2[x].sva.fZeroWidth),
                        "%i: fZeroWidth incorrect (%i)\n",x,glyphProp[x].sva.fZeroWidth);
        else if (glyphProp[x].sva.fZeroWidth != glyphItems[x].GlyphProp.sva.fZeroWidth)
            winetest_trace("%i: fZeroWidth incorrect (%i)\n",x,glyphProp[x].sva.fZeroWidth);
    }

    outpItems[item].a.fLogicalOrder = 1;
    hr = pScriptShapeOpenType(hdc, &sc, &outpItems[item].a, tags[item], 0x00000000, NULL, NULL, 0,
            string, cchString, maxGlyphs, logclust2, charProp2, glyphs2, glyphProp2, &outnGlyphs2);
    winetest_ok(hr == S_OK, "ScriptShapeOpenType failed (%x)\n",hr);
    /* Cluster maps are hard. */
    if (tags[item] != thaa_tag && tags[item] != syrc_tag)
    {
        for (x = 0; x < cchString; ++x)
        {
            unsigned int compare_idx = outpItems[item].a.fRTL ? cchString - x - 1 : x;
            winetest_ok(logclust2[x] == logclust[compare_idx],
                    "Got unexpected logclust2[%u] %#x, expected %#x.\n",
                    x, logclust2[x], logclust[compare_idx]);
            winetest_ok(charProp2[x].fCanGlyphAlone == charProp[compare_idx].fCanGlyphAlone,
                    "Got unexpected charProp2[%u].fCanGlyphAlone %#x, expected %#x.\n",
                    x, charProp2[x].fCanGlyphAlone, charProp[compare_idx].fCanGlyphAlone);
        }
    }
    winetest_ok(outnGlyphs2 == outnGlyphs, "Got unexpected glyph count %u.\n", outnGlyphs2);
    for (x = 0; x < outnGlyphs2; ++x)
    {
        unsigned int compare_idx = outpItems[item].a.fRTL ? outnGlyphs2 - x - 1 : x;
        winetest_ok(glyphs2[x] == glyphs[compare_idx], "Got unexpected glyphs2[%u] %#x, expected %#x.\n",
                x, glyphs2[x], glyphs[compare_idx]);
        winetest_ok(glyphProp2[x].sva.uJustification == glyphProp[compare_idx].sva.uJustification,
                "Got unexpected glyphProp2[%u].sva.uJustification %#x, expected %#x.\n",
                x, glyphProp2[x].sva.uJustification, glyphProp[compare_idx].sva.uJustification);
        winetest_ok(glyphProp2[x].sva.fClusterStart == glyphProp[compare_idx].sva.fClusterStart,
                "Got unexpected glyphProp2[%u].sva.fClusterStart %#x, expected %#x.\n",
                x, glyphProp2[x].sva.fClusterStart, glyphProp[compare_idx].sva.fClusterStart);
        winetest_ok(glyphProp2[x].sva.fDiacritic == glyphProp[compare_idx].sva.fDiacritic,
                "Got unexpected glyphProp2[%u].sva.fDiacritic %#x, expected %#x.\n",
                x, glyphProp2[x].sva.fDiacritic, glyphProp[compare_idx].sva.fDiacritic);
        winetest_ok(glyphProp2[x].sva.fZeroWidth == glyphProp[compare_idx].sva.fZeroWidth,
                "Got unexpected glyphProp2[%u].sva.fZeroWidth %#x, expected %#x.\n",
                x, glyphProp2[x].sva.fZeroWidth, glyphProp[compare_idx].sva.fZeroWidth);
    }

    /* Most scripts get this wrong. For example, when the font has the
     * appropriate ligatures, "ttfffi" get rendered as "<ttf><ffi>", but
     * "<RLO>iffftt" gets rendered as "t<ft><ff>i". Arabic gets it right,
     * and there exist applications that depend on that. */
    if (tags[item] == arab_tag && broken(script_count <= 75))
    {
        winetest_win_skip("Test broken on this platform, skipping.\n");
    }
    else if (tags[item] == arab_tag)
    {
        for (x = 0; x < cchString; ++x)
        {
            string2[x] = string[cchString - x - 1];
        }
        outpItems[item].a.fLogicalOrder = 0;
        outpItems[item].a.fRTL = !outpItems[item].a.fRTL;
        hr = pScriptShapeOpenType(hdc, &sc, &outpItems[item].a, tags[item], 0x00000000, NULL, NULL, 0,
                string2, cchString, maxGlyphs, logclust2, charProp2, glyphs2, glyphProp2, &outnGlyphs2);
        winetest_ok(hr == S_OK, "ScriptShapeOpenType failed (%x)\n",hr);
        for (x = 0; x < cchString; ++x)
        {
            unsigned int compare_idx = cchString - x - 1;
            winetest_ok(logclust2[x] == logclust[compare_idx],
                    "Got unexpected logclust2[%u] %#x, expected %#x.\n",
                    x, logclust2[x], logclust[compare_idx]);
            winetest_ok(charProp2[x].fCanGlyphAlone == charProp[compare_idx].fCanGlyphAlone,
                    "Got unexpected charProp2[%u].fCanGlyphAlone %#x, expected %#x.\n",
                    x, charProp2[x].fCanGlyphAlone, charProp[compare_idx].fCanGlyphAlone);
        }
        winetest_ok(outnGlyphs2 == outnGlyphs, "Got unexpected glyph count %u.\n", outnGlyphs2);
        for (x = 0; x < outnGlyphs2; ++x)
        {
            winetest_ok(glyphs2[x] == glyphs[x], "Got unexpected glyphs2[%u] %#x, expected %#x.\n",
                    x, glyphs2[x], glyphs[x]);
            winetest_ok(glyphProp2[x].sva.uJustification == glyphProp[x].sva.uJustification,
                    "Got unexpected glyphProp2[%u].sva.uJustification %#x, expected %#x.\n",
                    x, glyphProp2[x].sva.uJustification, glyphProp[x].sva.uJustification);
            winetest_ok(glyphProp2[x].sva.fClusterStart == glyphProp[x].sva.fClusterStart,
                    "Got unexpected glyphProp2[%u].sva.fClusterStart %#x, expected %#x.\n",
                    x, glyphProp2[x].sva.fClusterStart, glyphProp[x].sva.fClusterStart);
            winetest_ok(glyphProp2[x].sva.fDiacritic == glyphProp[x].sva.fDiacritic,
                    "Got unexpected glyphProp2[%u].sva.fDiacritic %#x, expected %#x.\n",
                    x, glyphProp2[x].sva.fDiacritic, glyphProp[x].sva.fDiacritic);
            winetest_ok(glyphProp2[x].sva.fZeroWidth == glyphProp[x].sva.fZeroWidth,
                    "Got unexpected glyphProp2[%u].sva.fZeroWidth %#x, expected %#x.\n",
                    x, glyphProp2[x].sva.fZeroWidth, glyphProp[x].sva.fZeroWidth);
        }
        outpItems[item].a.fLogicalOrder = 1;
        hr = pScriptShapeOpenType(hdc, &sc, &outpItems[item].a, tags[item], 0x00000000, NULL, NULL, 0,
                string2, cchString, maxGlyphs, logclust2, charProp2, glyphs2, glyphProp2, &outnGlyphs2);
        winetest_ok(hr == S_OK, "ScriptShapeOpenType failed (%x)\n",hr);
        for (x = 0; x < cchString; ++x)
        {
            unsigned int compare_idx = outpItems[item].a.fRTL ? x : cchString - x - 1;
            winetest_ok(logclust2[x] == logclust[compare_idx], "Got unexpected logclust2[%u] %#x, expected %#x.\n",
                    x, logclust2[x], logclust[compare_idx]);
            winetest_ok(charProp2[x].fCanGlyphAlone == charProp[compare_idx].fCanGlyphAlone,
                    "Got unexpected charProp2[%u].fCanGlyphAlone %#x, expected %#x.\n",
                    x, charProp2[x].fCanGlyphAlone, charProp[compare_idx].fCanGlyphAlone);
        }
        winetest_ok(outnGlyphs2 == outnGlyphs, "Got unexpected glyph count %u.\n", outnGlyphs2);
        for (x = 0; x < outnGlyphs2; ++x)
        {
            unsigned int compare_idx = outpItems[item].a.fRTL ? outnGlyphs2 - x - 1 : x;
            winetest_ok(glyphs2[x] == glyphs[compare_idx], "Got unexpected glyphs2[%u] %#x, expected %#x.\n",
                    x, glyphs2[x], glyphs[compare_idx]);
            winetest_ok(glyphProp2[x].sva.uJustification == glyphProp[compare_idx].sva.uJustification,
                    "Got unexpected glyphProp2[%u].sva.uJustification %#x, expected %#x.\n",
                    x, glyphProp2[x].sva.uJustification, glyphProp[compare_idx].sva.uJustification);
            winetest_ok(glyphProp2[x].sva.fClusterStart == glyphProp[compare_idx].sva.fClusterStart,
                    "Got unexpected glyphProp2[%u].sva.fClusterStart %#x, expected %#x.\n",
                    x, glyphProp2[x].sva.fClusterStart, glyphProp[compare_idx].sva.fClusterStart);
            winetest_ok(glyphProp2[x].sva.fDiacritic == glyphProp[compare_idx].sva.fDiacritic,
                    "Got unexpected glyphProp2[%u].sva.fDiacritic %#x, expected %#x.\n",
                    x, glyphProp2[x].sva.fDiacritic, glyphProp[compare_idx].sva.fDiacritic);
            winetest_ok(glyphProp2[x].sva.fZeroWidth == glyphProp[compare_idx].sva.fZeroWidth,
                    "Got unexpected glyphProp2[%u].sva.fZeroWidth %#x, expected %#x.\n",
                    x, glyphProp2[x].sva.fZeroWidth, glyphProp[compare_idx].sva.fZeroWidth);
        }
    }

cleanup:
    HeapFree(GetProcessHeap(),0,string2);
    HeapFree(GetProcessHeap(),0,logclust2);
    HeapFree(GetProcessHeap(),0,charProp2);
    HeapFree(GetProcessHeap(),0,glyphs2);
    HeapFree(GetProcessHeap(),0,glyphProp2);

    HeapFree(GetProcessHeap(),0,logclust);
    HeapFree(GetProcessHeap(),0,charProp);
    HeapFree(GetProcessHeap(),0,glyphs);
    HeapFree(GetProcessHeap(),0,glyphProp);
    ScriptFreeCache(&sc);
}

create_test_window()

static HWND create_test_window ( void  )

static

Definition at line 3383 of file usp10.c.

{
    HWND hwnd = CreateWindowExA(0, "Static", "", WS_POPUP, 0, 0, 100, 100, 0, 0, 0, NULL);
    ok(hwnd != NULL, "Failed to create test window.\n");

    ShowWindow(hwnd, SW_SHOW);
    UpdateWindow(hwnd);

    return hwnd;
}

Referenced by test_script_cache_reuse(), and test_ScriptCacheGetHeight().

enum_bitmap_font_proc()

static INT CALLBACK enum_bitmap_font_proc ( const LOGFONTA *  lf, const TEXTMETRICA *  ntm, DWORD  type, LPARAM  lParam  )

static

Definition at line 2475 of file usp10.c.

{
    struct enum_font_data *efnd = (struct enum_font_data *)lParam;

    if (type & (TRUETYPE_FONTTYPE | DEVICE_FONTTYPE)) return 1;

    if (efnd->total < MAX_ENUM_FONTS)
    {
        efnd->elf[efnd->total++] = *(ENUMLOGFONTA*)lf;
    }
    else
        trace("enum tests invalid; you have more than %d fonts\n", MAX_ENUM_FONTS);

    return 1;
}

Referenced by test_ScriptGetFontProperties().

enum_proc()

static BOOL CALLBACK enum_proc ( LGRPID  group, LCID  lcid, LPSTR  locale, LONG_PTR  lparam  )

static

Definition at line 3640 of file usp10.c.

{
    HRESULT hr;
    SCRIPT_DIGITSUBSTITUTE sds;
    SCRIPT_CONTROL sc;
    SCRIPT_STATE ss;
    LCID lcid_old;

    if (!IsValidLocale(lcid, LCID_INSTALLED)) return TRUE;

    memset(&sds, 0, sizeof(sds));
    memset(&sc, 0, sizeof(sc));
    memset(&ss, 0, sizeof(ss));

    lcid_old = GetThreadLocale();
    if (!SetThreadLocale(lcid)) return TRUE;

    hr = ScriptRecordDigitSubstitution(lcid, &sds);
    ok(hr == S_OK, "ScriptRecordDigitSubstitution failed: 0x%08x\n", hr);

    hr = ScriptApplyDigitSubstitution(&sds, &sc, &ss);
    ok(hr == S_OK, "ScriptApplyDigitSubstitution failed: 0x%08x\n", hr);

    SetThreadLocale(lcid_old);
    return TRUE;
}

Referenced by test_digit_substitution().

enum_truetype_proc()

static INT CALLBACK enum_truetype_proc ( const LOGFONTA *  lf, const TEXTMETRICA *  ntm, DWORD  type, LPARAM  lParam  )

static

Definition at line 2491 of file usp10.c.

{
    struct enum_font_data *efnd = (struct enum_font_data *)lParam;

    if (!(type & (TRUETYPE_FONTTYPE | DEVICE_FONTTYPE))) return 1;

    if (efnd->total < MAX_ENUM_FONTS)
    {
        efnd->elf[efnd->total++] = *(ENUMLOGFONTA*)lf;
    }
    else
        trace("enum tests invalid; you have more than %d fonts\n", MAX_ENUM_FONTS);

    return 1;
}

Referenced by test_ScriptGetFontProperties().

enumFontProc()

static int CALLBACK enumFontProc ( const LOGFONTA *  lpelfe, const TEXTMETRICA *  lpntme, DWORD  FontType, LPARAM  lParam  )

static

Definition at line 1244 of file usp10.c.

{
    NEWTEXTMETRICEXA *ntme = (NEWTEXTMETRICEXA*)lpntme;
    fontEnumParam *rp = (fontEnumParam*) lParam;
    int idx = 0;
    DWORD i;
    DWORD mask = 0;

    if (FontType != TRUETYPE_FONTTYPE)
        return 1;

    i = rp->range;
    while (i >= sizeof(DWORD)*8)
    {
        idx++;
        i -= (sizeof(DWORD)*8);
    }
    if (idx > 3)
        return 0;

    mask = 1 << i;

    if (ntme->ntmFontSig.fsUsb[idx] & mask)
    {
        memcpy(&(rp->lf),lpelfe,sizeof(LOGFONTA));
        return 0;
    }
    return 1;
}

Referenced by _find_font_for_range().

HRESULT()

static HRESULT ( WINAPI *  pScriptItemizeOpenType ) const

static

init_tests()

static void init_tests ( void  )

static

Definition at line 4177 of file usp10.c.

{
    HMODULE module = GetModuleHandleA("usp10.dll");

    ok(module != 0, "Expected usp10.dll to be loaded.\n");

    pScriptItemizeOpenType = (void *)GetProcAddress(module, "ScriptItemizeOpenType");
    pScriptShapeOpenType = (void *)GetProcAddress(module, "ScriptShapeOpenType");
    pScriptGetFontScriptTags = (void *)GetProcAddress(module, "ScriptGetFontScriptTags");
    pScriptGetFontLanguageTags = (void *)GetProcAddress(module, "ScriptGetFontLanguageTags");
    pScriptGetFontFeatureTags = (void *)GetProcAddress(module, "ScriptGetFontFeatureTags");
}

Referenced by START_TEST().

make_surrogate()

static void make_surrogate ( DWORD  i, WORD  out[2]  )

static

Definition at line 925 of file usp10.c.

{
    static const DWORD mask = (1 << 10) - 1;

    if (i <= 0xffff)
    {
        out[0] = i;
        out[1] = 0;
    }
    else
    {
        i -= 0x010000;
        out[0] = ((i >> 10) & mask) + 0xd800;
        out[1] = (i & mask) + 0xdc00;
    }
}

Referenced by test_ScriptItemize_surrogates().

START_TEST()

START_TEST

(

usp10

)

Definition at line 4190 of file usp10.c.

{
    HWND            hwnd;
    HDC             hdc;
    LOGFONTA        lf;
    HFONT           hfont;

    unsigned short  pwOutGlyphs[256];

    /* We need a valid HDC to drive a lot of Script functions which requires the following    *
     * to set up for the tests.                                                               */
    hwnd = CreateWindowExA(0, "static", "", WS_POPUP, 0,0,100,100,
                           0, 0, 0, NULL);
    assert(hwnd != 0);
    ShowWindow(hwnd, SW_SHOW);
    UpdateWindow(hwnd);

    hdc = GetDC(hwnd);                                      /* We now have a hdc             */
    ok( hdc != NULL, "HDC failed to be created %p\n", hdc);

    memset(&lf, 0, sizeof(LOGFONTA));
    lstrcpyA(lf.lfFaceName, "Tahoma");
    lf.lfHeight = 10;
    lf.lfWeight = 3;
    lf.lfWidth = 10;

    hfont = SelectObject(hdc, CreateFontIndirectA(&lf));
    ok(hfont != NULL, "SelectObject failed: %p\n", hfont);

    init_tests();

    test_ScriptItemize();
    test_ScriptItemize_surrogates();
    test_ScriptItemIzeShapePlace(hdc,pwOutGlyphs);
    test_ScriptGetCMap(hdc, pwOutGlyphs);
    test_ScriptCacheGetHeight(hdc);
    test_ScriptGetGlyphABCWidth(hdc);
    test_ScriptShape(hdc);
    test_ScriptShapeOpenType(hdc);
    test_ScriptPlace(hdc);

    test_ScriptGetFontProperties(hdc);
    test_ScriptTextOut(hdc);
    test_ScriptTextOut2(hdc);
    test_ScriptTextOut3(hdc);
    test_ScriptXtoX();
    test_ScriptString(hdc);
    test_ScriptStringXtoCP_CPtoX(hdc);
    test_ScriptString_pSize(hdc);

    test_ScriptLayout();
    test_digit_substitution();
    test_ScriptGetProperties();
    test_ScriptBreak();
    test_newlines();

    test_ScriptGetFontFunctions(hdc);
    test_ScriptGetLogicalWidths();

    test_ScriptIsComplex();
    test_script_cache_reuse();

    ReleaseDC(hwnd, hdc);
    DestroyWindow(hwnd);
}

test_digit_substitution()

static void test_digit_substitution ( void  )

static

Definition at line 3667 of file usp10.c.

{
    BOOL ret;
    unsigned int i;
    static const LGRPID groups[] =
    {
        LGRPID_WESTERN_EUROPE,
        LGRPID_CENTRAL_EUROPE,
        LGRPID_BALTIC,
        LGRPID_GREEK,
        LGRPID_CYRILLIC,
        LGRPID_TURKISH,
        LGRPID_JAPANESE,
        LGRPID_KOREAN,
        LGRPID_TRADITIONAL_CHINESE,
        LGRPID_SIMPLIFIED_CHINESE,
        LGRPID_THAI,
        LGRPID_HEBREW,
        LGRPID_ARABIC,
        LGRPID_VIETNAMESE,
        LGRPID_INDIC,
        LGRPID_GEORGIAN,
        LGRPID_ARMENIAN
    };

    for (i = 0; i < ARRAY_SIZE(groups); ++i)
    {
        ret = EnumLanguageGroupLocalesA(enum_proc, groups[i], 0, 0);
        ok(ret, "EnumLanguageGroupLocalesA failed unexpectedly: %u\n", GetLastError());
    }
}

Referenced by START_TEST().

test_newlines()

static void test_newlines ( void  )

static

Definition at line 3775 of file usp10.c.

{
    static const WCHAR test1[] = {'t','e','x','t','\r','t','e','x','t',0};
    static const WCHAR test2[] = {'t','e','x','t','\n','t','e','x','t',0};
    static const WCHAR test3[] = {'t','e','x','t','\r','\n','t','e','x','t',0};
    static const WCHAR test4[] = {'t','e','x','t','\n','\r','t','e','x','t',0};
    static const WCHAR test5[] = {'1','2','3','4','\n','\r','1','2','3','4',0};
    SCRIPT_ITEM items[5];
    HRESULT hr;
    int count;

    count = 0;
    hr = ScriptItemize(test1, lstrlenW(test1), 5, NULL, NULL, items, &count);
    ok(hr == S_OK, "ScriptItemize failed: 0x%08x\n", hr);
    ok(count == 3, "got %d expected 3\n", count);

    count = 0;
    hr = ScriptItemize(test2, lstrlenW(test2), 5, NULL, NULL, items, &count);
    ok(hr == S_OK, "ScriptItemize failed: 0x%08x\n", hr);
    ok(count == 3, "got %d expected 3\n", count);

    count = 0;
    hr = ScriptItemize(test3, lstrlenW(test3), 5, NULL, NULL, items, &count);
    ok(hr == S_OK, "ScriptItemize failed: 0x%08x\n", hr);
    ok(count == 4, "got %d expected 4\n", count);

    count = 0;
    hr = ScriptItemize(test4, lstrlenW(test4), 5, NULL, NULL, items, &count);
    ok(hr == S_OK, "ScriptItemize failed: 0x%08x\n", hr);
    ok(count == 4, "got %d expected 4\n", count);

    count = 0;
    hr = ScriptItemize(test5, lstrlenW(test5), 5, NULL, NULL, items, &count);
    ok(hr == S_OK, "ScriptItemize failed: 0x%08x\n", hr);
    ok(count == 4, "got %d expected 4\n", count);
}

Referenced by START_TEST().

test_script_cache_reuse()

static void test_script_cache_reuse ( void  )

static

Definition at line 4071 of file usp10.c.

{
    HRESULT hr;
    HWND hwnd1, hwnd2;
    HDC hdc1, hdc2;
    LOGFONTA lf;
    HFONT hfont1, hfont2;
    HFONT prev_hfont1, prev_hfont2;
    SCRIPT_CACHE sc = NULL;
    SCRIPT_CACHE sc2;
    LONG height;

    hwnd1 = create_test_window();
    hwnd2 = create_test_window();

    hdc1 = GetDC(hwnd1);
    hdc2 = GetDC(hwnd2);
    ok(hdc1 != NULL && hdc2 != NULL, "Failed to get window dc.\n");

    memset(&lf, 0, sizeof(LOGFONTA));
    lstrcpyA(lf.lfFaceName, "Tahoma");

    lf.lfHeight = 10;
    hfont1 = CreateFontIndirectA(&lf);
    ok(hfont1 != NULL, "CreateFontIndirectA failed\n");
    hfont2 = CreateFontIndirectA(&lf);
    ok(hfont2 != NULL, "CreateFontIndirectA failed\n");
    ok(hfont1 != hfont2, "Expected fonts %p and %p to differ\n", hfont1, hfont2);

    prev_hfont1 = SelectObject(hdc1, hfont1);
    ok(prev_hfont1 != NULL, "SelectObject failed: %p\n", prev_hfont1);
    prev_hfont2 = SelectObject(hdc2, hfont1);
    ok(prev_hfont2 != NULL, "SelectObject failed: %p\n", prev_hfont2);

    /* Get a script cache */
    hr = ScriptCacheGetHeight(hdc1, &sc, &height);
    ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
    ok(sc != NULL, "Script cache is NULL\n");

    /* Same font, same DC -> same SCRIPT_CACHE */
    sc2 = NULL;
    hr = ScriptCacheGetHeight(hdc1, &sc2, &height);
    ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
    ok(sc2 != NULL, "Script cache is NULL\n");
    ok(sc == sc2, "Expected caches %p, %p to be identical\n", sc, sc2);
    ScriptFreeCache(&sc2);

    /* Same font in different DC -> same SCRIPT_CACHE */
    sc2 = NULL;
    hr = ScriptCacheGetHeight(hdc2, &sc2, &height);
    ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
    ok(sc2 != NULL, "Script cache is NULL\n");
    ok(sc == sc2, "Expected caches %p, %p to be identical\n", sc, sc2);
    ScriptFreeCache(&sc2);

    /* Same font face & size, but different font handle */
    ok(SelectObject(hdc1, hfont2) != NULL, "SelectObject failed\n");
    ok(SelectObject(hdc2, hfont2) != NULL, "SelectObject failed\n");

    sc2 = NULL;
    hr = ScriptCacheGetHeight(hdc1, &sc2, &height);
    ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
    ok(sc2 != NULL, "Script cache is NULL\n");
    ok(sc == sc2, "Expected caches %p, %p to be identical\n", sc, sc2);
    ScriptFreeCache(&sc2);

    sc2 = NULL;
    hr = ScriptCacheGetHeight(hdc2, &sc2, &height);
    ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
    ok(sc2 != NULL, "Script cache is NULL\n");
    ok(sc == sc2, "Expected caches %p, %p to be identical\n", sc, sc2);
    ScriptFreeCache(&sc2);

    /* Different font size -- now we get a different SCRIPT_CACHE */
    SelectObject(hdc1, prev_hfont1);
    SelectObject(hdc2, prev_hfont2);
    DeleteObject(hfont2);
    lf.lfHeight = 20;
    hfont2 = CreateFontIndirectA(&lf);
    ok(hfont2 != NULL, "CreateFontIndirectA failed\n");
    ok(SelectObject(hdc1, hfont2) != NULL, "SelectObject failed\n");
    ok(SelectObject(hdc2, hfont2) != NULL, "SelectObject failed\n");

    sc2 = NULL;
    hr = ScriptCacheGetHeight(hdc1, &sc2, &height);
    ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
    ok(sc2 != NULL, "Script cache is NULL\n");
    ok(sc != sc2, "Expected caches %p, %p to be different\n", sc, sc2);
    ScriptFreeCache(&sc2);

    sc2 = NULL;
    hr = ScriptCacheGetHeight(hdc2, &sc2, &height);
    ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
    ok(sc2 != NULL, "Script cache is NULL\n");
    ok(sc != sc2, "Expected caches %p, %p to be different\n", sc, sc2);
    ScriptFreeCache(&sc2);

    ScriptFreeCache(&sc);
    SelectObject(hdc1, prev_hfont1);
    SelectObject(hdc2, prev_hfont2);
    DeleteObject(hfont1);
    DeleteObject(hfont2);
    DestroyWindow(hwnd1);
    DestroyWindow(hwnd2);
}

Referenced by START_TEST().

test_ScriptBreak()

static void test_ScriptBreak ( void  )

static

Definition at line 3718 of file usp10.c.

{
    static const WCHAR test[] = {' ','\r','\n',0};
    SCRIPT_ITEM items[4];
    SCRIPT_LOGATTR la;
    HRESULT hr;

    hr = ScriptItemize(test, 3, 4, NULL, NULL, items, NULL);
    ok(hr == S_OK, "ScriptItemize should return S_OK not %08x\n", hr);

    /*
     * This Test crashes pre Vista.

    hr = ScriptBreak(test, 1, &items[0].a, NULL);
    ok(hr == E_INVALIDARG, "ScriptBreak should return E_INVALIDARG not %08x\n", hr);
    */

    hr = ScriptBreak(test, 0, &items[0].a, &la);
    ok(hr == E_FAIL || broken(hr == S_OK), "ScriptBreak should return E_FAIL not %08x\n", hr);

    hr = ScriptBreak(test, -1, &items[0].a, &la);
    ok(hr == E_INVALIDARG || broken(hr == S_OK), "ScriptBreak should return E_INVALIDARG not %08x\n", hr);

    memset(&la, 0, sizeof(la));
    hr = ScriptBreak(test, 1, &items[0].a, &la);
    ok(hr == S_OK, "ScriptBreak should return S_OK not %08x\n", hr);

    ok(!la.fSoftBreak, "fSoftBreak set\n");
    ok(la.fWhiteSpace, "fWhiteSpace not set\n");
    ok(la.fCharStop, "fCharStop not set\n");
    ok(!la.fWordStop, "fWordStop set\n");
    ok(!la.fInvalid, "fInvalid set\n");
    ok(!la.fReserved, "fReserved set\n");

    memset(&la, 0, sizeof(la));
    hr = ScriptBreak(test + 1, 1, &items[1].a, &la);
    ok(hr == S_OK, "ScriptBreak should return S_OK not %08x\n", hr);

    ok(!la.fSoftBreak, "fSoftBreak set\n");
    ok(!la.fWhiteSpace, "fWhiteSpace set\n");
    ok(la.fCharStop, "fCharStop not set\n");
    ok(!la.fWordStop, "fWordStop set\n");
    ok(!la.fInvalid, "fInvalid set\n");
    ok(!la.fReserved, "fReserved set\n");

    memset(&la, 0, sizeof(la));
    hr = ScriptBreak(test + 2, 1, &items[2].a, &la);
    ok(hr == S_OK, "ScriptBreak should return S_OK not %08x\n", hr);

    ok(!la.fSoftBreak, "fSoftBreak set\n");
    ok(!la.fWhiteSpace, "fWhiteSpace set\n");
    ok(la.fCharStop, "fCharStop not set\n");
    ok(!la.fWordStop, "fWordStop set\n");
    ok(!la.fInvalid, "fInvalid set\n");
    ok(!la.fReserved, "fReserved set\n");
}

Referenced by START_TEST().

test_ScriptCacheGetHeight()

static void test_ScriptCacheGetHeight ( HDC  hdc )

static

Definition at line 3394 of file usp10.c.

{
    HFONT hfont, prev_hfont;
    SCRIPT_CACHE sc = NULL;
    LONG height, height2;
    TEXTMETRICW tm;
    LOGFONTA lf;
    HRESULT hr;
    HWND hwnd;
    HDC hdc2;

    hr = ScriptCacheGetHeight(NULL, NULL, NULL);
    ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got 0x%08x\n", hr);

    hr = ScriptCacheGetHeight(NULL, &sc, NULL);
    ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got 0x%08x\n", hr);

    hr = ScriptCacheGetHeight(NULL, &sc, &height);
    ok(hr == E_PENDING, "expected E_PENDING, got 0x%08x\n", hr);

    height = 123;
    hr = ScriptCacheGetHeight(hdc, NULL, &height);
    ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
    ok(height == 123, "Unexpected height.\n");

    memset(&tm, 0, sizeof(tm));
    GetTextMetricsW(hdc, &tm);
    ok(tm.tmHeight > 0, "Unexpected tmHeight %u.\n", tm.tmHeight);

    height = 0;
    hr = ScriptCacheGetHeight(hdc, &sc, &height);
    ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
    ok(height == tm.tmHeight, "expected height > 0\n");

    /* Try again with NULL dc. */
    height2 = 0;
    hr = ScriptCacheGetHeight(NULL, &sc, &height2);
    ok(hr == S_OK, "Failed to get cached height, hr %#x.\n", hr);
    ok(height2 == height, "Unexpected height %u.\n", height2);

    hwnd = create_test_window();

    hdc2 = GetDC(hwnd);
    ok(hdc2 != NULL, "Failed to get window dc.\n");

    memset(&lf, 0, sizeof(LOGFONTA));
    lstrcpyA(lf.lfFaceName, "Tahoma");
    lf.lfHeight = -32;

    hfont = CreateFontIndirectA(&lf);
    ok(hfont != NULL, "Failed to create font.\n");

    prev_hfont = SelectObject(hdc2, hfont);

    memset(&tm, 0, sizeof(tm));
    GetTextMetricsW(hdc2, &tm);
    ok(tm.tmHeight > height, "Unexpected tmHeight %u.\n", tm.tmHeight);

    height2 = 0;
    hr = ScriptCacheGetHeight(hdc2, &sc, &height2);
    ok(hr == S_OK, "Failed to get cached height, hr %#x.\n", hr);
    ok(height2 == height, "Unexpected height.\n");

    SelectObject(hdc2, prev_hfont);
    DeleteObject(hfont);

    ReleaseDC(hwnd, hdc2);
    DestroyWindow(hwnd);

    ScriptFreeCache(&sc);
}

Referenced by START_TEST().

test_ScriptGetCMap()

static void test_ScriptGetCMap ( HDC  hdc, unsigned short  pwOutGlyphs[256]  )

static

Definition at line 2369 of file usp10.c.

{
    HRESULT         hr;
    SCRIPT_CACHE    psc = NULL;
    int             cInChars;
    int             cChars;
    unsigned short  pwOutGlyphs2[256];
    unsigned short  pwOutGlyphs3[256];
    DWORD           dwFlags;
    int             cnt;

    static const WCHAR TestItem1[] = {'T', 'e', 's', 't', 'a', 0};
    static const WCHAR TestItem2[] = {0x202B, 'i', 'n', 0x202C,0};
    static const WCHAR TestItem3[] = {'a','b','c','d','(','<','{','[',0x2039,0};
    static const WCHAR TestItem3b[] = {'a','b','c','d',')','>','}',']',0x203A,0};

    /*  Check to make sure that SCRIPT_CACHE gets allocated ok                     */
    dwFlags = 0;
    cInChars = cChars = 5;
    /* Some sanity checks for ScriptGetCMap */

    hr = ScriptGetCMap(NULL, NULL, NULL, 0, 0, NULL);
    ok( hr == E_INVALIDARG, "(NULL,NULL,NULL,0,0,NULL), "
                            "expected E_INVALIDARG, got %08x\n", hr);

    hr = ScriptGetCMap(NULL, NULL, TestItem1, cInChars, dwFlags, pwOutGlyphs3);
    ok( hr == E_INVALIDARG, "(NULL,NULL,TestItem1, cInChars, dwFlags, pwOutGlyphs3), "
                            "expected E_INVALIDARG, got %08x\n", hr);

    /* Set psc to NULL, to be able to check if a pointer is returned in psc */
    psc = NULL;
    hr = ScriptGetCMap(NULL, &psc, TestItem1, cInChars, 0, pwOutGlyphs3);
    ok( hr == E_PENDING, "(NULL,&psc,NULL,0,0,NULL), expected E_PENDING, "
                         "got %08x\n", hr);
    ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);

    /* Set psc to NULL but add hdc, to be able to check if a pointer is returned in psc */
    psc = NULL;
    hr = ScriptGetCMap(hdc, &psc, TestItem1, cInChars, 0, pwOutGlyphs3);
    ok( hr == S_OK, "ScriptGetCMap(NULL,&psc,NULL,0,0,NULL), expected S_OK, "
                    "got %08x\n", hr);
    ok( psc != NULL, "ScriptGetCMap expected psc to be not NULL\n");
    ScriptFreeCache( &psc);

    /* Set psc to NULL, to be able to check if a pointer is returned in psc */
    psc = NULL;
    hr = ScriptGetCMap(NULL, &psc, TestItem1, cInChars, dwFlags, pwOutGlyphs3);
    ok( hr == E_PENDING, "(NULL,&psc,), expected E_PENDING, got %08x\n", hr);
    ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
    /*  Check to see if the results are the same as those returned by ScriptShape  */
    hr = ScriptGetCMap(hdc, &psc, TestItem1, cInChars, dwFlags, pwOutGlyphs3);
    ok (hr == S_OK, "ScriptGetCMap should return S_OK not (%08x)\n", hr);
    ok (psc != NULL, "psc should not be null and have SCRIPT_CACHE buffer address\n");
    for (cnt=0; cnt < cChars && pwOutGlyphs[cnt] == pwOutGlyphs3[cnt]; cnt++) {}
    ok (cnt == cInChars, "Translation not correct. WCHAR %d - %04x != %04x\n",
                         cnt, pwOutGlyphs[cnt], pwOutGlyphs3[cnt]);

    ScriptFreeCache( &psc);
    ok (!psc, "psc is not null after ScriptFreeCache\n");

    /* ScriptGetCMap returns whatever font defines, no special treatment for control chars */
    cInChars = cChars = 4;
    GetGlyphIndicesW(hdc, TestItem2, cInChars, pwOutGlyphs2, 0);

    hr = ScriptGetCMap(hdc, &psc, TestItem2, cInChars, dwFlags, pwOutGlyphs3);
    if (pwOutGlyphs3[0] == 0 || pwOutGlyphs3[3] == 0)
        ok(hr == S_FALSE, "ScriptGetCMap should return S_FALSE not (%08x)\n", hr);
    else
        ok(hr == S_OK, "ScriptGetCMap should return S_OK not (%08x)\n", hr);

    ok(psc != NULL, "psc should not be null and have SCRIPT_CACHE buffer address\n");
    ok(pwOutGlyphs3[0] == pwOutGlyphs2[0], "expected glyph %d, got %d\n", pwOutGlyphs2[0], pwOutGlyphs3[0]);
    ok(pwOutGlyphs3[3] == pwOutGlyphs2[3], "expected glyph %d, got %d\n", pwOutGlyphs2[3], pwOutGlyphs3[3]);

    cInChars = cChars = 9;
    hr = ScriptGetCMap(hdc, &psc, TestItem3b, cInChars, dwFlags, pwOutGlyphs2);
    ok (hr == S_OK, "ScriptGetCMap should return S_OK not (%08x)\n", hr);
    ok (psc != NULL, "psc should not be null and have SCRIPT_CACHE buffer address\n");

    cInChars = cChars = 9;
    dwFlags = SGCM_RTL;
    hr = ScriptGetCMap(hdc, &psc, TestItem3, cInChars, dwFlags, pwOutGlyphs3);
    ok (hr == S_OK, "ScriptGetCMap should return S_OK not (%08x)\n", hr);
    ok (psc != NULL, "psc should not be null and have SCRIPT_CACHE buffer address\n");
    ok(pwOutGlyphs3[0] == pwOutGlyphs2[0], "glyph incorrectly altered\n");
    ok(pwOutGlyphs3[1] == pwOutGlyphs2[1], "glyph incorrectly altered\n");
    ok(pwOutGlyphs3[2] == pwOutGlyphs2[2], "glyph incorrectly altered\n");
    ok(pwOutGlyphs3[3] == pwOutGlyphs2[3], "glyph incorrectly altered\n");
    ok(pwOutGlyphs3[4] == pwOutGlyphs2[4], "glyph not mirrored correctly\n");
    ok(pwOutGlyphs3[5] == pwOutGlyphs2[5], "glyph not mirrored correctly\n");
    ok(pwOutGlyphs3[6] == pwOutGlyphs2[6], "glyph not mirrored correctly\n");
    ok(pwOutGlyphs3[7] == pwOutGlyphs2[7], "glyph not mirrored correctly\n");
    ok(pwOutGlyphs3[8] == pwOutGlyphs2[8], "glyph not mirrored correctly\n");

    ScriptFreeCache( &psc);
    ok (!psc, "psc is not null after ScriptFreeCache\n");
}

Referenced by START_TEST().

test_ScriptGetFontFunctions()

static void test_ScriptGetFontFunctions ( HDC  hdc )

static

Definition at line 3812 of file usp10.c.

{
    static const WCHAR test_phagspa[] = {0xa84f, 0xa861, 0xa843, 0x0020, 0xa863, 0xa861, 0xa859,
            0x0020, 0xa850, 0xa85c, 0xa85e};
    SCRIPT_CONTROL control;
    SCRIPT_CACHE sc = NULL;
    SCRIPT_ITEM items[15];
    OPENTYPE_TAG tags[5];
    SCRIPT_STATE state;
    int count = 0;
    HRESULT hr;

    if (!pScriptGetFontScriptTags || !pScriptGetFontLanguageTags || !pScriptGetFontFeatureTags)
    {
        win_skip("ScriptGetFontScriptTags, ScriptGetFontLanguageTags or "
                "ScriptGetFontFeatureTags not available on this platform.\n");
        return;
    }

    hr = pScriptGetFontScriptTags(hdc, &sc, NULL, 0, NULL, NULL);
    ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr);
    ok(!sc, "Got unexpected script cache %p.\n", sc);
    hr = pScriptGetFontScriptTags(hdc, &sc, NULL, 0, NULL, &count);
    ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr);
    ok(!sc, "Got unexpected script cache %p.\n", sc);
    hr = pScriptGetFontScriptTags(hdc, &sc, NULL, ARRAY_SIZE(tags), tags, NULL);
    ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr);
    ok(!sc, "Got unexpected script cache %p.\n", sc);
    hr = pScriptGetFontScriptTags(hdc, &sc, NULL, 0, tags, &count);
    ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr);
    ok(!sc, "Got unexpected script cache %p.\n", sc);
    hr = pScriptGetFontScriptTags(NULL, &sc, NULL, ARRAY_SIZE(tags), tags, &count);
    ok(hr == E_PENDING, "Got unexpected hr %#x.\n", hr);
    ok(!sc, "Got unexpected script cache %p.\n", sc);
    hr = pScriptGetFontScriptTags(hdc, &sc, NULL, ARRAY_SIZE(tags), tags, &count);
    ok(hr == S_OK || hr == E_OUTOFMEMORY, "Got unexpected hr %#x.\n", hr);
    if (hr == S_OK)
        ok(count <= 5, "Got unexpected count %d.\n", count);
    else
        ok(!count, "Got unexpected count %d.\n", count);
    ok(!!sc, "Got unexpected script cache %p.\n", sc);

    ScriptFreeCache(&sc);
    sc = NULL;

    hr = pScriptGetFontLanguageTags(hdc, &sc, NULL, latn_tag, 0, NULL, NULL);
    ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr);
    ok(!sc, "Got unexpected script cache %p.\n", sc);
    hr = pScriptGetFontLanguageTags(hdc, &sc, NULL, latn_tag, 0, NULL, &count);
    ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr);
    ok(!sc, "Got unexpected script cache %p.\n", sc);
    hr = pScriptGetFontLanguageTags(hdc, &sc, NULL, latn_tag, ARRAY_SIZE(tags), tags, NULL);
    ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr);
    ok(!sc, "Got unexpected script cache %p.\n", sc);
    hr = pScriptGetFontLanguageTags(hdc, &sc, NULL, latn_tag, 0, tags, &count);
    ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr);
    ok(!sc, "Got unexpected script cache %p.\n", sc);
    hr = pScriptGetFontLanguageTags(NULL, &sc, NULL, latn_tag, ARRAY_SIZE(tags), tags, &count);
    ok(hr == E_PENDING, "Got unexpected hr %#x.\n", hr);
    ok(!sc, "Got unexpected script cache %p.\n", sc);
    hr = pScriptGetFontLanguageTags(hdc, &sc, NULL, latn_tag, ARRAY_SIZE(tags), tags, &count);
    ok(hr == S_OK || hr == E_OUTOFMEMORY, "Got unexpected hr %#x.\n", hr);
    if (hr == S_OK)
        ok(count <= 5, "Got unexpected count %d.\n", count);
    else
        ok(!count, "Got unexpected count %d.\n", count);

    ScriptFreeCache(&sc);
    sc = NULL;

    hr = pScriptGetFontFeatureTags(hdc, &sc, NULL, latn_tag, 0x0, 0, NULL, NULL);
    ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr);
    ok(!sc, "Got unexpected script cache %p.\n", sc);
    hr = pScriptGetFontFeatureTags(hdc, &sc, NULL, latn_tag, 0x0, 0, NULL, &count);
    ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr);
    ok(!sc, "Got unexpected script cache %p.\n", sc);
    hr = pScriptGetFontFeatureTags(hdc, &sc, NULL, latn_tag, 0x0, ARRAY_SIZE(tags), tags, NULL);
    ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr);
    ok(!sc, "Got unexpected script cache %p.\n", sc);
    hr = pScriptGetFontFeatureTags(hdc, &sc, NULL, latn_tag, 0x0, 0, tags, &count);
    ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr);
    ok(!sc, "Got unexpected script cache %p.\n", sc);
    hr = pScriptGetFontFeatureTags(NULL, &sc, NULL, latn_tag, 0x0, ARRAY_SIZE(tags), tags, &count);
    ok(hr == E_PENDING, "Got unexpected hr %#x.\n", hr);
    ok(!sc, "Got unexpected script cache %p.\n", sc);
    hr = pScriptGetFontFeatureTags(hdc, &sc, NULL, latn_tag, 0x0, ARRAY_SIZE(tags), tags, &count);
    ok(hr == S_OK || hr == E_OUTOFMEMORY, "Got unexpected hr %#x.\n", hr);
    if (hr == S_OK)
        ok(count <= 5, "Got unexpected count %d.\n", count);
    else
        ok(!count, "Got unexpected count %d.\n", count);

    memset(&control, 0, sizeof(control));
    memset(&state, 0, sizeof(state));

    hr = ScriptItemize(test_phagspa, ARRAY_SIZE(test_phagspa), ARRAY_SIZE(items),
            &control, &state, items, &count);
    ok(hr == S_OK, "Got unexpected hr %#x.\n", hr);
    memset(tags, 0, sizeof(tags));
    hr = pScriptGetFontScriptTags(hdc, &sc, &items[0].a, ARRAY_SIZE(tags), tags, &count);
    ok(hr == USP_E_SCRIPT_NOT_IN_FONT || broken(hr == S_OK), "Got unexpected hr %#x.\n", hr);

    hr = pScriptGetFontLanguageTags(hdc, &sc, NULL, dsrt_tag, ARRAY_SIZE(tags), tags, &count);
    ok(hr == S_OK, "Got unexpected hr %#x.\n", hr);
    hr = pScriptGetFontLanguageTags(hdc, &sc, &items[0].a, dsrt_tag, ARRAY_SIZE(tags), tags, &count);
    ok(hr == E_INVALIDARG || broken(hr == S_OK), "Got unexpected hr %#x.\n", hr);

    hr = pScriptGetFontFeatureTags(hdc, &sc, NULL, dsrt_tag, 0x0, ARRAY_SIZE(tags), tags, &count);
    ok(hr == S_OK, "Got unexpected hr %#x.\n", hr);
    hr = pScriptGetFontFeatureTags(hdc, &sc, &items[0].a, dsrt_tag, 0x0, ARRAY_SIZE(tags), tags, &count);
    ok(hr == E_INVALIDARG || broken(hr == S_OK), "Got unexpected hr %#x.\n", hr);

    ScriptFreeCache(&sc);
}

Referenced by START_TEST().

test_ScriptGetFontProperties()

static void test_ScriptGetFontProperties ( HDC  hdc )

static

Definition at line 2507 of file usp10.c.

{
    HRESULT         hr;
    SCRIPT_CACHE    psc,old_psc;
    SCRIPT_FONTPROPERTIES sfp;
    HFONT font, oldfont;
    LOGFONTA lf;
    struct enum_font_data efnd;
    TEXTMETRICA tmA;
    WORD gi[3];
    WCHAR str[3];
    DWORD  i, ret;
    WORD system_lang_id = PRIMARYLANGID(GetSystemDefaultLangID());
    static const WCHAR invalids[] = {0x0020, 0x200B, 0xF71B};
    /* U+0020: numeric space
       U+200B: zero width space
       U+F71B: unknown, found by black box testing */
    BOOL is_arial, is_times_new_roman, is_arabic = (system_lang_id == LANG_ARABIC);

    /* Some sanity checks for ScriptGetFontProperties */

    hr = ScriptGetFontProperties(NULL,NULL,NULL);
    ok( hr == E_INVALIDARG, "(NULL,NULL,NULL), expected E_INVALIDARG, got %08x\n", hr);

    hr = ScriptGetFontProperties(NULL,NULL,&sfp);
    ok( hr == E_INVALIDARG, "(NULL,NULL,&sfp), expected E_INVALIDARG, got %08x\n", hr);

    /* Set psc to NULL, to be able to check if a pointer is returned in psc */
    psc = NULL;
    hr = ScriptGetFontProperties(NULL,&psc,NULL);
    ok( hr == E_INVALIDARG, "(NULL,&psc,NULL), expected E_INVALIDARG, got %08x\n", hr);
    ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);

    /* Set psc to NULL, to be able to check if a pointer is returned in psc */
    psc = NULL;
    hr = ScriptGetFontProperties(NULL,&psc,&sfp);
    ok( hr == E_PENDING, "(NULL,&psc,&sfp), expected E_PENDING, got %08x\n", hr);
    ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);

    hr = ScriptGetFontProperties(hdc,NULL,NULL);
    ok( hr == E_INVALIDARG, "(hdc,NULL,NULL), expected E_INVALIDARG, got %08x\n", hr);

    hr = ScriptGetFontProperties(hdc,NULL,&sfp);
    ok( hr == E_INVALIDARG, "(hdc,NULL,&sfp), expected E_INVALIDARG, got %08x\n", hr);

    /* Set psc to NULL, to be able to check if a pointer is returned in psc */
    psc = NULL;
    hr = ScriptGetFontProperties(hdc,&psc,NULL);
    ok( hr == E_INVALIDARG, "(hdc,&psc,NULL), expected E_INVALIDARG, got %08x\n", hr);
    ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);

    /* Pass an invalid sfp */
    psc = NULL;
    sfp.cBytes = sizeof(SCRIPT_FONTPROPERTIES) - 1;
    hr = ScriptGetFontProperties(hdc,&psc,&sfp);
    ok( hr == E_INVALIDARG, "(hdc,&psc,&sfp) invalid, expected E_INVALIDARG, got %08x\n", hr);
    ok( psc != NULL, "Expected a pointer in psc, got NULL\n");
    ok( sfp.cBytes == sizeof(SCRIPT_FONTPROPERTIES) - 1, "Unexpected cBytes.\n");
    ScriptFreeCache(&psc);
    ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);

    /* Give it the correct cBytes, we don't care about what's coming back */
    sfp.cBytes = sizeof(SCRIPT_FONTPROPERTIES);
    psc = NULL;
    hr = ScriptGetFontProperties(hdc,&psc,&sfp);
    ok( hr == S_OK, "(hdc,&psc,&sfp) partly initialized, expected S_OK, got %08x\n", hr);
    ok( psc != NULL, "Expected a pointer in psc, got NULL\n");

    /* Save the psc pointer */
    old_psc = psc;
    /* Now a NULL hdc again */
    hr = ScriptGetFontProperties(NULL,&psc,&sfp);
    ok( hr == S_OK, "(NULL,&psc,&sfp), expected S_OK, got %08x\n", hr);
    ok( psc == old_psc, "Expected psc not to be changed, was %p is now %p\n", old_psc, psc);
    ScriptFreeCache(&psc);
    ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);

    memset(&lf, 0, sizeof(lf));
    lf.lfCharSet = DEFAULT_CHARSET;
    efnd.total = 0;
    EnumFontFamiliesA(hdc, NULL, enum_bitmap_font_proc, (LPARAM)&efnd);

    for (i = 0; i < efnd.total; i++)
    {
        if (strlen((char *)efnd.elf[i].elfFullName) >= LF_FACESIZE)
        {
            trace("Font name to long to test: %s\n",(char *)efnd.elf[i].elfFullName);
            continue;
        }
        lstrcpyA(lf.lfFaceName, (char *)efnd.elf[i].elfFullName);
        font = CreateFontIndirectA(&lf);
        oldfont = SelectObject(hdc, font);

        sfp.cBytes = sizeof(SCRIPT_FONTPROPERTIES);
        psc = NULL;
        hr = ScriptGetFontProperties(hdc, &psc, &sfp);
        ok(hr == S_OK, "ScriptGetFontProperties expected S_OK, got %08x\n", hr);
        if (winetest_interactive)
        {
            trace("bitmap font %s\n", lf.lfFaceName);
            trace("wgBlank %04x\n", sfp.wgBlank);
            trace("wgDefault %04x\n", sfp.wgDefault);
            trace("wgInvalid %04x\n", sfp.wgInvalid);
            trace("wgKashida %04x\n", sfp.wgKashida);
            trace("iKashidaWidth %d\n", sfp.iKashidaWidth);
        }

        ret = GetTextMetricsA(hdc, &tmA);
        ok(ret != 0, "GetTextMetricsA failed!\n");

        ret = GetGlyphIndicesW(hdc, invalids, 1, gi, GGI_MARK_NONEXISTING_GLYPHS);
        ok(ret != GDI_ERROR, "GetGlyphIndicesW failed!\n");

        ok(sfp.wgBlank == tmA.tmBreakChar || sfp.wgBlank == gi[0], "bitmap font %s wgBlank %04x tmBreakChar %04x Space %04x\n", lf.lfFaceName, sfp.wgBlank, tmA.tmBreakChar, gi[0]);

        ok(sfp.wgDefault == 0 || sfp.wgDefault == tmA.tmDefaultChar || broken(sfp.wgDefault == (0x100 | tmA.tmDefaultChar)), "bitmap font %s wgDefault %04x, tmDefaultChar %04x\n", lf.lfFaceName, sfp.wgDefault, tmA.tmDefaultChar);

        ok(sfp.wgInvalid == sfp.wgBlank || broken(is_arabic), "bitmap font %s wgInvalid %02x wgBlank %02x\n", lf.lfFaceName, sfp.wgInvalid, sfp.wgBlank);

        ok(sfp.wgKashida == 0xFFFF || broken(is_arabic), "bitmap font %s wgKashida %02x\n", lf.lfFaceName, sfp.wgKashida);

        ScriptFreeCache(&psc);

        SelectObject(hdc, oldfont);
        DeleteObject(font);
    }

    efnd.total = 0;
    EnumFontFamiliesA(hdc, NULL, enum_truetype_proc, (LPARAM)&efnd);

    for (i = 0; i < efnd.total; i++)
    {
        if (strlen((char *)efnd.elf[i].elfFullName) >= LF_FACESIZE)
        {
            trace("Font name to long to test: %s\n",(char *)efnd.elf[i].elfFullName);
            continue;
        }
        lstrcpyA(lf.lfFaceName, (char *)efnd.elf[i].elfFullName);
        font = CreateFontIndirectA(&lf);
        oldfont = SelectObject(hdc, font);

        sfp.cBytes = sizeof(SCRIPT_FONTPROPERTIES);
        psc = NULL;
        hr = ScriptGetFontProperties(hdc, &psc, &sfp);
        ok(hr == S_OK, "ScriptGetFontProperties expected S_OK, got %08x\n", hr);
        if (winetest_interactive)
        {
            trace("truetype font %s\n", lf.lfFaceName);
            trace("wgBlank %04x\n", sfp.wgBlank);
            trace("wgDefault %04x\n", sfp.wgDefault);
            trace("wgInvalid %04x\n", sfp.wgInvalid);
            trace("wgKashida %04x\n", sfp.wgKashida);
            trace("iKashidaWidth %d\n", sfp.iKashidaWidth);
        }

        str[0] = 0x0020; /* U+0020: numeric space */
        ret = GetGlyphIndicesW(hdc, str, 1, gi, 0);
        ok(ret != GDI_ERROR, "GetGlyphIndicesW failed!\n");
        ok(sfp.wgBlank == gi[0], "truetype font %s wgBlank %04x gi[0] %04x\n", lf.lfFaceName, sfp.wgBlank, gi[0]);

        ok(sfp.wgDefault == 0 || broken(is_arabic), "truetype font %s wgDefault %04x\n", lf.lfFaceName, sfp.wgDefault);

        ret = GetGlyphIndicesW(hdc, invalids, 3, gi, GGI_MARK_NONEXISTING_GLYPHS);
        ok(ret != GDI_ERROR, "GetGlyphIndicesW failed!\n");
        if (gi[2] != 0xFFFF) /* index of default non exist char */
            ok(sfp.wgInvalid == gi[2], "truetype font %s wgInvalid %04x gi[2] %04x\n", lf.lfFaceName, sfp.wgInvalid, gi[2]);
        else if (gi[1] != 0xFFFF)
            ok(sfp.wgInvalid == gi[1], "truetype font %s wgInvalid %04x gi[1] %04x\n", lf.lfFaceName, sfp.wgInvalid, gi[1]);
        else if (gi[0] != 0xFFFF)
            ok(sfp.wgInvalid == gi[0], "truetype font %s wgInvalid %04x gi[0] %04x\n", lf.lfFaceName, sfp.wgInvalid, gi[0]);
        else
            ok(sfp.wgInvalid == 0, "truetype font %s wgInvalid %04x expect 0\n", lf.lfFaceName, sfp.wgInvalid);

        str[0] = 0x0640; /* U+0640: kashida */
        ret = GetGlyphIndicesW(hdc, str, 1, gi, GGI_MARK_NONEXISTING_GLYPHS);
        ok(ret != GDI_ERROR, "GetGlyphIndicesW failed!\n");
        is_arial = !lstrcmpA(lf.lfFaceName, "Arial");
        is_times_new_roman= !lstrcmpA(lf.lfFaceName, "Times New Roman");
        ok(sfp.wgKashida == gi[0] || broken(is_arial || is_times_new_roman) || broken(is_arabic), "truetype font %s wgKashida %04x gi[0] %04x\n", lf.lfFaceName, sfp.wgKashida, gi[0]);

        ScriptFreeCache(&psc);

        SelectObject(hdc, oldfont);
        DeleteObject(font);
    }
}

Referenced by START_TEST().

test_ScriptGetGlyphABCWidth()

static void test_ScriptGetGlyphABCWidth ( HDC  hdc )

static

Definition at line 3466 of file usp10.c.

{
    HRESULT hr;
    SCRIPT_CACHE sc = NULL;
    HFONT hfont, prev_hfont;
    TEXTMETRICA tm;
    ABC abc, abc2;
    LOGFONTA lf;
    WORD glyph;
    INT width;
    DWORD ret;

    glyph = 0;
    ret = GetGlyphIndicesA(hdc, "a", 1, &glyph, 0);
    ok(ret == 1, "Failed to get glyph index.\n");
    ok(glyph != 0, "Unexpected glyph index.\n");

    hr = ScriptGetGlyphABCWidth(NULL, NULL, glyph, NULL);
    ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got 0x%08x\n", hr);

    hr = ScriptGetGlyphABCWidth(NULL, &sc, glyph, NULL);
    ok(broken(hr == E_PENDING) ||
       hr == E_INVALIDARG, /* WIN7 */
       "expected E_INVALIDARG, got 0x%08x\n", hr);

    hr = ScriptGetGlyphABCWidth(NULL, &sc, glyph, &abc);
    ok(hr == E_PENDING, "expected E_PENDING, got 0x%08x\n", hr);

    if (0) {    /* crashes on WinXP */
    hr = ScriptGetGlyphABCWidth(hdc, &sc, glyph, NULL);
    ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got 0x%08x\n", hr);
    }

    hr = ScriptGetGlyphABCWidth(hdc, &sc, glyph, &abc);
    ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
    ok(abc.abcB != 0, "Unexpected width.\n");

    ret = GetCharABCWidthsI(hdc, glyph, 1, NULL, &abc2);
    ok(ret, "Failed to get char width.\n");
    ok(!memcmp(&abc, &abc2, sizeof(abc)), "Unexpected width.\n");

    ScriptFreeCache(&sc);

    /* Bitmap font */
    memset(&lf, 0, sizeof(lf));
    strcpy(lf.lfFaceName, "System");
    lf.lfHeight = 20;

    hfont = CreateFontIndirectA(&lf);
    prev_hfont = SelectObject(hdc, hfont);

    ret = GetTextMetricsA(hdc, &tm);
    ok(ret, "Failed to get text metrics.\n");
    ok(!(tm.tmPitchAndFamily & TMPF_TRUETYPE), "Unexpected TrueType font.\n");
    ok(tm.tmPitchAndFamily & TMPF_FIXED_PITCH, "Unexpected fixed pitch font.\n");

    glyph = 0;
    ret = GetGlyphIndicesA(hdc, "i", 1, &glyph, 0);
    ok(ret == 1, "Failed to get glyph index.\n");
    ok(glyph != 0, "Unexpected glyph index.\n");

    sc = NULL;
    hr = ScriptGetGlyphABCWidth(hdc, &sc, glyph, &abc);
    ok(hr == S_OK, "Failed to get glyph width, hr %#x.\n", hr);
    ok(abc.abcB != 0, "Unexpected width.\n");

    ret = GetCharWidthI(hdc, glyph, 1, NULL, &width);
    ok(ret, "Failed to get char width.\n");
    abc2.abcA = abc2.abcC = 0;
    abc2.abcB = width;
    ok(!memcmp(&abc, &abc2, sizeof(abc)), "Unexpected width.\n");

    SelectObject(hdc, prev_hfont);
    DeleteObject(hfont);

    ScriptFreeCache(&sc);
}

Referenced by START_TEST().

test_ScriptGetLogicalWidths()

static void test_ScriptGetLogicalWidths ( void  )

static

Definition at line 3951 of file usp10.c.

{
    SCRIPT_ANALYSIS sa = { 0 };
    unsigned int i, j;

    for (i = 0; i < ARRAY_SIZE(logical_width_tests); ++i)
    {
        const struct logical_width_test *ptr = logical_width_tests + i;
        SCRIPT_VISATTR attrs[3];
        int widths[3];
        HRESULT hr;

        memset(attrs, 0, sizeof(attrs));
        for (j = 0; j < ptr->glyph_count; j++)
        {
            attrs[j].fClusterStart = ptr->clusterstart[j];
            attrs[j].fDiacritic = ptr->diacritic[j];
            attrs[j].fZeroWidth = ptr->zerowidth[j];
        }

        hr = ScriptGetLogicalWidths(&sa, ptr->char_count, ptr->glyph_count, ptr->advances, ptr->map, attrs, widths);
        ok(hr == S_OK, "got 0x%08x\n", hr);

        todo_wine_if(ptr->todo)
            ok(!memcmp(ptr->widths, widths, sizeof(widths)), "test %u: got wrong widths\n", i);
    }
}

Referenced by START_TEST().

test_ScriptGetProperties()

static void test_ScriptGetProperties ( void  )

static

Definition at line 3699 of file usp10.c.

{
    const SCRIPT_PROPERTIES **props;
    HRESULT hr;
    int num;

    hr = ScriptGetProperties(NULL, NULL);
    ok(hr == E_INVALIDARG, "ScriptGetProperties succeeded\n");

    hr = ScriptGetProperties(NULL, &num);
    ok(hr == S_OK, "ScriptGetProperties failed: 0x%08x\n", hr);

    hr = ScriptGetProperties(&props, NULL);
    ok(hr == S_OK, "ScriptGetProperties failed: 0x%08x\n", hr);

    hr = ScriptGetProperties(&props, &num);
    ok(hr == S_OK, "ScriptGetProperties failed: 0x%08x\n", hr);
}

Referenced by START_TEST().

test_ScriptIsComplex()

static void test_ScriptIsComplex ( void  )

static

Definition at line 3979 of file usp10.c.

{
    static const WCHAR testW[] = {0x202a,'1',0x202c,0};
    static const WCHAR test2W[] = {'1',0};
    static const struct complex_test
    {
        const WCHAR *text;
        DWORD flags;
        HRESULT hr;
        BOOL todo;
    } complex_tests[] =
    {
        { test2W, SIC_ASCIIDIGIT, S_OK },
        { test2W, SIC_COMPLEX, S_FALSE },
        { test2W, SIC_COMPLEX | SIC_ASCIIDIGIT, S_OK },
        { testW, SIC_NEUTRAL | SIC_COMPLEX, S_OK },
        { testW, SIC_NEUTRAL, S_FALSE, TRUE },
        { testW, SIC_COMPLEX, S_OK },
        { testW, 0, S_FALSE },
    };
    unsigned int i;
    HRESULT hr;

    hr = ScriptIsComplex(NULL, 0, 0);
    ok(hr == E_INVALIDARG || broken(hr == S_FALSE) /* winxp/vista */, "got 0x%08x\n", hr);

    if (hr == E_INVALIDARG)
    {
        hr = ScriptIsComplex(NULL, 1, 0);
        ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
    }

    hr = ScriptIsComplex(test2W, -1, SIC_ASCIIDIGIT);
    ok(hr == E_INVALIDARG || broken(hr == S_FALSE) /* winxp/vista */, "got 0x%08x\n", hr);

    hr = ScriptIsComplex(test2W, 0, SIC_ASCIIDIGIT);
    ok(hr == S_FALSE, "got 0x%08x\n", hr);

    for (i = 0; i < ARRAY_SIZE(complex_tests); ++i)
    {
        hr = ScriptIsComplex(complex_tests[i].text, lstrlenW(complex_tests[i].text), complex_tests[i].flags);
    todo_wine_if(complex_tests[i].todo)
        ok(hr == complex_tests[i].hr, "%u: got %#x, expected %#x, flags %#x\n", i, hr, complex_tests[i].hr,
            complex_tests[i].flags);
    }

    hr = ScriptIsComplex(test2W, 1, ~0u);
    ok(hr == S_OK, "got 0x%08x\n", hr);

    hr = ScriptIsComplex(testW, 3, 0);
    ok(hr == S_FALSE, "got 0x%08x\n", hr);

    hr = ScriptIsComplex(testW, 3, SIC_NEUTRAL | SIC_COMPLEX);
    ok(hr == S_OK, "got 0x%08x\n", hr);

    hr = ScriptIsComplex(testW, 3, SIC_COMPLEX);
    ok(hr == S_OK, "got 0x%08x\n", hr);

    hr = ScriptIsComplex(test2W, 1, SIC_COMPLEX);
    ok(hr == S_FALSE, "got 0x%08x\n", hr);
}

Referenced by START_TEST().

test_ScriptItemize()

static void test_ScriptItemize ( void  )

static

Definition at line 180 of file usp10.c.

{
    static const WCHAR test1[] = {'t', 'e', 's', 't',0};
    static const itemTest t11[2] = {{{0,0,0,0,0,0},0,0,0,0,0,latn_tag,FALSE},{{0,0,0,0,0,0},4,0,0,0,0,-1}};
    static const itemTest t12[2] = {{{0,0,0,0,0,0},0,0,0,2,0,latn_tag,FALSE},{{0,0,0,0,0,0},4,0,0,0,0,-1,FALSE}};

    static const WCHAR test1b[] = {' ', ' ', ' ', ' ',0};
    static const itemTest t1b1[2] = {{{0,0,0,0,0,0},0,0,0,0,0,0,FALSE},{{0,0,0,0,0,0},4,0,0,0,0,-1,FALSE}};
    static const itemTest t1b2[2] = {{{0,0,0,0,0,0},0,1,1,1,0,0,FALSE},{{0,0,0,0,0,0},4,0,0,0,0,-1,FALSE}};

    static const WCHAR test1c[] = {' ', ' ', ' ', '1', '2', ' ',0};
    static const itemTest t1c1[2] = {{{0,0,0,0,0,0},0,0,0,0,0,0,FALSE},{{0,0,0,0,0,0},6,0,0,0,0,-1,FALSE}};
    static const itemTest t1c2[4] = {{{0,0,0,0,0,0},0,1,1,1,0,0,FALSE},{{0,0,0,0,0,0},3,0,1,2,0,0,FALSE},{{0,0,0,0,0,0},5,1,1,1,0,0,FALSE},{{0,0,0,0,0,0},6,0,0,0,0,-1,FALSE}};

    /* Arabic, English*/
    static const WCHAR test2[] = {'1','2','3','-','5','2',0x064a,0x064f,0x0633,0x0627,0x0648,0x0650,0x064a,'7','1','.',0};
    static const itemTest t21[7] = {{{0,0,0,0,0,0},0,0,0,0,0,0,FALSE},{{0,0,0,0,0,0},3,0,0,0,0,0,FALSE},{{0,0,0,0,0,0},4,0,0,0,0,0,FALSE},{{0,0,0,0,0,0},6,1,1,1,0,arab_tag,FALSE},{{0,0,0,0,0,0},13,0,0,0,0,0,FALSE},{{0,0,0,0,0,0},15,0,0,0,0,0,FALSE},{{0,0,0,0,0,0},16,0,0,0,0,-1,FALSE}};
    static const itemTest t22[5] = {{{0,0,0,0,0,0},0,0,0,2,0,0,FALSE},{{0,0,0,0,0,0},6,1,1,1,0,arab_tag,FALSE},{{0,0,0,0,0,0},13,0,1,2,0,0,FALSE},{{0,0,0,0,0,0},15,0,0,0,0,0,FALSE},{{0,0,0,0,0,0},16,0,0,0,0,-1,FALSE}};
    static const itemTest t23[5] = {{{0,0,0,0,0,0},0,0,1,2,0,0,FALSE},{{0,0,0,0,0,0},6,1,1,1,0,arab_tag,FALSE},{{0,0,0,0,0,0},13,0,1,2,0,0,FALSE},{{0,0,0,0,0,0},15,1,1,1,0,0,FALSE},{{0,0,0,0,0,0},16,0,0,0,0,-1,FALSE}};
    static const itemTest t24[5] = {{{0,0,0,0,0,0},0,0,0,0,1,0,FALSE},
                                {{0,0,0,0,0,0},6,0,0,0,1,arab_tag,FALSE},
                                {{0,0,0,0,0,0},13,0,1,0,1,0,FALSE},
                                {{0,0,0,0,0,0},15,0,0,0,1,0,FALSE},
                                {{0,0,0,0,0,0},16,0,0,0,0,-1,FALSE}};

    static const WCHAR test2b[] = {'A','B','C','-','D','E','F',' ',0x0621,0x0623,0x0624,0};
    static const itemTest t2b1[5] = {{{0,0,0,0,0,0},0,0,0,0,0,latn_tag,FALSE},{{0,0,0,0,0,0},3,0,0,0,0,0,FALSE},{{0,0,0,0,0,0},4,0,0,0,0,latn_tag,FALSE},{{0,0,0,0,0,0},8,1,1,1,0,arab_tag,FALSE},{{0,0,0,0,0,0},11,0,0,0,0,-1,FALSE}};
    static const itemTest t2b2[5] = {{{0,0,0,0,0,0},0,0,0,2,0,latn_tag,FALSE},{{0,0,0,0,0,0},3,0,0,2,0,0,FALSE},{{0,0,0,0,0,0},4,0,0,2,0,latn_tag,FALSE},{{0,0,0,0,0,0},7,1,1,1,0,arab_tag,FALSE},{{0,0,0,0,0,0},11,0,0,0,0,-1,FALSE}};
    static const itemTest t2b3[3] = {{{0,0,0,0,0,0},0,0,0,2,0,latn_tag,FALSE},{{0,0,0,0,0,0},7,1,1,1,0,arab_tag,FALSE},{{0,0,0,0,0,0},11,0,0,0,0,-1,FALSE}};
    static const itemTest t2b4[5] = {{{0,0,0,0,0,0},0,0,0,0,1,latn_tag,FALSE},
                                    {{0,0,0,0,0,0},3,0,0,0,1,0,FALSE},
                                    {{0,0,0,0,0,0},4,0,0,0,1,latn_tag,