| /* | |
| * 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%lx 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 %lu/%lu\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 %lu\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 %lu\n", i, GetLastError() ); | |
| if (hinf == INVALID_HANDLE_VALUE) continue; | |
| ret = SetupGetLineCountA( hinf, section_names[i].section ); | |
| err = GetLastError(); | |
| trace( "hinf=%p ret=%ld err=0x%lx\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 %lu\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 %lu/%lu\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; | |
| HINF hinf; | |
| UINT err, index, len; | |
| 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 %lu\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 %lu\n", err ); | |
| } | |
| else | |
| { | |
| ok( !strcmp( key, wanted ), "bad key %s/%s\n", key, wanted ); | |
| ok( err == 0, "last error set to %lu\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 %lu\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 %lu\n", GetLastError()); | |
| } | |
| ret = SetupFindFirstLineA( hinf, "Test", 0, &context ); | |
| ok(ret, "SetupFindFirstLineA failed: le=%lu\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 %lu\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 %lu\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 %lu\n", GetLastError()); | |
| SetLastError(0xdeadbeef); | |
| SetupCloseInfFile(INVALID_HANDLE_VALUE); | |
| ok(GetLastError() == 0xdeadbeef || | |
| GetLastError() == ERROR_INVALID_PARAMETER, /* Win9x, WinMe */ | |
| "Expected 0xdeadbeef, got %lu\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 %lu\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 %lu\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 %lu\n", i, GetLastError() ); | |
| } | |
| else | |
| { | |
| ok( !retb, "%u: Expected failure\n", i ); | |
| ok( GetLastError() == keys[i].err, | |
| "%u: Expected %ld, got %lu\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 %08lx\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 %08lx\n", GetLastError()); | |
| SetLastError(0xdeadbeef); | |
| retb = SetupFindFirstLineA( hinf, "Sectionname", NULL, &context ); | |
| ok(retb, "Expected success\n"); | |
| ok(GetLastError() == ERROR_SUCCESS, | |
| "Expected ERROR_SUCCESS, got %08lx\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 %08lx\n", GetLastError()); | |
| SetLastError(0xdeadbeef); | |
| retb = SetupFindFirstLineA( hinf, "Sectionname", "Keyname1", &context ); | |
| ok(retb, "Expected success\n"); | |
| ok(GetLastError() == ERROR_SUCCESS, | |
| "Expected ERROR_SUCCESS, got %08lx\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 %08lx\n", GetLastError()); | |
| SetLastError(0xdeadbeef); | |
| retb = SetupFindNextMatchLineA( &context, "Keyname2", &context ); | |
| ok(retb, "Expected success\n"); | |
| ok(GetLastError() == ERROR_SUCCESS, | |
| "Expected ERROR_SUCCESS, got %08lx\n", GetLastError()); | |
| SetLastError(0xdeadbeef); | |
| retl = SetupGetLineCountA( hinf, "ImNotThere"); | |
| ok(retl == -1, "Expected -1, got %ld\n", retl); | |
| ok(GetLastError() == ERROR_SECTION_NOT_FOUND, | |
| "Expected ERROR_SECTION_NOT_FOUND, got %08lx\n", GetLastError()); | |
| SetLastError(0xdeadbeef); | |
| retl = SetupGetLineCountA( hinf, "Sectionname"); | |
| ok(retl == 2, "Expected 2, got %ld\n", retl); | |
| ok(GetLastError() == ERROR_SUCCESS, | |
| "Expected ERROR_SUCCESS, got %08lx\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 %08lx\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 %08lx\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 %08lx\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 %08lx\n", GetLastError()); | |
| SetLastError(0xdeadbeef); | |
| retb = SetupGetLineByIndexA( hinf, "Sectionname", 1, &context ); | |
| ok(retb, "Expected success\n"); | |
| ok(GetLastError() == ERROR_SUCCESS, | |
| "Expected ERROR_SUCCESS, got %08lx\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 %08lx\n", GetLastError()); | |
| SetupCloseInfFile( hinf ); | |
| } | |
| static void test_SetupGetBinaryField(void) | |
| { | |
| static const char inf[] = | |
| "[Version]\n" | |
| "Signature=\"$Windows NT$\"\n" | |
| "[section]\n" | |
| "key1=0,11,022,0xaA,0x0Ff\n" | |
| "key2=123\n"; | |
| INFCONTEXT context; | |
| BYTE buffer[6]; | |
| DWORD size; | |
| HINF hinf; | |
| UINT err; | |
| BOOL ret; | |
| hinf = test_file_contents(inf, strlen(inf), &err); | |
| ok(hinf != NULL, "Expected valid INF file\n"); | |
| ret = SetupFindFirstLineA(hinf, "section", "key1", &context); | |
| ok(ret == TRUE, "got error %lu\n", GetLastError()); | |
| memset(buffer, 0xcc, sizeof(buffer)); | |
| size = 0xdeadbeef; | |
| ret = SetupGetBinaryField(&context, 2, buffer, 0, &size); | |
| ok(!ret, "got %d\n", ret); | |
| ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got error %lu\n", GetLastError()); | |
| ok(size == 4, "got size %lu\n", size); | |
| ok(buffer[0] == 0xcc, "got %#x\n", buffer[0]); | |
| memset(buffer, 0xcc, sizeof(buffer)); | |
| size = 0xdeadbeef; | |
| ret = SetupGetBinaryField(&context, 2, buffer, 3, &size); | |
| ok(!ret, "got %d\n", ret); | |
| ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got error %lu\n", GetLastError()); | |
| ok(size == 4, "got size %lu\n", size); | |
| ok(buffer[0] == 0xcc, "got %#x\n", buffer[0]); | |
| memset(buffer, 0xcc, sizeof(buffer)); | |
| size = 0xdeadbeef; | |
| ret = SetupGetBinaryField(&context, 2, buffer, 4, &size); | |
| ok(ret == TRUE, "got %d\n", ret); | |
| todo_wine ok(!GetLastError(), "got error %lu\n", GetLastError()); | |
| ok(size == 4, "got size %lu\n", size); | |
| ok(buffer[0] == 0x11, "got %#x\n", buffer[0]); | |
| ok(buffer[1] == 0x22, "got %#x\n", buffer[1]); | |
| ok(buffer[2] == 0xaa, "got %#x\n", buffer[2]); | |
| ok(buffer[3] == 0xff, "got %#x\n", buffer[3]); | |
| ret = SetupFindFirstLineA(hinf, "section", "key2", &context); | |
| ok(ret == TRUE, "got error %lu\n", GetLastError()); | |
| memset(buffer, 0xcc, sizeof(buffer)); | |
| size = 0xdeadbeef; | |
| ret = SetupGetBinaryField(&context, 1, buffer, 0, &size); | |
| ok(!ret, "got %d\n", ret); | |
| todo_wine ok(GetLastError() == ERROR_INVALID_DATA, "got error %lu\n", GetLastError()); | |
| todo_wine ok(size == 0xdeadbeef, "got size %lu\n", size); | |
| ok(buffer[0] == 0xcc, "got %#x\n", buffer[0]); | |
| 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(); | |
| test_SetupGetBinaryField(); | |
| DeleteFileA( tmpfilename ); | |
| } |