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