const char *debugstr_variant(const VARIANT *v) { if (!v) return "(null)"; switch (V_VT(v)) { case VT_EMPTY: return "{VT_EMPTY}"; case VT_NULL: return "{VT_NULL}"; case VT_I2: return wine_dbg_sprintf("{VT_I2: %d}", V_I2(v)); case VT_I4: return wine_dbg_sprintf("{VT_I4: %d}", V_I4(v)); case VT_R8: return wine_dbg_sprintf("{VT_R8: %lf}", V_R8(v)); case VT_BSTR: return wine_dbg_sprintf("{VT_BSTR: %s}", debugstr_w(V_BSTR(v))); case VT_DISPATCH: return wine_dbg_sprintf("{VT_DISPATCH: %p}", V_DISPATCH(v)); case VT_ERROR: return wine_dbg_sprintf("{VT_ERROR: %08x}", V_ERROR(v)); case VT_BOOL: return wine_dbg_sprintf("{VT_BOOL: %x}", V_BOOL(v)); case VT_UINT: return wine_dbg_sprintf("{VT_UINT: %u}", V_UINT(v)); default: return wine_dbg_sprintf("{vt %d}", V_VT(v)); } }
static void ole_val2variant_err(VALUE val, VARIANT *var) { VALUE v = val; if (rb_obj_is_kind_of(v, cWIN32OLE_VARIANT)) { v = folevariant_value(v); } if (!(FIXNUM_P(v) || RB_TYPE_P(v, T_BIGNUM) || v == Qnil)) { rb_raise(eWIN32OLERuntimeError, "failed to convert VT_ERROR VARIANT:`%"PRIsVALUE"'", rb_inspect(v)); } V_VT(var) = VT_ERROR; if (v != Qnil) { V_ERROR(var) = RB_NUM2LONG(val); } else { V_ERROR(var) = 0; } }
JNIEXPORT void JNICALL Java_com_tangram_Variant_putVariantErrorRef(JNIEnv *env, jobject _this, jint i) { VARIANT *v = extractVariant(env, _this); if (v) { VariantClear(v); // whatever was there before V_VT(v) = VT_ERROR | VT_BYREF; V_ERROR(v) = (int)i; } }
/** * sets the type to VT_ERROR and the error message to DISP_E_PARAMNOTFOIUND * */ JNIEXPORT void JNICALL Java_com_tangram_Variant_putVariantNoParam(JNIEnv *env, jobject _this) { VARIANT *v = extractVariant(env, _this); if (v) { // SF 3377279 clear variable to fix leak VariantClear(v); V_VT(v) = VT_ERROR; V_ERROR(v) = DISP_E_PARAMNOTFOUND; } }
JNIEXPORT jint JNICALL Java_com_tangram_Variant_getVariantErrorRef(JNIEnv *env, jobject _this) { VARIANT *v = extractVariant(env, _this); if (v) { if (V_VT(v) != (VT_ERROR | VT_BYREF)) { return NULL; } return (jint)V_ERROR(v); } return NULL; }
//-----------------------------------------------------------------------------------------------// STDMETHODIMP CMyTrackPriceInfoWithNotify::CancelLastQuote(VARIANT Params) { ATLTRACE(_T("CMyTrackPriceInfoWithNotify::CancelLastQuote\n")); try { if (V_ERROR(&Params) == DISP_E_PARAMNOTFOUND) { _Module.GetMyTrackCore ()->CancelLastQuote (static_cast<CBaseNotifier*>(this),NULL); return S_OK; } else if (V_RECORD(&Params)) { _bstr_t bstrSymbol; _QuoteUpdateParams qup(Params); bstrSymbol = qup->Symbol; _Module.GetMyTrackCore ()->CancelLastQuote (static_cast<CBaseNotifier*>(this),(LPCSTR)bstrSymbol); { _QuoteUpdateParams params(Params); _bstr_t bsFullSymbol = params->Symbol; bsFullSymbol +=_T("_"); bsFullSymbol += params->Exchange; if(params->Type == enOPT) bsFullSymbol +=_T("_"); CCriticalSectionWrapper r(m_csResponce); RESPONCE::iterator iter = m_Responce.begin(); while(iter!=m_Responce.end()) { if(iter->m_enType == CResponce::enLastQuote && iter->m_bsFullSymbol == bstrSymbol) { m_Responce.erase(iter); iter = m_Responce.begin(); } iter++; } } return S_OK; } return DISP_E_BADVARTYPE; } catch (_com_error &err) { return eg_lib::utils::ComError2ErrInfo (err,this); } catch (...) { return DISP_E_BADVARTYPE; } }
const char *debugstr_variant(const VARIANT *v) { if(!v) return "(null)"; switch(V_VT(v)) { case VT_EMPTY: return "{VT_EMPTY}"; case VT_NULL: return "{VT_NULL}"; case VT_I1: return wine_dbg_sprintf("{VT_I1: %d}", V_I1(v)); case VT_I2: return wine_dbg_sprintf("{VT_I2: %d}", V_I2(v)); case VT_I4: return wine_dbg_sprintf("{VT_I4: %d}", V_I4(v)); case VT_INT: return wine_dbg_sprintf("{VT_INT: %d}", V_INT(v)); case VT_R8: return wine_dbg_sprintf("{VT_R8: %lf}", V_R8(v)); case VT_BSTR: return wine_dbg_sprintf("{VT_BSTR: %s}", debugstr_w(V_BSTR(v))); case VT_DISPATCH: return wine_dbg_sprintf("{VT_DISPATCH: %p}", V_DISPATCH(v)); case VT_BOOL: return wine_dbg_sprintf("{VT_BOOL: %x}", V_BOOL(v)); case VT_UNKNOWN: return wine_dbg_sprintf("{VT_UNKNOWN: %p}", V_UNKNOWN(v)); case VT_UINT: return wine_dbg_sprintf("{VT_UINT: %u}", V_UINT(v)); case VT_BSTR|VT_BYREF: return wine_dbg_sprintf("{VT_BSTR|VT_BYREF: ptr %p, data %s}", V_BSTRREF(v), debugstr_w(V_BSTRREF(v) ? *V_BSTRREF(v) : NULL)); case VT_ERROR: return wine_dbg_sprintf("{VT_ERROR: 0x%08x}", V_ERROR(v)); case VT_VARIANT|VT_BYREF: return wine_dbg_sprintf("{VT_VARIANT|VT_BYREF: %s}", debugstr_variant(V_VARIANTREF(v))); case VT_UI1|VT_ARRAY: return "{VT_UI1|VT_ARRAY}"; default: return wine_dbg_sprintf("{vt %d}", V_VT(v)); } }
static void test_registry(void) { static const WCHAR keypathW[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R','\\', 'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\','T','e','s','t','\\',0}; static const WCHAR regsz2W[] = {'r','e','g','s','z','2',0}; static const WCHAR regszW[] = {'r','e','g','s','z',0}; static const WCHAR regdwordW[] = {'r','e','g','d','w','o','r','d',0}; static const WCHAR regbinaryW[] = {'r','e','g','b','i','n','a','r','y',0}; static const WCHAR regmultiszW[] = {'r','e','g','m','u','l','t','i','s','z',0}; static const WCHAR regsz1W[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R','\\', 'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\','T','e','s','t','\\','r','e','g','s','z','1',0}; static const WCHAR foobarW[] = {'f','o','o','b','a','r',0}; static const WCHAR fooW[] = {'f','o','o',0}; static const WCHAR brokenW[] = {'H','K','E','Y','_','b','r','o','k','e','n','_','k','e','y',0}; static const WCHAR broken2W[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R','a',0}; WCHAR pathW[MAX_PATH]; DWORD dwvalue, type; VARIANT value, v; IWshShell3 *sh3; VARTYPE vartype; LONG bound; HRESULT hr; BSTR name; HKEY root; LONG ret; UINT dim; hr = CoCreateInstance(&CLSID_WshShell, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER, &IID_IWshShell3, (void**)&sh3); ok(hr == S_OK, "got 0x%08x\n", hr); /* RegRead() */ V_VT(&value) = VT_I2; hr = IWshShell3_RegRead(sh3, NULL, &value); ok(hr == E_POINTER, "got 0x%08x\n", hr); ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value)); name = SysAllocString(brokenW); hr = IWshShell3_RegRead(sh3, name, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); V_VT(&value) = VT_I2; hr = IWshShell3_RegRead(sh3, name, &value); ok(hr == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND), "got 0x%08x\n", hr); ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value)); SysFreeString(name); name = SysAllocString(broken2W); V_VT(&value) = VT_I2; hr = IWshShell3_RegRead(sh3, name, &value); ok(hr == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND), "got 0x%08x\n", hr); ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value)); SysFreeString(name); ret = RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Test", &root); ok(ret == 0, "got %d\n", ret); ret = RegSetValueExA(root, "regsz", 0, REG_SZ, (const BYTE*)"foobar", 7); ok(ret == 0, "got %d\n", ret); ret = RegSetValueExA(root, "regsz2", 0, REG_SZ, (const BYTE*)"foobar\0f", 9); ok(ret == 0, "got %d\n", ret); ret = RegSetValueExA(root, "regmultisz", 0, REG_MULTI_SZ, (const BYTE*)"foo\0bar\0", 9); ok(ret == 0, "got %d\n", ret); dwvalue = 10; ret = RegSetValueExA(root, "regdword", 0, REG_DWORD, (const BYTE*)&dwvalue, sizeof(dwvalue)); ok(ret == 0, "got %d\n", ret); dwvalue = 11; ret = RegSetValueExA(root, "regbinary", 0, REG_BINARY, (const BYTE*)&dwvalue, sizeof(dwvalue)); ok(ret == 0, "got %d\n", ret); /* REG_SZ */ lstrcpyW(pathW, keypathW); lstrcatW(pathW, regszW); name = SysAllocString(pathW); VariantInit(&value); hr = IWshShell3_RegRead(sh3, name, &value); ok(hr == S_OK, "got 0x%08x\n", hr); ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value)); ok(!lstrcmpW(V_BSTR(&value), foobarW), "got %s\n", wine_dbgstr_w(V_BSTR(&value))); VariantClear(&value); SysFreeString(name); /* REG_SZ with embedded NULL */ lstrcpyW(pathW, keypathW); lstrcatW(pathW, regsz2W); name = SysAllocString(pathW); VariantInit(&value); hr = IWshShell3_RegRead(sh3, name, &value); ok(hr == S_OK, "got 0x%08x\n", hr); ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value)); ok(SysStringLen(V_BSTR(&value)) == 6, "len %d\n", SysStringLen(V_BSTR(&value))); VariantClear(&value); SysFreeString(name); /* REG_DWORD */ lstrcpyW(pathW, keypathW); lstrcatW(pathW, regdwordW); name = SysAllocString(pathW); VariantInit(&value); hr = IWshShell3_RegRead(sh3, name, &value); ok(hr == S_OK, "got 0x%08x\n", hr); ok(V_VT(&value) == VT_I4, "got %d\n", V_VT(&value)); ok(V_I4(&value) == 10, "got %d\n", V_I4(&value)); SysFreeString(name); /* REG_BINARY */ lstrcpyW(pathW, keypathW); lstrcatW(pathW, regbinaryW); name = SysAllocString(pathW); VariantInit(&value); hr = IWshShell3_RegRead(sh3, name, &value); ok(hr == S_OK, "got 0x%08x\n", hr); ok(V_VT(&value) == (VT_ARRAY|VT_VARIANT), "got 0x%x\n", V_VT(&value)); dim = SafeArrayGetDim(V_ARRAY(&value)); ok(dim == 1, "got %u\n", dim); hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &bound); ok(hr == S_OK, "got 0x%08x\n", hr); ok(bound == 0, "got %u\n", bound); hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &bound); ok(hr == S_OK, "got 0x%08x\n", hr); ok(bound == 3, "got %u\n", bound); hr = SafeArrayGetVartype(V_ARRAY(&value), &vartype); ok(hr == S_OK, "got 0x%08x\n", hr); ok(vartype == VT_VARIANT, "got %d\n", vartype); bound = 0; hr = SafeArrayGetElement(V_ARRAY(&value), &bound, &v); ok(hr == S_OK, "got 0x%08x\n", hr); ok(V_VT(&v) == VT_UI1, "got %d\n", V_VT(&v)); ok(V_UI1(&v) == 11, "got %u\n", V_UI1(&v)); VariantClear(&v); VariantClear(&value); SysFreeString(name); /* REG_MULTI_SZ */ lstrcpyW(pathW, keypathW); lstrcatW(pathW, regmultiszW); name = SysAllocString(pathW); VariantInit(&value); hr = IWshShell3_RegRead(sh3, name, &value); ok(hr == S_OK, "got 0x%08x\n", hr); ok(V_VT(&value) == (VT_ARRAY|VT_VARIANT), "got 0x%x\n", V_VT(&value)); SysFreeString(name); dim = SafeArrayGetDim(V_ARRAY(&value)); ok(dim == 1, "got %u\n", dim); hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &bound); ok(hr == S_OK, "got 0x%08x\n", hr); ok(bound == 0, "got %u\n", bound); hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &bound); ok(hr == S_OK, "got 0x%08x\n", hr); ok(bound == 1, "got %u\n", bound); hr = SafeArrayGetVartype(V_ARRAY(&value), &vartype); ok(hr == S_OK, "got 0x%08x\n", hr); ok(vartype == VT_VARIANT, "got %d\n", vartype); bound = 0; hr = SafeArrayGetElement(V_ARRAY(&value), &bound, &v); ok(hr == S_OK, "got 0x%08x\n", hr); ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v)); ok(!lstrcmpW(V_BSTR(&v), fooW), "got %s\n", wine_dbgstr_w(V_BSTR(&v))); VariantClear(&v); VariantClear(&value); name = SysAllocString(regsz1W); V_VT(&value) = VT_I2; hr = IWshShell3_RegRead(sh3, name, &value); ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr); ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value)); VariantClear(&value); SysFreeString(name); delete_key(root); /* RegWrite() */ ret = RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Test", &root); ok(ret == 0, "got %d\n", ret); hr = IWshShell3_RegWrite(sh3, NULL, NULL, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); lstrcpyW(pathW, keypathW); lstrcatW(pathW, regszW); name = SysAllocString(pathW); hr = IWshShell3_RegWrite(sh3, name, NULL, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); VariantInit(&value); hr = IWshShell3_RegWrite(sh3, name, &value, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); hr = IWshShell3_RegWrite(sh3, name, &value, &value); ok(hr == E_INVALIDARG, "got 0x%08x\n", hr); /* type is optional */ V_VT(&v) = VT_ERROR; V_ERROR(&v) = DISP_E_PARAMNOTFOUND; hr = IWshShell3_RegWrite(sh3, name, &value, &v); ok(hr == S_OK, "got 0x%08x\n", hr); /* default type is REG_SZ */ V_VT(&value) = VT_I4; V_I4(&value) = 12; hr = IWshShell3_RegWrite(sh3, name, &value, &v); ok(hr == S_OK, "got 0x%08x\n", hr); type = REG_NONE; ret = RegGetValueA(root, NULL, "regsz", RRF_RT_ANY, &type, NULL, NULL); ok(ret == ERROR_SUCCESS, "got %d\n", ret); ok(type == REG_SZ, "got %d\n", type); ret = RegDeleteValueA(root, "regsz"); ok(ret == ERROR_SUCCESS, "got %d\n", ret); V_VT(&value) = VT_BSTR; V_BSTR(&value) = SysAllocString(regszW); hr = IWshShell3_RegWrite(sh3, name, &value, &v); ok(hr == S_OK, "got 0x%08x\n", hr); VariantClear(&value); type = REG_NONE; ret = RegGetValueA(root, NULL, "regsz", RRF_RT_ANY, &type, NULL, NULL); ok(ret == ERROR_SUCCESS, "got %d\n", ret); ok(type == REG_SZ, "got %d\n", type); ret = RegDeleteValueA(root, "regsz"); ok(ret == ERROR_SUCCESS, "got %d\n", ret); V_VT(&value) = VT_R4; V_R4(&value) = 1.2; hr = IWshShell3_RegWrite(sh3, name, &value, &v); ok(hr == S_OK, "got 0x%08x\n", hr); VariantClear(&value); type = REG_NONE; ret = RegGetValueA(root, NULL, "regsz", RRF_RT_ANY, &type, NULL, NULL); ok(ret == ERROR_SUCCESS, "got %d\n", ret); ok(type == REG_SZ, "got %d\n", type); ret = RegDeleteValueA(root, "regsz"); ok(ret == ERROR_SUCCESS, "got %d\n", ret); V_VT(&value) = VT_R4; V_R4(&value) = 1.2; V_VT(&v) = VT_I2; V_I2(&v) = 1; hr = IWshShell3_RegWrite(sh3, name, &value, &v); ok(hr == E_INVALIDARG, "got 0x%08x\n", hr); VariantClear(&value); SysFreeString(name); delete_key(root); IWshShell3_Release(sh3); }
static BOOL is_optional_argument(const VARIANT *arg) { return V_VT(arg) == VT_ERROR && V_ERROR(arg) == DISP_E_PARAMNOTFOUND; }
static void ole_set_byref(VARIANT *realvar, VARIANT *var, VARTYPE vt) { V_VT(var) = vt; if (vt == (VT_VARIANT|VT_BYREF)) { V_VARIANTREF(var) = realvar; } else { if (V_VT(realvar) != (vt & ~VT_BYREF)) { rb_raise(eWIN32OLERuntimeError, "variant type mismatch"); } switch(vt & ~VT_BYREF) { case VT_I1: V_I1REF(var) = &V_I1(realvar); break; case VT_UI1: V_UI1REF(var) = &V_UI1(realvar); break; case VT_I2: V_I2REF(var) = &V_I2(realvar); break; case VT_UI2: V_UI2REF(var) = &V_UI2(realvar); break; case VT_I4: V_I4REF(var) = &V_I4(realvar); break; case VT_UI4: V_UI4REF(var) = &V_UI4(realvar); break; case VT_R4: V_R4REF(var) = &V_R4(realvar); break; case VT_R8: V_R8REF(var) = &V_R8(realvar); break; #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__) #ifdef V_I8REF case VT_I8: V_I8REF(var) = &V_I8(realvar); break; #endif #ifdef V_UI8REF case VT_UI8: V_UI8REF(var) = &V_UI8(realvar); break; #endif #endif case VT_INT: V_INTREF(var) = &V_INT(realvar); break; case VT_UINT: V_UINTREF(var) = &V_UINT(realvar); break; case VT_CY: V_CYREF(var) = &V_CY(realvar); break; case VT_DATE: V_DATEREF(var) = &V_DATE(realvar); break; case VT_BSTR: V_BSTRREF(var) = &V_BSTR(realvar); break; case VT_DISPATCH: V_DISPATCHREF(var) = &V_DISPATCH(realvar); break; case VT_ERROR: V_ERRORREF(var) = &V_ERROR(realvar); break; case VT_BOOL: V_BOOLREF(var) = &V_BOOL(realvar); break; case VT_UNKNOWN: V_UNKNOWNREF(var) = &V_UNKNOWN(realvar); break; case VT_ARRAY: V_ARRAYREF(var) = &V_ARRAY(realvar); break; default: rb_raise(eWIN32OLERuntimeError, "unknown type specified(setting BYREF):%d", vt); break; } } }
static void test_xmlelem(void) { HRESULT hr; IXMLDocument *doc = NULL; IXMLElement *element = NULL, *parent; IXMLElement *child, *child2; IXMLElementCollection *children; VARIANT vType, vName; VARIANT vIndex, vValue; BSTR str, val; long type, num_child; static const WCHAR propName[] = {'p','r','o','p',0}; static const WCHAR propVal[] = {'v','a','l',0}; static const WCHAR nextVal[] = {'n','e','x','t',0}; static const WCHAR noexist[] = {'n','o','e','x','i','s','t',0}; static const WCHAR crazyCase1[] = {'C','R','a','z','Y','c','A','S','E',0}; static const WCHAR crazyCase2[] = {'C','R','A','Z','Y','C','A','S','E',0}; hr = CoCreateInstance(&CLSID_XMLDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDocument, (LPVOID*)&doc); if (FAILED(hr)) { skip("Failed to create XMLDocument instance\n"); return; } V_VT(&vType) = VT_I4; V_I4(&vType) = XMLELEMTYPE_ELEMENT; V_VT(&vName) = VT_NULL; hr = IXMLDocument_createElement(doc, vType, vName, &element); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(element != NULL, "Expected non-NULL element\n"); hr = IXMLElement_get_tagName(element, &str); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(lstrlenW(str) == 0, "Expected empty tag name\n"); SysFreeString(str); parent = (IXMLElement *)0xdeadbeef; hr = IXMLElement_get_parent(element, &parent); ok(hr == 1, "Expected 1, got %d\n", hr); ok(parent == NULL, "Expected NULL parent\n"); str = SysAllocString(noexist); hr = IXMLElement_getAttribute(element, str, &vValue); ok(hr == S_FALSE, "Expected S_FALSE, got %d\n", hr); ok(V_VT(&vValue) == VT_EMPTY, "Expected VT_EMPTY, got %d\n", V_VT(&vValue)); ok(V_BSTR(&vValue) == NULL, "Expected null value\n"); VariantClear(&vValue); SysFreeString(str); str = SysAllocString(crazyCase1); val = SysAllocString(propVal); V_VT(&vValue) = VT_BSTR; V_BSTR(&vValue) = val; hr = IXMLElement_setAttribute(element, str, vValue); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); SysFreeString(str); SysFreeString(val); str = SysAllocString(crazyCase2); hr = IXMLElement_getAttribute(element, str, &vValue); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(V_VT(&vValue) == VT_BSTR, "Expected VT_BSTR, got %d\n", V_VT(&vValue)); ok(!lstrcmpW(V_BSTR(&vValue), propVal), "Expected 'val'\n"); VariantClear(&vValue); SysFreeString(str); str = SysAllocString(propName); val = SysAllocString(propVal); V_VT(&vValue) = VT_BSTR; V_BSTR(&vValue) = val; hr = IXMLElement_setAttribute(element, str, vValue); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); SysFreeString(val); hr = IXMLElement_getAttribute(element, str, &vValue); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(V_VT(&vValue) == VT_BSTR, "Expected VT_BSTR, got %d\n", V_VT(&vValue)); ok(!lstrcmpW(V_BSTR(&vValue), propVal), "Expected 'val'\n"); VariantClear(&vValue); hr = IXMLElement_removeAttribute(element, str); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); /* remove now nonexistent attribute */ hr = IXMLElement_removeAttribute(element, str); ok(hr == S_FALSE, "Expected S_FALSE, got %d\n", hr); hr = IXMLElement_getAttribute(element, str, &vValue); ok(hr == 1, "Expected 1, got %d\n", hr); ok(V_VT(&vValue) == VT_EMPTY, "Expected VT_EMPTY, got %d\n", V_VT(&vValue)); ok(V_BSTR(&vValue) == NULL, "Expected null value\n"); SysFreeString(str); VariantClear(&vValue); children = (IXMLElementCollection *)0xdeadbeef; hr = IXMLElement_get_children(element, &children); ok(hr == 1, "Expected 1, got %d\n", hr); ok(children == NULL, "Expected NULL collection\n"); hr = IXMLElement_get_type(element, &type); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(type == XMLELEMTYPE_ELEMENT, "Expected XMLELEMTYPE_ELEMENT, got %ld\n", type); hr = IXMLElement_get_text(element, &str); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(lstrlenW(str) == 0, "Expected empty text\n"); SysFreeString(str); /* put_text with an ELEMENT */ str = SysAllocString(propVal); hr = IXMLElement_put_text(element, str); ok(hr == E_NOTIMPL, "Expected E_NOTIMPL, got %d\n", hr); SysFreeString(str); V_VT(&vType) = VT_I4; V_I4(&vType) = XMLELEMTYPE_TEXT; V_VT(&vName) = VT_NULL; hr = IXMLDocument_createElement(doc, vType, vName, &child); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(child != NULL, "Expected non-NULL child\n"); hr = IXMLElement_addChild(element, child, 0, -1); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); str = SysAllocString(propVal); hr = IXMLElement_put_text(child, str); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); SysFreeString(str); parent = (IXMLElement *)0xdeadbeef; hr = IXMLElement_get_parent(child, &parent); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(parent != element, "Expected parent != element\n"); hr = IXMLElement_get_type(parent, &type); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(type == XMLELEMTYPE_ELEMENT, "Expected XMLELEMTYPE_ELEMENT, got %ld\n", type); children = (IXMLElementCollection *)0xdeadbeef; hr = IXMLElement_get_children(element, &children); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(children != NULL, "Expected non-NULL collection\n"); hr = IXMLElementCollection_get_length(children, &num_child); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(num_child == 1, "Expected 1, got %ld\n", num_child); V_VT(&vIndex) = VT_I4; V_I4(&vIndex) = 0; V_VT(&vName) = VT_ERROR; V_ERROR(&vName) = DISP_E_PARAMNOTFOUND; hr = IXMLElementCollection_item(children, vIndex, vName, (IDispatch **)&child2); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(child2 != NULL, "Expected non-NULL child\n"); hr = IXMLElement_get_type(child2, &type); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(type == XMLELEMTYPE_TEXT, "Expected XMLELEMTYPE_TEXT, got %ld\n", type); hr = IXMLElement_get_text(element, &str); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(!lstrcmpW(str, propVal), "Expected 'val'\n"); SysFreeString(str); hr = IXMLElement_get_text(child2, &str); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(!lstrcmpW(str, propVal), "Expected 'val'\n"); SysFreeString(str); /* try put_text on ELEMENT again, now that it has a text child */ str = SysAllocString(nextVal); hr = IXMLElement_put_text(element, str); ok(hr == E_NOTIMPL, "Expected E_NOTIMPL, got %d\n", hr); SysFreeString(str); str = SysAllocString(nextVal); hr = IXMLElement_put_text(child2, str); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); SysFreeString(str); hr = IXMLElement_get_text(element, &str); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(!lstrcmpW(str, nextVal), "Expected 'val'\n"); SysFreeString(str); IXMLElement_Release(child2); IXMLElementCollection_Release(children); IXMLElement_Release(parent); IXMLElement_Release(child); IXMLElement_Release(element); IXMLDocument_Release(doc); }
static HRESULT ExtractArgument(VARIANT * pvArg, WCHAR chIdentifier, BOOL * pbFreeArg, va_list * marker) { HRESULT hr = NOERROR; *pbFreeArg = FALSE; if (chIdentifier == L'T') chIdentifier = (dh_g_bIsUnicodeMode ? L'S' : L's'); switch (chIdentifier) { case L'd': V_VT(pvArg) = VT_I4; V_I4(pvArg) = va_arg(*marker, LONG); break; case L'u': V_VT(pvArg) = VT_UI4; V_UI4(pvArg) = va_arg(*marker, ULONG); break; case L'e': V_VT(pvArg) = VT_R8; V_R8(pvArg) = va_arg(*marker, DOUBLE); break; case L'b': V_VT(pvArg) = VT_BOOL; V_BOOL(pvArg) = ( va_arg(*marker, BOOL) ? VARIANT_TRUE : VARIANT_FALSE ); break; case L'v': *pvArg = *va_arg(*marker, VARIANT *); break; case L'm': V_VT(pvArg) = VT_ERROR; V_ERROR(pvArg) = DISP_E_PARAMNOTFOUND; break; case L'B': V_VT(pvArg) = VT_BSTR; V_BSTR(pvArg) = va_arg(*marker, BSTR); break; case L'S': { LPOLESTR szTemp = va_arg(*marker, LPOLESTR); V_VT(pvArg) = VT_BSTR; V_BSTR(pvArg) = SysAllocString(szTemp); if (V_BSTR(pvArg) == NULL && szTemp != NULL) hr = E_OUTOFMEMORY; *pbFreeArg = TRUE; break; } case L's': V_VT(pvArg) = VT_BSTR; hr = ConvertAnsiStrToBStr(va_arg(*marker, LPSTR), &V_BSTR(pvArg)); *pbFreeArg = TRUE; break; case L'o': V_VT(pvArg) = VT_DISPATCH; V_DISPATCH(pvArg) = va_arg(*marker, IDispatch *); break; case L'O': V_VT(pvArg) = VT_UNKNOWN; V_UNKNOWN(pvArg) = va_arg(*marker, IUnknown *); break; case L'D': V_VT(pvArg) = VT_DATE; V_DATE(pvArg) = va_arg(*marker, DATE); break; case L't': V_VT(pvArg) = VT_DATE; hr = ConvertTimeTToVariantTime(va_arg(*marker, time_t), &V_DATE(pvArg)); break; case L'W': V_VT(pvArg) = VT_DATE; hr = ConvertSystemTimeToVariantTime(va_arg(*marker, SYSTEMTIME *), &V_DATE(pvArg)); break; case L'f': V_VT(pvArg) = VT_DATE; hr = ConvertFileTimeToVariantTime(va_arg(*marker, FILETIME *), &V_DATE(pvArg)); break; case L'p': #ifndef _WIN64 V_VT(pvArg) = VT_I4; V_I4(pvArg) = (LONG) va_arg(*marker, LPVOID); #else V_VT(pvArg) = VT_I8; V_I8(pvArg) = (LONGLONG) va_arg(*marker, LPVOID); #endif break; default: hr = E_INVALIDARG; DEBUG_NOTIFY_INVALID_IDENTIFIER(chIdentifier); break; } return hr; }
static void test_xmlelem_collection(void) { HRESULT hr; IUnknown *unk = NULL; IXMLDocument *doc = NULL; IXMLElement *element = NULL, *child; IXMLElementCollection *collection = NULL; IEnumVARIANT *enumVar = NULL; WCHAR path[MAX_PATH]; long length, type; ULONG num_vars; VARIANT var, vIndex, vName; BSTR url, str; static const WCHAR szBankXML[] = {'b','a','n','k','.','x','m','l',0}; static const WCHAR szNumber[] = {'N','U','M','B','E','R',0}; static const WCHAR szName[] = {'N','A','M','E',0}; hr = CoCreateInstance(&CLSID_XMLDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDocument, (LPVOID*)&doc); if (FAILED(hr)) { skip("Failed to create XMLDocument instance\n"); return; } create_xml_file("bank.xml"); GetFullPathNameW(szBankXML, MAX_PATH, path, NULL); url = SysAllocString(path); hr = IXMLDocument_put_URL(doc, url); /* Win98 returns ERROR_URL_NOT_FOUND */ ok(hr == S_OK || hr == ERROR_URL_NOT_FOUND, "Expected S_OK, got 0x%08x\n", hr); SysFreeString(url); if(hr != S_OK) goto cleanup; hr = IXMLDocument_get_root(doc, &element); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(element != NULL, "Expected non-NULL element\n"); hr = IXMLElement_get_children(element, &collection); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(collection != NULL, "Expected non-NULL collection\n"); hr = IXMLElementCollection_get_length(collection, NULL); ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %d\n", hr); hr = IXMLElementCollection_get_length(collection, &length); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(length == 2, "Expected 2, got %ld\n", length); /* IXMLElementCollection:put_length does nothing */ hr = IXMLElementCollection_put_length(collection, -1); ok(hr == E_FAIL, "Expected E_FAIL, got %08x\n", hr); hr = IXMLElementCollection_put_length(collection, 0); ok(hr == E_FAIL, "Expected E_FAIL, got %08x\n", hr); hr = IXMLElementCollection_put_length(collection, 1); ok(hr == E_FAIL, "Expected E_FAIL, got %08x\n", hr); hr = IXMLElementCollection_put_length(collection, 2); ok(hr == E_FAIL, "Expected E_FAIL, got %08x\n", hr); hr = IXMLElementCollection_put_length(collection, 3); ok(hr == E_FAIL, "Expected E_FAIL, got %08x\n", hr); hr = IXMLElementCollection_put_length(collection, 50); ok(hr == E_FAIL, "Expected E_FAIL, got %08x\n", hr); /* make sure the length hasn't changed */ hr = IXMLElementCollection_get_length(collection, &length); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(length == 2, "Expected 2, got %ld\n", length); /* IXMLElementCollection implements IEnumVARIANT */ hr = IXMLElementCollection_QueryInterface(collection, &IID_IEnumVARIANT, (LPVOID *)&enumVar); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(enumVar != NULL, "Expected non-NULL enumVar\n"); IEnumVARIANT_Release(enumVar); hr = IXMLElementCollection_get__newEnum(collection, &unk); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(unk != NULL, "Expected non-NULL unk\n"); hr = IUnknown_QueryInterface(unk, &IID_IEnumVARIANT, (LPVOID *)&enumVar); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(enumVar != NULL, "Expected non-NULL enumVar\n"); IUnknown_Release(unk); /* <Number>1234</Number> */ hr = IEnumVARIANT_Next(enumVar, 1, &var, &num_vars); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(V_VT(&var) == VT_DISPATCH, "Expected VT_DISPATCH, got %d\n", V_VT(&var)); ok(num_vars == 1, "Expected 1, got %d\n", 1); hr = IUnknown_QueryInterface(V_DISPATCH(&var), &IID_IXMLElement, (LPVOID *)&child); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(child != NULL, "Expected non-NULL child\n"); VariantClear(&var); hr = IXMLElement_get_type(child, &type); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(type == XMLELEMTYPE_ELEMENT, "Expected XMLELEMTYPE_ELEMENT, got %ld\n", type); hr = IXMLElement_get_tagName(child, &str); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(!lstrcmpW(str, szNumber), "Expected NUMBER\n"); SysFreeString(str); IXMLElement_Release(child); /* <Name>Captain Ahab</Name> */ hr = IEnumVARIANT_Next(enumVar, 1, &var, &num_vars); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(V_VT(&var) == VT_DISPATCH, "Expected VT_DISPATCH, got %d\n", V_VT(&var)); ok(num_vars == 1, "Expected 1, got %d\n", 1); hr = IUnknown_QueryInterface(V_DISPATCH(&var), &IID_IXMLElement, (LPVOID *)&child); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(child != NULL, "Expected non-NULL child\n"); VariantClear(&var); hr = IXMLElement_get_type(child, &type); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(type == XMLELEMTYPE_ELEMENT, "Expected XMLELEMTYPE_ELEMENT, got %ld\n", type); hr = IXMLElement_get_tagName(child, &str); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(!lstrcmpW(str, szName), "Expected NAME\n"); SysFreeString(str); IXMLElement_Release(child); /* <Number>1234</Number> */ V_VT(&vIndex) = VT_I4; V_I4(&vIndex) = 0; V_VT(&vName) = VT_ERROR; V_ERROR(&vName) = DISP_E_PARAMNOTFOUND; hr = IXMLElementCollection_item(collection, vIndex, vName, (IDispatch **)&child); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(child != NULL, "Expected non-NULL child\n"); hr = IXMLElement_get_type(child, &type); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(type == XMLELEMTYPE_ELEMENT, "Expected XMLELEMTYPE_ELEMENT, got %ld\n", type); hr = IXMLElement_get_tagName(child, &str); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(!lstrcmpW(str, szNumber), "Expected NUMBER\n"); SysFreeString(str); IXMLElement_Release(child); /* <Name>Captain Ahab</Name> */ V_VT(&vIndex) = VT_I4; V_I4(&vIndex) = 1; V_VT(&vName) = VT_ERROR; V_ERROR(&vName) = DISP_E_PARAMNOTFOUND; hr = IXMLElementCollection_item(collection, vIndex, vName, (IDispatch **)&child); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(child != NULL, "Expected non-NULL child\n"); hr = IXMLElement_get_type(child, &type); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(type == XMLELEMTYPE_ELEMENT, "Expected XMLELEMTYPE_ELEMENT, got %ld\n", type); hr = IXMLElement_get_tagName(child, &str); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(!lstrcmpW(str, szName), "Expected NAME\n"); SysFreeString(str); IXMLElement_Release(child); V_I4(&vIndex) = 100; hr = IXMLElementCollection_item(collection, vIndex, vName, (IDispatch **)&child); ok(hr == E_FAIL, "Expected E_FAIL, got %08x\n", hr); ok(child == NULL, "Expected NULL child\n"); V_I4(&vIndex) = -1; child = (IXMLElement *)0xdeadbeef; hr = IXMLElementCollection_item(collection, vIndex, vName, (IDispatch **)&child); ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %d\n", hr); ok(child == NULL, "Expected NULL child\n"); IEnumVARIANT_Release(enumVar); IXMLElement_Release(element); IXMLElementCollection_Release(collection); cleanup: IXMLDocument_Release(doc); DeleteFileA("bank.xml"); }
TclObject::TclObject (VARIANT *pSrc, const Type &type, Tcl_Interp *interp, int bytes) { if (V_ISARRAY(pSrc)) { SAFEARRAY *psa = V_ISBYREF(pSrc) ? *V_ARRAYREF(pSrc) : V_ARRAY(pSrc); VARTYPE elementType = V_VT(pSrc) & VT_TYPEMASK; unsigned numDimensions = SafeArrayGetDim(psa); std::vector<long> indices(numDimensions); m_pObj = convertFromSafeArray( psa, elementType, 1, &indices[0], type, interp, bytes); } else if (vtMissing == pSrc) { m_pObj = Extension::newNaObj(); } else { switch (V_VT(pSrc)) { case VT_BOOL: m_pObj = Tcl_NewBooleanObj(V_BOOL(pSrc)); break; case VT_ERROR: m_pObj = Tcl_NewLongObj(V_ERROR(pSrc)); break; case VT_I1: case VT_UI1: m_pObj = Tcl_NewLongObj(V_I1(pSrc)); break; case VT_I2: case VT_UI2: m_pObj = Tcl_NewLongObj(V_I2(pSrc)); break; case VT_I4: case VT_UI4: case VT_INT: case VT_UINT: m_pObj = Tcl_NewLongObj(V_I4(pSrc)); break; #ifdef V_I8 case VT_I8: case VT_UI8: m_pObj = Tcl_NewWideIntObj(V_I8(pSrc)); break; #endif case VT_R4: m_pObj = Tcl_NewDoubleObj(V_R4(pSrc)); break; case VT_DATE: case VT_R8: m_pObj = Tcl_NewDoubleObj(V_R8(pSrc)); break; case VT_DISPATCH: m_pObj = convertFromUnknown(V_DISPATCH(pSrc), type.iid(), interp); break; case VT_DISPATCH | VT_BYREF: m_pObj = convertFromUnknown( (V_DISPATCHREF(pSrc) != 0) ? *V_DISPATCHREF(pSrc) : 0, type.iid(), interp); break; case VT_UNKNOWN: m_pObj = convertFromUnknown(V_UNKNOWN(pSrc), type.iid(), interp); break; case VT_UNKNOWN | VT_BYREF: m_pObj = convertFromUnknown( (V_UNKNOWNREF(pSrc) != 0) ? *V_UNKNOWNREF(pSrc) : 0, type.iid(), interp); break; case VT_NULL: m_pObj = Extension::newNullObj(); break; case VT_LPSTR: m_pObj = Tcl_NewStringObj(V_I1REF(pSrc), -1); break; case VT_LPWSTR: { #if TCL_MINOR_VERSION >= 2 // Uses Unicode function introduced in Tcl 8.2. m_pObj = newUnicodeObj(V_UI2REF(pSrc), -1); #else const wchar_t *pWide = V_UI2REF(pSrc); _bstr_t str(pWide); m_pObj = Tcl_NewStringObj(str, -1); #endif } break; default: if (V_VT(pSrc) == VT_USERDEFINED && type.name() == "GUID") { Uuid uuid(*static_cast<UUID *>(V_BYREF(pSrc))); m_pObj = Tcl_NewStringObj( const_cast<char *>(uuid.toString().c_str()), -1); } else { if (V_VT(pSrc) == (VT_VARIANT | VT_BYREF)) { pSrc = V_VARIANTREF(pSrc); } _bstr_t str(pSrc); #if TCL_MINOR_VERSION >= 2 // Uses Unicode function introduced in Tcl 8.2. wchar_t *pWide = str; m_pObj = newUnicodeObj( reinterpret_cast<Tcl_UniChar *>(pWide), str.length()); #else m_pObj = Tcl_NewStringObj(str, -1); #endif } } } Tcl_IncrRefCount(m_pObj); }
//////////////////////////////////////////////////////// // CompareVariant // //////////////////////////////////////////////////////// LONG CompareVariant ( VARIANT *pVar1, //@parm [in]: Pointer to the variant in the consumer's buffer. VARIANT *pVar2, //@parm [in]: Pointer to the variant at the backend. BOOL fCaseSensitive ) { //Handle NULL cases... if(pVar1==NULL || pVar2==NULL) { if(pVar1 == pVar2) return TRUE; return FALSE; } // The variant has to be the same type if (V_VT(pVar1) != V_VT(pVar2)) return FALSE; // Return FALSE if vt is ORed with VT_RESERVED if (V_VT(pVar1) & VT_RESERVED) return FALSE; // Return TRUE is the vt is VT_EMPTY or VT_NULL if (V_VT(pVar1)==VT_EMPTY || V_VT(pVar1)==VT_NULL) return TRUE; switch(V_VT(pVar1)) { case VT_UI1: return V_UI1(pVar1) == V_UI1(pVar2); case VT_I2: return V_I2(pVar1) == V_I2(pVar2); case VT_I4: return V_I4(pVar1) == V_I4(pVar2); case VT_R4: return V_R4(pVar1) == V_R4(pVar2); case VT_R8: return V_R8(pVar1) == V_R8(pVar2); case VT_BOOL: return V_BOOL(pVar1) == V_BOOL(pVar2); case VT_ERROR: return V_ERROR(pVar1) == V_ERROR(pVar2); case VT_CY: return memcmp(&V_CY(pVar1), &V_CY(pVar2),8)==0; case VT_DATE: return V_DATE(pVar1) == V_DATE(pVar2); case VT_BSTR: if(fCaseSensitive) return wcscmp(V_BSTR(pVar1), V_BSTR(pVar2)); else return _wcsicmp(V_BSTR(pVar1), V_BSTR(pVar2)); // As we are not testing OLE object, return FALSE for VT_UNKNOWN case VT_UNKNOWN: return FALSE; // As we are not testing OLE object, return FALSE for VT_DISPATCH case VT_DISPATCH: return FALSE; case VT_I2 | VT_BYREF: return *V_I2REF(pVar1) == *V_I2REF(pVar2); case VT_I4 | VT_BYREF: return *V_I4REF(pVar1) == *V_I4REF(pVar2); case VT_R4 | VT_BYREF: return *V_R4REF(pVar1) == *V_R4REF(pVar2); case VT_R8 | VT_BYREF: return *V_R8REF(pVar1) == *V_R8REF(pVar2); case VT_BOOL | VT_BYREF: return *V_BOOLREF(pVar1) == *V_BOOLREF(pVar2); case VT_ERROR | VT_BYREF: return *V_ERRORREF(pVar1) == *V_ERRORREF(pVar2); case VT_CY | VT_BYREF: return memcmp(V_CYREF(pVar1), V_CYREF(pVar2),8)==0; case VT_DATE | VT_BYREF: return *V_DATEREF(pVar1) == *V_DATEREF(pVar2); case VT_BSTR | VT_BYREF: if(fCaseSensitive) return wcscmp(*V_BSTRREF(pVar1), *V_BSTRREF(pVar2)); else return _wcsicmp(*V_BSTRREF(pVar1), *V_BSTRREF(pVar2)); // As we are not testing OLE object, return FALSE for VT_UNKNOWN case VT_UNKNOWN | VT_BYREF: return FALSE; // As we are not testing OLE object, return FALSE for VT_DISPATCH case VT_DISPATCH | VT_BYREF: return FALSE; } return FALSE; }
HRESULT Reference::invokeDispatch ( MEMBERID memberid, WORD dispatchFlags, const TypedArguments &arguments, VARIANT *pResult) { IDispatch *pDispatch = dispatch(); if (pDispatch == 0) { return E_NOINTERFACE; } // Remove missing optional arguments from the end of the argument list. // This permits calling servers which modify their action depending on // the actual number of arguments. DISPPARAMS *pParams = arguments.dispParams(); // Count the number of missing arguments. unsigned cMissingArgs = 0; VARIANT *pArg = pParams->rgvarg + pParams->cNamedArgs; for (unsigned i = pParams->cNamedArgs; i < pParams->cArgs; ++i) { if (V_VT(pArg) != VT_ERROR || V_ERROR(pArg) != DISP_E_PARAMNOTFOUND) { break; } ++cMissingArgs; ++pArg; } // Move the named arguments up next to the remaining unnamed arguments and // adjust the DISPPARAMS struct. if (cMissingArgs > 0) { for (unsigned i = 0; i < pParams->cNamedArgs; ++i) { pParams->rgvarg[i + cMissingArgs] = pParams->rgvarg[i]; } pParams->cArgs -= cMissingArgs; pParams->rgvarg += cMissingArgs; } EXCEPINFO excepInfo; memset(&excepInfo, 0, sizeof(excepInfo)); unsigned argErr; // Invoke through IDispatch interface. HRESULT hr = pDispatch->Invoke( memberid, IID_NULL, LOCALE_USER_DEFAULT, dispatchFlags, pParams, pResult, &excepInfo, &argErr); if (hr == DISP_E_EXCEPTION) { throwDispatchException(excepInfo); } else if (hr == DISP_E_TYPEMISMATCH || hr == DISP_E_PARAMNOTFOUND) { throw InvokeException(hr, pParams->cArgs - argErr); } return hr; }
static void test_xmldoc(void) { IXMLElement *element = NULL, *child = NULL, *value = NULL; IXMLElementCollection *collection = NULL, *inner = NULL; IPersistStreamInit *psi = NULL; IXMLDocument *doc = NULL; IStream *stream = NULL; VARIANT vIndex, vName; LONG type, num_child; CHAR path[MAX_PATH]; IDispatch *disp; ITypeInfo *ti; HRESULT hr; BSTR name; static const WCHAR szBankAccount[] = {'B','A','N','K','A','C','C','O','U','N','T',0}; static const WCHAR szNumber[] = {'N','U','M','B','E','R',0}; static const WCHAR szNumVal[] = {'1','2','3','4',0}; static const WCHAR szName[] = {'N','A','M','E',0}; static const WCHAR szNameVal[] = {'C','a','p','t','a','i','n',' ','A','h','a','b',0}; static const WCHAR szVersion[] = {'1','.','0',0}; static const WCHAR rootW[] = {'r','o','o','t',0}; hr = CoCreateInstance(&CLSID_XMLDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDocument, (void**)&doc); EXPECT_HR(hr, S_OK); /* IDispatch */ hr = IXMLDocument_QueryInterface(doc, &IID_IDispatch, (void**)&disp); EXPECT_HR(hr, S_OK); /* just to make sure we're on right type data */ hr = IDispatch_GetTypeInfo(disp, 0, 0, &ti); EXPECT_HR(hr, S_OK); name = NULL; hr = ITypeInfo_GetDocumentation(ti, DISPID_XMLDOCUMENT_ROOT, &name, NULL, NULL, NULL); EXPECT_HR(hr, S_OK); ok(!lstrcmpW(name, rootW), "got name %s\n", wine_dbgstr_w(name)); SysFreeString(name); ITypeInfo_Release(ti); IDispatch_Release(disp); hr = IXMLDocument_QueryInterface(doc, &IID_IXMLDOMDocument, (void**)&disp); EXPECT_HR(hr, E_NOINTERFACE); create_xml_file("bank.xml"); GetFullPathNameA("bank.xml", MAX_PATH, path, NULL); create_stream_on_file(&stream, path); hr = IXMLDocument_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&psi); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(psi != NULL, "Expected non-NULL psi\n"); hr = IXMLDocument_get_root(doc, &element); ok(hr == E_FAIL, "Expected E_FAIL, got %08x\n", hr); ok(element == NULL, "Expected NULL element\n"); hr = IPersistStreamInit_Load(psi, stream); ok(hr == S_OK || hr == XML_E_INVALIDATROOTLEVEL, "Expected S_OK, got %08x\n", hr); if(hr == XML_E_INVALIDATROOTLEVEL) goto cleanup; ok(stream != NULL, "Expected non-NULL stream\n"); /* version field */ hr = IXMLDocument_get_version(doc, NULL); ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr); name = NULL; hr = IXMLDocument_get_version(doc, &name); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(!lstrcmpW(name, szVersion), "Expected 1.0, got %s\n", wine_dbgstr_w(name)); SysFreeString(name); /* doctype */ hr = IXMLDocument_get_doctype(doc, NULL); ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n", hr); hr = IXMLDocument_get_doctype(doc, &name); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(!lstrcmpW(name, szBankAccount), "Expected BANKACCOUNT, got %s\n", wine_dbgstr_w(name)); SysFreeString(name); hr = IXMLDocument_get_root(doc, &element); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(element != NULL, "Expected non-NULL element\n"); /* ::root() returns new instance each time */ hr = IXMLDocument_get_root(doc, &child); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(child != NULL, "Expected non-NULL element\n"); ok(child != element, "Expected new element instance\n"); IXMLElement_Release(child); hr = IXMLElement_get_type(element, &type); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(type == XMLELEMTYPE_ELEMENT, "Expected XMLELEMTYPE_ELEMENT, got %d\n", type); hr = IXMLElement_get_tagName(element, &name); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(!lstrcmpW(name, szBankAccount), "Expected BANKACCOUNT\n"); SysFreeString(name); hr = IXMLElement_get_children(element, &collection); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(collection != NULL, "Expected non-NULL collection\n"); hr = IXMLElementCollection_get_length(collection, &num_child); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(num_child == 2, "Expected 2, got %d\n", num_child); V_VT(&vIndex) = VT_I4; V_I4(&vIndex) = 0; V_VT(&vName) = VT_ERROR; V_ERROR(&vName) = DISP_E_PARAMNOTFOUND; hr = IXMLElementCollection_item(collection, vIndex, vName, (IDispatch **)&child); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(child != NULL, "Expected non-NULL child\n"); hr = IXMLElement_get_type(child, &type); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(type == XMLELEMTYPE_ELEMENT, "Expected XMLELEMTYPE_ELEMENT, got %d\n", type); hr = IXMLElement_get_tagName(child, &name); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(!lstrcmpW(name, szNumber), "Expected NUMBER\n"); SysFreeString(name); hr = IXMLElement_get_children(child, &inner); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(inner != NULL, "Expected non-NULL inner\n"); hr = IXMLElementCollection_get_length(inner, &num_child); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(num_child == 1, "Expected 1, got %d\n", num_child); hr = IXMLElementCollection_item(inner, vIndex, vName, (IDispatch **)&value); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(value != NULL, "Expected non-NULL value\n"); hr = IXMLElement_get_type(value, &type); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(type == XMLELEMTYPE_TEXT, "Expected XMLELEMTYPE_TEXT, got %d\n", type); hr = IXMLElement_get_text(value, &name); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(!lstrcmpW(name, szNumVal), "Expected '1234'\n"); SysFreeString(name); IXMLElementCollection_Release(inner); inner = (IXMLElementCollection *)0xdeadbeef; hr = IXMLElement_get_children(value, &inner); ok(hr == 1, "Expected 1, got %08x\n", hr); ok(inner == NULL, "Expected NULL inner, got %p\n", inner); IXMLElement_Release(value); IXMLElement_Release(child); value = NULL; child = NULL; V_I4(&vIndex) = 1; hr = IXMLElementCollection_item(collection, vIndex, vName, (IDispatch **)&child); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(child != NULL, "Expected non-NULL child\n"); hr = IXMLElement_get_type(child, &type); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(type == XMLELEMTYPE_ELEMENT, "Expected XMLELEMTYPE_ELEMENT, got %d\n", type); hr = IXMLElement_get_tagName(child, &name); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(!lstrcmpW(name, szName), "Expected NAME\n"); SysFreeString(name); hr = IXMLElement_get_children(child, &inner); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(inner != NULL, "Expected non-NULL inner\n"); hr = IXMLElementCollection_get_length(inner, &num_child); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(num_child == 1, "Expected 1, got %d\n", num_child); V_I4(&vIndex) = 0; hr = IXMLElementCollection_item(inner, vIndex, vName, (IDispatch **)&value); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(value != NULL, "Expected non-NULL value\n"); hr = IXMLElement_get_type(value, &type); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(type == XMLELEMTYPE_TEXT, "Expected XMLELEMTYPE_TEXT, got %d\n", type); hr = IXMLElement_get_text(value, &name); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(!lstrcmpW(name, szNameVal), "Expected 'Captain Ahab'\n"); SysFreeString(name); IXMLElementCollection_Release(inner); inner = (IXMLElementCollection *)0xdeadbeef; hr = IXMLElement_get_children(value, &inner); ok(hr == 1, "Expected 1, got %08x\n", hr); ok(inner == NULL, "Expected NULL inner, got %p\n", inner); IXMLElement_Release(value); IXMLElement_Release(child); IXMLElementCollection_Release(collection); IXMLElement_Release(element); cleanup: IStream_Release(stream); IPersistStreamInit_Release(psi); IXMLDocument_Release(doc); DeleteFileA("bank.xml"); }
static HRESULT invoke_builtin_function(DispatchEx *This, func_info_t *func, DISPPARAMS *dp, VARIANT *res, IServiceProvider *caller) { VARIANT arg_buf[MAX_ARGS], *arg_ptrs[MAX_ARGS], *arg, retv, ret_ref, vhres; unsigned i, nconv = 0; IUnknown *iface; HRESULT hres; if(dp->cNamedArgs) { FIXME("Named arguments not supported\n"); return E_NOTIMPL; } if(dp->cArgs != func->argc) { FIXME("Invalid argument count (expected %u, got %u)\n", func->argc, dp->cArgs); return E_INVALIDARG; } hres = IUnknown_QueryInterface(This->outer, tid_ids[func->tid], (void**)&iface); if(FAILED(hres)) return hres; for(i=0; i < func->argc; i++) { arg = dp->rgvarg+dp->cArgs-i-1; if(func->arg_types[i] == V_VT(arg)) { arg_ptrs[i] = arg; }else { hres = change_type(arg_buf+nconv, arg, func->arg_types[i], caller); if(FAILED(hres)) break; arg_ptrs[i] = arg_buf + nconv++; } } if(SUCCEEDED(hres)) { if(func->prop_vt == VT_VOID) { V_VT(&retv) = VT_EMPTY; }else { V_VT(&retv) = func->prop_vt; arg_ptrs[func->argc] = &ret_ref; V_VT(&ret_ref) = VT_BYREF|func->prop_vt; switch(func->prop_vt) { #define CASE_VT(vt,type,access) \ case vt: \ V_BYREF(&ret_ref) = &access(&retv); \ break BUILTIN_TYPES_SWITCH; #undef CASE_VT default: assert(0); } } V_VT(&vhres) = VT_ERROR; hres = DispCallFunc(iface, func->call_vtbl_off*sizeof(void*), CC_STDCALL, VT_ERROR, func->argc + (func->prop_vt == VT_VOID ? 0 : 1), func->arg_types, arg_ptrs, &vhres); } while(nconv--) VariantClear(arg_buf+nconv); IUnknown_Release(iface); if(FAILED(hres)) return hres; if(FAILED(V_ERROR(&vhres))) return V_ERROR(&vhres); if(res) *res = retv; else VariantClear(&retv); return V_ERROR(&vhres); }
static void test_wshshell(void) { static const WCHAR notepadW[] = {'n','o','t','e','p','a','d','.','e','x','e',0}; static const WCHAR desktopW[] = {'D','e','s','k','t','o','p',0}; static const WCHAR lnk1W[] = {'f','i','l','e','.','l','n','k',0}; static const WCHAR pathW[] = {'%','P','A','T','H','%',0}; static const WCHAR sysW[] = {'S','Y','S','T','E','M',0}; static const WCHAR path2W[] = {'P','A','T','H',0}; static const WCHAR dummydirW[] = {'d','e','a','d','p','a','r','r','o','t',0}; static const WCHAR emptyW[] = {'e','m','p','t','y',0}; IWshEnvironment *env; IWshExec *shexec; IWshShell3 *sh3; IDispatchEx *dispex; IWshCollection *coll; IDispatch *disp, *shortcut; IUnknown *shell, *unk; IFolderCollection *folders; IWshShortcut *shcut; ITypeInfo *ti; HRESULT hr; TYPEATTR *tattr; DISPPARAMS dp; EXCEPINFO ei; VARIANT arg, res, arg2; BSTR str, ret; DWORD retval; UINT err; hr = CoCreateInstance(&CLSID_WshShell, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER, &IID_IDispatch, (void**)&disp); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IDispatch_QueryInterface(disp, &IID_IWshShell3, (void**)&shell); EXPECT_HR(hr, S_OK); IDispatch_Release(disp); hr = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex); EXPECT_HR(hr, E_NOINTERFACE); hr = IUnknown_QueryInterface(shell, &IID_IWshShell3, (void**)&sh3); EXPECT_HR(hr, S_OK); hr = IWshShell3_QueryInterface(sh3, &IID_IObjectWithSite, (void**)&unk); ok(hr == E_NOINTERFACE, "got 0x%08x\n", hr); hr = IWshShell3_QueryInterface(sh3, &IID_IWshShell, (void**)&unk); ok(hr == S_OK, "got 0x%08x\n", hr); IUnknown_Release(unk); hr = IWshShell3_QueryInterface(sh3, &IID_IWshShell2, (void**)&unk); ok(hr == S_OK, "got 0x%08x\n", hr); IUnknown_Release(unk); hr = IWshShell3_get_SpecialFolders(sh3, &coll); EXPECT_HR(hr, S_OK); hr = IWshCollection_QueryInterface(coll, &IID_IFolderCollection, (void**)&folders); EXPECT_HR(hr, E_NOINTERFACE); hr = IWshCollection_QueryInterface(coll, &IID_IDispatch, (void**)&disp); EXPECT_HR(hr, S_OK); hr = IDispatch_GetTypeInfo(disp, 0, 0, &ti); EXPECT_HR(hr, S_OK); hr = ITypeInfo_GetTypeAttr(ti, &tattr); EXPECT_HR(hr, S_OK); ok(IsEqualIID(&tattr->guid, &IID_IWshCollection), "got wrong type guid\n"); ITypeInfo_ReleaseTypeAttr(ti, tattr); /* try to call Item() with normal IDispatch procedure */ str = SysAllocString(desktopW); V_VT(&arg) = VT_BSTR; V_BSTR(&arg) = str; dp.rgvarg = &arg; dp.rgdispidNamedArgs = NULL; dp.cArgs = 1; dp.cNamedArgs = 0; hr = IDispatch_Invoke(disp, DISPID_VALUE, &IID_NULL, 1033, DISPATCH_PROPERTYGET, &dp, &res, &ei, &err); EXPECT_HR(hr, DISP_E_MEMBERNOTFOUND); /* try Item() directly, it returns directory path apparently */ V_VT(&res) = VT_EMPTY; hr = IWshCollection_Item(coll, &arg, &res); EXPECT_HR(hr, S_OK); ok(V_VT(&res) == VT_BSTR, "got res type %d\n", V_VT(&res)); SysFreeString(str); VariantClear(&res); /* CreateShortcut() */ str = SysAllocString(lnk1W); hr = IWshShell3_CreateShortcut(sh3, str, &shortcut); EXPECT_HR(hr, S_OK); SysFreeString(str); hr = IDispatch_QueryInterface(shortcut, &IID_IWshShortcut, (void**)&shcut); EXPECT_HR(hr, S_OK); hr = IWshShortcut_get_Arguments(shcut, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); hr = IWshShortcut_get_IconLocation(shcut, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); IWshShortcut_Release(shcut); IDispatch_Release(shortcut); /* ExpandEnvironmentStrings */ hr = IWshShell3_ExpandEnvironmentStrings(sh3, NULL, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); str = SysAllocString(pathW); hr = IWshShell3_ExpandEnvironmentStrings(sh3, str, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); SysFreeString(str); V_VT(&arg) = VT_BSTR; V_BSTR(&arg) = SysAllocString(sysW); hr = IWshShell3_get_Environment(sh3, &arg, &env); ok(hr == S_OK, "got 0x%08x\n", hr); VariantClear(&arg); hr = IWshEnvironment_get_Item(env, NULL, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); ret = (BSTR)0x1; hr = IWshEnvironment_get_Item(env, NULL, &ret); ok(hr == S_OK, "got 0x%08x\n", hr); ok(ret && !*ret, "got %p\n", ret); SysFreeString(ret); /* invalid var name */ str = SysAllocString(lnk1W); hr = IWshEnvironment_get_Item(env, str, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); ret = NULL; hr = IWshEnvironment_get_Item(env, str, &ret); ok(hr == S_OK, "got 0x%08x\n", hr); ok(ret && *ret == 0, "got %s\n", wine_dbgstr_w(ret)); SysFreeString(ret); SysFreeString(str); /* valid name */ str = SysAllocString(path2W); hr = IWshEnvironment_get_Item(env, str, &ret); ok(hr == S_OK, "got 0x%08x\n", hr); ok(ret && *ret != 0, "got %s\n", wine_dbgstr_w(ret)); SysFreeString(ret); SysFreeString(str); IWshEnvironment_Release(env); V_VT(&arg) = VT_I2; V_I2(&arg) = 0; V_VT(&arg2) = VT_ERROR; V_ERROR(&arg2) = DISP_E_PARAMNOTFOUND; str = SysAllocString(notepadW); hr = IWshShell3_Run(sh3, str, &arg, &arg2, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); retval = 10; hr = IWshShell3_Run(sh3, str, NULL, &arg2, &retval); ok(hr == E_POINTER, "got 0x%08x\n", hr); ok(retval == 10, "got %u\n", retval); retval = 10; hr = IWshShell3_Run(sh3, str, &arg, NULL, &retval); ok(hr == E_POINTER, "got 0x%08x\n", hr); ok(retval == 10, "got %u\n", retval); retval = 10; V_VT(&arg2) = VT_ERROR; V_ERROR(&arg2) = 0; hr = IWshShell3_Run(sh3, str, &arg, &arg2, &retval); ok(hr == DISP_E_TYPEMISMATCH, "got 0x%08x\n", hr); ok(retval == 10, "got %u\n", retval); SysFreeString(str); /* current directory */ if (0) /* crashes on native */ hr = IWshShell3_get_CurrentDirectory(sh3, NULL); str = NULL; hr = IWshShell3_get_CurrentDirectory(sh3, &str); ok(hr == S_OK, "got 0x%08x\n", hr); ok(str && str[0] != 0, "got empty string\n"); SysFreeString(str); hr = IWshShell3_put_CurrentDirectory(sh3, NULL); ok(hr == E_INVALIDARG, "got 0x%08x\n", hr); str = SysAllocString(emptyW); hr = IWshShell3_put_CurrentDirectory(sh3, str); ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr); SysFreeString(str); str = SysAllocString(dummydirW); hr = IWshShell3_put_CurrentDirectory(sh3, str); ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr); SysFreeString(str); /* Exec */ hr = IWshShell3_Exec(sh3, NULL, NULL); ok(hr == E_POINTER, "got 0x%08x\n", hr); hr = IWshShell3_Exec(sh3, NULL, &shexec); ok(hr == DISP_E_EXCEPTION, "got 0x%08x\n", hr); str = SysAllocString(emptyW); hr = IWshShell3_Exec(sh3, str, &shexec); ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr); SysFreeString(str); IWshCollection_Release(coll); IDispatch_Release(disp); IWshShell3_Release(sh3); IUnknown_Release(shell); }
static void test_XMLHTTP(void) { static const char bodyA[] = "mode=Test"; static const char urlA[] = "http://crossover.codeweavers.com/posttest.php"; static const char xmltestA[] = "http://crossover.codeweavers.com/xmltest.xml"; static const char referertesturl[] = "http://test.winehq.org/tests/referer.php"; static const WCHAR wszExpectedResponse[] = {'F','A','I','L','E','D',0}; static const CHAR xmltestbodyA[] = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<a>TEST</a>\n"; static const WCHAR norefererW[] = {'n','o',' ','r','e','f','e','r','e','r',' ','s','e','t',0}; IXMLHttpRequest *xhr; IObjectWithSite *obj_site, *obj_site2; BSTR bstrResponse, str, str1; VARIANT varbody, varbody_ref; VARIANT dummy; LONG state, status, bound; IDispatch *event; void *ptr; HRESULT hr; HGLOBAL g; xhr = create_xhr(); VariantInit(&dummy); V_VT(&dummy) = VT_ERROR; V_ERROR(&dummy) = DISP_E_MEMBERNOTFOUND; hr = IXMLHttpRequest_put_onreadystatechange(xhr, NULL); EXPECT_HR(hr, S_OK); hr = IXMLHttpRequest_abort(xhr); EXPECT_HR(hr, S_OK); V_VT(&varbody) = VT_I2; V_I2(&varbody) = 1; hr = IXMLHttpRequest_get_responseBody(xhr, &varbody); EXPECT_HR(hr, E_PENDING); ok(V_VT(&varbody) == VT_EMPTY, "got type %d\n", V_VT(&varbody)); ok(V_I2(&varbody) == 1, "got %d\n", V_I2(&varbody)); V_VT(&varbody) = VT_I2; V_I2(&varbody) = 1; hr = IXMLHttpRequest_get_responseStream(xhr, &varbody); EXPECT_HR(hr, E_PENDING); ok(V_VT(&varbody) == VT_EMPTY, "got type %d\n", V_VT(&varbody)); ok(V_I2(&varbody) == 1, "got %d\n", V_I2(&varbody)); /* send before open */ hr = IXMLHttpRequest_send(xhr, dummy); ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr); /* initial status code */ hr = IXMLHttpRequest_get_status(xhr, NULL); ok(hr == E_POINTER || broken(hr == E_INVALIDARG) /* <win8 */, "got 0x%08x\n", hr); status = 0xdeadbeef; hr = IXMLHttpRequest_get_status(xhr, &status); ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr); ok(status == READYSTATE_UNINITIALIZED || broken(status == 0xdeadbeef) /* <win8 */, "got %d\n", status); hr = IXMLHttpRequest_get_statusText(xhr, &str); ok(hr == E_FAIL, "got 0x%08x\n", hr); /* invalid parameters */ test_open(xhr, NULL, NULL, E_INVALIDARG); test_open(xhr, "POST", NULL, E_INVALIDARG); test_open(xhr, NULL, urlA, E_INVALIDARG); hr = IXMLHttpRequest_setRequestHeader(xhr, NULL, NULL); EXPECT_HR(hr, E_INVALIDARG); hr = IXMLHttpRequest_setRequestHeader(xhr, _bstr_("header1"), NULL); ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr); hr = IXMLHttpRequest_setRequestHeader(xhr, NULL, _bstr_("value1")); EXPECT_HR(hr, E_INVALIDARG); hr = IXMLHttpRequest_setRequestHeader(xhr, _bstr_("header1"), _bstr_("value1")); ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr); hr = IXMLHttpRequest_get_readyState(xhr, NULL); ok(hr == E_POINTER || broken(hr == E_INVALIDARG) /* <win8 */, "got 0x%08x\n", hr); state = -1; hr = IXMLHttpRequest_get_readyState(xhr, &state); EXPECT_HR(hr, S_OK); ok(state == READYSTATE_UNINITIALIZED, "got %d, expected READYSTATE_UNINITIALIZED\n", state); httpreq = xhr; event = create_dispevent(); EXPECT_REF(event, 1); hr = IXMLHttpRequest_put_onreadystatechange(xhr, event); EXPECT_HR(hr, S_OK); EXPECT_REF(event, 2); g_unexpectedcall = g_expectedcall = 0; test_open(xhr, "POST", urlA, S_OK); ok(g_unexpectedcall == 0, "unexpected disp event call\n"); ok(g_expectedcall == 1 || broken(g_expectedcall == 0) /* win2k */, "no expected disp event call\n"); /* status code after ::open() */ status = 0xdeadbeef; hr = IXMLHttpRequest_get_status(xhr, &status); ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr); ok(status == READYSTATE_UNINITIALIZED || broken(status == 0xdeadbeef) /* <win8 */, "got %d\n", status); state = -1; hr = IXMLHttpRequest_get_readyState(xhr, &state); EXPECT_HR(hr, S_OK); ok(state == READYSTATE_LOADING, "got %d, expected READYSTATE_LOADING\n", state); hr = IXMLHttpRequest_abort(xhr); EXPECT_HR(hr, S_OK); state = -1; hr = IXMLHttpRequest_get_readyState(xhr, &state); EXPECT_HR(hr, S_OK); ok(state == READYSTATE_UNINITIALIZED || broken(state == READYSTATE_LOADING) /* win2k */, "got %d, expected READYSTATE_UNINITIALIZED\n", state); test_open(xhr, "POST", urlA, S_OK); hr = IXMLHttpRequest_setRequestHeader(xhr, _bstr_("header1"), _bstr_("value1")); EXPECT_HR(hr, S_OK); hr = IXMLHttpRequest_setRequestHeader(xhr, NULL, _bstr_("value1")); EXPECT_HR(hr, E_INVALIDARG); hr = IXMLHttpRequest_setRequestHeader(xhr, _bstr_(""), _bstr_("value1")); EXPECT_HR(hr, E_INVALIDARG); V_VT(&varbody) = VT_BSTR; V_BSTR(&varbody) = _bstr_(bodyA); hr = IXMLHttpRequest_send(xhr, varbody); if (hr == INET_E_RESOURCE_NOT_FOUND) { skip("No connection could be made with crossover.codeweavers.com\n"); IXMLHttpRequest_Release(xhr); return; } EXPECT_HR(hr, S_OK); /* response headers */ hr = IXMLHttpRequest_getAllResponseHeaders(xhr, NULL); ok(hr == E_POINTER || broken(hr == E_INVALIDARG) /* <win8 */, "got 0x%08x\n", hr); hr = IXMLHttpRequest_getAllResponseHeaders(xhr, &str); EXPECT_HR(hr, S_OK); /* status line is stripped already */ ok(memcmp(str, _bstr_("HTTP"), 4*sizeof(WCHAR)), "got response headers %s\n", wine_dbgstr_w(str)); ok(*str, "got empty headers\n"); hr = IXMLHttpRequest_getAllResponseHeaders(xhr, &str1); EXPECT_HR(hr, S_OK); ok(str1 != str, "got %p\n", str1); SysFreeString(str1); SysFreeString(str); hr = IXMLHttpRequest_getResponseHeader(xhr, NULL, NULL); EXPECT_HR(hr, E_INVALIDARG); hr = IXMLHttpRequest_getResponseHeader(xhr, _bstr_("Date"), NULL); ok(hr == E_POINTER || broken(hr == E_INVALIDARG) /* <win8 */, "got 0x%08x\n", hr); hr = IXMLHttpRequest_getResponseHeader(xhr, _bstr_("Date"), &str); EXPECT_HR(hr, S_OK); ok(*str != ' ', "got leading space in header %s\n", wine_dbgstr_w(str)); SysFreeString(str); /* status code after ::send() */ status = 0xdeadbeef; hr = IXMLHttpRequest_get_status(xhr, &status); EXPECT_HR(hr, S_OK); ok(status == 200, "got %d\n", status); hr = IXMLHttpRequest_get_statusText(xhr, NULL); ok(hr == E_POINTER || broken(hr == E_INVALIDARG) /* <win8 */, "got 0x%08x\n", hr); hr = IXMLHttpRequest_get_statusText(xhr, &str); EXPECT_HR(hr, S_OK); ok(!lstrcmpW(str, _bstr_("OK")), "got status %s\n", wine_dbgstr_w(str)); SysFreeString(str); /* another ::send() after completed request */ V_VT(&varbody) = VT_BSTR; V_BSTR(&varbody) = _bstr_(bodyA); hr = IXMLHttpRequest_send(xhr, varbody); ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr); hr = IXMLHttpRequest_get_responseText(xhr, &bstrResponse); EXPECT_HR(hr, S_OK); /* the server currently returns "FAILED" because the Content-Type header is * not what the server expects */ if(hr == S_OK) { ok(!memcmp(bstrResponse, wszExpectedResponse, sizeof(wszExpectedResponse)), "expected %s, got %s\n", wine_dbgstr_w(wszExpectedResponse), wine_dbgstr_w(bstrResponse)); SysFreeString(bstrResponse); } /* POST: VT_VARIANT|VT_BYREF body */ test_open(xhr, "POST", urlA, S_OK); V_VT(&varbody_ref) = VT_VARIANT|VT_BYREF; V_VARIANTREF(&varbody_ref) = &varbody; hr = IXMLHttpRequest_send(xhr, varbody_ref); EXPECT_HR(hr, S_OK); /* GET request */ test_open(xhr, "GET", xmltestA, S_OK); V_VT(&varbody) = VT_EMPTY; hr = IXMLHttpRequest_send(xhr, varbody); if (hr == INET_E_RESOURCE_NOT_FOUND) { skip("No connection could be made with crossover.codeweavers.com\n"); IXMLHttpRequest_Release(xhr); return; } EXPECT_HR(hr, S_OK); hr = IXMLHttpRequest_get_responseText(xhr, NULL); ok(hr == E_POINTER || broken(hr == E_INVALIDARG) /* <win8 */, "got 0x%08x\n", hr); hr = IXMLHttpRequest_get_responseText(xhr, &bstrResponse); EXPECT_HR(hr, S_OK); ok(!memcmp(bstrResponse, _bstr_(xmltestbodyA), sizeof(xmltestbodyA)*sizeof(WCHAR)), "expected %s, got %s\n", xmltestbodyA, wine_dbgstr_w(bstrResponse)); SysFreeString(bstrResponse); hr = IXMLHttpRequest_get_responseBody(xhr, NULL); EXPECT_HR(hr, E_INVALIDARG); V_VT(&varbody) = VT_EMPTY; hr = IXMLHttpRequest_get_responseBody(xhr, &varbody); EXPECT_HR(hr, S_OK); ok(V_VT(&varbody) == (VT_ARRAY|VT_UI1), "got type %d, expected %d\n", V_VT(&varbody), VT_ARRAY|VT_UI1); ok(SafeArrayGetDim(V_ARRAY(&varbody)) == 1, "got %d, expected one dimension\n", SafeArrayGetDim(V_ARRAY(&varbody))); bound = -1; hr = SafeArrayGetLBound(V_ARRAY(&varbody), 1, &bound); EXPECT_HR(hr, S_OK); ok(bound == 0, "got %d, expected zero bound\n", bound); hr = SafeArrayAccessData(V_ARRAY(&varbody), &ptr); EXPECT_HR(hr, S_OK); ok(memcmp(ptr, xmltestbodyA, sizeof(xmltestbodyA)-1) == 0, "got wrong body data\n"); SafeArrayUnaccessData(V_ARRAY(&varbody)); VariantClear(&varbody); /* get_responseStream */ hr = IXMLHttpRequest_get_responseStream(xhr, NULL); EXPECT_HR(hr, E_INVALIDARG); V_VT(&varbody) = VT_EMPTY; hr = IXMLHttpRequest_get_responseStream(xhr, &varbody); ok(V_VT(&varbody) == VT_UNKNOWN, "got type %d\n", V_VT(&varbody)); EXPECT_HR(hr, S_OK); EXPECT_REF(V_UNKNOWN(&varbody), 1); g = NULL; hr = GetHGlobalFromStream((IStream*)V_UNKNOWN(&varbody), &g); EXPECT_HR(hr, S_OK); ok(g != NULL, "got %p\n", g); IDispatch_Release(event); /* test if referrer header is sent */ test_open(xhr, "GET", referertesturl, S_OK); V_VT(&varbody) = VT_EMPTY; hr = IXMLHttpRequest_send(xhr, varbody); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXMLHttpRequest_get_responseText(xhr, &str); ok(hr == S_OK, "got 0x%08x\n", hr); ok(!lstrcmpW(str, norefererW), "got response text %s\n", wine_dbgstr_w(str)); SysFreeString(str); /* interaction with object site */ hr = IXMLHttpRequest_QueryInterface(xhr, &IID_IObjectWithSite, (void**)&obj_site); EXPECT_HR(hr, S_OK); hr = IObjectWithSite_SetSite(obj_site, NULL); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXMLHttpRequest_QueryInterface(xhr, &IID_IObjectWithSite, (void**)&obj_site2); EXPECT_HR(hr, S_OK); ok(obj_site == obj_site2 || broken(obj_site != obj_site2), "got new instance\n"); IObjectWithSite_Release(obj_site2); set_xhr_site(xhr); test_open(xhr, "GET", "tests/referer.php", S_OK); str1 = a2bstr("http://test.winehq.org/"); V_VT(&varbody) = VT_EMPTY; hr = IXMLHttpRequest_send(xhr, varbody); ok(hr == S_OK, "got 0x%08x\n", hr); hr = IXMLHttpRequest_get_responseText(xhr, &str); ok(hr == S_OK, "got 0x%08x\n", hr); ok(!lstrcmpW(str, str1), "got response text %s, expected %s\n", wine_dbgstr_w(str), wine_dbgstr_w(str1)); SysFreeString(str); SysFreeString(str1); /* try to set site another time */ hr = IObjectWithSite_SetSite(obj_site, &testsite); EXPECT_HR(hr, S_OK); IObjectWithSite_Release(obj_site); IXMLHttpRequest_Release(xhr); free_bstrs(); }
HRESULT CTCPropBagOnRegKey::_WriteSafeArray(CRegKey& key, const _bstr_t& strPropName, VARIANT* pVar) { ASSERT(V_ISARRAY(pVar)); ASSERT(lstrlen(strPropName)); // Get the SAFEARRAY pointer from the variant SAFEARRAY* psa = V_ARRAY(pVar); if (IsBadReadPtr(psa)) return E_POINTER; // Only support 1-dimensional arrays (currently) if (1 != SafeArrayGetDim(psa)) return E_INVALIDARG; // Get the element size of the safe array UINT cbElement = SafeArrayGetElemsize(psa); // Get the safe array type from the variant VARTYPE vt = V_VT(pVar) & ~VT_ARRAY; // Check for supported types and validate the element size switch (vt) { case VT_BOOL: if (sizeof(V_BOOL(pVar)) != cbElement) return E_UNEXPECTED; break; case VT_I1: if (sizeof(V_I1(pVar)) != cbElement) return E_UNEXPECTED; break; case VT_I2: if (sizeof(V_I2(pVar)) != cbElement) return E_UNEXPECTED; break; case VT_I4: if (sizeof(V_I4(pVar)) != cbElement) return E_UNEXPECTED; break; case VT_UI1: if (sizeof(V_UI1(pVar)) != cbElement) return E_UNEXPECTED; break; case VT_UI2: if (sizeof(V_UI2(pVar)) != cbElement) return E_UNEXPECTED; break; case VT_UI4: if (sizeof(V_UI4(pVar)) != cbElement) return E_UNEXPECTED; break; case VT_ERROR: if (sizeof(V_ERROR(pVar)) != cbElement) return E_UNEXPECTED; break; case VT_R4: if (sizeof(V_R4(pVar)) != cbElement) return E_UNEXPECTED; break; case VT_R8: if (sizeof(V_R8(pVar)) != cbElement) return E_UNEXPECTED; break; case VT_DECIMAL: if (sizeof(V_DECIMAL(pVar)) != cbElement) return E_UNEXPECTED; break; case VT_CY: if (sizeof(V_CY(pVar)) != cbElement) return E_UNEXPECTED; break; case VT_DATE: if (sizeof(V_DATE(pVar)) != cbElement) return E_UNEXPECTED; break; case VT_BSTR: if (sizeof(V_BSTR(pVar)) != cbElement) return E_UNEXPECTED; break; case VT_UNKNOWN: if (sizeof(V_UNKNOWN(pVar)) != cbElement) return E_UNEXPECTED; break; case VT_DISPATCH: if (sizeof(V_DISPATCH(pVar)) != cbElement) return E_UNEXPECTED; break; case VT_VARIANT: if (sizeof(V_VARIANTREF(pVar)) != cbElement) return E_UNEXPECTED; break; default: return E_UNEXPECTED; } // Get the upper and lower bounds of the safe array HRESULT hr; LONG lUBound = 0, lLBound = 0; if (FAILED(hr = SafeArrayGetUBound(psa, 1, &lUBound))) return hr; if (FAILED(hr = SafeArrayGetLBound(psa, 1, &lLBound))) return hr; UINT nElements = lUBound - lLBound + 1; // Create a subkey with the specified name key.DeleteValue(strPropName); key.RecurseDeleteKey(strPropName); CRegKey subkey; if (!subkey.Open(key, strPropName)) return HRESULT_FROM_WIN32(GetLastError()); // Get access to the safe array data BYTE* pElement = NULL; if (FAILED(hr = SafeArrayAccessData(psa, (void**)&pElement))) return hr; // Write the variant type value subkey.WriteDWord(m_szVariantType, DWORD(V_VT(pVar))); // Write the element count value subkey.WriteDWord(m_szElementCount, DWORD(nElements)); // Write the lower bound value, if not 0 if (lLBound) subkey.WriteDWord(m_szLowerBound, DWORD(lLBound)); // Special handling for arrays of variants _bstr_t strText; if (VT_VARIANT == vt) { // Write each variant array element to the registry for (UINT i = 0; i < nElements; i++, pElement += cbElement) { // Format the value name strText.Format(m_szElementFmt, i); // Write the variant array element to the registry subkey if (FAILED(hr = WriteVariant(subkey, strText, (VARIANT*)pElement))) { TRACE1("CTCPropBagOnRegKey::_WriteSafeArray(\"%s\", pVar): ", strPropName); TRACE2("WriteVariant(subkey, \"%s\", &var) returned 0x%08X\n", strText, hr); } } } else { // Write each array element to the registry VARIANT var; V_VT(&var) = vt; for (UINT i = 0; i < nElements; i++, pElement += cbElement) { // Copy the array element to the data portion of the VARIANT memcpy(&V_NONE(&var), pElement, cbElement); // Format the value name strText.Format(m_szElementFmt, i); // Write the variant to the registry subkey if (FAILED(hr = WriteVariant(subkey, strText, &var))) { TRACE1("CTCPropBagOnRegKey::_WriteSafeArray(\"%s\", pVar): ", strPropName); TRACE2("WriteVariant(subkey, \"%s\", &var) returned 0x%08X\n", strText, hr); } } } // Release access to the safe array data VERIFY(SUCCEEDED(SafeArrayUnaccessData(psa))); // Indicate success return S_OK; }