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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 void testWin98OnlyFunctions(void)
 150 {
 151 }
 152
 153 static void testGetNumberOfInterfaces(void)
 154 {
 155   if (gGetNumberOfInterfaces) {
 156     DWORD apiReturn = gGetNumberOfInterfaces(NULL), numInterfaces;
 157
 158     if (apiReturn == ERROR_NOT_SUPPORTED)
 159       return;
 160     ok(apiReturn == ERROR_INVALID_PARAMETER,
 161      "GetNumberOfInterfaces(NULL) returned %ld, expected ERROR_INVALID_PARAMETER\n",
 162      apiReturn);
 163     apiReturn = gGetNumberOfInterfaces(&numInterfaces);
 164     ok(apiReturn == NO_ERROR,
 165      "GetNumberOfInterfaces returned %ld, expected 0\n", apiReturn);
 166   }
 167 }
 168
 169 static void testGetIfEntry(DWORD index)
 170 {
 171   if (gGetIfEntry) {
 172     DWORD apiReturn;
 173     MIB_IFROW row;
 174
 175     memset(&row, 0, sizeof(row));
 176     apiReturn = gGetIfEntry(NULL);
 177     if (apiReturn == ERROR_NOT_SUPPORTED)
 178       return;
 179     ok(apiReturn == ERROR_INVALID_PARAMETER,
 180      "GetIfEntry(NULL) returned %ld, expected ERROR_INVALID_PARAMETER\n",
 181      apiReturn);
 182     row.dwIndex = -1; /* hope that's always bogus! */
 183     apiReturn = gGetIfEntry(&row);
 184     ok(apiReturn == ERROR_INVALID_DATA,
 185      "GetIfEntry(bogus row) returned %ld, expected ERROR_INVALID_DATA\n",
 186      apiReturn);
 187     row.dwIndex = index;
 188     apiReturn = gGetIfEntry(&row);
 189     ok(apiReturn == NO_ERROR,
 190      "GetIfEntry returned %ld, expected NO_ERROR\n", apiReturn);
 191   }
 192 }
 193
 194 static void testGetIpAddrTable(void)
 195 {
 196   if (gGetIpAddrTable) {
 197     DWORD apiReturn;
 198     ULONG dwSize = 0;
 199
 200     apiReturn = gGetIpAddrTable(NULL, NULL, FALSE);
 201     if (apiReturn == ERROR_NOT_SUPPORTED)
 202       return;
 203     ok(apiReturn == ERROR_INVALID_PARAMETER,
 204      "GetIpAddrTable(NULL, NULL, FALSE) returned %ld, expected ERROR_INVALID_PARAMETER\n",
 205      apiReturn);
 206     apiReturn = gGetIpAddrTable(NULL, &dwSize, FALSE);
 207     ok(apiReturn == ERROR_INSUFFICIENT_BUFFER,
 208      "GetIpAddrTable(NULL, &dwSize, FALSE) returned %ld, expected ERROR_INSUFFICIENT_BUFFER\n",
 209      apiReturn);
 210     if (apiReturn == ERROR_INSUFFICIENT_BUFFER) {
 211       PMIB_IPADDRTABLE buf = (PMIB_IPADDRTABLE)malloc(dwSize);
 212
 213       apiReturn = gGetIpAddrTable(buf, &dwSize, FALSE);
 214       ok(apiReturn == NO_ERROR,
 215        "GetIpAddrTable(buf, &dwSize, FALSE) returned %ld, expected NO_ERROR\n",
 216        apiReturn);
 217       if (apiReturn == NO_ERROR)
 218         testGetIfEntry(buf->table[0].dwIndex);
 219       free(buf);
 220     }
 221   }
 222 }
 223
 224 static void testGetIfTable(void)
 225 {
 226   if (gGetIfTable) {
 227     DWORD apiReturn;
 228     ULONG dwSize = 0;
 229
 230     apiReturn = gGetIfTable(NULL, NULL, FALSE);
 231     if (apiReturn == ERROR_NOT_SUPPORTED)
 232       return;
 233     ok(apiReturn == ERROR_INVALID_PARAMETER,
 234      "GetIfTable(NULL, NULL, FALSE) returned %ld, expected ERROR_INVALID_PARAMETER\n",
 235      apiReturn);
 236     apiReturn = gGetIfTable(NULL, &dwSize, FALSE);
 237     ok(apiReturn == ERROR_INSUFFICIENT_BUFFER,
 238      "GetIfTable(NULL, &dwSize, FALSE) returned %ld, expected ERROR_INSUFFICIENT_BUFFER\n",
 239      apiReturn);
 240     if (apiReturn == ERROR_INSUFFICIENT_BUFFER) {
 241       PMIB_IFTABLE buf = (PMIB_IFTABLE)malloc(dwSize);
 242
 243       apiReturn = gGetIfTable(buf, &dwSize, FALSE);
 244       ok(apiReturn == NO_ERROR,
 245        "GetIfTable(buf, &dwSize, FALSE) returned %ld, expected NO_ERROR\n\n",
 246        apiReturn);
 247       free(buf);
 248     }
 249   }
 250 }
 251
 252 static void testGetIpForwardTable(void)
 253 {
 254   if (gGetIpForwardTable) {
 255     DWORD apiReturn;
 256     ULONG dwSize = 0;
 257
 258     apiReturn = gGetIpForwardTable(NULL, NULL, FALSE);
 259     if (apiReturn == ERROR_NOT_SUPPORTED)
 260       return;
 261     ok(apiReturn == ERROR_INVALID_PARAMETER,
 262      "GetIpForwardTable(NULL, NULL, FALSE) returned %ld, expected ERROR_INVALID_PARAMETER\n",
 263      apiReturn);
 264     apiReturn = gGetIpForwardTable(NULL, &dwSize, FALSE);
 265     ok(apiReturn == ERROR_INSUFFICIENT_BUFFER,
 266      "GetIpForwardTable(NULL, &dwSize, FALSE) returned %ld, expected ERROR_INSUFFICIENT_BUFFER\n",
 267      apiReturn);
 268     if (apiReturn == ERROR_INSUFFICIENT_BUFFER) {
 269       PMIB_IPFORWARDTABLE buf = (PMIB_IPFORWARDTABLE)malloc(dwSize);
 270
 271       apiReturn = gGetIpForwardTable(buf, &dwSize, FALSE);
 272       ok(apiReturn == NO_ERROR,
 273        "GetIpForwardTable(buf, &dwSize, FALSE) returned %ld, expected NO_ERROR\n",
 274        apiReturn);
 275       if (apiReturn == NO_ERROR)
 276         ok(buf->dwNumEntries > 0,
 277           "Got 0 IP forward table entries, expect at least 1\n");
 278       free(buf);
 279     }
 280   }
 281 }
 282
 283 void testGetIpNetTable(void)
 284 {
 285   if (gGetIpNetTable) {
 286     DWORD apiReturn;
 287     ULONG dwSize = 0;
 288
 289     apiReturn = gGetIpNetTable(NULL, NULL, FALSE);
 290     if (apiReturn == ERROR_NOT_SUPPORTED)
 291       return;
 292     ok(apiReturn == ERROR_INVALID_PARAMETER,
 293      "GetIpNetTable(NULL, NULL, FALSE) returned %ld, expected ERROR_INVALID_PARAMETER\n",
 294      apiReturn);
 295     apiReturn = gGetIpNetTable(NULL, &dwSize, FALSE);
 296     ok(apiReturn == ERROR_NO_DATA || apiReturn == ERROR_INSUFFICIENT_BUFFER,
 297      "GetIpNetTable(NULL, &dwSize, FALSE) returned %ld, expected ERROR_NO_DATA or ERROR_INSUFFICIENT_BUFFER\n",
 298      apiReturn);
 299     if (apiReturn == ERROR_NO_DATA)
 300       ; /* empty ARP table's okay */
 301     else if (apiReturn == ERROR_INSUFFICIENT_BUFFER) {
 302       PMIB_IPNETTABLE buf = (PMIB_IPNETTABLE)malloc(dwSize);
 303
 304       apiReturn = gGetIpNetTable(buf, &dwSize, FALSE);
 305       ok(apiReturn == NO_ERROR,
 306        "GetIpNetTable(buf, &dwSize, FALSE) returned %ld, expected NO_ERROR\n",
 307        apiReturn);
 308       free(buf);
 309     }
 310   }
 311 }
 312
 313 void testGetIcmpStatistics(void)
 314 {
 315   if (gGetIcmpStatistics) {
 316     DWORD apiReturn;
 317     MIB_ICMP stats;
 318
 319     apiReturn = gGetIcmpStatistics(NULL);
 320     if (apiReturn == ERROR_NOT_SUPPORTED)
 321       return;
 322     ok(apiReturn == ERROR_INVALID_PARAMETER,
 323      "GetIcmpStatistics(NULL) returned %ld, expected ERROR_INVALID_PARAMETER\n",
 324      apiReturn);
 325     apiReturn = gGetIcmpStatistics(&stats);
 326     ok(apiReturn == NO_ERROR,
 327      "GetIcmpStatistics returned %ld, expected NO_ERROR\n", apiReturn);
 328   }
 329 }
 330
 331 void testGetIpStatistics(void)
 332 {
 333   if (gGetIpStatistics) {
 334     DWORD apiReturn;
 335     MIB_IPSTATS stats;
 336
 337     apiReturn = gGetIpStatistics(NULL);
 338     if (apiReturn == ERROR_NOT_SUPPORTED)
 339       return;
 340     ok(apiReturn == ERROR_INVALID_PARAMETER,
 341      "GetIpStatistics(NULL) returned %ld, expected ERROR_INVALID_PARAMETER\n",
 342      apiReturn);
 343     apiReturn = gGetIpStatistics(&stats);
 344     ok(apiReturn == NO_ERROR,
 345       "GetIpStatistics returned %ld, expected NO_ERROR\n", apiReturn);
 346   }
 347 }
 348
 349 void testGetTcpStatistics(void)
 350 {
 351   if (gGetTcpStatistics) {
 352     DWORD apiReturn;
 353     MIB_TCPSTATS stats;
 354
 355     apiReturn = gGetTcpStatistics(NULL);
 356     if (apiReturn == ERROR_NOT_SUPPORTED)
 357       return;
 358     ok(apiReturn == ERROR_INVALID_PARAMETER,
 359      "GetTcpStatistics(NULL) returned %ld, expected ERROR_INVALID_PARAMETER\n",
 360      apiReturn);
 361     apiReturn = gGetTcpStatistics(&stats);
 362     ok(apiReturn == NO_ERROR,
 363       "GetTcpStatistics returned %ld, expected NO_ERROR\n", apiReturn);
 364   }
 365 }
 366
 367 void testGetUdpStatistics(void)
 368 {
 369   if (gGetUdpStatistics) {
 370     DWORD apiReturn;
 371     MIB_UDPSTATS stats;
 372
 373     apiReturn = gGetUdpStatistics(NULL);
 374     if (apiReturn == ERROR_NOT_SUPPORTED)
 375       return;
 376     ok(apiReturn == ERROR_INVALID_PARAMETER,
 377      "GetUdpStatistics(NULL) returned %ld, expected ERROR_INVALID_PARAMETER\n",
 378      apiReturn);
 379     apiReturn = gGetUdpStatistics(&stats);
 380     ok(apiReturn == NO_ERROR,
 381      "GetUdpStatistics returned %ld, expected NO_ERROR\n", apiReturn);
 382   }
 383 }
 384
 385 void testGetTcpTable(void)
 386 {
 387   if (gGetTcpTable) {
 388     DWORD apiReturn;
 389     ULONG dwSize = 0;
 390
 391     apiReturn = gGetTcpTable(NULL, NULL, FALSE);
 392     if (apiReturn == ERROR_NOT_SUPPORTED)
 393       return;
 394     ok(apiReturn == ERROR_INVALID_PARAMETER,
 395      "GetTcpTable(NULL, NULL, FALSE) returned %ld, expected ERROR_INVALID_PARAMETER\n",
 396      apiReturn);
 397     apiReturn = gGetTcpTable(NULL, &dwSize, FALSE);
 398     ok(apiReturn == ERROR_INSUFFICIENT_BUFFER,
 399      "GetTcpTable(NULL, &dwSize, FALSE) returned %ld, expected ERROR_INSUFFICIENT_BUFFER\n",
 400      apiReturn);
 401     if (apiReturn == ERROR_INSUFFICIENT_BUFFER) {
 402       PMIB_TCPTABLE buf = (PMIB_TCPTABLE)malloc(dwSize);
 403
 404       apiReturn = gGetTcpTable(buf, &dwSize, FALSE);
 405       ok(apiReturn == NO_ERROR,
 406        "GetTcpTable(buf, &dwSize, FALSE) returned %ld, expected NO_ERROR\n",
 407        apiReturn);
 408       free(buf);
 409     }
 410   }
 411 }
 412
 413 void testGetUdpTable(void)
 414 {
 415   if (gGetUdpTable) {
 416     DWORD apiReturn;
 417     ULONG dwSize = 0;
 418
 419     apiReturn = gGetUdpTable(NULL, NULL, FALSE);
 420     if (apiReturn == ERROR_NOT_SUPPORTED)
 421       return;
 422     ok(apiReturn == ERROR_INVALID_PARAMETER,
 423      "GetUdpTable(NULL, NULL, FALSE) returned %ld, expected ERROR_INVALID_PARAMETER\n",
 424      apiReturn);
 425     apiReturn = gGetUdpTable(NULL, &dwSize, FALSE);
 426     ok(apiReturn == ERROR_INSUFFICIENT_BUFFER,
 427      "GetUdpTable(NULL, &dwSize, FALSE) returned %ld, expected ERROR_INSUFFICIENT_BUFFER\n",
 428      apiReturn);
 429     if (apiReturn != ERROR_INSUFFICIENT_BUFFER) {
 430       PMIB_UDPTABLE buf = (PMIB_UDPTABLE)malloc(dwSize);
 431
 432       apiReturn = gGetUdpTable(buf, &dwSize, FALSE);
 433       ok(apiReturn == NO_ERROR,
 434        "GetUdpTable(buf, &dwSize, FALSE) returned %ld, expected NO_ERROR\n",
 435        apiReturn);
 436       free(buf);
 437     }
 438   }
 439 }
 440
 441 /*
 442 still-to-be-tested NT4-onward functions:
 443 CreateIpForwardEntry
 444 DeleteIpForwardEntry
 445 CreateIpNetEntry
 446 DeleteIpNetEntry
 447 GetFriendlyIfIndex
 448 GetRTTAndHopCount
 449 SetIfEntry
 450 SetIpForwardEntry
 451 SetIpNetEntry
 452 SetIpStatistics
 453 SetIpTTL
 454 SetTcpEntry
 455 */
 456 static void testWinNT4Functions(void)
 457 {
 458   testGetNumberOfInterfaces();
 459   testGetIpAddrTable();
 460   testGetIfTable();
 461   testGetIpForwardTable();
 462   testGetIpNetTable();
 463   testGetIcmpStatistics();
 464   testGetIpStatistics();
 465   testGetTcpStatistics();
 466   testGetUdpStatistics();
 467   testGetTcpTable();
 468   testGetUdpTable();
 469 }
 470
 471 static void testGetInterfaceInfo(void)
 472 {
 473   if (gGetInterfaceInfo) {
 474     DWORD apiReturn;
 475     ULONG len = 0;
 476
 477     apiReturn = gGetInterfaceInfo(NULL, NULL);
 478     if (apiReturn == ERROR_NOT_SUPPORTED)
 479       return;
 480     ok(apiReturn == ERROR_INVALID_PARAMETER,
 481      "GetInterfaceInfo returned %ld, expected ERROR_INVALID_PARAMETER\n",
 482      apiReturn);
 483     apiReturn = gGetInterfaceInfo(NULL, &len);
 484     ok(apiReturn == ERROR_INSUFFICIENT_BUFFER,
 485      "GetInterfaceInfo returned %ld, expected ERROR_INSUFFICIENT_BUFFER\n",
 486      apiReturn);
 487     if (apiReturn == ERROR_INSUFFICIENT_BUFFER) {
 488       PIP_INTERFACE_INFO buf = (PIP_INTERFACE_INFO)malloc(len);
 489
 490       apiReturn = gGetInterfaceInfo(buf, &len);
 491       ok(apiReturn == NO_ERROR,
 492        "GetInterfaceInfo(buf, &dwSize) returned %ld, expected NO_ERROR\n",
 493        apiReturn);
 494       free(buf);
 495     }
 496   }
 497 }
 498
 499 static void testGetAdaptersInfo(void)
 500 {
 501   if (gGetAdaptersInfo) {
 502     DWORD apiReturn;
 503     ULONG len = 0;
 504
 505     apiReturn = gGetAdaptersInfo(NULL, NULL);
 506     if (apiReturn == ERROR_NOT_SUPPORTED)
 507       return;
 508     ok(apiReturn == ERROR_INVALID_PARAMETER,
 509      "GetAdaptersInfo returned %ld, expected ERROR_INVALID_PARAMETER\n",
 510      apiReturn);
 511     apiReturn = gGetAdaptersInfo(NULL, &len);
 512     ok(apiReturn == ERROR_NO_DATA || apiReturn == ERROR_BUFFER_OVERFLOW,
 513      "GetAdaptersInfo returned %ld, expected ERROR_NO_DATA or ERROR_BUFFER_OVERFLOW\n",
 514      apiReturn);
 515     if (apiReturn == ERROR_NO_DATA)
 516       ; /* no adapter's, that's okay */
 517     else if (apiReturn == ERROR_BUFFER_OVERFLOW) {
 518       PIP_ADAPTER_INFO buf = (PIP_ADAPTER_INFO)malloc(len);
 519
 520       apiReturn = gGetAdaptersInfo(buf, &len);
 521       ok(apiReturn == NO_ERROR,
 522        "GetAdaptersInfo(buf, &dwSize) returned %ld, expected NO_ERROR\n",
 523        apiReturn);
 524       free(buf);
 525     }
 526   }
 527 }
 528
 529 static void testGetNetworkParams(void)
 530 {
 531   if (gGetNetworkParams) {
 532     DWORD apiReturn;
 533     ULONG len = 0;
 534
 535     apiReturn = gGetNetworkParams(NULL, NULL);
 536     if (apiReturn == ERROR_NOT_SUPPORTED)
 537       return;
 538     ok(apiReturn == ERROR_INVALID_PARAMETER,
 539      "GetNetworkParams returned %ld, expected ERROR_INVALID_PARAMETER\n",
 540      apiReturn);
 541     apiReturn = gGetNetworkParams(NULL, &len);
 542     ok(apiReturn == ERROR_BUFFER_OVERFLOW,
 543      "GetNetworkParams returned %ld, expected ERROR_BUFFER_OVERFLOW\n",
 544      apiReturn);
 545     if (apiReturn == ERROR_BUFFER_OVERFLOW) {
 546       PFIXED_INFO buf = (PFIXED_INFO)malloc(len);
 547
 548       apiReturn = gGetNetworkParams(buf, &len);
 549       ok(apiReturn == NO_ERROR,
 550        "GetNetworkParams(buf, &dwSize) returned %ld, expected NO_ERROR\n",
 551        apiReturn);
 552       free(buf);
 553     }
 554   }
 555 }
 556
 557 /*
 558 still-to-be-tested 98-onward functions:
 559 GetBestInterface
 560 GetBestRoute
 561 IpReleaseAddress
 562 IpRenewAddress
 563 */
 564 static void testWin98Functions(void)
 565 {
 566   testGetInterfaceInfo();
 567   testGetAdaptersInfo();
 568   testGetNetworkParams();
 569 }
 570
 571 /*
 572 still-to-be-tested 2K-onward functions:
 573 AddIPAddress
 574 CreateProxyArpEntry
 575 DeleteIPAddress
 576 DeleteProxyArpEntry
 577 EnableRouter
 578 FlushIpNetTable
 579 GetAdapterIndex
 580 GetPerAdapterInfo
 581 NotifyAddrChange
 582 NotifyRouteChange
 583 SendARP
 584 UnenableRouter
 585 */
 586 static void testWin2KFunctions(void)
 587 {
 588 }
 589
 590 START_TEST(iphlpapi)
 591 {
 592
 593   loadIPHlpApi();
 594   if (hLibrary) {
 595     testWin98OnlyFunctions();
 596     testWinNT4Functions();
 597     testWin98Functions();
 598     testWin2KFunctions();
 599     freeIPHlpApi();
 600   }
 601 }