parser.c File Reference

#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "winreg.h"
#include "setupapi.h"
#include "wine/test.h"

Include dependency graph for parser.c:

Go to the source code of this file.

Macros
#define	A255
#define	A256   "a" A255
#define	A400
#define	A1200   A400 A400 A400
#define	A511   A255 A256
#define	A4096   A256 A256 A256 A256 A256 A256 A256 A256 A256 A256 A256 A256 A256 A256 A256 A256
#define	A4097   "a" A4096
#define	STD_HEADER   "[Version]\r\nSignature=\"$CHICAGO$\"\r\n"
#define	STR_SECTION

Functions
static	LPCSTR (WINAPI *pSetupGetFieldA)(PINFCONTEXT
static	LPCWSTR (WINAPI *pSetupGetFieldW)(PINFCONTEXT
static	BOOL (WINAPI *pSetupEnumInfSectionsA)(HINF hinf
static void	init_function_pointers (void)
static HINF	test_file_contents (const char *data, UINT *err_line)
static const char *	get_string_field (INFCONTEXT *context, DWORD index)
static const char *	get_line_text (INFCONTEXT *context)
static void	test_invalid_files (void)
static void	test_section_names (void)
static void	test_enum_sections (void)
static const char *	check_key (INFCONTEXT *context, const char *wanted)
static void	test_key_names (void)
static void	test_close_inf_file (void)
static void	test_pSetupGetField (void)
static void	test_SetupGetIntField (void)
static void	test_GLE (void)
	START_TEST (parser)

Variables
static HMODULE	hSetupAPI
static	DWORD
static UINT	index
static UINT PSTR	buffer
static UINT PSTR DWORD	size
static UINT PSTR DWORD UINT *	need
static const char	tmpfilename [] = ".\\tmp.inf"
struct {
const char *   data
DWORD   error
UINT   err_line
BOOL   todo
}	invalid_files []
struct {
const char *   data
const char *   section
DWORD   error
}	section_names []
struct {
const char *   data
const char *   key
const char *   fields [10]
}	key_names []
static const char *	contents
static const CHAR	getfield_resA [][20]
static const WCHAR	getfield_resW [][20]

Macro Definition Documentation

A1200

#define A1200   A400 A400 A400

Definition at line 60 of file parser.c.

A255

#define A255

Value:

             "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" \
             "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" \
             "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" \
             "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"

Definition at line 52 of file parser.c.

A256

#define A256   "a" A255

Definition at line 56 of file parser.c.

A400

#define A400

Value:

             "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" \
             "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" \
             "aaaaaaaaaaaaaaaa" A256

Definition at line 57 of file parser.c.

A4096

#define A4096   A256 A256 A256 A256 A256 A256 A256 A256 A256 A256 A256 A256 A256 A256 A256 A256

Definition at line 62 of file parser.c.

A4097

#define A4097   "a" A4096

Definition at line 63 of file parser.c.

A511

#define A511   A255 A256

Definition at line 61 of file parser.c.

STD_HEADER

#define STD_HEADER   "[Version]\r\nSignature=\"$CHICAGO$\"\r\n"

Definition at line 65 of file parser.c.

STR_SECTION

#define STR_SECTION

Value:

                    "[Strings]\nfoo=aaa\nbar=bbb\nloop=%loop2%\nloop2=%loop%\n" \
                    "per%%cent=abcd\nper=1\ncent=2\n22=foo\n" \
                    "big=" A400 "\n" \
                    "mydrive=\"C:\\\"\n" \
                    "verybig=" A1200 "\n"

Definition at line 67 of file parser.c.

Function Documentation

BOOL()

static BOOL ( WINAPI *  pSetupEnumInfSectionsA )

static

check_key()

static const char * check_key ( INFCONTEXT *  context, const char *  wanted  )

static

Definition at line 393 of file parser.c.

{
    const char *key = get_string_field( context, 0 );
    DWORD err = GetLastError();
 
    if (!key)
    {
        ok( !wanted, "missing key %s\n", wanted );
        ok( err == 0 || err == ERROR_INVALID_PARAMETER, "last error set to %u\n", err );
    }
    else
    {
        ok( !strcmp( key, wanted ), "bad key %s/%s\n", key, wanted );
        ok( err == 0, "last error set to %u\n", err );
    }
    return key;
}

Referenced by test_key_names().

get_line_text()

static const char * get_line_text ( INFCONTEXT *  context )

static

Definition at line 92 of file parser.c.

{
    static char buffer[MAX_INF_STRING_LENGTH+32];
    if (SetupGetLineTextA( context, 0, 0, 0, buffer, sizeof(buffer), NULL )) return buffer;
    return NULL;
}

Referenced by test_key_names().

get_string_field()

static const char * get_string_field ( INFCONTEXT *  context, DWORD  index  )

static

Definition at line 85 of file parser.c.

{
    static char buffer[MAX_INF_STRING_LENGTH+32];
    if (SetupGetStringFieldA( context, index, buffer, sizeof(buffer), NULL )) return buffer;
    return NULL;
}

Referenced by check_key(), and test_key_names().

init_function_pointers()

static void init_function_pointers ( void  )

static

Definition at line 38 of file parser.c.

{
    hSetupAPI = GetModuleHandleA("setupapi.dll");
 
    /* Nice, pSetupGetField is either A or W depending on the Windows version! The actual test
     * takes care of this difference */
    pSetupGetFieldA = (void *)GetProcAddress(hSetupAPI, "pSetupGetField");
    pSetupGetFieldW = (void *)GetProcAddress(hSetupAPI, "pSetupGetField");
    pSetupEnumInfSectionsA = (void *)GetProcAddress(hSetupAPI, "SetupEnumInfSectionsA" );
}

Referenced by START_TEST().

LPCSTR()

static LPCSTR ( WINAPI *  pSetupGetFieldA )

static

LPCWSTR()

static LPCWSTR ( WINAPI *  pSetupGetFieldW )

static

START_TEST()

START_TEST

(

parser

)

Definition at line 784 of file parser.c.

{
    init_function_pointers();
    test_invalid_files();
    test_section_names();
    test_enum_sections();
    test_key_names();
    test_close_inf_file();
    test_pSetupGetField();
    test_SetupGetIntField();
    test_GLE();
    DeleteFileA( tmpfilename );
}

test_close_inf_file()

static void test_close_inf_file ( void  )

static

Definition at line 496 of file parser.c.

{
    SetLastError(0xdeadbeef);
    SetupCloseInfFile(NULL);
    ok(GetLastError() == 0xdeadbeef ||
        GetLastError() == ERROR_INVALID_PARAMETER, /* Win9x, WinMe */
        "Expected 0xdeadbeef, got %u\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    SetupCloseInfFile(INVALID_HANDLE_VALUE);
    ok(GetLastError() == 0xdeadbeef ||
        GetLastError() == ERROR_INVALID_PARAMETER, /* Win9x, WinMe */
        "Expected 0xdeadbeef, got %u\n", GetLastError());
}

Referenced by START_TEST().

test_enum_sections()

static void test_enum_sections ( void  )

static

Definition at line 260 of file parser.c.

{
    static const char *contents = STD_HEADER "[s1]\nfoo=bar\n[s2]\nbar=foo\n[s3]\n[strings]\na=b\n";
 
    BOOL ret;
    DWORD len;
    HINF hinf;
    UINT err, index;
    char buffer[256];
 
    if (!pSetupEnumInfSectionsA)
    {
        win_skip( "SetupEnumInfSectionsA not available\n" );
        return;
    }
 
    hinf = test_file_contents( contents, &err );
    ok( hinf != NULL, "Expected valid INF file\n" );
 
    for (index = 0; ; index++)
    {
        SetLastError( 0xdeadbeef );
        ret = pSetupEnumInfSectionsA( hinf, index, NULL, 0, &len );
        err = GetLastError();
        if (!ret && GetLastError() == ERROR_NO_MORE_ITEMS) break;
        ok( ret, "SetupEnumInfSectionsA failed\n" );
        ok( len == 3 || len == 8, "wrong len %u\n", len );
 
        SetLastError( 0xdeadbeef );
        ret = pSetupEnumInfSectionsA( hinf, index, NULL, sizeof(buffer), &len );
        err = GetLastError();
        ok( !ret, "SetupEnumInfSectionsA succeeded\n" );
        ok( err == ERROR_INVALID_USER_BUFFER, "wrong error %u\n", err );
        ok( len == 3 || len == 8, "wrong len %u\n", len );
 
        SetLastError( 0xdeadbeef );
        ret = pSetupEnumInfSectionsA( hinf, index, buffer, sizeof(buffer), &len );
        ok( ret, "SetupEnumInfSectionsA failed err %u\n", GetLastError() );
        ok( len == 3 || len == 8, "wrong len %u\n", len );
        ok( !lstrcmpiA( buffer, "version" ) || !lstrcmpiA( buffer, "s1" ) ||
            !lstrcmpiA( buffer, "s2" ) || !lstrcmpiA( buffer, "s3" ) || !lstrcmpiA( buffer, "strings" ),
            "bad section '%s'\n", buffer );
    }
    SetupCloseInfFile( hinf );
}

Referenced by START_TEST().

test_file_contents()

static HINF test_file_contents ( const char *  data, UINT *  err_line  )

static

Definition at line 74 of file parser.c.

{
    DWORD res;
    HANDLE handle = CreateFileA( tmpfilename, GENERIC_READ|GENERIC_WRITE,
                                 FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, 0 );
    if (handle == INVALID_HANDLE_VALUE) return 0;
    if (!WriteFile( handle, data, strlen(data), &res, NULL )) trace( "write error\n" );
    CloseHandle( handle );
    return SetupOpenInfFileA( tmpfilename, 0, INF_STYLE_WIN4, err_line );
}

Referenced by test_enum_sections(), test_GLE(), test_invalid_files(), test_key_names(), test_pSetupGetField(), test_section_names(), and test_SetupGetIntField().

test_GLE()

static void test_GLE ( void  )

static

Definition at line 670 of file parser.c.

{
    static const char *inf =
        "[Version]\n"
        "Signature=\"$Windows NT$\"\n"
        "[Sectionname]\n"
        "Keyname1=Field1,Field2,Field3\n"
        "\n"
        "Keyname2=Field4,Field5\n";
    HINF hinf;
    UINT err;
    INFCONTEXT context;
    BOOL retb;
    LONG retl;
    char buf[MAX_INF_STRING_LENGTH];
    int bufsize = MAX_INF_STRING_LENGTH;
    DWORD retsize;
 
    hinf = test_file_contents( inf, &err );
    ok( hinf != NULL, "Expected valid INF file\n" );
 
    SetLastError(0xdeadbeef);
    retb = SetupFindFirstLineA( hinf, "ImNotThere", NULL, &context );
    ok(!retb, "Expected failure\n");
    ok(GetLastError() == ERROR_LINE_NOT_FOUND,
        "Expected ERROR_LINE_NOT_FOUND, got %08x\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    retb = SetupFindFirstLineA( hinf, "ImNotThere", "ImNotThere", &context );
    ok(!retb, "Expected failure\n");
    ok(GetLastError() == ERROR_LINE_NOT_FOUND,
        "Expected ERROR_LINE_NOT_FOUND, got %08x\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    retb = SetupFindFirstLineA( hinf, "Sectionname", NULL, &context );
    ok(retb, "Expected success\n");
    ok(GetLastError() == ERROR_SUCCESS,
        "Expected ERROR_SUCCESS, got %08x\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    retb = SetupFindFirstLineA( hinf, "Sectionname", "ImNotThere", &context );
    ok(!retb, "Expected failure\n");
    ok(GetLastError() == ERROR_LINE_NOT_FOUND,
        "Expected ERROR_LINE_NOT_FOUND, got %08x\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    retb = SetupFindFirstLineA( hinf, "Sectionname", "Keyname1", &context );
    ok(retb, "Expected success\n");
    ok(GetLastError() == ERROR_SUCCESS,
        "Expected ERROR_SUCCESS, got %08x\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    retb = SetupFindNextMatchLineA( &context, "ImNotThere", &context );
    ok(!retb, "Expected failure\n");
    ok(GetLastError() == ERROR_LINE_NOT_FOUND,
        "Expected ERROR_LINE_NOT_FOUND, got %08x\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    retb = SetupFindNextMatchLineA( &context, "Keyname2", &context );
    ok(retb, "Expected success\n");
    ok(GetLastError() == ERROR_SUCCESS,
        "Expected ERROR_SUCCESS, got %08x\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    retl = SetupGetLineCountA( hinf, "ImNotThere");
    ok(retl == -1, "Expected -1, got %d\n", retl);
    ok(GetLastError() == ERROR_SECTION_NOT_FOUND,
        "Expected ERROR_SECTION_NOT_FOUND, got %08x\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    retl = SetupGetLineCountA( hinf, "Sectionname");
    ok(retl == 2, "Expected 2, got %d\n", retl);
    ok(GetLastError() == ERROR_SUCCESS,
        "Expected ERROR_SUCCESS, got %08x\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    retb = SetupGetLineTextA( NULL, hinf, "ImNotThere", "ImNotThere", buf, bufsize, &retsize);
    ok(!retb, "Expected failure\n");
    ok(GetLastError() == ERROR_LINE_NOT_FOUND,
        "Expected ERROR_LINE_NOT_FOUND, got %08x\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    retb = SetupGetLineTextA( NULL, hinf, "Sectionname", "ImNotThere", buf, bufsize, &retsize);
    ok(!retb, "Expected failure\n");
    ok(GetLastError() == ERROR_LINE_NOT_FOUND,
        "Expected ERROR_LINE_NOT_FOUND, got %08x\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    retb = SetupGetLineTextA( NULL, hinf, "Sectionname", "Keyname1", buf, bufsize, &retsize);
    ok(retb, "Expected success\n");
    ok(GetLastError() == ERROR_SUCCESS,
        "Expected ERROR_SUCCESS, got %08x\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    retb = SetupGetLineByIndexA( hinf, "ImNotThere", 1, &context );
    ok(!retb, "Expected failure\n");
    ok(GetLastError() == ERROR_LINE_NOT_FOUND,
        "Expected ERROR_LINE_NOT_FOUND, got %08x\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    retb = SetupGetLineByIndexA( hinf, "Sectionname", 1, &context );
    ok(retb, "Expected success\n");
    ok(GetLastError() == ERROR_SUCCESS,
        "Expected ERROR_SUCCESS, got %08x\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    retb = SetupGetLineByIndexA( hinf, "Sectionname", 3, &context );
    ok(!retb, "Expected failure\n");
    ok(GetLastError() == ERROR_LINE_NOT_FOUND,
        "Expected ERROR_LINE_NOT_FOUND, got %08x\n", GetLastError());
 
    SetupCloseInfFile( hinf );
}

Referenced by START_TEST().

test_invalid_files()

static void test_invalid_files ( void  )

static

Definition at line 151 of file parser.c.

{
    unsigned int i;
    UINT err_line;
    HINF hinf;
    DWORD err;
 
    for (i = 0; i < ARRAY_SIZE(invalid_files); i++)
    {
        SetLastError( 0xdeadbeef );
        err_line = 0xdeadbeef;
        hinf = test_file_contents( invalid_files[i].data, &err_line );
        err = GetLastError();
        trace( "hinf=%p err=0x%x line=%d\n", hinf, err, err_line );
        if (invalid_files[i].error)  /* should fail */
        {
            ok( hinf == INVALID_HANDLE_VALUE, "file %u: Open succeeded\n", i );
            todo_wine_if (invalid_files[i].todo)
            {
                ok( err == invalid_files[i].error, "file %u: Bad error %u/%u\n",
                    i, err, invalid_files[i].error );
                ok( err_line == invalid_files[i].err_line, "file %u: Bad error line %d/%d\n",
                    i, err_line, invalid_files[i].err_line );
            }
        }
        else  /* should succeed */
        {
            ok( hinf != INVALID_HANDLE_VALUE, "file %u: Open failed\n", i );
            ok( err == 0, "file %u: Error code set to %u\n", i, err );
        }
        SetupCloseInfFile( hinf );
    }
}

Referenced by START_TEST().

test_key_names()

static void test_key_names ( void  )

static

Definition at line 411 of file parser.c.

{
    char buffer[MAX_INF_STRING_LENGTH+32];
    const char *line;
    unsigned int i, index, count;
    UINT err_line;
    HINF hinf;
    DWORD err;
    BOOL ret;
    INFCONTEXT context;
 
    for (i = 0; i < ARRAY_SIZE(key_names); i++)
    {
        strcpy( buffer, STD_HEADER "[Test]\n" );
        strcat( buffer, key_names[i].data );
        SetLastError( 0xdeadbeef );
        hinf = test_file_contents( buffer, &err_line );
        ok( hinf != INVALID_HANDLE_VALUE, "line %u: open failed err %u\n", i, GetLastError() );
        if (hinf == INVALID_HANDLE_VALUE) continue;
 
        ret = SetupFindFirstLineA( hinf, "Test", 0, &context );
        ok(ret, "SetupFindFirstLineA failed: le=%u\n", GetLastError());
        if (!ret)
        {
            SetupCloseInfFile( hinf );
            continue;
        }
 
        check_key( &context, key_names[i].key );
 
        buffer[0] = buffer[1] = 0;  /* build the full line */
        for (index = 0; ; index++)
        {
            const char *field = get_string_field( &context, index + 1 );
            err = GetLastError();
            if (field)
            {
                ok( err == 0, "line %u: bad error %u\n", i, err );
                if (key_names[i].fields[index])
                {
                    if (i == 49)
                        ok( !strcmp( field, key_names[i].fields[index] ) ||
                            !strcmp( field, A1200), /* Vista, W2K8 */
                            "line %u: bad field %s/%s\n",
                            i, field, key_names[i].fields[index] );
                    else if (i == 52)
                        ok( !strcmp( field, key_names[i].fields[index] ) ||
                            !strcmp( field, A4096), /* Win10 >= 1709 */
                            "line %u: bad field %s/%s\n",
                            i, field, key_names[i].fields[index] );
                    else  /* don't compare drive letter of paths */
                        if (field[0] && field[1] == ':' && field[2] == '\\')
                        ok( !strcmp( field + 1, key_names[i].fields[index] + 1 ),
                            "line %u: bad field %s/%s\n",
                            i, field, key_names[i].fields[index] );
                    else
                        ok( !strcmp( field, key_names[i].fields[index] ), "line %u: bad field %s/%s\n",
                            i, field, key_names[i].fields[index] );
                }
                else
                    ok( 0, "line %u: got extra field %s\n", i, field );
                strcat( buffer, "," );
                strcat( buffer, field );
            }
            else
            {
                ok( err == 0 || err == ERROR_INVALID_PARAMETER,
                    "line %u: bad error %u\n", i, err );
                if (key_names[i].fields[index])
                    ok( 0, "line %u: missing field %s\n", i, key_names[i].fields[index] );
            }
            if (!key_names[i].fields[index]) break;
        }
        count = SetupGetFieldCount( &context );
        ok( count == index, "line %u: bad count %d/%d\n", i, index, count );
 
        line = get_line_text( &context );
        ok( line != NULL, "line %u: SetupGetLineText failed\n", i );
        if (line) ok( !strcmp( line, buffer+1 ), "line %u: bad text %s/%s\n", i, line, buffer+1 );
 
        SetupCloseInfFile( hinf );
    }
 
}

Referenced by START_TEST().

test_pSetupGetField()

static void test_pSetupGetField ( void  )

static

Definition at line 533 of file parser.c.

{
    UINT err;
    BOOL ret;
    HINF hinf;
    LPCSTR fieldA;
    LPCWSTR fieldW;
    INFCONTEXT context;
    int i;
    int len;
    BOOL unicode = TRUE;
 
    SetLastError(0xdeadbeef);
    lstrcmpW(NULL, NULL);
    if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
    {
        win_skip("Using A-functions instead of W\n");
        unicode = FALSE;
    }
 
    hinf = test_file_contents( contents, &err );
    ok( hinf != NULL, "Expected valid INF file\n" );
 
    ret = SetupFindFirstLineA( hinf, "FileBranchInfo", NULL, &context );
    ok( ret, "Failed to find first line\n" );
 
    /* native Windows crashes if a NULL context is sent in */
 
    for ( i = 0; i < 3; i++ )
    {
        if (unicode)
        {
            fieldW = pSetupGetFieldW( &context, i );
            ok( fieldW != NULL, "Failed to get field %i\n", i );
            ok( !lstrcmpW( getfield_resW[i], fieldW ), "Wrong string returned\n" );
        }
        else
        {
            fieldA = pSetupGetFieldA( &context, i );
            ok( fieldA != NULL, "Failed to get field %i\n", i );
            ok( !lstrcmpA( getfield_resA[i], fieldA ), "Wrong string returned\n" );
        }
    }
 
    if (unicode)
    {
        fieldW = pSetupGetFieldW( &context, 3 );
        ok( fieldW != NULL, "Failed to get field 3\n" );
        len = lstrlenW( fieldW );
        ok( len == 511 || /* NT4, W2K, XP and W2K3 */
            len == 4096,  /* Vista */
            "Unexpected length, got %d\n", len );
 
        fieldW = pSetupGetFieldW( &context, 4 );
        ok( fieldW == NULL, "Expected NULL, got %p\n", fieldW );
        ok( GetLastError() == ERROR_INVALID_PARAMETER,
            "Expected ERROR_INVALID_PARAMETER, got %u\n", GetLastError() );
    }
    else
    {
        fieldA = pSetupGetFieldA( &context, 3 );
        ok( fieldA != NULL, "Failed to get field 3\n" );
        len = lstrlenA( fieldA );
        ok( len == 511, /* Win9x, WinME */
            "Unexpected length, got %d\n", len );
 
        fieldA = pSetupGetFieldA( &context, 4 );
        ok( fieldA == NULL, "Expected NULL, got %p\n", fieldA );
        ok( GetLastError() == ERROR_INVALID_PARAMETER,
            "Expected ERROR_INVALID_PARAMETER, got %u\n", GetLastError() );
    }
 
    SetupCloseInfFile( hinf );
}

Referenced by START_TEST().

test_section_names()

static void test_section_names ( void  )

static

Definition at line 225 of file parser.c.

{
    unsigned int i;
    UINT err_line;
    HINF hinf;
    DWORD err;
    LONG ret;
 
    for (i = 0; i < ARRAY_SIZE(section_names); i++)
    {
        SetLastError( 0xdeadbeef );
        hinf = test_file_contents( section_names[i].data, &err_line );
        ok( hinf != INVALID_HANDLE_VALUE, "line %u: open failed err %u\n", i, GetLastError() );
        if (hinf == INVALID_HANDLE_VALUE) continue;
 
        ret = SetupGetLineCountA( hinf, section_names[i].section );
        err = GetLastError();
        trace( "hinf=%p ret=%d err=0x%x\n", hinf, ret, err );
        if (ret != -1)
        {
            ok( !section_names[i].error, "line %u: section name %s found\n",
                i, section_names[i].section );
            ok( !err, "line %u: bad error code %u\n", i, err );
        }
        else
        {
            ok( section_names[i].error, "line %u: section name %s not found\n",
                i, section_names[i].section );
            ok( err == section_names[i].error, "line %u: bad error %u/%u\n",
                i, err, section_names[i].error );
        }
        SetupCloseInfFile( hinf );
    }
}

Referenced by START_TEST().

test_SetupGetIntField()

static void test_SetupGetIntField ( void  )

static

Definition at line 608 of file parser.c.

{
    static const struct
    {
        const char *key;
        const char *fields;
        DWORD index;
        INT value;
        DWORD err;
    } keys[] =
    {
    /* key     fields            index   expected int  errorcode */
    {  "Key", "48",             1,      48,           ERROR_SUCCESS },
    {  "Key", "48",             0,      -1,           ERROR_INVALID_DATA },
    {  "123", "48",             0,      123,          ERROR_SUCCESS },
    {  "Key", "0x4",            1,      4,            ERROR_SUCCESS },
    {  "Key", "Field1",         1,      -1,           ERROR_INVALID_DATA },
    {  "Key", "Field1,34",      2,      34,           ERROR_SUCCESS },
    {  "Key", "Field1,,Field3", 2,      0,            ERROR_SUCCESS },
    {  "Key", "Field1,",        2,      0,            ERROR_SUCCESS }
    };
    unsigned int i;
 
    for (i = 0; i < ARRAY_SIZE(keys); i++)
    {
        HINF hinf;
        char buffer[MAX_INF_STRING_LENGTH];
        INFCONTEXT context;
        UINT err;
        BOOL retb;
        INT intfield;
 
        strcpy( buffer, STD_HEADER "[TestSection]\n" );
        strcat( buffer, keys[i].key );
        strcat( buffer, "=" );
        strcat( buffer, keys[i].fields );
        hinf = test_file_contents( buffer, &err);
        ok( hinf != NULL, "Expected valid INF file\n" );
 
        SetupFindFirstLineA( hinf, "TestSection", keys[i].key, &context );
        SetLastError( 0xdeadbeef );
        intfield = -1;
        retb = SetupGetIntField( &context, keys[i].index, &intfield );
        if ( keys[i].err == ERROR_SUCCESS )
        {
            ok( retb, "%u: Expected success\n", i );
            ok( GetLastError() == ERROR_SUCCESS ||
                GetLastError() == 0xdeadbeef /* win9x, NT4 */,
                "%u: Expected ERROR_SUCCESS or 0xdeadbeef, got %u\n", i, GetLastError() );
        }
        else
        {
            ok( !retb, "%u: Expected failure\n", i );
            ok( GetLastError() == keys[i].err,
                "%u: Expected %d, got %u\n", i, keys[i].err, GetLastError() );
        }
        ok( intfield == keys[i].value, "%u: Expected %d, got %d\n", i, keys[i].value, intfield );
 
        SetupCloseInfFile( hinf );
    }
}

Referenced by START_TEST().

Variable Documentation

buffer

UINT PSTR buffer

Definition at line 36 of file parser.c.

contents

const char* contents

static

Initial value:

= "[Version]\n"
                              "Signature=\"$Windows NT$\"\n"
                              "FileVersion=5.1.1.2\n"
                              "[FileBranchInfo]\n"
                              "RTMQFE=\"%RTMGFE_NAME%\",SP1RTM,"A4097"\n"
                              "[Strings]\n"
                              "RTMQFE_NAME = \"RTMQFE\"\n"

Definition at line 511 of file parser.c.

Referenced by create_cdf_file(), create_stream(), D3DReadFileToBlob(), DataCacheEntry_Save(), DoReadAllOfFile(), import_reg(), CZipCreatorImpl::JustDoIt(), makeFile(), merge_old_directory_into_tree(), save_dib(), save_emf(), save_mfpict(), test__hwrite(), test__lwrite(), test_create_file_imp(), test_enum_sections(), test_profile_delete_on_close(), test_pSetupGetField(), test_read_write(), tmp_fill_segdir_seg(), write_reg_file(), and xwin_toggle_fullscreen().

data

const char* data

Definition at line 104 of file parser.c.

DWORD

DWORD

Definition at line 34 of file parser.c.

err_line

UINT err_line

Definition at line 106 of file parser.c.

Referenced by inf_open_file_content(), test_file_contents(), test_invalid_files(), test_key_names(), test_section_names(), test_SetupAddInstallSectionToDiskSpaceListA(), and test_SetupAddSectionToDiskSpaceListA().

error

return error = FT_THROW( Invalid_CharMap_Format )

Definition at line 105 of file parser.c.

fields

const char* fields[10]

Definition at line 313 of file parser.c.

Referenced by fields_memsize(), find_array_or_string_in_struct(), find_identifier(), FT_Stream_ReadFields(), get_padding(), get_struct_fc(), MSI_CreateRecord(), msi_query_merge_record(), pcf_get_metric(), test_DeviceCapabilities(), test_key_names(), test_SetupGetIntField(), type_buffer_alignment(), type_has_full_pointer(), type_has_pointers(), type_new_nonencapsulated_union(), type_new_struct(), union_memsize(), write_conf_or_var_desc(), write_fields(), write_struct_members(), write_struct_tfs(), and write_union_tfs().

getfield_resA

const CHAR getfield_resA[][20]

static

Initial value:

=
{
    "RTMQFE",
    "%RTMGFE_NAME%",
    "SP1RTM",
}

Definition at line 519 of file parser.c.

Referenced by test_pSetupGetField().

getfield_resW

const WCHAR getfield_resW[][20]

static

Initial value:

=
{
    {'R','T','M','Q','F','E',0},
    {'%','R','T','M','G','F','E','_','N','A','M','E','%',0},
    {'S','P','1','R','T','M',0},
}

Definition at line 526 of file parser.c.

Referenced by test_pSetupGetField().

hSetupAPI

HMODULE hSetupAPI

static

Definition at line 33 of file parser.c.

Referenced by init_function_pointers().

index

UINT index

Definition at line 36 of file parser.c.

const struct { ... } invalid_files[]

Referenced by test_invalid_files().

key

const char* key

Definition at line 312 of file parser.c.

Referenced by check_key(), and test_SetupGetIntField().

const struct { ... } key_names[]

Referenced by test_key_names().

need

UINT PSTR DWORD UINT* need

Definition at line 36 of file parser.c.

Referenced by buffered_fullread(), mbedtls_ssl_chk_buf_ptr(), ME_StreamInText(), SetupEnumInfSectionsA(), SetupEnumInfSectionsW(), translate_data_def(), and ZSTD_decodeLiteralsBlock().

section

const char* section

Definition at line 191 of file parser.c.

const struct { ... } section_names[]

Referenced by test_section_names().

size

UINT PSTR DWORD size

Definition at line 36 of file parser.c.

Referenced by xmlParseBalancedChunkMemoryInternal().

tmpfilename

const char tmpfilename[] = ".\\tmp.inf"

static

Definition at line 49 of file parser.c.

Referenced by inf_open_file_content(), START_TEST(), test_file_contents(), test_ok(), test_SetupAddInstallSectionToDiskSpaceListA(), and test_SetupAddSectionToDiskSpaceListA().

todo

BOOL todo

Definition at line 107 of file parser.c.

Referenced by test_invalid_files().