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) ||
 108             broken(!lstrcmp(dest, "")), /* Win7 */
 109             "Expected destination to not have changed\n");
 110
 111         count = 0;
 112         count = pStr_GetPtrA(source, NULL, destsize);
 113         ok (count == sourcelen ||
 114             broken(count == sourcelen - 1), /* win9x */
 115             "Expected count to be %d, it was %d\n", sourcelen, count);
 116
 117         count = 0;
 118         count = pStr_GetPtrA(source, dest, destsize);
 119         ok (count == sourcelen ||
 120             broken(count == sourcelen - 1), /* win9x */
 121             "Expected count to be %d, it was %d\n", sourcelen, count);
 122         ok (!lstrcmp(source, dest), "Expected source and destination to be the same\n");
 123
 124         count = -1;
 125         strcpy(dest, desttest);
 126         count = pStr_GetPtrA(NULL, dest, destsize);
 127         ok (count == 0, "Expected count to be 0, it was %d\n", count);
 128         ok (dest[0] == '\0', "Expected destination to be cut-off and 0 terminated\n");
 129
 130         count = 0;
 131         destsize = 15;
 132         count = pStr_GetPtrA(source, dest, destsize);
 133         ok (count == 15 ||
 134             broken(count == 14), /* win9x */
 135             "Expected count to be 15, it was %d\n", count);
 136         ok (!memcmp(source, dest, 14), "Expected first part of source and destination to be the same\n");
 137         ok (dest[14] == '\0', "Expected destination to be cut-off and 0 terminated\n");
 138     }
 139 }
 140
 141 static void test_Alloc(void)
 142 {
 143     PCHAR p;
 144     BOOL res;
 145     DWORD size, min;
 146
 147     /* allocate size 0 */
 148     p = pAlloc(0);
 149     ok(p != NULL, "Expected non-NULL ptr\n");
 150
 151     /* get the minimum size */
 152     min = pGetSize(p);
 153
 154     /* free the block */
 155     res = pFree(p);
 156     ok(res == TRUE, "Expected TRUE, got %d\n", res);
 157
 158     /* allocate size 1 */
 159     p = pAlloc(1);
 160     ok(p != NULL, "Expected non-NULL ptr\n");
 161
 162     /* get the allocated size */
 163     size = pGetSize(p);
 164     ok(size == 1 ||
 165        broken(size == min), /* win9x */
 166        "Expected 1, got %d\n", size);
 167
 168     /* reallocate the block */
 169     p = pReAlloc(p, 2);
 170     ok(p != NULL, "Expected non-NULL ptr\n");
 171
 172     /* get the new size */
 173     size = pGetSize(p);
 174     ok(size == 2 ||
 175        broken(size == min), /* win9x */
 176        "Expected 2, got %d\n", size);
 177
 178     /* free the block */
 179     res = pFree(p);
 180     ok(res == TRUE, "Expected TRUE, got %d\n", res);
 181
 182     /* free a NULL ptr */
 183     res = pFree(NULL);
 184     ok(res == TRUE ||
 185        broken(res == FALSE), /* win9x */
 186        "Expected TRUE, got %d\n", res);
 187
 188     /* reallocate a NULL ptr */
 189     p = pReAlloc(NULL, 2);
 190     ok(p != NULL, "Expectd non-NULL ptr\n");
 191
 192     res = pFree(p);
 193     ok(res == TRUE, "Expected TRUE, got %d\n", res);
 194 }
 195
 196 START_TEST(misc)
 197 {
 198     if(!InitFunctionPtrs())
 199         return;
 200
 201     test_GetPtrAW();
 202     test_Alloc();
 203
 204     FreeLibrary(hComctl32);
 205 }