dlls/ole32/tests/moniker.c

   1 /*
   2  * Moniker 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 #define _WIN32_DCOM
  22 #define COBJMACROS
  23
  24 #include <stdarg.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "objbase.h"
  29 #include "comcat.h"
  30
  31 #include "wine/test.h"
  32
  33 #define ok_ole_success(hr, func) ok(hr == S_OK, #func " failed with error 0x%08lx\n", hr)
  34
  35 static void test_MkParseDisplayName()
  36 {
  37     IBindCtx * pbc = NULL;
  38     HRESULT hr;
  39     IMoniker * pmk  = NULL;
  40     IMoniker * pmk1 = NULL;
  41     IMoniker * pmk2 = NULL;
  42     IMoniker * ppmk = NULL;
  43     IMoniker * spMoniker;
  44     ULONG eaten;
  45     int        monCnt;
  46     IUnknown * object = NULL;
  47
  48     IUnknown *lpEM1;
  49
  50     IEnumMoniker *spEM1  = NULL;
  51     IEnumMoniker *spEM2  = NULL;
  52     IEnumMoniker *spEM3  = NULL;
  53
  54     DWORD pdwReg1=0;
  55     DWORD grflags=0;
  56     DWORD pdwReg2=0;
  57     IRunningObjectTable * pprot=NULL;
  58
  59     /* CLSID of My Computer */
  60     static const WCHAR wszDisplayName[] = {'c','l','s','i','d',':',
  61         '2','0','D','0','4','F','E','0','-','3','A','E','A','-','1','0','6','9','-','A','2','D','8','-','0','8','0','0','2','B','3','0','3','0','9','D',':',0};
  62     static const WCHAR wszFileName1[] = {'c',':','\\','w','i','n','d','o','w','s','\\','t','e','s','t','1','.','d','o','c',0};
  63     static const WCHAR wszFileName2[] = {'c',':','\\','w','i','n','d','o','w','s','\\','t','e','s','t','2','.','d','o','c',0};
  64     WCHAR * szDisplayn;
  65
  66     hr = CreateBindCtx(0, &pbc);
  67     ok_ole_success(hr, CreateBindCtx);
  68
  69     hr = MkParseDisplayName(pbc, wszDisplayName, &eaten, &pmk);
  70     todo_wine { ok_ole_success(hr, MkParseDisplayName); }
  71
  72     if (object)
  73     {
  74         hr = IMoniker_BindToObject(pmk, pbc, NULL, &IID_IUnknown, (LPVOID*)&object);
  75         ok_ole_success(hr, IMoniker_BindToObject);
  76
  77         IUnknown_Release(object);
  78     }
  79     IBindCtx_Release(pbc);
  80
  81     /* Test the EnumMoniker interface */
  82     hr = CreateBindCtx(0, &pbc);
  83     ok_ole_success(hr, CreateBindCtx);
  84
  85     hr = CreateFileMoniker(wszFileName1, &pmk1);
  86     ok(hr==0, "CreateFileMoniker for file hr=%08lx\n", hr);
  87     hr = CreateFileMoniker(wszFileName2, &pmk2);
  88     ok(hr==0, "CreateFileMoniker for file hr=%08lx\n", hr);
  89     hr = IBindCtx_GetRunningObjectTable(pbc, &pprot);
  90     ok(hr==0, "IBindCtx_GetRunningObjectTable hr=%08lx\n", hr);
  91
  92     /* Check EnumMoniker before registering */
  93     hr = IRunningObjectTable_EnumRunning(pprot, &spEM1);
  94     ok(hr==0, "IRunningObjectTable_EnumRunning hr=%08lx\n", hr);
  95     hr = IEnumMoniker_QueryInterface(spEM1, &IID_IUnknown, (void*) &lpEM1);
  96     /* Register a couple of Monikers and check is ok */
  97     ok(hr==0, "IEnumMoniker_QueryInterface hr %08lx %p\n", hr, lpEM1);
  98     hr = MK_E_NOOBJECT;
  99     monCnt = 0;
 100     while ((IEnumMoniker_Next(spEM1, 1, &spMoniker, NULL)==S_OK) &&
 101            (ppmk ==NULL))
 102     {
 103         monCnt++;
 104         szDisplayn=NULL;
 105         hr=IMoniker_GetDisplayName(spMoniker, pbc, NULL,
 106                                    (LPOLESTR*) &szDisplayn);
 107                                           /* szDisplayn needs to be freed by
 108                                            * IMalloc_Free hence the use of
 109                                            * CoGetMalloc                      */
 110         if (SUCCEEDED(hr))
 111         {
 112             CoTaskMemFree(szDisplayn);
 113         }
 114     }
 115     ok(monCnt==0, "Number of monikers should be equal to 0 not %i\n", monCnt);      grflags= grflags | ROTFLAGS_REGISTRATIONKEEPSALIVE;
 116     hr = IRunningObjectTable_Register(pprot, grflags, lpEM1, pmk1, &pdwReg1);
 117     ok(hr==0, "IRunningObjectTable_Register hr=%08lx %p %08lx %p %p %ld\n",
 118         hr, pprot, grflags, lpEM1, pmk1, pdwReg1);
 119
 120     grflags=0;
 121     grflags= grflags | ROTFLAGS_REGISTRATIONKEEPSALIVE;
 122     hr = IRunningObjectTable_Register(pprot, grflags, lpEM1, pmk2, &pdwReg2);
 123     ok(hr==0, "IRunningObjectTable_Register hr=%08lx %p %08lx %p %p %ld\n", hr,
 124        pprot, grflags, lpEM1, pmk2, pdwReg2);
 125
 126     hr = IRunningObjectTable_EnumRunning(pprot, &spEM2);
 127     ok(hr==0, "IRunningObjectTable_EnumRunning hr=%08lx\n", hr);
 128
 129     monCnt=0;
 130     while ((IEnumMoniker_Next(spEM2, 1, &spMoniker, NULL)==S_OK) &&
 131            (ppmk ==NULL))
 132     {
 133         WCHAR *szDisplayn=NULL;
 134         monCnt++;
 135         hr=IMoniker_GetDisplayName(spMoniker, pbc, NULL,
 136                                    (LPOLESTR*) &szDisplayn);
 137                                           /* szDisplayn needs to be freed by
 138                                            * IMalloc_Free hence the use of
 139                                            * CoGetMalloc                      */
 140         if (SUCCEEDED(hr))
 141         {
 142             CoTaskMemFree(szDisplayn);
 143         }
 144     }
 145     ok(monCnt==2, "Number of monikers should be equal to 2 not %i\n", monCnt);
 146
 147     IEnumMoniker_Clone(spEM2, &spEM3);
 148     monCnt=0;
 149     while ((IEnumMoniker_Next(spEM3, 1, &spMoniker, NULL)==S_OK) &&
 150            (ppmk ==NULL))
 151     {
 152         WCHAR *szDisplayn=NULL;
 153         monCnt++;
 154         hr=IMoniker_GetDisplayName(spMoniker, pbc, NULL,
 155                                    (LPOLESTR*) &szDisplayn);
 156                                           /* szDisplayn needs to be freed by
 157                                            * IMalloc_Free hence the use of
 158                                            * CoGetMalloc                      */
 159         if (SUCCEEDED(hr))
 160         {
 161             CoTaskMemFree(szDisplayn);
 162         }
 163     }
 164     ok(monCnt==2, "Number of monikers should be equal to 2 not %i\n", monCnt);
 165     IRunningObjectTable_Revoke(pprot,pdwReg1);
 166     IRunningObjectTable_Revoke(pprot,pdwReg2);
 167     IEnumMoniker_Release(spEM1);
 168     IEnumMoniker_Release(spEM1);
 169     IEnumMoniker_Release(spEM2);
 170     IEnumMoniker_Release(spEM3);
 171     IMoniker_Release(pmk1);
 172     IMoniker_Release(pmk2);
 173     IRunningObjectTable_Release(pprot);
 174
 175     IBindCtx_Release(pbc);
 176     /* Finished testing EnumMoniker */
 177 }
 178
 179 static const BYTE expected_moniker_data[] =
 180 {
 181         0x4d,0x45,0x4f,0x57,0x04,0x00,0x00,0x00,
 182         0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 183         0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
 184         0x1a,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
 185         0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
 186         0x00,0x00,0x00,0x00,0x14,0x00,0x00,0x00,
 187         0x05,0xe0,0x02,0x00,0x00,0x00,0x00,0x00,
 188         0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46,
 189         0x00,0x00,0x00,0x00,
 190 };
 191
 192 static const LARGE_INTEGER llZero;
 193
 194 static void test_class_moniker()
 195 {
 196     IStream * stream;
 197     IMoniker * moniker;
 198     HRESULT hr;
 199     HGLOBAL hglobal;
 200     LPBYTE moniker_data;
 201     DWORD moniker_size;
 202     DWORD i;
 203     BOOL same = TRUE;
 204
 205     hr = CreateClassMoniker(&CLSID_StdComponentCategoriesMgr, &moniker);
 206     todo_wine { ok_ole_success(hr, CreateClassMoniker); }
 207
 208     hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 209
 210     hr = CoMarshalInterface(stream, &IID_IMoniker, (IUnknown *)moniker, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
 211     todo_wine { ok_ole_success(hr, CoMarshalInterface); }
 212
 213     hr = GetHGlobalFromStream(stream, &hglobal);
 214     ok_ole_success(hr, GetHGlobalFromStream);
 215
 216     moniker_size = GlobalSize(hglobal);
 217
 218     moniker_data = GlobalLock(hglobal);
 219
 220     /* first check we have the right amount of data */
 221     todo_wine {
 222     ok(moniker_size == sizeof(expected_moniker_data),
 223         "Size of marshaled data differs (expected %d, actual %ld)\n",
 224         sizeof(expected_moniker_data), moniker_size);
 225     }
 226
 227     /* then do a byte-by-byte comparison */
 228     for (i = 0; i < min(moniker_size, sizeof(expected_moniker_data)); i++)
 229     {
 230         if (expected_moniker_data[i] != moniker_data[i])
 231         {
 232             same = FALSE;
 233             break;
 234         }
 235     }
 236
 237     ok(same, "Marshaled data differs\n");
 238     if (!same)
 239     {
 240         trace("Dumping marshaled moniker data:\n");
 241         for (i = 0; i < moniker_size; i++)
 242         {
 243             trace("0x%02x,", moniker_data[i]);
 244             if (i % 8 == 7) trace("\n");
 245             if (i % 8 == 0) trace("     ");
 246         }
 247     }
 248
 249     GlobalUnlock(hglobal);
 250
 251     IStream_Seek(stream, llZero, STREAM_SEEK_SET, NULL);
 252     hr = CoReleaseMarshalData(stream);
 253     todo_wine { ok_ole_success(hr, CoReleaseMarshalData); }
 254
 255     IStream_Release(stream);
 256     if (moniker) IMoniker_Release(moniker);
 257 }
 258
 259 START_TEST(moniker)
 260 {
 261     CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 262
 263     test_MkParseDisplayName();
 264     test_class_moniker();
 265     /* FIXME: test moniker creation funcs and parsing other moniker formats */
 266
 267     CoUninitialize();
 268 }