dlls/oleaut32/tests/dispatch.c

   1 /*
   2  * Dispatch test
   3  *
   4  * Copyright 2009 James Hawkins
   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 <wine/test.h>
  22 #include <windef.h>
  23 #include <winbase.h>
  24 #include <oaidl.h>
  25
  26 static const WCHAR szSunshine[] = {'S','u','n','s','h','i','n','e',0};
  27
  28 /* Temporary storage for ok_bstr. */
  29 static CHAR temp_str[MAX_PATH];
  30
  31 #define ok_bstr(bstr, expected, format) \
  32     do { \
  33     WideCharToMultiByte(CP_ACP, 0, bstr, -1, temp_str, MAX_PATH, NULL, NULL); \
  34     if (lstrcmpA(temp_str, expected) != 0) \
  35         ok(0, format, expected, temp_str); \
  36     } while(0);
  37
  38 #define INIT_DISPPARAMS(dp, args, named_args, num_args, num_named_args) \
  39   dp.rgvarg = args; \
  40   dp.rgdispidNamedArgs = named_args; \
  41   dp.cArgs = num_args; \
  42   dp.cNamedArgs = num_named_args; \
  43
  44 /* Initializes vararg with three values:
  45  *  VT_I2 - 42
  46  *  VT_I4 - 1234567890
  47  *  VT_BSTR - "Sunshine"
  48  */
  49 #define INIT_VARARG(vararg) \
  50   VariantInit(&vararg[0]); \
  51   V_VT(&vararg[0]) = VT_I2; \
  52   V_I2(&vararg[0]) = 42; \
  53   VariantInit(&vararg[1]); \
  54   V_VT(&vararg[1]) = VT_I4; \
  55   V_I4(&vararg[1]) = 1234567890; \
  56   VariantInit(&vararg[2]); \
  57   V_VT(&vararg[2]) = VT_BSTR; \
  58   V_BSTR(&vararg[2]) = SysAllocString(szSunshine);
  59
  60 /* Clears the vararg. */
  61 #define CLEAR_VARARG(vararg) \
  62   VariantClear(&vararg[0]); \
  63   VariantClear(&vararg[1]); \
  64   VariantClear(&vararg[2]);
  65
  66 static void test_DispGetParam(void)
  67 {
  68     HRESULT hr;
  69     DISPPARAMS dispparams;
  70     VARIANTARG vararg[3];
  71     VARIANT result;
  72     unsigned int err_index;
  73
  74     VariantInit(&result);
  75
  76     /* DispGetParam crashes on Windows if pdispparams is NULL. */
  77
  78     /* pdispparams has zero parameters. */
  79     INIT_DISPPARAMS(dispparams, NULL, NULL, 0, 0);
  80     VariantInit(&result);
  81     err_index = 0xdeadbeef;
  82     hr = DispGetParam(&dispparams, 0, VT_I2, &result, &err_index);
  83     ok(hr == DISP_E_PARAMNOTFOUND,
  84        "Expected DISP_E_PARAMNOTFOUND, got %08x\n", hr);
  85     ok(V_VT(&result) == VT_EMPTY,
  86        "Expected VT_EMPTY, got %08x\n", V_VT(&result));
  87     ok(err_index == 0xdeadbeef,
  88        "Expected err_index to be unchanged, got %d\n", err_index);
  89
  90     /* pdispparams has zero parameters, position is invalid. */
  91     INIT_DISPPARAMS(dispparams, NULL, NULL, 0, 0);
  92     VariantInit(&result);
  93     err_index = 0xdeadbeef;
  94     hr = DispGetParam(&dispparams, 1, VT_I2, &result, &err_index);
  95     ok(hr == DISP_E_PARAMNOTFOUND,
  96        "Expected DISP_E_PARAMNOTFOUND, got %08x\n", hr);
  97     ok(V_VT(&result) == VT_EMPTY,
  98        "Expected VT_EMPTY, got %08x\n", V_VT(&result));
  99     ok(err_index == 0xdeadbeef,
 100        "Expected err_index to be unchanged, got %d\n", err_index);
 101
 102     /* pdispparams has zero parameters, pvarResult is NULL. */
 103     INIT_DISPPARAMS(dispparams, NULL, NULL, 0, 0);
 104     err_index = 0xdeadbeef;
 105     hr = DispGetParam(&dispparams, 0, VT_I2, NULL, &err_index);
 106     ok(hr == DISP_E_PARAMNOTFOUND,
 107        "Expected DISP_E_PARAMNOTFOUND, got %08x\n", hr);
 108     ok(err_index == 0xdeadbeef,
 109        "Expected err_index to be unchanged, got %d\n", err_index);
 110
 111     /* pdispparams has zero parameters, puArgErr is NULL. */
 112     INIT_DISPPARAMS(dispparams, NULL, NULL, 0, 0);
 113     VariantInit(&result);
 114     hr = DispGetParam(&dispparams, 0, VT_I2, &result, NULL);
 115     ok(hr == DISP_E_PARAMNOTFOUND,
 116        "Expected DISP_E_PARAMNOTFOUND, got %08x\n", hr);
 117     ok(V_VT(&result) == VT_EMPTY,
 118        "Expected VT_EMPTY, got %08x\n", V_VT(&result));
 119
 120     /* pdispparams.cArgs is 1, yet pdispparams.rgvarg is NULL. */
 121     INIT_DISPPARAMS(dispparams, NULL, NULL, 1, 0);
 122     VariantInit(&result);
 123     err_index = 0xdeadbeef;
 124     hr = DispGetParam(&dispparams, 0, VT_I2, &result, &err_index);
 125     ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
 126     ok(V_VT(&result) == VT_EMPTY,
 127        "Expected VT_EMPTY, got %08x\n", V_VT(&result));
 128     ok(err_index == 0, "Expected 0, got %d\n", err_index);
 129
 130     /* pdispparams.cNamedArgs is 1, yet pdispparams.rgdispidNamedArgs is NULL.
 131      *
 132      * This crashes on Windows.
 133      */
 134
 135     /* {42, 1234567890, "Sunshine"} */
 136     INIT_VARARG(vararg);
 137
 138     /* Get the first param.  position is end-based, so 2 is the first parameter
 139      * of 3 parameters.
 140      */
 141     INIT_DISPPARAMS(dispparams, vararg, NULL, 3, 0);
 142     VariantInit(&result);
 143     err_index = 0xdeadbeef;
 144     hr = DispGetParam(&dispparams, 2, VT_I2, &result, &err_index);
 145     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 146     ok(V_VT(&result) == VT_I2, "Expected VT_I2, got %08x\n", V_VT(&result));
 147     ok(V_I2(&result) == 42, "Expected 42, got %d\n", V_I2(&result));
 148     ok(err_index == 0xdeadbeef,
 149        "Expected err_index to be unchanged, got %d\n", err_index);
 150
 151     /* Get the second param. */
 152     INIT_DISPPARAMS(dispparams, vararg, NULL, 3, 0);
 153     VariantInit(&result);
 154     err_index = 0xdeadbeef;
 155     hr = DispGetParam(&dispparams, 1, VT_I4, &result, &err_index);
 156     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 157     ok(V_VT(&result) == VT_I4, "Expected VT_I4, got %08x\n", V_VT(&result));
 158     ok(V_I4(&result) == 1234567890,
 159        "Expected 1234567890, got %d\n", V_I4(&result));
 160     ok(err_index == 0xdeadbeef,
 161        "Expected err_index to be unchanged, got %d\n", err_index);
 162
 163     /* Get the third param. */
 164     INIT_DISPPARAMS(dispparams, vararg, NULL, 3, 0);
 165     VariantInit(&result);
 166     err_index = 0xdeadbeef;
 167     hr = DispGetParam(&dispparams, 0, VT_BSTR, &result, &err_index);
 168     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 169     ok(V_VT(&result) == VT_BSTR, "Expected VT_BSTR, got %08x\n", V_VT(&result));
 170     ok_bstr(V_BSTR(&result), "Sunshine", "Expected %s, got %s\n");
 171     ok(err_index == 0xdeadbeef,
 172        "Expected err_index to be unchanged, got %d\n", err_index);
 173     VariantClear(&result);
 174
 175     /* position is out of range. */
 176     INIT_DISPPARAMS(dispparams, vararg, NULL, 3, 0);
 177     VariantInit(&result);
 178     err_index = 0xdeadbeef;
 179     hr = DispGetParam(&dispparams, 3, VT_I2, &result, &err_index);
 180     ok(hr == DISP_E_PARAMNOTFOUND,
 181        "Expected DISP_E_PARAMNOTFOUND, got %08x\n", hr);
 182     ok(V_VT(&result) == VT_EMPTY,
 183        "Expected VT_EMPTY, got %08x\n", V_VT(&result));
 184     ok(err_index == 0xdeadbeef,
 185        "Expected err_index to be unchanged, got %d\n", err_index);
 186
 187     /* pvarResult is NULL. */
 188     INIT_DISPPARAMS(dispparams, vararg, NULL, 3, 0);
 189     err_index = 0xdeadbeef;
 190     hr = DispGetParam(&dispparams, 2, VT_I2, NULL, &err_index);
 191     ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr);
 192     ok(err_index == 0, "Expected 0, got %d\n", err_index);
 193
 194     /* puArgErr is NULL. */
 195     INIT_DISPPARAMS(dispparams, vararg, NULL, 3, 0);
 196     VariantInit(&result);
 197     hr = DispGetParam(&dispparams, 2, VT_I2, &result, NULL);
 198     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 199     ok(V_VT(&result) == VT_I2, "Expected VT_I2, got %08x\n", V_VT(&result));
 200     ok(V_I2(&result) == 42, "Expected 42, got %d\n", V_I2(&result));
 201
 202     /* Coerce the first param to VT_I4. */
 203     INIT_DISPPARAMS(dispparams, vararg, NULL, 3, 0);
 204     VariantInit(&result);
 205     err_index = 0xdeadbeef;
 206     hr = DispGetParam(&dispparams, 2, VT_I4, &result, &err_index);
 207     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 208     ok(V_VT(&result) == VT_I4, "Expected VT_I4, got %08x\n", V_VT(&result));
 209     ok(V_I4(&result) == 42, "Expected 42, got %d\n", V_I4(&result));
 210     ok(err_index == 0xdeadbeef,
 211        "Expected err_index to be unchanged, got %d\n", err_index);
 212
 213     /* Coerce the first param to VT_BSTR. */
 214     INIT_DISPPARAMS(dispparams, vararg, NULL, 3, 0);
 215     VariantInit(&result);
 216     err_index = 0xdeadbeef;
 217     hr = DispGetParam(&dispparams, 2, VT_BSTR, &result, &err_index);
 218     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 219     ok(V_VT(&result) == VT_BSTR, "Expected VT_BSTR, got %08x\n", V_VT(&result));
 220     ok_bstr(V_BSTR(&result), "42", "Expected %s, got %s\n");
 221     ok(err_index == 0xdeadbeef,
 222        "Expected err_index to be unchanged, got %d\n", err_index);
 223     VariantClear(&result);
 224
 225     /* Coerce the second (VT_I4) param to VT_I2. */
 226     INIT_DISPPARAMS(dispparams, vararg, NULL, 3, 0);
 227     VariantInit(&result);
 228     err_index = 0xdeadbeef;
 229     hr = DispGetParam(&dispparams, 1, VT_I2, &result, &err_index);
 230     ok(hr == DISP_E_OVERFLOW, "Expected DISP_E_OVERFLOW, got %08x\n", hr);
 231     ok(V_VT(&result) == VT_EMPTY,
 232        "Expected VT_EMPTY, got %08x\n", V_VT(&result));
 233     ok(err_index == 1, "Expected 1, got %d\n", err_index);
 234
 235     /* Coerce the third (VT_BSTR) param to VT_I2. */
 236     INIT_DISPPARAMS(dispparams, vararg, NULL, 3, 0);
 237     VariantInit(&result);
 238     err_index = 0xdeadbeef;
 239     hr = DispGetParam(&dispparams, 0, VT_I2, &result, &err_index);
 240     ok(hr == DISP_E_TYPEMISMATCH,
 241        "Expected DISP_E_TYPEMISMATCH, got %08x\n", hr);
 242     ok(V_VT(&result) == VT_EMPTY,
 243        "Expected VT_EMPTY, got %08x\n", V_VT(&result));
 244     ok(err_index == 2, "Expected 2, got %d\n", err_index);
 245
 246     /* Coerce the first parameter to an invalid type. */
 247     INIT_DISPPARAMS(dispparams, vararg, NULL, 3, 0);
 248     VariantInit(&result);
 249     err_index = 0xdeadbeef;
 250     hr = DispGetParam(&dispparams, 2, VT_ILLEGAL, &result, &err_index);
 251     ok(hr == DISP_E_BADVARTYPE, "Expected DISP_E_BADVARTYPE, got %08x\n", hr);
 252     ok(V_VT(&result) == VT_EMPTY,
 253        "Expected VT_EMPTY, got %08x\n", V_VT(&result));
 254     ok(err_index == 0, "Expected 0, got %d\n", err_index);
 255
 256     CLEAR_VARARG(vararg);
 257
 258     /* Coerce the first parameter, which is of type VT_EMPTY, to VT_BSTR. */
 259     VariantInit(&vararg[0]);
 260     INIT_DISPPARAMS(dispparams, vararg, NULL, 1, 0);
 261     VariantInit(&result);
 262     err_index = 0xdeadbeef;
 263     hr = DispGetParam(&dispparams, 0, VT_BSTR, &result, &err_index);
 264     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 265     ok(V_VT(&result) == VT_BSTR, "Expected VT_BSTR, got %08x\n", V_VT(&result));
 266     ok(err_index == 0xdeadbeef, "Expected 0xdeadbeef, got %d\n", err_index);
 267     VariantClear(&result);
 268 }
 269
 270 START_TEST(dispatch)
 271 {
 272     test_DispGetParam();
 273 }