dlls/oleaut32/tests/usrmarshal.c

   1 /*
   2  * Marshaling Tests
   3  *
   4  * Copyright 2004 Robert Shearman
   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <stdarg.h>
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "objbase.h"
  26 #include "propidl.h" /* for LPSAFEARRAY_User* routines */
  27
  28 #include "wine/test.h"
  29
  30 /* doesn't work on Windows due to needing more of the
  31  * MIDL_STUB_MESSAGE structure to be filled out */
  32 #define LPSAFEARRAY_UNMARSHAL_WORKS 0
  33 #define BSTR_UNMARSHAL_WORKS 0
  34
  35 static inline SF_TYPE get_union_type(SAFEARRAY *psa)
  36 {
  37     VARTYPE vt;
  38     HRESULT hr;
  39
  40     hr = SafeArrayGetVartype(psa, &vt);
  41     if (FAILED(hr))
  42         return 0;
  43
  44     if (psa->fFeatures & FADF_HAVEIID)
  45         return SF_HAVEIID;
  46
  47     switch (vt)
  48     {
  49     case VT_I1:
  50     case VT_UI1:      return SF_I1;
  51     case VT_BOOL:
  52     case VT_I2:
  53     case VT_UI2:      return SF_I2;
  54     case VT_INT:
  55     case VT_UINT:
  56     case VT_I4:
  57     case VT_UI4:
  58     case VT_R4:       return SF_I4;
  59     case VT_DATE:
  60     case VT_CY:
  61     case VT_R8:
  62     case VT_I8:
  63     case VT_UI8:      return SF_I8;
  64     case VT_INT_PTR:
  65     case VT_UINT_PTR: return (sizeof(UINT_PTR) == 4 ? SF_I4 : SF_I8);
  66     case VT_BSTR:     return SF_BSTR;
  67     case VT_DISPATCH: return SF_DISPATCH;
  68     case VT_VARIANT:  return SF_VARIANT;
  69     case VT_UNKNOWN:  return SF_UNKNOWN;
  70     /* Note: Return a non-zero size to indicate vt is valid. The actual size
  71      * of a UDT is taken from the result of IRecordInfo_GetSize().
  72      */
  73     case VT_RECORD:   return SF_RECORD;
  74     default:          return SF_ERROR;
  75     }
  76 }
  77
  78 static ULONG get_cell_count(const SAFEARRAY *psa)
  79 {
  80     const SAFEARRAYBOUND* psab = psa->rgsabound;
  81     USHORT cCount = psa->cDims;
  82     ULONG ulNumCells = 1;
  83
  84     while (cCount--)
  85     {
  86          if (!psab->cElements)
  87             return 0;
  88         ulNumCells *= psab->cElements;
  89         psab++;
  90     }
  91     return ulNumCells;
  92 }
  93
  94 static void check_safearray(void *buffer, LPSAFEARRAY lpsa)
  95 {
  96     unsigned char *wiresa = buffer;
  97     VARTYPE vt;
  98     SF_TYPE sftype;
  99     ULONG cell_count;
 100
 101     if(!lpsa)
 102     {
 103         ok(*(void **)wiresa == NULL, "wiresa + 0x0 should be NULL instead of 0x%08lx\n", *(DWORD *)wiresa);
 104         return;
 105     }
 106
 107     SafeArrayGetVartype(lpsa, &vt);
 108     sftype = get_union_type(lpsa);
 109     cell_count = get_cell_count(lpsa);
 110
 111     ok(*(DWORD *)wiresa, "wiresa + 0x0 should be non-NULL instead of 0x%08lx\n", *(DWORD *)wiresa); /* win2k: this is lpsa. winxp: this is 0x00000001 */
 112     wiresa += sizeof(DWORD);
 113     ok(*(DWORD *)wiresa == lpsa->cDims, "wiresa + 0x4 should be lpsa->cDims instead of 0x%08lx\n", *(DWORD *)wiresa);
 114     wiresa += sizeof(DWORD);
 115     ok(*(WORD *)wiresa == lpsa->cDims, "wiresa + 0x8 should be lpsa->cDims instead of 0x%04x\n", *(WORD *)wiresa);
 116     wiresa += sizeof(WORD);
 117     ok(*(WORD *)wiresa == lpsa->fFeatures, "wiresa + 0xc should be lpsa->fFeatures instead of 0x%08x\n", *(WORD *)wiresa);
 118     wiresa += sizeof(WORD);
 119     ok(*(DWORD *)wiresa == lpsa->cbElements, "wiresa + 0x10 should be lpsa->cbElements instead of 0x%08lx\n", *(DWORD *)wiresa);
 120     wiresa += sizeof(DWORD);
 121     ok(*(WORD *)wiresa == lpsa->cLocks, "wiresa + 0x16 should be lpsa->cLocks instead of 0x%04x\n", *(WORD *)wiresa);
 122     wiresa += sizeof(WORD);
 123     ok(*(WORD *)wiresa == vt, "wiresa + 0x14 should be %04x instead of 0x%04x\n", vt, *(WORD *)wiresa);
 124     wiresa += sizeof(WORD);
 125     ok(*(DWORD *)wiresa == sftype, "wiresa + 0x18 should be %08lx instead of 0x%08lx\n", (DWORD)sftype, *(DWORD *)wiresa);
 126     wiresa += sizeof(DWORD);
 127     ok(*(DWORD *)wiresa == cell_count, "wiresa + 0x1c should be %lu instead of %lu\n", cell_count, *(DWORD *)wiresa);
 128     wiresa += sizeof(DWORD);
 129     ok(*(DWORD_PTR *)wiresa == (DWORD_PTR)lpsa->pvData, "wirestgm + 0x20 should be lpsa->pvData instead of 0x%08lx\n", *(DWORD_PTR *)wiresa);
 130     wiresa += sizeof(DWORD_PTR);
 131     if(sftype == SF_HAVEIID)
 132     {
 133         GUID guid;
 134         SafeArrayGetIID(lpsa, &guid);
 135         ok(IsEqualGUID(&guid, (GUID*)wiresa), "guid mismatch\n");
 136         wiresa += sizeof(GUID);
 137     }
 138     ok(!memcmp(wiresa, lpsa->rgsabound, sizeof(lpsa->rgsabound[0]) * lpsa->cDims), "bounds mismatch\n");
 139     wiresa += sizeof(lpsa->rgsabound[0]) * lpsa->cDims;
 140
 141     ok(*(DWORD *)wiresa == cell_count, "wiresa + 0x2c should be %lu instead of %lu\n", cell_count, *(DWORD*)wiresa);
 142     wiresa += sizeof(DWORD);
 143     /* elements are now pointed to by wiresa */
 144 }
 145
 146 static void test_marshal_LPSAFEARRAY(void)
 147 {
 148     unsigned char *buffer;
 149     unsigned long size;
 150     LPSAFEARRAY lpsa;
 151     LPSAFEARRAY lpsa2 = NULL;
 152     SAFEARRAYBOUND sab;
 153     MIDL_STUB_MESSAGE stubMsg = { 0 };
 154     USER_MARSHAL_CB umcb = { 0 };
 155
 156     umcb.Flags = MAKELONG(MSHCTX_DIFFERENTMACHINE, NDR_LOCAL_DATA_REPRESENTATION);
 157     umcb.pReserve = NULL;
 158     umcb.pStubMsg = &stubMsg;
 159
 160     sab.lLbound = 5;
 161     sab.cElements = 10;
 162
 163     lpsa = SafeArrayCreate(VT_I2, 1, &sab);
 164     *(DWORD *)lpsa->pvData = 0xcafebabe;
 165
 166     lpsa->cLocks = 7;
 167     size = LPSAFEARRAY_UserSize(&umcb.Flags, 1, &lpsa);
 168     ok(size == 68, "size should be 68 bytes, not %ld\n", size);
 169     size = LPSAFEARRAY_UserSize(&umcb.Flags, 0, &lpsa);
 170     ok(size == 64, "size should be 64 bytes, not %ld\n", size);
 171     buffer = (unsigned char *)HeapAlloc(GetProcessHeap(), 0, size);
 172     LPSAFEARRAY_UserMarshal(&umcb.Flags, buffer, &lpsa);
 173
 174     check_safearray(buffer, lpsa);
 175
 176     if (LPSAFEARRAY_UNMARSHAL_WORKS)
 177     {
 178         LPSAFEARRAY_UserUnmarshal(&umcb.Flags, buffer, &lpsa2);
 179         ok(lpsa2 != NULL, "LPSAFEARRAY didn't unmarshal\n");
 180         LPSAFEARRAY_UserFree(&umcb.Flags, &lpsa2);
 181     }
 182     HeapFree(GetProcessHeap(), 0, buffer);
 183     SafeArrayDestroy(lpsa);
 184
 185     /* test NULL safe array */
 186     lpsa = NULL;
 187
 188     size = LPSAFEARRAY_UserSize(&umcb.Flags, 0, &lpsa);
 189     ok(size == 4, "size should be 4 bytes, not %ld\n", size);
 190     buffer = (unsigned char *)HeapAlloc(GetProcessHeap(), 0, size);
 191     LPSAFEARRAY_UserMarshal(&umcb.Flags, buffer, &lpsa);
 192     check_safearray(buffer, lpsa);
 193
 194     if (LPSAFEARRAY_UNMARSHAL_WORKS)
 195     {
 196         LPSAFEARRAY_UserUnmarshal(&umcb.Flags, buffer, &lpsa2);
 197         ok(lpsa2 == NULL, "NULL LPSAFEARRAY didn't unmarshal\n");
 198         LPSAFEARRAY_UserFree(&umcb.Flags, &lpsa2);
 199     }
 200     HeapFree(GetProcessHeap(), 0, buffer);
 201
 202     sab.lLbound = 5;
 203     sab.cElements = 10;
 204
 205     lpsa = SafeArrayCreate(VT_R8, 1, &sab);
 206     *(double *)lpsa->pvData = 3.1415;
 207
 208     lpsa->cLocks = 7;
 209     size = LPSAFEARRAY_UserSize(&umcb.Flags, 1, &lpsa);
 210     ok(size == 128, "size should be 128 bytes, not %ld\n", size);
 211     size = LPSAFEARRAY_UserSize(&umcb.Flags, 0, &lpsa);
 212     ok(size == 128, "size should be 128 bytes, not %ld\n", size);
 213     buffer = (unsigned char *)HeapAlloc(GetProcessHeap(), 0, size);
 214     LPSAFEARRAY_UserMarshal(&umcb.Flags, buffer, &lpsa);
 215
 216     check_safearray(buffer, lpsa);
 217
 218     HeapFree(GetProcessHeap(), 0, buffer);
 219     SafeArrayDestroy(lpsa);
 220 }
 221
 222 static void check_bstr(void *buffer, BSTR b)
 223 {
 224     DWORD *wireb = buffer;
 225     DWORD len = SysStringLen(b);
 226
 227     ok(*wireb == len, "wv[0] %08lx\n", *wireb);
 228     wireb++;
 229     if(len)
 230         ok(*wireb == len * 2, "wv[1] %08lx\n", *wireb);
 231     else
 232         ok(*wireb == 0xffffffff, "wv[1] %08lx\n", *wireb);
 233     wireb++;
 234     ok(*wireb == len, "wv[2] %08lx\n", *wireb);
 235     if(len)
 236     {
 237         wireb++;
 238         ok(!memcmp(wireb, b, len * 2), "strings differ\n");
 239     }
 240     return;
 241 }
 242
 243 static void test_marshal_BSTR(void)
 244 {
 245     unsigned long size;
 246     MIDL_STUB_MESSAGE stubMsg = { 0 };
 247     USER_MARSHAL_CB umcb = { 0 };
 248     unsigned char *buffer;
 249     BSTR b, b2;
 250     WCHAR str[] = {'m','a','r','s','h','a','l',' ','t','e','s','t','1',0};
 251     DWORD len;
 252
 253     umcb.Flags = MAKELONG(MSHCTX_DIFFERENTMACHINE, NDR_LOCAL_DATA_REPRESENTATION);
 254     umcb.pReserve = NULL;
 255     umcb.pStubMsg = &stubMsg;
 256
 257     b = SysAllocString(str);
 258     len = SysStringLen(b);
 259     ok(len == 13, "get %ld\n", len);
 260
 261     /* BSTRs are DWORD aligned */
 262     size = BSTR_UserSize(&umcb.Flags, 1, &b);
 263     ok(size == 42, "size %ld\n", size);
 264
 265     size = BSTR_UserSize(&umcb.Flags, 0, &b);
 266     ok(size == 38, "size %ld\n", size);
 267
 268     buffer = HeapAlloc(GetProcessHeap(), 0, size);
 269     BSTR_UserMarshal(&umcb.Flags, buffer, &b);
 270     check_bstr(buffer, b);
 271
 272     if (BSTR_UNMARSHAL_WORKS)
 273     {
 274         b2 = NULL;
 275         BSTR_UserUnmarshal(&umcb.Flags, buffer, &b2);
 276         ok(b2 != NULL, "NULL LPSAFEARRAY didn't unmarshal\n");
 277         ok(!memcmp(b, b2, (len + 1) * 2), "strings differ\n");
 278         BSTR_UserFree(&umcb.Flags, &b2);
 279     }
 280
 281     HeapFree(GetProcessHeap(), 0, buffer);
 282     SysFreeString(b);
 283
 284     b = NULL;
 285     size = BSTR_UserSize(&umcb.Flags, 0, &b);
 286     ok(size == 12, "size %ld\n", size);
 287
 288     buffer = HeapAlloc(GetProcessHeap(), 0, size);
 289     BSTR_UserMarshal(&umcb.Flags, buffer, &b);
 290
 291     check_bstr(buffer, b);
 292     HeapFree(GetProcessHeap(), 0, buffer);
 293
 294 }
 295
 296 START_TEST(usrmarshal)
 297 {
 298     CoInitialize(NULL);
 299
 300     test_marshal_LPSAFEARRAY();
 301     test_marshal_BSTR();
 302
 303     CoUninitialize();
 304 }