dlls/comctl32/tests/misc.c

   1 /*
   2  * Misc tests
   3  *
   4  * Copyright 2006 Paul Vriens
   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 #include <stdio.h>
  22 #include <windows.h>
  23
  24 #include "wine/test.h"
  25
  26 static PVOID (WINAPI * pAlloc)(LONG);
  27 static PVOID (WINAPI * pReAlloc)(PVOID, LONG);
  28 static BOOL (WINAPI * pFree)(PVOID);
  29 static LONG (WINAPI * pGetSize)(PVOID);
  30
  31 static INT (WINAPI * pStr_GetPtrA)(LPCSTR, LPSTR, INT);
  32 static BOOL (WINAPI * pStr_SetPtrA)(LPSTR, LPCSTR);
  33 static INT (WINAPI * pStr_GetPtrW)(LPCWSTR, LPWSTR, INT);
  34 static BOOL (WINAPI * pStr_SetPtrW)(LPWSTR, LPCWSTR);
  35
  36 static HMODULE hComctl32 = 0;
  37
  38 #define COMCTL32_GET_PROC(ordinal, func) \
  39     p ## func = (void*)GetProcAddress(hComctl32, (LPSTR)ordinal); \
  40     if(!p ## func) { \
  41       trace("GetProcAddress(%d)(%s) failed\n", ordinal, #func); \
  42       FreeLibrary(hComctl32); \
  43     }
  44
  45 static BOOL InitFunctionPtrs(void)
  46 {
  47     hComctl32 = LoadLibraryA("comctl32.dll");
  48
  49     if(!hComctl32)
  50     {
  51         trace("Could not load comctl32.dll\n");
  52         return FALSE;
  53     }
  54
  55     COMCTL32_GET_PROC(71, Alloc);
  56     COMCTL32_GET_PROC(72, ReAlloc);
  57     COMCTL32_GET_PROC(73, Free);
  58     COMCTL32_GET_PROC(74, GetSize);
  59
  60     COMCTL32_GET_PROC(233, Str_GetPtrA)
  61     COMCTL32_GET_PROC(234, Str_SetPtrA)
  62     COMCTL32_GET_PROC(235, Str_GetPtrW)
  63     COMCTL32_GET_PROC(236, Str_SetPtrW)
  64
  65     return TRUE;
  66 }
  67
  68 static void test_GetPtrAW(void)
  69 {
  70     if (pStr_GetPtrA)
  71     {
  72         static const char source[] = "Just a source string";
  73         static const char desttest[] = "Just a destination string";
  74         static char dest[MAX_PATH];
  75         int sourcelen;
  76         int destsize = MAX_PATH;
  77         int count = -1;
  78
  79         sourcelen = strlen(source) + 1;
  80
  81         count = pStr_GetPtrA(NULL, NULL, 0);
  82         ok (count == 0, "Expected count to be 0, it was %d\n", count);
  83
  84         if (0)
  85         {
  86             /* Crashes on W98, NT4, W2K, XP, W2K3
  87              * Our implementation also crashes and we should probably leave
  88              * it like that.
  89              */
  90             count = -1;
  91             count = pStr_GetPtrA(NULL, NULL, destsize);
  92             trace("count : %d\n", count);
  93         }
  94
  95         count = 0;
  96         count = pStr_GetPtrA(source, NULL, 0);
  97         ok (count == sourcelen ||
  98             broken(count == sourcelen - 1), /* win9x */
  99             "Expected count to be %d, it was %d\n", sourcelen, count);
 100
 101         count = 0;
 102         strcpy(dest, desttest);
 103         count = pStr_GetPtrA(source, dest, 0);
 104         ok (count == sourcelen ||
 105             broken(count == 0), /* win9x */
 106             "Expected count to be %d, it was %d\n", sourcelen, count);
 107         ok (!lstrcmp(dest, desttest), "Expected destination to not have changed\n");
 108
 109         count = 0;
 110         count = pStr_GetPtrA(source, NULL, destsize);
 111         ok (count == sourcelen ||
 112             broken(count == sourcelen - 1), /* win9x */
 113             "Expected count to be %d, it was %d\n", sourcelen, count);
 114
 115         count = 0;
 116         count = pStr_GetPtrA(source, dest, destsize);
 117         ok (count == sourcelen ||
 118             broken(count == sourcelen - 1), /* win9x */
 119             "Expected count to be %d, it was %d\n", sourcelen, count);
 120         ok (!lstrcmp(source, dest), "Expected source and destination to be the same\n");
 121
 122         count = -1;
 123         strcpy(dest, desttest);
 124         count = pStr_GetPtrA(NULL, dest, destsize);
 125         ok (count == 0, "Expected count to be 0, it was %d\n", count);
 126         ok (dest[0] == '\0', "Expected destination to be cut-off and 0 terminated\n");
 127
 128         count = 0;
 129         destsize = 15;
 130         count = pStr_GetPtrA(source, dest, destsize);
 131         ok (count == 15 ||
 132             broken(count == 14), /* win9x */
 133             "Expected count to be 15, it was %d\n", count);
 134         ok (!memcmp(source, dest, 14), "Expected first part of source and destination to be the same\n");
 135         ok (dest[14] == '\0', "Expected destination to be cut-off and 0 terminated\n");
 136     }
 137 }
 138
 139 static void test_Alloc(void)
 140 {
 141     PCHAR p;
 142     BOOL res;
 143     DWORD size, min;
 144
 145     /* allocate size 0 */
 146     p = pAlloc(0);
 147     ok(p != NULL, "Expected non-NULL ptr\n");
 148
 149     /* get the minimum size */
 150     min = pGetSize(p);
 151
 152     /* free the block */
 153     res = pFree(p);
 154     ok(res == TRUE, "Expected TRUE, got %d\n", res);
 155
 156     /* allocate size 1 */
 157     p = pAlloc(1);
 158     ok(p != NULL, "Expected non-NULL ptr\n");
 159
 160     /* get the allocated size */
 161     size = pGetSize(p);
 162     ok(size == 1 ||
 163        broken(size == min), /* win9x */
 164        "Expected 1, got %d\n", size);
 165
 166     /* reallocate the block */
 167     p = pReAlloc(p, 2);
 168     ok(p != NULL, "Expected non-NULL ptr\n");
 169
 170     /* get the new size */
 171     size = pGetSize(p);
 172     ok(size == 2 ||
 173        broken(size == min), /* win9x */
 174        "Expected 2, got %d\n", size);
 175
 176     /* free the block */
 177     res = pFree(p);
 178     ok(res == TRUE, "Expected TRUE, got %d\n", res);
 179
 180     /* free a NULL ptr */
 181     res = pFree(NULL);
 182     ok(res == TRUE ||
 183        broken(res == FALSE), /* win9x */
 184        "Expected TRUE, got %d\n", res);
 185
 186     /* reallocate a NULL ptr */
 187     p = pReAlloc(NULL, 2);
 188     ok(p != NULL, "Expectd non-NULL ptr\n");
 189
 190     res = pFree(p);
 191     ok(res == TRUE, "Expected TRUE, got %d\n", res);
 192 }
 193
 194 START_TEST(misc)
 195 {
 196     if(!InitFunctionPtrs())
 197         return;
 198
 199     test_GetPtrAW();
 200     test_Alloc();
 201
 202     FreeLibrary(hComctl32);
 203 }