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