822 lines
34 KiB
C
822 lines
34 KiB
C
/*
|
|
* INF file parsing tests
|
|
*
|
|
* Copyright 2002, 2005 Alexandre Julliard for CodeWeavers
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#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"
|
|
|
|
/* function pointers */
|
|
static HMODULE hSetupAPI;
|
|
static LPCSTR (WINAPI *pSetupGetFieldA)(PINFCONTEXT,DWORD);
|
|
static LPCWSTR (WINAPI *pSetupGetFieldW)(PINFCONTEXT,DWORD);
|
|
static BOOL (WINAPI *pSetupEnumInfSectionsA)( HINF hinf, UINT index, PSTR buffer, DWORD size, UINT *need );
|
|
|
|
static void init_function_pointers(void)
|
|
{
|
|
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" );
|
|
}
|
|
|
|
static const char tmpfilename[] = ".\\tmp.inf";
|
|
|
|
/* some large strings */
|
|
#define A255 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" \
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" \
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" \
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
#define A256 "a" A255
|
|
#define A400 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" \
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" \
|
|
"aaaaaaaaaaaaaaaa" A256
|
|
#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 "[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"
|
|
|
|
/* create a new file with specified contents and open it */
|
|
static HINF test_file_contents( const char *data, int size, UINT *err_line )
|
|
{
|
|
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, size, &res, NULL )) trace( "write error\n" );
|
|
CloseHandle( handle );
|
|
return SetupOpenInfFileA( tmpfilename, 0, INF_STYLE_WIN4, err_line );
|
|
}
|
|
|
|
static const char *get_string_field( INFCONTEXT *context, DWORD index )
|
|
{
|
|
static char buffer[MAX_INF_STRING_LENGTH+32];
|
|
if (SetupGetStringFieldA( context, index, buffer, sizeof(buffer), NULL )) return buffer;
|
|
return NULL;
|
|
}
|
|
|
|
static const char *get_line_text( INFCONTEXT *context )
|
|
{
|
|
static char buffer[MAX_INF_STRING_LENGTH+32];
|
|
if (SetupGetLineTextA( context, 0, 0, 0, buffer, sizeof(buffer), NULL )) return buffer;
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/* Test various valid/invalid file formats */
|
|
|
|
static const struct
|
|
{
|
|
const char *data;
|
|
int data_size;
|
|
DWORD error;
|
|
UINT err_line;
|
|
BOOL todo;
|
|
} invalid_files[] =
|
|
{
|
|
#define C(s) s, sizeof(s)-1
|
|
/* file contents expected error (or 0) errline todo */
|
|
{ C("\r\n"), ERROR_WRONG_INF_STYLE, 0, FALSE },
|
|
{ C("abcd\r\n"), ERROR_WRONG_INF_STYLE, 0, TRUE },
|
|
{ C("[Version]\r\n"), ERROR_WRONG_INF_STYLE, 0, FALSE },
|
|
{ C("[Version]\nSignature="), ERROR_WRONG_INF_STYLE, 0, FALSE },
|
|
{ C("[Version]\nSignature=foo"), ERROR_WRONG_INF_STYLE, 0, FALSE },
|
|
{ C("[version]\nsignature=$chicago$"), 0, 0, FALSE },
|
|
{ C("[VERSION]\nSIGNATURE=$CHICAGO$"), 0, 0, FALSE },
|
|
{ C("[Version]\nSignature=$chicago$,abcd"), 0, 0, FALSE },
|
|
{ C("[Version]\nabc=def\nSignature=$chicago$"), 0, 0, FALSE },
|
|
{ C("[Version]\nabc=def\n[Version]\nSignature=$chicago$"), 0, 0, FALSE },
|
|
{ C(STD_HEADER), 0, 0, FALSE },
|
|
{ C(STD_HEADER "[]\r\n"), 0, 0, FALSE },
|
|
{ C(STD_HEADER "]\r\n"), 0, 0, FALSE },
|
|
{ C(STD_HEADER "[" A255 "]\r\n"), 0, 0, FALSE },
|
|
{ C(STD_HEADER "[ab\r\n"), ERROR_BAD_SECTION_NAME_LINE, 3, FALSE },
|
|
{ C(STD_HEADER "\n\n[ab\x1a]\n"), ERROR_BAD_SECTION_NAME_LINE, 5, FALSE },
|
|
{ C(STD_HEADER "[" A256 "]\r\n"), ERROR_SECTION_NAME_TOO_LONG, 3, FALSE },
|
|
{ C("[abc]\n" STD_HEADER), 0, 0, FALSE },
|
|
{ C("abc\r\n" STD_HEADER), ERROR_EXPECTED_SECTION_NAME, 1, FALSE },
|
|
{ C(";\n;\nabc\r\n" STD_HEADER), ERROR_EXPECTED_SECTION_NAME, 3, FALSE },
|
|
{ C(";\n;\nab\nab\n" STD_HEADER), ERROR_EXPECTED_SECTION_NAME, 3, FALSE },
|
|
{ C(";aa\n;bb\n" STD_HEADER), 0, 0, FALSE },
|
|
{ C(STD_HEADER " [TestSection\x00]\n"), 0, 0, TRUE },
|
|
{ C(STD_HEADER " [Test\x00Section]\n"), 0, 0, TRUE },
|
|
{ C(STD_HEADER " [TestSection\x00]\n"), 0, 0, TRUE },
|
|
{ C(STD_HEADER " [Test\x00Section]\n"), 0, 0, TRUE },
|
|
{ C("garbage1\ngarbage2\n[abc]\n" STD_HEADER), ERROR_EXPECTED_SECTION_NAME, 1, FALSE },
|
|
{ C("garbage1\ngarbage2\n[Strings]\n" STD_HEADER), 0, 0, FALSE },
|
|
{ C(";comment\ngarbage1\ngarbage2\n[abc]\n" STD_HEADER), ERROR_EXPECTED_SECTION_NAME, 2, FALSE },
|
|
{ C(";comment\ngarbage1\ngarbage2\n[Strings]\n" STD_HEADER), 0, 0, FALSE },
|
|
{ C(" \t\ngarbage1\ngarbage2\n[abc]\n" STD_HEADER), ERROR_EXPECTED_SECTION_NAME, 2, FALSE },
|
|
{ C(" \t\ngarbage1\ngarbage2\n[Strings]\n" STD_HEADER), 0, 0, FALSE },
|
|
{ C("garbage1\ngarbage2\n" STD_HEADER "[abc]\n"), ERROR_EXPECTED_SECTION_NAME, 1, FALSE },
|
|
{ C("garbage1\ngarbage2\n" STD_HEADER "[Strings]\n"), 0, 0, FALSE },
|
|
{ C(";comment\ngarbage1\ngarbage2\n" STD_HEADER "[abc]\n"), ERROR_EXPECTED_SECTION_NAME, 2, FALSE },
|
|
{ C(";comment\ngarbage1\ngarbage2\n" STD_HEADER "[Strings]\n"), 0, 0, FALSE },
|
|
{ C(" \t\ngarbage1\ngarbage2\n" STD_HEADER "[abc]\n"), ERROR_EXPECTED_SECTION_NAME, 2, FALSE },
|
|
{ C(" \t\ngarbage1\ngarbage2\n" STD_HEADER "[Strings]\n"), 0, 0, FALSE },
|
|
#undef C
|
|
};
|
|
|
|
static void test_invalid_files(void)
|
|
{
|
|
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, invalid_files[i].data_size, &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 */
|
|
{
|
|
todo_wine_if (invalid_files[i].todo)
|
|
{
|
|
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 );
|
|
}
|
|
}
|
|
|
|
|
|
/* Test various section names */
|
|
|
|
static const struct
|
|
{
|
|
const char *data;
|
|
const char *section;
|
|
DWORD error;
|
|
} section_names[] =
|
|
{
|
|
/* file contents section name error code */
|
|
{ STD_HEADER "[TestSection]", "TestSection", 0 },
|
|
{ STD_HEADER "[TestSection]\n", "TestSection", 0 },
|
|
{ STD_HEADER "[TESTSECTION]\r\n", "TestSection", 0 },
|
|
{ STD_HEADER "[TestSection]\n[abc]", "testsection", 0 },
|
|
{ STD_HEADER ";[TestSection]\n", "TestSection", ERROR_SECTION_NOT_FOUND },
|
|
{ STD_HEADER "[TestSection]\n", "Bad name", ERROR_SECTION_NOT_FOUND },
|
|
/* spaces */
|
|
{ STD_HEADER "[TestSection] \r\n", "TestSection", 0 },
|
|
{ STD_HEADER " [TestSection]\r\n", "TestSection", 0 },
|
|
{ STD_HEADER " [TestSection] dummy\r\n", "TestSection", 0 },
|
|
{ STD_HEADER " [TestSection] [foo]\r\n", "TestSection", 0 },
|
|
{ STD_HEADER " [ Test Section ] dummy\r\n", " Test Section ", 0 },
|
|
{ STD_HEADER "[TestSection] \032\ndummy", "TestSection", 0 },
|
|
{ STD_HEADER "[TestSection] \n\032dummy", "TestSection", 0 },
|
|
/* special chars in section name */
|
|
{ STD_HEADER "[Test[Section]\r\n", "Test[Section", 0 },
|
|
{ STD_HEADER "[Test[S]ection]\r\n", "Test[S", 0 },
|
|
{ STD_HEADER "[Test[[[Section]\r\n", "Test[[[Section", 0 },
|
|
{ STD_HEADER "[]\r\n", "", 0 },
|
|
{ STD_HEADER "[[[]\n", "[[", 0 },
|
|
{ STD_HEADER "[Test\"Section]\r\n", "Test\"Section", 0 },
|
|
{ STD_HEADER "[Test\\Section]\r\n", "Test\\Section", 0 },
|
|
{ STD_HEADER "[Test\\ Section]\r\n", "Test\\ Section", 0 },
|
|
{ STD_HEADER "[Test;Section]\r\n", "Test;Section", 0 },
|
|
/* various control chars */
|
|
{ STD_HEADER " [Test\r\b\tSection] \n", "Test\r\b\tSection", 0 },
|
|
/* nulls */
|
|
};
|
|
|
|
static void test_section_names(void)
|
|
{
|
|
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, strlen(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 );
|
|
}
|
|
}
|
|
|
|
static void test_enum_sections(void)
|
|
{
|
|
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, strlen(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 );
|
|
}
|
|
|
|
|
|
/* Test various key and value names */
|
|
|
|
static const struct
|
|
{
|
|
const char *data;
|
|
int data_size;
|
|
const char *key;
|
|
const char *fields[10];
|
|
} key_names[] =
|
|
{
|
|
#define C(s) s, sizeof(s)-1
|
|
/* file contents expected key expected fields */
|
|
{ C("ab=cd"), "ab", { "cd" } },
|
|
{ C("ab=cd,ef,gh,ij"), "ab", { "cd", "ef", "gh", "ij" } },
|
|
{ C("ab"), "ab", { "ab" } },
|
|
{ C("ab,cd"), NULL, { "ab", "cd" } },
|
|
{ C("ab,cd=ef"), NULL, { "ab", "cd=ef" } },
|
|
{ C("=abcd,ef"), "", { "abcd", "ef" } },
|
|
/* backslashes */
|
|
{ C("ba\\\ncd=ef"), "bacd", { "ef" } },
|
|
{ C("ab \\ \ncd=ef"), "abcd", { "ef" } },
|
|
{ C("ab\\\ncd,ef"), NULL, { "abcd", "ef" } },
|
|
{ C("ab \\ ;cc\ncd=ef"), "abcd", { "ef" } },
|
|
{ C("ab \\ \\ \ncd=ef"), "abcd", { "ef" } },
|
|
{ C("ba \\ dc=xx"), "ba \\ dc", { "xx" } },
|
|
{ C("ba \\\\ \nc=d"), "bac", { "d" } },
|
|
{ C("a=b\\\\c"), "a", { "b\\\\c" } },
|
|
{ C("ab=cd \\ "), "ab", { "cd" } },
|
|
{ C("ba=c \\ \n \\ \n a"), "ba", { "ca" } },
|
|
{ C("ba=c \\ \n \\ a"), "ba", { "c\\ a" } },
|
|
{ C(" \\ a= \\ b"), "\\ a", { "\\ b" } },
|
|
/* quotes */
|
|
{ C("Ab\"Cd\"=Ef"), "AbCd", { "Ef" } },
|
|
{ C("Ab\"Cd=Ef\""), "AbCd=Ef", { "AbCd=Ef" } },
|
|
{ C("ab\"\"\"cd,ef=gh\""), "ab\"cd,ef=gh", { "ab\"cd,ef=gh" } },
|
|
{ C("ab\"\"cd=ef"), "abcd", { "ef" } },
|
|
{ C("ab\"\"cd=ef,gh"), "abcd", { "ef", "gh" } },
|
|
{ C("ab=cd\"\"ef"), "ab", { "cdef" } },
|
|
{ C("ab=cd\",\"ef"), "ab", { "cd,ef" } },
|
|
{ C("ab=cd\",ef"), "ab", { "cd,ef" } },
|
|
{ C("ab=cd\",ef\\\nab"), "ab", { "cd,ef\\" } },
|
|
|
|
/* single quotes (unhandled)*/
|
|
{ C("HKLM,A,B,'C',D"), NULL, { "HKLM", "A","B","'C'","D" } },
|
|
/* spaces */
|
|
{ C(" a b = c , d \n"), "a b", { "c", "d" } },
|
|
{ C(" a b = c ,\" d\" \n"), "a b", { "c", " d" } },
|
|
{ C(" a b\r = c\r\n"), "a b", { "c" } },
|
|
/* empty fields */
|
|
{ C("a=b,,,c,,,d"), "a", { "b", "", "", "c", "", "", "d" } },
|
|
{ C("a=b,\"\",c,\" \",d"), "a", { "b", "", "c", " ", "d" } },
|
|
{ C("=,,b"), "", { "", "", "b" } },
|
|
{ C(",=,,b"), NULL, { "", "=", "", "b" } },
|
|
{ C("a=\n"), "a", { "" } },
|
|
{ C("="), "", { "" } },
|
|
/* eof */
|
|
{ C("ab=c\032d"), "ab", { "c" } },
|
|
{ C("ab\032=cd"), "ab", { "ab" } },
|
|
/* nulls */
|
|
{ C("abcd=ef\x0gh"), "abcd", { "ef gh" } },
|
|
{ C("foo=%bar%\n[Strings]\nbar=bbb\0\n"), "foo", { "bbb" } },
|
|
{ C("foo=%bar%\n[Strings]\nbar=bbb \0\n"), "foo", { "bbb" } },
|
|
{ C("foo=%bar%\n[Strings]\nbar=aaa\0bbb \0\n"), "foo", { "aaa bbb" } },
|
|
/* multiple sections with same name */
|
|
{ C("[Test2]\nab\n[Test]\nee=ff\n"), "ee", { "ff" } },
|
|
/* string substitution */
|
|
{ C("%foo%=%bar%\n" STR_SECTION), "aaa", { "bbb" } },
|
|
{ C("%foo%xx=%bar%yy\n" STR_SECTION), "aaaxx", { "bbbyy" } },
|
|
{ C("%% %foo%=%bar%\n" STR_SECTION), "% aaa", { "bbb" } },
|
|
{ C("%f\"o\"o%=ccc\n" STR_SECTION), "aaa", { "ccc" } },
|
|
{ C("abc=%bar;bla%\n" STR_SECTION), "abc", { "%bar" } },
|
|
{ C("loop=%loop%\n" STR_SECTION), "loop", { "%loop2%" } },
|
|
{ C("%per%%cent%=100\n" STR_SECTION), "12", { "100" } },
|
|
{ C("a=%big%\n" STR_SECTION), "a", { A400 } },
|
|
{ C("a=%verybig%\n" STR_SECTION), "a", { A511 } }, /* truncated to 511, not on Vista/W2K8 */
|
|
{ C("a=%big%%big%%big%%big%\n" STR_SECTION), "a", { A400 A400 A400 A400 } },
|
|
{ C("a=%big%%big%%big%%big%%big%%big%%big%%big%%big%\n" STR_SECTION), "a", { A400 A400 A400 A400 A400 A400 A400 A400 A400 } },
|
|
{ C("a=%big%%big%%big%%big%%big%%big%%big%%big%%big%%big%%big%\n" STR_SECTION), "a", { A4097 /*MAX_INF_STRING_LENGTH+1*/ } },
|
|
|
|
/* Prove expansion of system entries removes extra \'s and string
|
|
replacements doesn't */
|
|
{ C("ab=\"%24%\"\n" STR_SECTION), "ab", { "C:\\" } },
|
|
{ C("ab=\"%mydrive%\"\n" STR_SECTION), "ab", { "C:\\" } },
|
|
{ C("ab=\"%24%\\fred\"\n" STR_SECTION), "ab", { "C:\\fred" } },
|
|
{ C("ab=\"%mydrive%\\fred\"\n" STR_SECTION),"ab", { "C:\\\\fred" } },
|
|
/* Confirm duplicate \'s kept */
|
|
{ C("ab=\"%24%\\\\fred\""), "ab", { "C:\\\\fred" } },
|
|
{ C("ab=C:\\\\FRED"), "ab", { "C:\\\\FRED" } },
|
|
};
|
|
|
|
/* check the key of a certain line */
|
|
static const char *check_key( INFCONTEXT *context, const char *wanted )
|
|
{
|
|
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;
|
|
}
|
|
|
|
static void test_key_names(void)
|
|
{
|
|
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++)
|
|
{
|
|
int data_size;
|
|
|
|
strcpy( buffer, STD_HEADER "[Test]\n" );
|
|
data_size = strlen(buffer);
|
|
memcpy( buffer + data_size, key_names[i].data, key_names[i].data_size );
|
|
data_size += key_names[i].data_size;
|
|
SetLastError( 0xdeadbeef );
|
|
hinf = test_file_contents( buffer, data_size, &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", key_names[i].key, &context );
|
|
ok(ret, "Test %d: failed to find key %s\n", i, key_names[i].key);
|
|
|
|
if (!strncmp( key_names[i].data, "%foo%", strlen( "%foo%" ) ))
|
|
{
|
|
ret = SetupFindFirstLineA( hinf, "Test", "%foo%", &context );
|
|
ok(!ret, "SetupFindFirstLine() should not match unsubstituted keys\n");
|
|
ok(GetLastError() == ERROR_LINE_NOT_FOUND, "got wrong error %u\n", GetLastError());
|
|
}
|
|
|
|
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 == 52)
|
|
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 == 55)
|
|
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 );
|
|
}
|
|
|
|
}
|
|
|
|
static void test_close_inf_file(void)
|
|
{
|
|
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());
|
|
}
|
|
|
|
static const char *contents = "[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";
|
|
|
|
static const CHAR getfield_resA[][20] =
|
|
{
|
|
"RTMQFE",
|
|
"%RTMGFE_NAME%",
|
|
"SP1RTM",
|
|
};
|
|
|
|
static const WCHAR getfield_resW[][20] =
|
|
{
|
|
{'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},
|
|
};
|
|
|
|
static void test_pSetupGetField(void)
|
|
{
|
|
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, strlen(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 );
|
|
}
|
|
|
|
static void test_SetupGetIntField(void)
|
|
{
|
|
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, strlen(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 );
|
|
}
|
|
}
|
|
|
|
static void test_GLE(void)
|
|
{
|
|
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, strlen(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 );
|
|
}
|
|
|
|
START_TEST(parser)
|
|
{
|
|
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 );
|
|
}
|