git.oblomov.eu Git - wine/blob - dlls/msvcp90/tests/string.c

   1 /*
   2  * Copyright 2010 Piotr Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdio.h>
  20
  21 #include <windef.h>
  22 #include <winbase.h>
  23 #include "wine/test.h"
  24
  25 /* basic_string<char, char_traits<char>, allocator<char>> */
  26 #define BUF_SIZE_CHAR 16
  27 typedef struct _basic_string_char
  28 {
  29     void *allocator;
  30     union {
  31         char buf[BUF_SIZE_CHAR];
  32         char *ptr;
  33     } data;
  34     size_t size;
  35     size_t res;
  36 } basic_string_char;
  37
  38 /* basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t>> */
  39 #define BUF_SIZE_WCHAR 8
  40 typedef struct _basic_string_wchar
  41 {
  42     void *allocator;
  43     union {
  44         wchar_t buf[BUF_SIZE_WCHAR];
  45         wchar_t *ptr;
  46     } data;
  47     size_t size;
  48     size_t res;
  49 } basic_string_wchar;
  50
  51 static void* (__cdecl *p_set_invalid_parameter_handler)(void*);
  52
  53 #ifdef __i386__
  54 static basic_string_char* (WINAPI *p_basic_string_char_ctor)(void);
  55 static basic_string_char* (WINAPI *p_basic_string_char_copy_ctor)(basic_string_char*);
  56 static basic_string_char* (WINAPI *p_basic_string_char_ctor_cstr)(const char*);
  57 static void (WINAPI *p_basic_string_char_dtor)(void);
  58 static basic_string_char* (WINAPI *p_basic_string_char_erase)(size_t, size_t);
  59 static basic_string_char* (WINAPI *p_basic_string_char_assign_cstr_len)(const char*, size_t);
  60 static const char* (WINAPI *p_basic_string_char_cstr)(void);
  61 static const char* (WINAPI *p_basic_string_char_data)(void);
  62 static size_t (WINAPI *p_basic_string_char_size)(void);
  63 static void (WINAPI *p_basic_string_char_swap)(basic_string_char*);
  64 static basic_string_char* (WINAPI *p_basic_string_char_append)(basic_string_char*);
  65 static basic_string_char* (WINAPI *p_basic_string_char_append_substr)(basic_string_char*, size_t, size_t);
  66 static int (WINAPI *p_basic_string_char_compare_substr_substr)(size_t, size_t, basic_string_char*, size_t, size_t);
  67 static int (WINAPI *p_basic_string_char_compare_substr_cstr_len)(size_t, size_t, const char*, size_t);
  68
  69 static basic_string_wchar* (WINAPI *p_basic_string_wchar_ctor)(void);
  70 static basic_string_wchar* (WINAPI *p_basic_string_wchar_copy_ctor)(basic_string_wchar*);
  71 static basic_string_wchar* (WINAPI *p_basic_string_wchar_ctor_cstr)(const wchar_t*);
  72 static void (WINAPI *p_basic_string_wchar_dtor)(void);
  73 static basic_string_wchar* (WINAPI *p_basic_string_wchar_erase)(size_t, size_t);
  74 static basic_string_wchar* (WINAPI *p_basic_string_wchar_assign_cstr_len)(const wchar_t*, size_t);
  75 static const wchar_t* (WINAPI *p_basic_string_wchar_cstr)(void);
  76 static const wchar_t* (WINAPI *p_basic_string_wchar_data)(void);
  77 static size_t (WINAPI *p_basic_string_wchar_size)(void);
  78 static void (WINAPI *p_basic_string_wchar_swap)(basic_string_wchar*);
  79 #else
  80 static basic_string_char* (__cdecl *p_basic_string_char_ctor)(basic_string_char*);
  81 static basic_string_char* (__cdecl *p_basic_string_char_copy_ctor)(basic_string_char*, basic_string_char*);
  82 static basic_string_char* (__cdecl *p_basic_string_char_ctor_cstr)(basic_string_char*, const char*);
  83 static void (__cdecl *p_basic_string_char_dtor)(basic_string_char*);
  84 static basic_string_char* (__cdecl *p_basic_string_char_erase)(basic_string_char*, size_t, size_t);
  85 static basic_string_char* (__cdecl *p_basic_string_char_assign_cstr_len)(basic_string_char*, const char*, size_t);
  86 static const char* (__cdecl *p_basic_string_char_cstr)(basic_string_char*);
  87 static const char* (__cdecl *p_basic_string_char_data)(basic_string_char*);
  88 static size_t (__cdecl *p_basic_string_char_size)(basic_string_char*);
  89 static void (__cdecl *p_basic_string_char_swap)(basic_string_char*, basic_string_char*);
  90 static basic_string_char* (WINAPI *p_basic_string_char_append)(basic_string_char*, basic_string_char*);
  91 static basic_string_char* (WINAPI *p_basic_string_char_append_substr)(basic_string_char*, basic_string_char*, size_t, size_t);
  92 static int (WINAPI *p_basic_string_char_compare_substr_substr)(basic_string_char*, size_t, size_t, basic_string_char*, size_t, size_t);
  93 static int (WINAPI *p_basic_string_char_compare_substr_cstr_len)(basic_string_char*, size_t, size_t, const char*, size_t);
  94
  95 static basic_string_wchar* (__cdecl *p_basic_string_wchar_ctor)(basic_string_wchar*);
  96 static basic_string_wchar* (__cdecl *p_basic_string_wchar_copy_ctor)(basic_string_wchar*, basic_string_wchar*);
  97 static basic_string_wchar* (__cdecl *p_basic_string_wchar_ctor_cstr)(basic_string_wchar*, const wchar_t*);
  98 static void (__cdecl *p_basic_string_wchar_dtor)(basic_string_wchar*);
  99 static basic_string_wchar* (__cdecl *p_basic_string_wchar_erase)(basic_string_wchar*, size_t, size_t);
 100 static basic_string_wchar* (__cdecl *p_basic_string_wchar_assign_cstr_len)(basic_string_wchar*, const wchar_t*, size_t);
 101 static const wchar_t* (__cdecl *p_basic_string_wchar_cstr)(basic_string_wchar*);
 102 static const wchar_t* (__cdecl *p_basic_string_wchar_data)(basic_string_wchar*);
 103 static size_t (__cdecl *p_basic_string_wchar_size)(basic_string_wchar*);
 104 static void (__cdecl *p_basic_string_wchar_swap)(basic_string_wchar*, basic_string_wchar*);
 105 #endif
 106
 107 static int invalid_parameter = 0;
 108 static void __cdecl test_invalid_parameter_handler(const wchar_t *expression,
 109         const wchar_t *function, const wchar_t *file,
 110         unsigned line, uintptr_t arg)
 111 {
 112     ok(expression == NULL, "expression is not NULL\n");
 113     ok(function == NULL, "function is not NULL\n");
 114     ok(file == NULL, "file is not NULL\n");
 115     ok(line == 0, "line = %u\n", line);
 116     ok(arg == 0, "arg = %lx\n", (UINT_PTR)arg);
 117     invalid_parameter++;
 118 }
 119
 120 /* Emulate a __thiscall */
 121 #ifdef __i386__
 122 #ifdef _MSC_VER
 123 static inline void* do_call_func1(void *func, void *_this)
 124 {
 125     volatile void* retval = 0;
 126     __asm
 127     {
 128         push ecx
 129         mov ecx, _this
 130         call func
 131         mov retval, eax
 132         pop ecx
 133     }
 134     return (void*)retval;
 135 }
 136
 137 static inline void* do_call_func2(void *func, void *_this, const void *arg)
 138 {
 139     volatile void* retval = 0;
 140     __asm
 141     {
 142         push ecx
 143         push arg
 144         mov ecx, _this
 145         call func
 146         mov retval, eax
 147         pop ecx
 148     }
 149     return (void*)retval;
 150 }
 151
 152 static inline void* do_call_func3(void *func, void *_this,
 153         const void *arg1, const void *arg2)
 154 {
 155     volatile void* retval = 0;
 156     __asm
 157     {
 158         push ecx
 159         push arg1
 160         push arg2
 161         mov ecx, _this
 162         call func
 163         mov retval, eax
 164         pop ecx
 165     }
 166     return (void*)retval;
 167 }
 168
 169 static inline void* do_call_func4(void *func, void *_this,
 170         const void *arg1, const void *arg2, const void *arg3)
 171 {
 172     volatile void* retval = 0;
 173     __asm
 174     {
 175         push ecx
 176         push arg1
 177         push arg2
 178         push arg3
 179         mov ecx, _this
 180         call func
 181         mov retval, eax
 182         pop ecx
 183     }
 184     return (void*)retval;
 185 }
 186
 187 static inline void* do_call_func5(void *func, void *_this,
 188         const void *arg1, const void *arg2, const void *arg3, const void *arg4)
 189 {
 190     volatile void* retval = 0;
 191     __asm
 192     {
 193         push ecx
 194         push arg1
 195         push arg2
 196         push arg3
 197         push arg4
 198         mov ecx, _this
 199         call func
 200         mov retval, eax
 201         pop ecx
 202     }
 203     return (void*)retval;
 204 }
 205
 206 static inline void* do_call_func6(void *func, void *_this,
 207         const void *arg1, const void *arg2, const void *arg3,
 208         const void *arg4, const void *arg5)
 209 {
 210     volatile void* retval = 0;
 211     __asm
 212     {
 213         push ecx
 214         push arg1
 215         push arg2
 216         push arg3
 217         push arg4
 218         push arg5
 219         mov ecx, _this
 220         call func
 221         mov retval, eax
 222         pop ecx
 223     }
 224     return (void*)retval;
 225 }
 226 #else
 227 static void* do_call_func1(void *func, void *_this)
 228 {
 229     void *ret, *dummy;
 230     __asm__ __volatile__ (
 231             "call *%2"
 232             : "=a" (ret), "=c" (dummy)
 233             : "g" (func), "1" (_this)
 234             : "edx", "memory"
 235             );
 236     return ret;
 237 }
 238
 239 static void* do_call_func2(void *func, void *_this, const void *arg)
 240 {
 241     void *ret, *dummy;
 242     __asm__ __volatile__ (
 243             "pushl %3\n\tcall *%2"
 244             : "=a" (ret), "=c" (dummy)
 245             : "r" (func), "r" (arg), "1" (_this)
 246             : "edx", "memory"
 247             );
 248     return ret;
 249 }
 250
 251 static void* do_call_func3(void *func, void *_this,
 252         const void *arg1, const void *arg2)
 253 {
 254     void *ret, *dummy;
 255     __asm__ __volatile__ (
 256             "pushl %4\n\tpushl %3\n\tcall *%2"
 257             : "=a" (ret), "=c" (dummy)
 258             : "r" (func), "r" (arg1), "r" (arg2), "1" (_this)
 259             : "edx", "memory"
 260             );
 261     return ret;
 262 }
 263
 264 static void* do_call_func4(void *func, void *_this,
 265         const void *arg1, const void *arg2, const void *arg3)
 266 {
 267     void *ret, *dummy;
 268     __asm__ __volatile__ (
 269             "pushl %5\n\tpushl %4\n\tpushl %3\n\tcall *%2"
 270             : "=a" (ret), "=c" (dummy)
 271             : "r" (func), "r" (arg1), "r" (arg2), "m" (arg3), "1" (_this)
 272             : "edx", "memory"
 273             );
 274     return ret;
 275 }
 276
 277 static void* do_call_func5(void *func, void *_this,
 278         const void *arg1, const void *arg2, const void *arg3, const void *arg4)
 279 {
 280     void *ret, *dummy;
 281     __asm__ __volatile__ (
 282             "pushl %6\n\tpushl %5\n\tpushl %4\n\tpushl %3\n\tcall *%2"
 283             : "=a" (ret), "=c" (dummy)
 284             : "r" (func), "r" (arg1), "r" (arg2), "m" (arg3), "m" (arg4), "1" (_this)
 285             : "edx", "memory"
 286             );
 287     return ret;
 288 }
 289
 290 static void* do_call_func6(void *func, void *_this,
 291         const void *arg1, const void *arg2, const void *arg3,
 292         const void *arg4, const void *arg5)
 293 {
 294     void *ret, *dummy;
 295     __asm__ __volatile__ (
 296             "pushl %7\n\tpushl %6\n\tpushl %5\n\tpushl %4\n\tpushl %3\n\tcall *%2"
 297             : "=a" (ret), "=c" (dummy)
 298             : "r" (func), "r" (arg1), "r" (arg2), "m" (arg3), "m" (arg4), "m" (arg5), "1" (_this)
 299             : "edx", "memory"
 300             );
 301     return ret;
 302 }
 303 #endif
 304
 305 #define call_func1(func,_this)   do_call_func1(func,_this)
 306 #define call_func2(func,_this,a) do_call_func2(func,_this,(const void*)a)
 307 #define call_func3(func,_this,a,b) do_call_func3(func,_this,(const void*)a,(const void*)b)
 308 #define call_func4(func,_this,a,b,c) do_call_func4(func,_this,(const void*)a,\
 309         (const void*)b,(const void*)c)
 310 #define call_func5(func,_this,a,b,c,d) do_call_func5(func,_this,(const void*)a,\
 311         (const void*)b,(const void*)c,(const void*)d)
 312 #define call_func6(func,_this,a,b,c,d,e) do_call_func6(func,_this,(const void*)a,\
 313         (const void*)b,(const void*)c,(const void*)d,(const void*)e)
 314
 315 #else
 316
 317 #define call_func1(func,_this) func(_this)
 318 #define call_func2(func,_this,a) func(_this,a)
 319 #define call_func3(func,_this,a,b) func(_this,a,b)
 320 #define call_func4(func,_this,a,b,c) func(_this,a,b,c)
 321 #define call_func5(func,_this,a,b,c,d) func(_this,a,b,c,d)
 322 #define call_func6(func,_this,a,b,c,d,e) func(_this,a,b,c,d,e)
 323
 324 #endif /* __i386__ */
 325
 326 static BOOL init(void)
 327 {
 328     HMODULE msvcr = LoadLibraryA("msvcr90.dll");
 329     HMODULE msvcp = LoadLibraryA("msvcp90.dll");
 330     if(!msvcr || !msvcp) {
 331         win_skip("msvcp90.dll or msvcrt90.dll not installed\n");
 332         return FALSE;
 333     }
 334
 335     p_set_invalid_parameter_handler = (void*)GetProcAddress(msvcr, "_set_invalid_parameter_handler");
 336     if(!p_set_invalid_parameter_handler) {
 337         win_skip("Error setting tests environment\n");
 338         return FALSE;
 339     }
 340
 341     p_set_invalid_parameter_handler(test_invalid_parameter_handler);
 342
 343     if(sizeof(void*) == 8) { /* 64-bit initialization */
 344         p_basic_string_char_ctor = (void*)GetProcAddress(msvcp,
 345                 "??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ");
 346         p_basic_string_char_copy_ctor = (void*)GetProcAddress(msvcp,
 347                 "??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@AEBV01@@Z");
 348         p_basic_string_char_ctor_cstr = (void*)GetProcAddress(msvcp,
 349                 "??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@PEBD@Z");
 350         p_basic_string_char_dtor = (void*)GetProcAddress(msvcp,
 351                 "??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ");
 352         p_basic_string_char_erase = (void*)GetProcAddress(msvcp,
 353                 "?erase@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAAAEAV12@_K0@Z");
 354         p_basic_string_char_assign_cstr_len = (void*)GetProcAddress(msvcp,
 355                 "?assign@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAAAEAV12@PEBD_K@Z");
 356         p_basic_string_char_cstr = (void*)GetProcAddress(msvcp,
 357                 "?c_str@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBAPEBDXZ");
 358         p_basic_string_char_data = (void*)GetProcAddress(msvcp,
 359                 "?data@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBAPEBDXZ");
 360         p_basic_string_char_size = (void*)GetProcAddress(msvcp,
 361                 "?size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBA_KXZ");
 362         p_basic_string_char_swap = (void*)GetProcAddress(msvcp,
 363                 "?swap@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAAXAEAV12@@Z");
 364         p_basic_string_char_append = (void*)GetProcAddress(msvcp,
 365                 "?append@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAAAEAV12@AEBV12@@Z");
 366         p_basic_string_char_append_substr = (void*)GetProcAddress(msvcp,
 367                 "?append@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAAAEAV12@AEBV12@_K1@Z");
 368         p_basic_string_char_compare_substr_substr = (void*)GetProcAddress(msvcp,
 369                 "?compare@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBAH_K0AEBV12@00@Z");
 370         p_basic_string_char_compare_substr_cstr_len = (void*)GetProcAddress(msvcp,
 371                 "?compare@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBAH_K0PEBD0@Z");
 372
 373         p_basic_string_wchar_ctor = (void*)GetProcAddress(msvcp,
 374                 "??0?$basic_string@_WU?$char_traits@_W@std@@V?$allocator@_W@2@@std@@QEAA@XZ");
 375         p_basic_string_wchar_copy_ctor = (void*)GetProcAddress(msvcp,
 376                 "??0?$basic_string@_WU?$char_traits@_W@std@@V?$allocator@_W@2@@std@@QEAA@AEBV01@@Z");
 377         p_basic_string_wchar_ctor_cstr = (void*)GetProcAddress(msvcp,
 378                 "??0?$basic_string@_WU?$char_traits@_W@std@@V?$allocator@_W@2@@std@@QEAA@PEB_W@Z");
 379         p_basic_string_wchar_dtor = (void*)GetProcAddress(msvcp,
 380                 "??1?$basic_string@_WU?$char_traits@_W@std@@V?$allocator@_W@2@@std@@QEAA@XZ");
 381         p_basic_string_wchar_erase = (void*)GetProcAddress(msvcp,
 382                 "?erase@?$basic_string@_WU?$char_traits@_W@std@@V?$allocator@_W@2@@std@@QEAAAEAV12@_K0@Z");
 383         p_basic_string_wchar_assign_cstr_len = (void*)GetProcAddress(msvcp,
 384                 "?assign@?$basic_string@_WU?$char_traits@_W@std@@V?$allocator@_W@2@@std@@QEAAAEAV12@PEB_W_K@Z");
 385         p_basic_string_wchar_cstr = (void*)GetProcAddress(msvcp,
 386                 "?c_str@?$basic_string@_WU?$char_traits@_W@std@@V?$allocator@_W@2@@std@@QEBAPEB_WXZ");
 387         p_basic_string_wchar_data = (void*)GetProcAddress(msvcp,
 388                 "?data@?$basic_string@_WU?$char_traits@_W@std@@V?$allocator@_W@2@@std@@QEBAPEB_WXZ");
 389         p_basic_string_wchar_size = (void*)GetProcAddress(msvcp,
 390                 "?size@?$basic_string@_WU?$char_traits@_W@std@@V?$allocator@_W@2@@std@@QEBA_KXZ");
 391         p_basic_string_wchar_swap = (void*)GetProcAddress(msvcp,
 392                 "?swap@?$basic_string@_WU?$char_traits@_W@std@@V?$allocator@_W@2@@std@@QEAAXAEAV12@@Z");
 393     } else {
 394         p_basic_string_char_ctor = (void*)GetProcAddress(msvcp,
 395                 "??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ");
 396         p_basic_string_char_copy_ctor = (void*)GetProcAddress(msvcp,
 397                 "??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@ABV01@@Z");
 398         p_basic_string_char_ctor_cstr = (void*)GetProcAddress(msvcp,
 399                 "??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@PBD@Z");
 400         p_basic_string_char_dtor = (void*)GetProcAddress(msvcp,
 401                 "??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ");
 402         p_basic_string_char_erase = (void*)GetProcAddress(msvcp,
 403                 "?erase@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV12@II@Z");
 404         p_basic_string_char_assign_cstr_len = (void*)GetProcAddress(msvcp,
 405                 "?assign@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV12@PBDI@Z");
 406         p_basic_string_char_cstr = (void*)GetProcAddress(msvcp,
 407                 "?c_str@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEPBDXZ");
 408         p_basic_string_char_data = (void*)GetProcAddress(msvcp,
 409                 "?data@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEPBDXZ");
 410         p_basic_string_char_size = (void*)GetProcAddress(msvcp,
 411                 "?size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEIXZ");
 412         p_basic_string_char_swap = (void*)GetProcAddress(msvcp,
 413                 "?swap@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEXAAV12@@Z");
 414         p_basic_string_char_append = (void*)GetProcAddress(msvcp,
 415                 "?append@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV12@ABV12@@Z");
 416         p_basic_string_char_append_substr = (void*)GetProcAddress(msvcp,
 417                 "?append@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV12@ABV12@II@Z");
 418         p_basic_string_char_compare_substr_substr = (void*)GetProcAddress(msvcp,
 419                 "?compare@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEHIIABV12@II@Z");
 420         p_basic_string_char_compare_substr_cstr_len = (void*)GetProcAddress(msvcp,
 421                 "?compare@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEHIIPBDI@Z");
 422
 423         p_basic_string_wchar_ctor = (void*)GetProcAddress(msvcp,
 424                 "??0?$basic_string@_WU?$char_traits@_W@std@@V?$allocator@_W@2@@std@@QAE@XZ");
 425         p_basic_string_wchar_copy_ctor = (void*)GetProcAddress(msvcp,
 426                 "??0?$basic_string@_WU?$char_traits@_W@std@@V?$allocator@_W@2@@std@@QAE@ABV01@@Z");
 427         p_basic_string_wchar_ctor_cstr = (void*)GetProcAddress(msvcp,
 428                 "??0?$basic_string@_WU?$char_traits@_W@std@@V?$allocator@_W@2@@std@@QAE@PB_W@Z");
 429         p_basic_string_wchar_dtor = (void*)GetProcAddress(msvcp,
 430                 "??1?$basic_string@_WU?$char_traits@_W@std@@V?$allocator@_W@2@@std@@QAE@XZ");
 431         p_basic_string_wchar_erase = (void*)GetProcAddress(msvcp,
 432                 "?erase@?$basic_string@_WU?$char_traits@_W@std@@V?$allocator@_W@2@@std@@QAEAAV12@II@Z");
 433         p_basic_string_wchar_assign_cstr_len = (void*)GetProcAddress(msvcp,
 434                 "?assign@?$basic_string@_WU?$char_traits@_W@std@@V?$allocator@_W@2@@std@@QAEAAV12@PB_WI@Z");
 435         p_basic_string_wchar_cstr = (void*)GetProcAddress(msvcp,
 436                 "?c_str@?$basic_string@_WU?$char_traits@_W@std@@V?$allocator@_W@2@@std@@QBEPB_WXZ");
 437         p_basic_string_wchar_data = (void*)GetProcAddress(msvcp,
 438                 "?data@?$basic_string@_WU?$char_traits@_W@std@@V?$allocator@_W@2@@std@@QBEPB_WXZ");
 439         p_basic_string_wchar_size = (void*)GetProcAddress(msvcp,
 440                 "?size@?$basic_string@_WU?$char_traits@_W@std@@V?$allocator@_W@2@@std@@QBEIXZ");
 441         p_basic_string_wchar_swap = (void*)GetProcAddress(msvcp,
 442                 "?swap@?$basic_string@_WU?$char_traits@_W@std@@V?$allocator@_W@2@@std@@QAEXAAV12@@Z");
 443     }
 444
 445     return TRUE;
 446 }
 447
 448 static void test_basic_string_char(void) {
 449     basic_string_char str1, str2, *pstr;
 450     const char *str;
 451     size_t size;
 452
 453     if(!p_basic_string_char_ctor || !p_basic_string_char_copy_ctor
 454             || !p_basic_string_char_ctor_cstr || !p_basic_string_char_dtor
 455             || !p_basic_string_char_erase || !p_basic_string_char_assign_cstr_len
 456             || !p_basic_string_char_cstr || !p_basic_string_char_data
 457             || !p_basic_string_char_size) {
 458         win_skip("basic_string<char> unavailable\n");
 459         return;
 460     }
 461
 462     call_func1(p_basic_string_char_ctor, &str1);
 463     str = NULL;
 464     str = call_func1(p_basic_string_char_cstr, &str1);
 465     ok(str != NULL, "str = NULL\n");
 466     ok(*str == '\0', "*str = %c\n", *str);
 467     str = call_func1(p_basic_string_char_data, &str1);
 468     ok(str != NULL, "str = NULL\n");
 469     ok(*str == '\0', "*str = %c\n", *str);
 470     call_func1(p_basic_string_char_dtor, &str1);
 471
 472     pstr = call_func2(p_basic_string_char_ctor_cstr, &str1, "test");
 473     ok(pstr == &str1, "pstr != &str1\n");
 474     str = call_func1(p_basic_string_char_cstr, &str1);
 475     ok(!memcmp(str, "test", 5), "str = %s\n", str);
 476     str = call_func1(p_basic_string_char_data, &str1);
 477     ok(!memcmp(str, "test", 5), "str = %s\n", str);
 478     size = (size_t)call_func1(p_basic_string_char_size, &str1);
 479     ok(size == 4, "size = %lu\n", (unsigned long)size);
 480
 481     pstr = call_func2(p_basic_string_char_copy_ctor, &str2, &str1);
 482     ok(pstr == &str2, "pstr != &str2\n");
 483     str = call_func1(p_basic_string_char_cstr, &str2);
 484     ok(!memcmp(str, "test", 5), "str = %s\n", str);
 485     str = call_func1(p_basic_string_char_data, &str2);
 486     ok(!memcmp(str, "test", 5), "str = %s\n", str);
 487
 488     call_func3(p_basic_string_char_erase, &str2, 1, 2);
 489     str = call_func1(p_basic_string_char_cstr, &str2);
 490     ok(!memcmp(str, "tt", 3), "str = %s\n", str);
 491     str = call_func1(p_basic_string_char_data, &str2);
 492     ok(!memcmp(str, "tt", 3), "str = %s\n", str);
 493     size = (size_t)call_func1(p_basic_string_char_size, &str1);
 494     ok(size == 4, "size = %lu\n", (unsigned long)size);
 495
 496     call_func3(p_basic_string_char_erase, &str2, 1, 100);
 497     str = call_func1(p_basic_string_char_cstr, &str2);
 498     ok(!memcmp(str, "t", 2), "str = %s\n", str);
 499     str = call_func1(p_basic_string_char_data, &str2);
 500     ok(!memcmp(str, "t", 2), "str = %s\n", str);
 501     size = (size_t)call_func1(p_basic_string_char_size, &str1);
 502     ok(size == 4, "size = %lu\n", (unsigned long)size);
 503
 504     call_func3(p_basic_string_char_assign_cstr_len, &str2, "test", 4);
 505     str = call_func1(p_basic_string_char_cstr, &str2);
 506     ok(!memcmp(str, "test", 5), "str = %s\n", str);
 507     str = call_func1(p_basic_string_char_data, &str2);
 508     ok(!memcmp(str, "test", 5), "str = %s\n", str);
 509
 510     call_func3(p_basic_string_char_assign_cstr_len, &str2, (str+1), 2);
 511     str = call_func1(p_basic_string_char_cstr, &str2);
 512     ok(!memcmp(str, "es", 3), "str = %s\n", str);
 513     str = call_func1(p_basic_string_char_data, &str2);
 514     ok(!memcmp(str, "es", 3), "str = %s\n", str);
 515
 516     call_func1(p_basic_string_char_dtor, &str1);
 517     call_func1(p_basic_string_char_dtor, &str2);
 518 }
 519
 520 static void test_basic_string_char_swap(void) {
 521     basic_string_char str1, str2;
 522     char atmp1[32], atmp2[32];
 523
 524     if(!p_basic_string_char_ctor_cstr || !p_basic_string_char_dtor ||
 525             !p_basic_string_char_swap || !p_basic_string_char_cstr) {
 526         win_skip("basic_string<char> unavailable\n");
 527         return;
 528     }
 529
 530     /* Swap self, local */
 531     strcpy(atmp1, "qwerty");
 532     call_func2(p_basic_string_char_ctor_cstr, &str1, atmp1);
 533     call_func2(p_basic_string_char_swap, &str1, &str1);
 534     ok(strcmp(atmp1, (const char *) call_func1(p_basic_string_char_cstr, &str1)) == 0, "Invalid value of str1\n");
 535     call_func2(p_basic_string_char_swap, &str1, &str1);
 536     ok(strcmp(atmp1, (const char *) call_func1(p_basic_string_char_cstr, &str1)) == 0, "Invalid value of str1\n");
 537     call_func1(p_basic_string_char_dtor, &str1);
 538
 539     /* str1 allocated, str2 local */
 540     strcpy(atmp1, "qwerty12345678901234567890");
 541     strcpy(atmp2, "asd");
 542     call_func2(p_basic_string_char_ctor_cstr, &str1, atmp1);
 543     call_func2(p_basic_string_char_ctor_cstr, &str2, atmp2);
 544     call_func2(p_basic_string_char_swap, &str1, &str2);
 545     ok(strcmp(atmp2, (const char *) call_func1(p_basic_string_char_cstr, &str1)) == 0, "Invalid value of str1\n");
 546     ok(strcmp(atmp1, (const char *) call_func1(p_basic_string_char_cstr, &str2)) == 0, "Invalid value of str2\n");
 547     call_func2(p_basic_string_char_swap, &str1, &str2);
 548     ok(strcmp(atmp1, (const char *) call_func1(p_basic_string_char_cstr, &str1)) == 0, "Invalid value of str1\n");
 549     ok(strcmp(atmp2, (const char *) call_func1(p_basic_string_char_cstr, &str2)) == 0, "Invalid value of str2\n");
 550     call_func1(p_basic_string_char_dtor, &str1);
 551     call_func1(p_basic_string_char_dtor, &str2);
 552 }
 553
 554 static void test_basic_string_char_append(void) {
 555     basic_string_char str1, str2;
 556     const char *str;
 557
 558     if(!p_basic_string_char_ctor_cstr || !p_basic_string_char_dtor
 559             || !p_basic_string_char_append || !p_basic_string_char_append_substr
 560             || !p_basic_string_char_cstr) {
 561         win_skip("basic_string<char> unavailable\n");
 562         return;
 563     }
 564
 565     call_func2(p_basic_string_char_ctor_cstr, &str1, "");
 566     call_func2(p_basic_string_char_ctor_cstr, &str2, "append");
 567
 568     call_func2(p_basic_string_char_append, &str1, &str2);
 569     str = call_func1(p_basic_string_char_cstr, &str1);
 570     ok(!memcmp(str, "append", 7), "str = %s\n", str);
 571
 572     call_func4(p_basic_string_char_append_substr, &str1, &str2, 3, 1);
 573     str = call_func1(p_basic_string_char_cstr, &str1);
 574     ok(!memcmp(str, "appende", 8), "str = %s\n", str);
 575
 576     call_func4(p_basic_string_char_append_substr, &str1, &str2, 5, 100);
 577     str = call_func1(p_basic_string_char_cstr, &str1);
 578     ok(!memcmp(str, "appended", 9), "str = %s\n", str);
 579
 580     call_func4(p_basic_string_char_append_substr, &str1, &str2, 6, 100);
 581     str = call_func1(p_basic_string_char_cstr, &str1);
 582     ok(!memcmp(str, "appended", 9), "str = %s\n", str);
 583
 584     call_func1(p_basic_string_char_dtor, &str1);
 585     call_func1(p_basic_string_char_dtor, &str2);
 586 }
 587
 588 static void test_basic_string_char_compare(void) {
 589     basic_string_char str1, str2;
 590     int ret;
 591
 592     if(!p_basic_string_char_ctor_cstr || !p_basic_string_char_dtor
 593             || !p_basic_string_char_compare_substr_substr
 594             || !p_basic_string_char_compare_substr_cstr_len) {
 595         win_skip("basic_string<char> unavailable\n");
 596         return;
 597     }
 598
 599     call_func2(p_basic_string_char_ctor_cstr, &str1, "str1str");
 600     call_func2(p_basic_string_char_ctor_cstr, &str2, "str9str");
 601
 602     ret = (int)call_func6(p_basic_string_char_compare_substr_substr,
 603             &str1, 0, 3, &str2, 0, 3);
 604     ok(ret == 0, "ret = %d\n", ret);
 605     ret = (int)call_func6(p_basic_string_char_compare_substr_substr,
 606             &str1, 4, 3, &str2, 4, 10);
 607     ok(ret == 0, "ret = %d\n", ret);
 608     ret = (int)call_func6(p_basic_string_char_compare_substr_substr,
 609             &str1, 1, 3, &str2, 1, 4);
 610     ok(ret == -1, "ret = %d\n", ret);
 611
 612     ret = (int)call_func5(p_basic_string_char_compare_substr_cstr_len,
 613             &str1, 0, 1000, "str1str", 7);
 614     ok(ret == 0, "ret = %d\n", ret);
 615     ret = (int)call_func5(p_basic_string_char_compare_substr_cstr_len,
 616             &str1, 1, 2, "tr", 2);
 617     ok(ret == 0, "ret = %d\n", ret);
 618     ret = (int)call_func5(p_basic_string_char_compare_substr_cstr_len,
 619             &str1, 1, 0, "aaa", 0);
 620     ok(ret == 0, "ret = %d\n", ret);
 621     ret = (int)call_func5(p_basic_string_char_compare_substr_cstr_len,
 622             &str1, 1, 0, "aaa", 1);
 623     ok(ret == -1, "ret = %d\n", ret);
 624
 625     call_func1(p_basic_string_char_dtor, &str1);
 626     call_func1(p_basic_string_char_dtor, &str2);
 627 }
 628
 629 static void test_basic_string_wchar(void) {
 630     static const wchar_t test[] = { 't','e','s','t',0 };
 631
 632     basic_string_wchar str1, str2, *pstr;
 633     const wchar_t *str;
 634     size_t size;
 635
 636     if(!p_basic_string_wchar_ctor || !p_basic_string_wchar_copy_ctor
 637             || !p_basic_string_wchar_ctor_cstr || !p_basic_string_wchar_dtor
 638             || !p_basic_string_wchar_erase || !p_basic_string_wchar_assign_cstr_len
 639             || !p_basic_string_wchar_cstr || !p_basic_string_wchar_data
 640             || !p_basic_string_wchar_size) {
 641         win_skip("basic_string<wchar_t> unavailable\n");
 642         return;
 643     }
 644
 645     call_func1(p_basic_string_wchar_ctor, &str1);
 646     str = NULL;
 647     str = call_func1(p_basic_string_wchar_cstr, &str1);
 648     ok(str != NULL, "str = NULL\n");
 649     ok(*str == '\0', "*str = %c\n", *str);
 650     str = call_func1(p_basic_string_wchar_data, &str1);
 651     ok(str != NULL, "str = NULL\n");
 652     ok(*str == '\0', "*str = %c\n", *str);
 653     call_func1(p_basic_string_wchar_dtor, &str1);
 654
 655     pstr = call_func2(p_basic_string_wchar_ctor_cstr, &str1, test);
 656     ok(pstr == &str1, "pstr != &str1\n");
 657     str = call_func1(p_basic_string_wchar_cstr, &str1);
 658     ok(!memcmp(str, test, 5*sizeof(wchar_t)), "str = %s\n", wine_dbgstr_w(str));
 659     str = call_func1(p_basic_string_wchar_data, &str1);
 660     ok(!memcmp(str, test, 5*sizeof(wchar_t)), "str = %s\n", wine_dbgstr_w(str));
 661     size = (size_t)call_func1(p_basic_string_wchar_size, &str1);
 662     ok(size == 4, "size = %lu\n", (unsigned long)size);
 663
 664     memset(&str2, 0, sizeof(basic_string_wchar));
 665     pstr = call_func2(p_basic_string_wchar_copy_ctor, &str2, &str1);
 666     ok(pstr == &str2, "pstr != &str2\n");
 667     str = call_func1(p_basic_string_wchar_cstr, &str2);
 668     ok(!memcmp(str, test, 5*sizeof(wchar_t)), "str = %s\n", wine_dbgstr_w(str));
 669     str = call_func1(p_basic_string_wchar_data, &str2);
 670     ok(!memcmp(str, test, 5*sizeof(wchar_t)), "str = %s\n", wine_dbgstr_w(str));
 671
 672     call_func3(p_basic_string_wchar_erase, &str2, 1, 2);
 673     str = call_func1(p_basic_string_wchar_cstr, &str2);
 674     ok(str[0]=='t' && str[1]=='t' && str[2]=='\0', "str = %s\n", wine_dbgstr_w(str));
 675     str = call_func1(p_basic_string_wchar_data, &str2);
 676     ok(str[0]=='t' && str[1]=='t' && str[2]=='\0', "str = %s\n", wine_dbgstr_w(str));
 677     size = (size_t)call_func1(p_basic_string_wchar_size, &str1);
 678     ok(size == 4, "size = %lu\n", (unsigned long)size);
 679
 680     call_func3(p_basic_string_wchar_erase, &str2, 1, 100);
 681     str = call_func1(p_basic_string_wchar_cstr, &str2);
 682     ok(str[0]=='t' && str[1]=='\0', "str = %s\n", wine_dbgstr_w(str));
 683     str = call_func1(p_basic_string_wchar_data, &str2);
 684     ok(str[0]=='t' && str[1]=='\0', "str = %s\n", wine_dbgstr_w(str));
 685     size = (size_t)call_func1(p_basic_string_wchar_size, &str1);
 686     ok(size == 4, "size = %lu\n", (unsigned long)size);
 687
 688     call_func3(p_basic_string_wchar_assign_cstr_len, &str2, test, 4);
 689     str = call_func1(p_basic_string_wchar_cstr, &str2);
 690     ok(!memcmp(str, test, 5*sizeof(wchar_t)), "str = %s\n", wine_dbgstr_w(str));
 691     str = call_func1(p_basic_string_wchar_data, &str2);
 692     ok(!memcmp(str, test, 5*sizeof(wchar_t)), "str = %s\n", wine_dbgstr_w(str));
 693
 694     call_func3(p_basic_string_wchar_assign_cstr_len, &str2, (str+1), 2);
 695     str = call_func1(p_basic_string_wchar_cstr, &str2);
 696     ok(str[0]=='e' && str[1]=='s' && str[2]=='\0', "str = %s\n", wine_dbgstr_w(str));
 697     str = call_func1(p_basic_string_wchar_data, &str2);
 698     ok(str[0]=='e' && str[1]=='s' && str[2]=='\0', "str = %s\n", wine_dbgstr_w(str));
 699
 700     call_func1(p_basic_string_wchar_dtor, &str1);
 701     call_func1(p_basic_string_wchar_dtor, &str2);
 702 }
 703
 704 static void test_basic_string_wchar_swap(void) {
 705     basic_string_wchar str1, str2;
 706     wchar_t wtmp1[32], wtmp2[32];
 707
 708     if(!p_basic_string_wchar_ctor_cstr || !p_basic_string_wchar_dtor ||
 709             !p_basic_string_wchar_swap || !p_basic_string_wchar_cstr) {
 710         win_skip("basic_string<wchar_t> unavailable\n");
 711         return;
 712     }
 713
 714     /* Swap self, local */
 715     mbstowcs(wtmp1, "qwerty", 32);
 716     call_func2(p_basic_string_wchar_ctor_cstr, &str1, wtmp1);
 717     call_func2(p_basic_string_wchar_swap, &str1, &str1);
 718     ok(wcscmp(wtmp1, (const wchar_t *) call_func1(p_basic_string_wchar_cstr, &str1)) == 0, "Invalid value of str1\n");
 719     call_func2(p_basic_string_wchar_swap, &str1, &str1);
 720     ok(wcscmp(wtmp1, (const wchar_t *) call_func1(p_basic_string_wchar_cstr, &str1)) == 0, "Invalid value of str1\n");
 721     call_func1(p_basic_string_wchar_dtor, &str1);
 722
 723     /* str1 allocated, str2 local */
 724     mbstowcs(wtmp1, "qwerty12345678901234567890", 32);
 725     mbstowcs(wtmp2, "asd", 32);
 726     call_func2(p_basic_string_wchar_ctor_cstr, &str1, wtmp1);
 727     call_func2(p_basic_string_wchar_ctor_cstr, &str2, wtmp2);
 728     call_func2(p_basic_string_wchar_swap, &str1, &str2);
 729     ok(wcscmp(wtmp2, (const wchar_t *) call_func1(p_basic_string_wchar_cstr, &str1)) == 0, "Invalid value of str1\n");
 730     ok(wcscmp(wtmp1, (const wchar_t *) call_func1(p_basic_string_wchar_cstr, &str2)) == 0, "Invalid value of str2\n");
 731     call_func2(p_basic_string_wchar_swap, &str1, &str2);
 732     ok(wcscmp(wtmp1, (const wchar_t *) call_func1(p_basic_string_wchar_cstr, &str1)) == 0, "Invalid value of str1\n");
 733     ok(wcscmp(wtmp2, (const wchar_t *) call_func1(p_basic_string_wchar_cstr, &str2)) == 0, "Invalid value of str2\n");
 734     call_func1(p_basic_string_wchar_dtor, &str1);
 735     call_func1(p_basic_string_wchar_dtor, &str2);
 736 }
 737
 738 START_TEST(string)
 739 {
 740     if(!init())
 741         return;
 742
 743     test_basic_string_char();
 744     test_basic_string_char_swap();
 745     test_basic_string_char_append();
 746     test_basic_string_char_compare();
 747     test_basic_string_wchar();
 748     test_basic_string_wchar_swap();
 749
 750     ok(!invalid_parameter, "invalid_parameter_handler was invoked too many times\n");
 751 }