git.oblomov.eu Git - wine/blob - dlls/iphlpapi/tests/iphlpapi.c

   1 /*
   2  * iphlpapi dll test
   3  *
   4  * Copyright (C) 2003 Juan Lang
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 /*
  22  * Some observations that an automated test can't produce:
  23  * An adapter index is a key for an adapter.  That is, if an index is returned
  24  * from one API, that same index may be used successfully in another API, as
  25  * long as the adapter remains present.
  26  * If the adapter is removed and reinserted, however, the index may change (and
  27  * indeed it does change on Win2K).
  28  *
  29  * The Name field of the IP_ADAPTER_INDEX_MAP entries returned by
  30  * GetInterfaceInfo is declared as a wide string, but the bytes are actually
  31  * an ASCII string on some versions of the IP helper API under Win9x.  This was
  32  * apparently an MS bug, it's corrected in later versions.
  33  *
  34  * The DomainName field of FIXED_INFO isn't NULL-terminated on Win98.
  35  */
  36
  37 #include <stdarg.h>
  38 #include "windef.h"
  39 #include "winbase.h"
  40 #include "iphlpapi.h"
  41 #include "iprtrmib.h"
  42 #include "wine/test.h"
  43 #include <stdio.h>
  44 #include <stdlib.h>
  45
  46 static HMODULE hLibrary = NULL;
  47
  48 typedef DWORD (WINAPI *GetNumberOfInterfacesFunc)(PDWORD);
  49 typedef DWORD (WINAPI *GetIpAddrTableFunc)(PMIB_IPADDRTABLE,PULONG,BOOL);
  50 typedef DWORD (WINAPI *GetIfEntryFunc)(PMIB_IFROW);
  51 typedef DWORD (WINAPI *GetFriendlyIfIndexFunc)(DWORD);
  52 typedef DWORD (WINAPI *GetIfTableFunc)(PMIB_IFTABLE,PULONG,BOOL);
  53 typedef DWORD (WINAPI *GetIpForwardTableFunc)(PMIB_IPFORWARDTABLE,PULONG,BOOL);
  54 typedef DWORD (WINAPI *GetIpNetTableFunc)(PMIB_IPNETTABLE,PULONG,BOOL);
  55 typedef DWORD (WINAPI *GetInterfaceInfoFunc)(PIP_INTERFACE_INFO,PULONG);
  56 typedef DWORD (WINAPI *GetAdaptersInfoFunc)(PIP_ADAPTER_INFO,PULONG);
  57 typedef DWORD (WINAPI *GetNetworkParamsFunc)(PFIXED_INFO,PULONG);
  58 typedef DWORD (WINAPI *GetIcmpStatisticsFunc)(PMIB_ICMP);
  59 typedef DWORD (WINAPI *GetIpStatisticsFunc)(PMIB_IPSTATS);
  60 typedef DWORD (WINAPI *GetTcpStatisticsFunc)(PMIB_TCPSTATS);
  61 typedef DWORD (WINAPI *GetUdpStatisticsFunc)(PMIB_UDPSTATS);
  62 typedef DWORD (WINAPI *GetTcpTableFunc)(PMIB_TCPTABLE,PDWORD,BOOL);
  63 typedef DWORD (WINAPI *GetUdpTableFunc)(PMIB_UDPTABLE,PDWORD,BOOL);
  64
  65 static GetNumberOfInterfacesFunc gGetNumberOfInterfaces = NULL;
  66 static GetIpAddrTableFunc gGetIpAddrTable = NULL;
  67 static GetIfEntryFunc gGetIfEntry = NULL;
  68 static GetFriendlyIfIndexFunc gGetFriendlyIfIndex = NULL;
  69 static GetIfTableFunc gGetIfTable = NULL;
  70 static GetIpForwardTableFunc gGetIpForwardTable = NULL;
  71 static GetIpNetTableFunc gGetIpNetTable = NULL;
  72 static GetInterfaceInfoFunc gGetInterfaceInfo = NULL;
  73 static GetAdaptersInfoFunc gGetAdaptersInfo = NULL;
  74 static GetNetworkParamsFunc gGetNetworkParams = NULL;
  75 static GetIcmpStatisticsFunc gGetIcmpStatistics = NULL;
  76 static GetIpStatisticsFunc gGetIpStatistics = NULL;
  77 static GetTcpStatisticsFunc gGetTcpStatistics = NULL;
  78 static GetUdpStatisticsFunc gGetUdpStatistics = NULL;
  79 static GetTcpTableFunc gGetTcpTable = NULL;
  80 static GetUdpTableFunc gGetUdpTable = NULL;
  81
  82 static void loadIPHlpApi(void)
  83 {
  84   hLibrary = LoadLibraryA("iphlpapi.dll");
  85   if (hLibrary) {
  86     gGetNumberOfInterfaces = (GetNumberOfInterfacesFunc)GetProcAddress(
  87      hLibrary, "GetNumberOfInterfaces");
  88     gGetIpAddrTable = (GetIpAddrTableFunc)GetProcAddress(
  89      hLibrary, "GetIpAddrTable");
  90     gGetIfEntry = (GetIfEntryFunc)GetProcAddress(
  91      hLibrary, "GetIfEntry");
  92     gGetFriendlyIfIndex = (GetFriendlyIfIndexFunc)GetProcAddress(
  93      hLibrary, "GetFriendlyIfIndex");
  94     gGetIfTable = (GetIfTableFunc)GetProcAddress(
  95      hLibrary, "GetIfTable");
  96     gGetIpForwardTable = (GetIpForwardTableFunc)GetProcAddress(
  97      hLibrary, "GetIpForwardTable");
  98     gGetIpNetTable = (GetIpNetTableFunc)GetProcAddress(
  99      hLibrary, "GetIpNetTable");
 100     gGetInterfaceInfo = (GetInterfaceInfoFunc)GetProcAddress(
 101      hLibrary, "GetInterfaceInfo");
 102     gGetAdaptersInfo = (GetAdaptersInfoFunc)GetProcAddress(
 103      hLibrary, "GetAdaptersInfo");
 104     gGetNetworkParams = (GetNetworkParamsFunc)GetProcAddress(
 105      hLibrary, "GetNetworkParams");
 106     gGetIcmpStatistics = (GetIcmpStatisticsFunc)GetProcAddress(
 107      hLibrary, "GetIcmpStatistics");
 108     gGetIpStatistics = (GetIpStatisticsFunc)GetProcAddress(
 109      hLibrary, "GetIpStatistics");
 110     gGetTcpStatistics = (GetTcpStatisticsFunc)GetProcAddress(
 111      hLibrary, "GetTcpStatistics");
 112     gGetUdpStatistics = (GetUdpStatisticsFunc)GetProcAddress(
 113      hLibrary, "GetUdpStatistics");
 114     gGetTcpTable = (GetTcpTableFunc)GetProcAddress(
 115      hLibrary, "GetTcpTable");
 116     gGetUdpTable = (GetUdpTableFunc)GetProcAddress(
 117      hLibrary, "GetUdpTable");
 118   }
 119 }
 120
 121 static void freeIPHlpApi(void)
 122 {
 123   if (hLibrary) {
 124     gGetNumberOfInterfaces = NULL;
 125     gGetIpAddrTable = NULL;
 126     gGetIfEntry = NULL;
 127     gGetFriendlyIfIndex = NULL;
 128     gGetIfTable = NULL;
 129     gGetIpForwardTable = NULL;
 130     gGetIpNetTable = NULL;
 131     gGetInterfaceInfo = NULL;
 132     gGetAdaptersInfo = NULL;
 133     gGetNetworkParams = NULL;
 134     gGetIcmpStatistics = NULL;
 135     gGetIpStatistics = NULL;
 136     gGetTcpStatistics = NULL;
 137     gGetUdpStatistics = NULL;
 138     gGetTcpTable = NULL;
 139     gGetUdpTable = NULL;
 140     FreeLibrary(hLibrary);
 141     hLibrary = NULL;
 142   }
 143 }
 144
 145 /*
 146 still-to-be-tested 98-only functions:
 147 GetUniDirectionalAdapterInfo
 148 */
 149 static void testWin98OnlyFunctions(void)
 150 {
 151 }
 152
 153 static void testGetNumberOfInterfaces(void)
 154 {
 155   if (gGetNumberOfInterfaces) {
 156     DWORD apiReturn, numInterfaces;
 157
 158     /* Crashes on Vista */
 159     if (0) {
 160       apiReturn = gGetNumberOfInterfaces(NULL), numInterfaces;
 161       if (apiReturn == ERROR_NOT_SUPPORTED)
 162         return;
 163       ok(apiReturn == ERROR_INVALID_PARAMETER,
 164        "GetNumberOfInterfaces(NULL) returned %d, expected ERROR_INVALID_PARAMETER\n",
 165        apiReturn);
 166     }
 167
 168     apiReturn = gGetNumberOfInterfaces(&numInterfaces);
 169     if (apiReturn == ERROR_NOT_SUPPORTED) {
 170       skip("GetNumberOfInterfaces is not supported\n");
 171       return;
 172     }
 173     ok(apiReturn == NO_ERROR,
 174      "GetNumberOfInterfaces returned %d, expected 0\n", apiReturn);
 175   }
 176 }
 177
 178 static void testGetIfEntry(DWORD index)
 179 {
 180   if (gGetIfEntry) {
 181     DWORD apiReturn;
 182     MIB_IFROW row;
 183
 184     memset(&row, 0, sizeof(row));
 185     apiReturn = gGetIfEntry(NULL);
 186     if (apiReturn == ERROR_NOT_SUPPORTED)
 187       return;
 188     ok(apiReturn == ERROR_INVALID_PARAMETER,
 189      "GetIfEntry(NULL) returned %d, expected ERROR_INVALID_PARAMETER\n",
 190      apiReturn);
 191     row.dwIndex = -1; /* hope that's always bogus! */
 192     apiReturn = gGetIfEntry(&row);
 193     ok(apiReturn == ERROR_INVALID_DATA ||
 194      apiReturn == ERROR_FILE_NOT_FOUND /* Vista */,
 195      "GetIfEntry(bogus row) returned %d, expected ERROR_INVALID_DATA or ERROR_FILE_NOT_FOUND\n",
 196      apiReturn);
 197     row.dwIndex = index;
 198     apiReturn = gGetIfEntry(&row);
 199     ok(apiReturn == NO_ERROR,
 200      "GetIfEntry returned %d, expected NO_ERROR\n", apiReturn);
 201   }
 202 }
 203
 204 static void testGetIpAddrTable(void)
 205 {
 206   if (gGetIpAddrTable) {
 207     DWORD apiReturn;
 208     ULONG dwSize = 0;
 209
 210     apiReturn = gGetIpAddrTable(NULL, NULL, FALSE);
 211     if (apiReturn == ERROR_NOT_SUPPORTED)
 212       return;
 213     ok(apiReturn == ERROR_INVALID_PARAMETER,
 214      "GetIpAddrTable(NULL, NULL, FALSE) returned %d, expected ERROR_INVALID_PARAMETER\n",
 215      apiReturn);
 216     apiReturn = gGetIpAddrTable(NULL, &dwSize, FALSE);
 217     ok(apiReturn == ERROR_INSUFFICIENT_BUFFER,
 218      "GetIpAddrTable(NULL, &dwSize, FALSE) returned %d, expected ERROR_INSUFFICIENT_BUFFER\n",
 219      apiReturn);
 220     if (apiReturn == ERROR_INSUFFICIENT_BUFFER) {
 221       PMIB_IPADDRTABLE buf = (PMIB_IPADDRTABLE)malloc(dwSize);
 222
 223       apiReturn = gGetIpAddrTable(buf, &dwSize, FALSE);
 224       ok(apiReturn == NO_ERROR,
 225        "GetIpAddrTable(buf, &dwSize, FALSE) returned %d, expected NO_ERROR\n",
 226        apiReturn);
 227       if (apiReturn == NO_ERROR && buf->dwNumEntries)
 228         testGetIfEntry(buf->table[0].dwIndex);
 229       free(buf);
 230     }
 231   }
 232 }
 233
 234 static void testGetIfTable(void)
 235 {
 236   if (gGetIfTable) {
 237     DWORD apiReturn;
 238     ULONG dwSize = 0;
 239
 240     apiReturn = gGetIfTable(NULL, NULL, FALSE);
 241     if (apiReturn == ERROR_NOT_SUPPORTED)
 242       return;
 243     ok(apiReturn == ERROR_INVALID_PARAMETER,
 244      "GetIfTable(NULL, NULL, FALSE) returned %d, expected ERROR_INVALID_PARAMETER\n",
 245      apiReturn);
 246     apiReturn = gGetIfTable(NULL, &dwSize, FALSE);
 247     ok(apiReturn == ERROR_INSUFFICIENT_BUFFER,
 248      "GetIfTable(NULL, &dwSize, FALSE) returned %d, expected ERROR_INSUFFICIENT_BUFFER\n",
 249      apiReturn);
 250     if (apiReturn == ERROR_INSUFFICIENT_BUFFER) {
 251       PMIB_IFTABLE buf = (PMIB_IFTABLE)malloc(dwSize);
 252
 253       apiReturn = gGetIfTable(buf, &dwSize, FALSE);
 254       ok(apiReturn == NO_ERROR,
 255        "GetIfTable(buf, &dwSize, FALSE) returned %d, expected NO_ERROR\n\n",
 256        apiReturn);
 257       free(buf);
 258     }
 259   }
 260 }
 261
 262 static void testGetIpForwardTable(void)
 263 {
 264   if (gGetIpForwardTable) {
 265     DWORD apiReturn;
 266     ULONG dwSize = 0;
 267
 268     apiReturn = gGetIpForwardTable(NULL, NULL, FALSE);
 269     if (apiReturn == ERROR_NOT_SUPPORTED)
 270       return;
 271     ok(apiReturn == ERROR_INVALID_PARAMETER,
 272      "GetIpForwardTable(NULL, NULL, FALSE) returned %d, expected ERROR_INVALID_PARAMETER\n",
 273      apiReturn);
 274     apiReturn = gGetIpForwardTable(NULL, &dwSize, FALSE);
 275     ok(apiReturn == ERROR_INSUFFICIENT_BUFFER,
 276      "GetIpForwardTable(NULL, &dwSize, FALSE) returned %d, expected ERROR_INSUFFICIENT_BUFFER\n",
 277      apiReturn);
 278     if (apiReturn == ERROR_INSUFFICIENT_BUFFER) {
 279       PMIB_IPFORWARDTABLE buf = (PMIB_IPFORWARDTABLE)malloc(dwSize);
 280
 281       apiReturn = gGetIpForwardTable(buf, &dwSize, FALSE);
 282       ok(apiReturn == NO_ERROR,
 283        "GetIpForwardTable(buf, &dwSize, FALSE) returned %d, expected NO_ERROR\n",
 284        apiReturn);
 285       free(buf);
 286     }
 287   }
 288 }
 289
 290 static void testGetIpNetTable(void)
 291 {
 292   if (gGetIpNetTable) {
 293     DWORD apiReturn;
 294     ULONG dwSize = 0;
 295
 296     apiReturn = gGetIpNetTable(NULL, NULL, FALSE);
 297     if (apiReturn == ERROR_NOT_SUPPORTED)
 298       return;
 299     ok(apiReturn == ERROR_INVALID_PARAMETER,
 300      "GetIpNetTable(NULL, NULL, FALSE) returned %d, expected ERROR_INVALID_PARAMETER\n",
 301      apiReturn);
 302     apiReturn = gGetIpNetTable(NULL, &dwSize, FALSE);
 303     ok(apiReturn == ERROR_NO_DATA || apiReturn == ERROR_INSUFFICIENT_BUFFER,
 304      "GetIpNetTable(NULL, &dwSize, FALSE) returned %d, expected ERROR_NO_DATA or ERROR_INSUFFICIENT_BUFFER\n",
 305      apiReturn);
 306     if (apiReturn == ERROR_NO_DATA)
 307       ; /* empty ARP table's okay */
 308     else if (apiReturn == ERROR_INSUFFICIENT_BUFFER) {
 309       PMIB_IPNETTABLE buf = (PMIB_IPNETTABLE)malloc(dwSize);
 310
 311       apiReturn = gGetIpNetTable(buf, &dwSize, FALSE);
 312       ok(apiReturn == NO_ERROR,
 313        "GetIpNetTable(buf, &dwSize, FALSE) returned %d, expected NO_ERROR\n",
 314        apiReturn);
 315       free(buf);
 316     }
 317   }
 318 }
 319
 320 static void testGetIcmpStatistics(void)
 321 {
 322   if (gGetIcmpStatistics) {
 323     DWORD apiReturn;
 324     MIB_ICMP stats;
 325
 326     /* Crashes on Vista */
 327     if (0) {
 328       apiReturn = gGetIcmpStatistics(NULL);
 329       if (apiReturn == ERROR_NOT_SUPPORTED)
 330         return;
 331       ok(apiReturn == ERROR_INVALID_PARAMETER,
 332        "GetIcmpStatistics(NULL) returned %d, expected ERROR_INVALID_PARAMETER\n",
 333        apiReturn);
 334     }
 335
 336     apiReturn = gGetIcmpStatistics(&stats);
 337     if (apiReturn == ERROR_NOT_SUPPORTED)
 338     {
 339       skip("GetIcmpStatistics is not supported\n");
 340       return;
 341     }
 342     ok(apiReturn == NO_ERROR,
 343      "GetIcmpStatistics returned %d, expected NO_ERROR\n", apiReturn);
 344   }
 345 }
 346
 347 static void testGetIpStatistics(void)
 348 {
 349   if (gGetIpStatistics) {
 350     DWORD apiReturn;
 351     MIB_IPSTATS stats;
 352
 353     apiReturn = gGetIpStatistics(NULL);
 354     if (apiReturn == ERROR_NOT_SUPPORTED)
 355       return;
 356     ok(apiReturn == ERROR_INVALID_PARAMETER,
 357      "GetIpStatistics(NULL) returned %d, expected ERROR_INVALID_PARAMETER\n",
 358      apiReturn);
 359     apiReturn = gGetIpStatistics(&stats);
 360     ok(apiReturn == NO_ERROR,
 361       "GetIpStatistics returned %d, expected NO_ERROR\n", apiReturn);
 362   }
 363 }
 364
 365 static void testGetTcpStatistics(void)
 366 {
 367   if (gGetTcpStatistics) {
 368     DWORD apiReturn;
 369     MIB_TCPSTATS stats;
 370
 371     apiReturn = gGetTcpStatistics(NULL);
 372     if (apiReturn == ERROR_NOT_SUPPORTED)
 373       return;
 374     ok(apiReturn == ERROR_INVALID_PARAMETER,
 375      "GetTcpStatistics(NULL) returned %d, expected ERROR_INVALID_PARAMETER\n",
 376      apiReturn);
 377     apiReturn = gGetTcpStatistics(&stats);
 378     ok(apiReturn == NO_ERROR,
 379       "GetTcpStatistics returned %d, expected NO_ERROR\n", apiReturn);
 380   }
 381 }
 382
 383 static void testGetUdpStatistics(void)
 384 {
 385   if (gGetUdpStatistics) {
 386     DWORD apiReturn;
 387     MIB_UDPSTATS stats;
 388
 389     apiReturn = gGetUdpStatistics(NULL);
 390     if (apiReturn == ERROR_NOT_SUPPORTED)
 391       return;
 392     ok(apiReturn == ERROR_INVALID_PARAMETER,
 393      "GetUdpStatistics(NULL) returned %d, expected ERROR_INVALID_PARAMETER\n",
 394      apiReturn);
 395     apiReturn = gGetUdpStatistics(&stats);
 396     ok(apiReturn == NO_ERROR,
 397      "GetUdpStatistics returned %d, expected NO_ERROR\n", apiReturn);
 398   }
 399 }
 400
 401 static void testGetTcpTable(void)
 402 {
 403   if (gGetTcpTable) {
 404     DWORD apiReturn;
 405     ULONG dwSize = 0;
 406
 407     apiReturn = gGetTcpTable(NULL, NULL, FALSE);
 408     if (apiReturn == ERROR_NOT_SUPPORTED)
 409       return;
 410     ok(apiReturn == ERROR_INVALID_PARAMETER,
 411      "GetTcpTable(NULL, NULL, FALSE) returned %d, expected ERROR_INVALID_PARAMETER\n",
 412      apiReturn);
 413     apiReturn = gGetTcpTable(NULL, &dwSize, FALSE);
 414     ok(apiReturn == ERROR_INSUFFICIENT_BUFFER,
 415      "GetTcpTable(NULL, &dwSize, FALSE) returned %d, expected ERROR_INSUFFICIENT_BUFFER\n",
 416      apiReturn);
 417     if (apiReturn == ERROR_INSUFFICIENT_BUFFER) {
 418       PMIB_TCPTABLE buf = (PMIB_TCPTABLE)malloc(dwSize);
 419
 420       apiReturn = gGetTcpTable(buf, &dwSize, FALSE);
 421       ok(apiReturn == NO_ERROR,
 422        "GetTcpTable(buf, &dwSize, FALSE) returned %d, expected NO_ERROR\n",
 423        apiReturn);
 424       free(buf);
 425     }
 426   }
 427 }
 428
 429 static void testGetUdpTable(void)
 430 {
 431   if (gGetUdpTable) {
 432     DWORD apiReturn;
 433     ULONG dwSize = 0;
 434
 435     apiReturn = gGetUdpTable(NULL, NULL, FALSE);
 436     if (apiReturn == ERROR_NOT_SUPPORTED)
 437       return;
 438     ok(apiReturn == ERROR_INVALID_PARAMETER,
 439      "GetUdpTable(NULL, NULL, FALSE) returned %d, expected ERROR_INVALID_PARAMETER\n",
 440      apiReturn);
 441     apiReturn = gGetUdpTable(NULL, &dwSize, FALSE);
 442     ok(apiReturn == ERROR_INSUFFICIENT_BUFFER,
 443      "GetUdpTable(NULL, &dwSize, FALSE) returned %d, expected ERROR_INSUFFICIENT_BUFFER\n",
 444      apiReturn);
 445     if (apiReturn != ERROR_INSUFFICIENT_BUFFER) {
 446       PMIB_UDPTABLE buf = (PMIB_UDPTABLE)malloc(dwSize);
 447
 448       apiReturn = gGetUdpTable(buf, &dwSize, FALSE);
 449       ok(apiReturn == NO_ERROR,
 450        "GetUdpTable(buf, &dwSize, FALSE) returned %d, expected NO_ERROR\n",
 451        apiReturn);
 452       free(buf);
 453     }
 454   }
 455 }
 456
 457 /*
 458 still-to-be-tested NT4-onward functions:
 459 CreateIpForwardEntry
 460 DeleteIpForwardEntry
 461 CreateIpNetEntry
 462 DeleteIpNetEntry
 463 GetFriendlyIfIndex
 464 GetRTTAndHopCount
 465 SetIfEntry
 466 SetIpForwardEntry
 467 SetIpNetEntry
 468 SetIpStatistics
 469 SetIpTTL
 470 SetTcpEntry
 471 */
 472 static void testWinNT4Functions(void)
 473 {
 474   testGetNumberOfInterfaces();
 475   testGetIpAddrTable();
 476   testGetIfTable();
 477   testGetIpForwardTable();
 478   testGetIpNetTable();
 479   testGetIcmpStatistics();
 480   testGetIpStatistics();
 481   testGetTcpStatistics();
 482   testGetUdpStatistics();
 483   testGetTcpTable();
 484   testGetUdpTable();
 485 }
 486
 487 static void testGetInterfaceInfo(void)
 488 {
 489   if (gGetInterfaceInfo) {
 490     DWORD apiReturn;
 491     ULONG len = 0;
 492
 493     apiReturn = gGetInterfaceInfo(NULL, NULL);
 494     if (apiReturn == ERROR_NOT_SUPPORTED)
 495       return;
 496     ok(apiReturn == ERROR_INVALID_PARAMETER,
 497      "GetInterfaceInfo returned %d, expected ERROR_INVALID_PARAMETER\n",
 498      apiReturn);
 499     apiReturn = gGetInterfaceInfo(NULL, &len);
 500     ok(apiReturn == ERROR_INSUFFICIENT_BUFFER,
 501      "GetInterfaceInfo returned %d, expected ERROR_INSUFFICIENT_BUFFER\n",
 502      apiReturn);
 503     if (apiReturn == ERROR_INSUFFICIENT_BUFFER) {
 504       PIP_INTERFACE_INFO buf = (PIP_INTERFACE_INFO)malloc(len);
 505
 506       apiReturn = gGetInterfaceInfo(buf, &len);
 507       ok(apiReturn == NO_ERROR,
 508        "GetInterfaceInfo(buf, &dwSize) returned %d, expected NO_ERROR\n",
 509        apiReturn);
 510       free(buf);
 511     }
 512   }
 513 }
 514
 515 static void testGetAdaptersInfo(void)
 516 {
 517   if (gGetAdaptersInfo) {
 518     DWORD apiReturn;
 519     ULONG len = 0;
 520
 521     apiReturn = gGetAdaptersInfo(NULL, NULL);
 522     if (apiReturn == ERROR_NOT_SUPPORTED)
 523       return;
 524     ok(apiReturn == ERROR_INVALID_PARAMETER,
 525      "GetAdaptersInfo returned %d, expected ERROR_INVALID_PARAMETER\n",
 526      apiReturn);
 527     apiReturn = gGetAdaptersInfo(NULL, &len);
 528     ok(apiReturn == ERROR_NO_DATA || apiReturn == ERROR_BUFFER_OVERFLOW,
 529      "GetAdaptersInfo returned %d, expected ERROR_NO_DATA or ERROR_BUFFER_OVERFLOW\n",
 530      apiReturn);
 531     if (apiReturn == ERROR_NO_DATA)
 532       ; /* no adapter's, that's okay */
 533     else if (apiReturn == ERROR_BUFFER_OVERFLOW) {
 534       PIP_ADAPTER_INFO buf = (PIP_ADAPTER_INFO)malloc(len);
 535
 536       apiReturn = gGetAdaptersInfo(buf, &len);
 537       ok(apiReturn == NO_ERROR,
 538        "GetAdaptersInfo(buf, &dwSize) returned %d, expected NO_ERROR\n",
 539        apiReturn);
 540       free(buf);
 541     }
 542   }
 543 }
 544
 545 static void testGetNetworkParams(void)
 546 {
 547   if (gGetNetworkParams) {
 548     DWORD apiReturn;
 549     ULONG len = 0;
 550
 551     apiReturn = gGetNetworkParams(NULL, NULL);
 552     if (apiReturn == ERROR_NOT_SUPPORTED)
 553       return;
 554     ok(apiReturn == ERROR_INVALID_PARAMETER,
 555      "GetNetworkParams returned %d, expected ERROR_INVALID_PARAMETER\n",
 556      apiReturn);
 557     apiReturn = gGetNetworkParams(NULL, &len);
 558     ok(apiReturn == ERROR_BUFFER_OVERFLOW,
 559      "GetNetworkParams returned %d, expected ERROR_BUFFER_OVERFLOW\n",
 560      apiReturn);
 561     if (apiReturn == ERROR_BUFFER_OVERFLOW) {
 562       PFIXED_INFO buf = (PFIXED_INFO)malloc(len);
 563
 564       apiReturn = gGetNetworkParams(buf, &len);
 565       ok(apiReturn == NO_ERROR,
 566        "GetNetworkParams(buf, &dwSize) returned %d, expected NO_ERROR\n",
 567        apiReturn);
 568       free(buf);
 569     }
 570   }
 571 }
 572
 573 /*
 574 still-to-be-tested 98-onward functions:
 575 GetBestInterface
 576 GetBestRoute
 577 IpReleaseAddress
 578 IpRenewAddress
 579 */
 580 static void testWin98Functions(void)
 581 {
 582   testGetInterfaceInfo();
 583   testGetAdaptersInfo();
 584   testGetNetworkParams();
 585 }
 586
 587 /*
 588 still-to-be-tested 2K-onward functions:
 589 AddIPAddress
 590 CreateProxyArpEntry
 591 DeleteIPAddress
 592 DeleteProxyArpEntry
 593 EnableRouter
 594 FlushIpNetTable
 595 GetAdapterIndex
 596 GetPerAdapterInfo
 597 NotifyAddrChange
 598 NotifyRouteChange
 599 SendARP
 600 UnenableRouter
 601 */
 602 static void testWin2KFunctions(void)
 603 {
 604 }
 605
 606 START_TEST(iphlpapi)
 607 {
 608
 609   loadIPHlpApi();
 610   if (hLibrary) {
 611     testWin98OnlyFunctions();
 612     testWinNT4Functions();
 613     testWin98Functions();
 614     testWin2KFunctions();
 615     freeIPHlpApi();
 616   }
 617 }