STDMETHODIMP Commit(DWORD grfCommitFlags)
{
RETURNIFFAILED(m_spMemStream->Commit(grfCommitFlags));
if (m_bDirty)
{
m_bDirty=false;
// Get stream size
STATSTG stat;
m_spMemStream->Stat(&stat, STATFLAG_NONAME);
// Get stream data
HGLOBAL hData;
GetHGlobalFromStream(m_spMemStream, &hData);
// Convert to string
CUniString strData;
if (hData && stat.cbSize.QuadPart)
{
strData=FormatBinaryData((unsigned char*)GlobalLock(hData), (size_t)stat.cbSize.QuadPart, 64);
GlobalUnlock(hData);
}
// Save it
m_pEntry->SetValue(strData);
}
return S_OK;
};
static HRESULT WINAPI bsc_OnStopBinding(
IBindStatusCallback* iface,
HRESULT hresult,
LPCWSTR szError)
{
bsc_t *This = impl_from_IBindStatusCallback(iface);
HRESULT hr = S_OK;
TRACE("(%p)->(%08x %s)\n", This, hresult, debugstr_w(szError));
if(This->binding) {
IBinding_Release(This->binding);
This->binding = NULL;
}
if(This->obj && SUCCEEDED(hresult)) {
HGLOBAL hglobal;
hr = GetHGlobalFromStream(This->memstream, &hglobal);
if(SUCCEEDED(hr))
{
DWORD len = GlobalSize(hglobal);
char *ptr = GlobalLock(hglobal);
hr = This->onDataAvailable(This->obj, ptr, len);
GlobalUnlock(hglobal);
}
}
return hr;
}
HRESULT
CSite::HrStreamToFile(LPSTREAM pStream, LPCTSTR fileName)
{
HRESULT hr = S_OK;
HGLOBAL hMem = NULL;
LPVOID memBuf = NULL;
DWORD memSize = 0;
CFile file;
if (file.Open(fileName, CFile::modeCreate | CFile::modeReadWrite, NULL) == FALSE)
return E_FAIL;
hr = GetHGlobalFromStream(pStream, &hMem);
ASSERT(SUCCEEDED(hr));
memSize = GlobalSize(hMem);
VERIFY(memBuf = GlobalLock(hMem));
file.Write(memBuf, memSize);
// Reference count of hMem not checked here
// since we can't assume how many times the
// Stream has locked it
GlobalUnlock(hMem);
file.Close();
return hr;
}
BSTR
GetUnicodeHTML(CComPtr<IHTMLDocument2> spDocument)
{
ATLASSERT(!!spDocument);
BSTR str = 0;
// retrieve IPersistStreamInit interface
CComQIPtr<IPersistStreamInit> persistStream = spDocument;
ATLASSERT(!!persistStream);
// save stream
IStream* stream;
CreateStreamOnHGlobal(NULL, TRUE, &stream);
persistStream->Save(stream, FALSE);
// lock stream memory
HGLOBAL handle;
GetHGlobalFromStream(stream, &handle);
size_t size = GlobalSize(handle);
LPVOID ptr = GlobalLock(handle);
if (size>=2 && ((TCHAR*)ptr)[0]==0xFEFF) // we have her UCS-2LE Unicode little-endian
{
// copy string as is
ATLASSERT(size%2==0);
str = ::SysAllocStringLen(NULL, (ULONG)size>>1);
memcpy(str, ptr, size);
str[size>>1] = 0; // add ending marker
}
static void test_writeenddocument(void)
{
static const WCHAR aW[] = {'a',0};
static const WCHAR bW[] = {'b',0};
IXmlWriter *writer;
IStream *stream;
HGLOBAL hglobal;
HRESULT hr;
char *ptr;
hr = CreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
hr = IXmlWriter_WriteEndDocument(writer);
ok(hr == E_UNEXPECTED, "got 0x%08x\n", hr);
stream = writer_set_output(writer);
/* WriteEndDocument resets it to initial state */
hr = IXmlWriter_WriteEndDocument(writer);
ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteEndDocument(writer);
ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Omit);
ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteStartElement(writer, NULL, aW, NULL);
ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
hr = IXmlWriter_SetOutput(writer, (IUnknown*)stream);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteStartElement(writer, NULL, aW, NULL);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteStartElement(writer, NULL, bW, NULL);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteEndDocument(writer);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = GetHGlobalFromStream(stream, &hglobal);
ok(hr == S_OK, "got 0x%08x\n", hr);
ptr = GlobalLock(hglobal);
ok(ptr == NULL, "got %p\n", ptr);
/* we still need to flush manually, WriteEndDocument doesn't do that */
hr = IXmlWriter_Flush(writer);
ok(hr == S_OK, "got 0x%08x\n", hr);
CHECK_OUTPUT(stream, "<a><b /></a>");
IXmlWriter_Release(writer);
IStream_Release(stream);
}
/*static */
bool display_t::save_bitmap(const char *szFileName, HBITMAP bmp, HPALETTE pal /*= NULL*/)
{
START_FUNCTION_BOOL();
PICTDESC pdPictDesc;
pdPictDesc.cbSizeofstruct = sizeof(PICTDESC);
pdPictDesc.picType = PICTYPE_BITMAP;
pdPictDesc.bmp.hbitmap = bmp;
pdPictDesc.bmp.hpal = pal;
LPPICTURE plPicture = NULL;
HRESULT hResult = OleCreatePictureIndirect(&pdPictDesc, IID_IPicture, false, reinterpret_cast<void**>(&plPicture));
if (!SUCCEEDED(hResult))
{
break;
}
LPSTREAM lpStream = NULL;
hResult = CreateStreamOnHGlobal(0, true, &lpStream);
if (!SUCCEEDED(hResult))
{
plPicture->Release();
return false;
}
LONG lBytesStreamed = 0;
hResult = plPicture->SaveAsFile(lpStream, true, &lBytesStreamed);
HANDLE hFile = CreateFileA(szFileName, GENERIC_WRITE, FILE_SHARE_READ, 0,
CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
if (!SUCCEEDED(hResult) || !hFile)
{
lpStream->Release();
plPicture->Release();
break;
}
HGLOBAL hgMemory = 0;
GetHGlobalFromStream(lpStream, &hgMemory);
LPVOID lpData = GlobalLock(hgMemory);
DWORD dwBytesWritten = 0;
bool bResult = !!WriteFile(hFile, lpData, lBytesStreamed, &dwBytesWritten, 0);
bResult &= (dwBytesWritten == static_cast<DWORD>(lBytesStreamed));
GlobalUnlock(hgMemory);
CloseHandle(hFile);
lpStream->Release();
plPicture->Release();
END_FUNCTION_BOOL();
}
/////////////////////////////////////////////////////////////////////////////////////////
// Utility to save a bitmap to file for later examination. Used for debugging only.
// Based on an article by "gelbert" on www.experts-exchange.com at
// http://www.experts-exchange.com/Programming/Programming_Languages/MFC/Q_20193761.html
//
// This version is a member function and instead of taking an HBITMAP as the 2nd
// parameter, it take a reference to a CBitmap. Otherwise, it is identical.
/////////////////////////////////////////////////////////////////////////////////////////
BOOL CSliderCtrlEx::SaveBitmap(LPCSTR lpFileName, CBitmap &hBitmap, HPALETTE hPal)
{
BOOL bResult = FALSE;
PICTDESC stPictDesc;
stPictDesc.cbSizeofstruct = sizeof(PICTDESC);
stPictDesc.picType = PICTYPE_BITMAP;
stPictDesc.bmp.hbitmap = hBitmap;
stPictDesc.bmp.hpal = hPal;
LPPICTURE pPicture;
HRESULT hr = OleCreatePictureIndirect( &stPictDesc, IID_IPicture, FALSE,
reinterpret_cast<void**>(&pPicture) );
if ( SUCCEEDED(hr) )
{
LPSTREAM pStream;
hr = CreateStreamOnHGlobal( NULL, TRUE, &pStream );
if ( SUCCEEDED(hr) )
{
long lBytesStreamed = 0;
hr = pPicture->SaveAsFile( pStream, TRUE, &lBytesStreamed );
if ( SUCCEEDED(hr) )
{
HANDLE hFile = CreateFile(_T(lpFileName),
GENERIC_WRITE,
FILE_SHARE_READ,
NULL,
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL );
if ( hFile )
{
HGLOBAL hMem = NULL;
GetHGlobalFromStream( pStream, &hMem );
LPVOID lpData = GlobalLock( hMem );
DWORD dwBytesWritten;
bResult = WriteFile( hFile, lpData, lBytesStreamed, &dwBytesWritten, NULL );
bResult &= ( dwBytesWritten == (DWORD)lBytesStreamed );
// clean up
GlobalUnlock(hMem);
CloseHandle(hFile);
}
}
// clean up
pStream->Release();
}
// clean up
pPicture->Release();
}
return bResult;
}
static HRESULT WINAPI xmldoc_IPersistStreamInit_Load(
IPersistStreamInit *iface, LPSTREAM pStm)
{
xmldoc *This = impl_from_IPersistStreamInit(iface);
HRESULT hr;
HGLOBAL hglobal;
DWORD read, written, len;
BYTE buf[4096];
char *ptr;
TRACE("(%p, %p)\n", iface, pStm);
if (!pStm)
return E_INVALIDARG;
/* release previously allocated stream */
if (This->stream) IStream_Release(This->stream);
hr = CreateStreamOnHGlobal(NULL, TRUE, &This->stream);
if (FAILED(hr))
return hr;
do
{
IStream_Read(pStm, buf, sizeof(buf), &read);
hr = IStream_Write(This->stream, buf, read, &written);
} while(SUCCEEDED(hr) && written != 0 && read != 0);
if (FAILED(hr))
{
ERR("Failed to copy stream\n");
return hr;
}
hr = GetHGlobalFromStream(This->stream, &hglobal);
if (FAILED(hr))
return hr;
len = GlobalSize(hglobal);
ptr = GlobalLock(hglobal);
if (len != 0)
{
xmlFreeDoc(This->xmldoc);
This->xmldoc = parse_xml(ptr, len);
}
GlobalUnlock(hglobal);
if (!This->xmldoc)
{
ERR("Failed to parse xml\n");
return E_FAIL;
}
return S_OK;
}
HRESULT CAGCEventDef::ExpandFmtString(BSTR bstrFmt, IAGCEvent* pEvent,
BSTR* pbstrOut)
{
assert(BSTRLen(bstrFmt));
assert(pbstrOut);
// Create a growable stream into which we'll write
IStreamPtr spStm;
RETURN_FAILED(CreateStreamOnHGlobal(NULL, true, &spStm));
// Initialize the parsing data
XParseData data =
{pEvent, spStm, NULL, NULL, NULL, bstrFmt, NULL, false};
// Iterate through the characters of the format string
XStateProc pfnState = ParseState_Base;
for (UINT cch = SysStringLen(bstrFmt); cch && pfnState; --cch)
{
RETURN_FAILED(pfnState(data));
pfnState = data.m_pfnNextState;
++data.m_pszInput;
}
data.m_bEndOfString = true;
while (pfnState)
{
RETURN_FAILED(pfnState(data));
pfnState = data.m_pfnNextState;
}
// Get the current seek pointer of the stream (which is it's size)
LARGE_INTEGER li = {0};
ULARGE_INTEGER uli;
RETURN_FAILED(spStm->Seek(li, STREAM_SEEK_CUR, &uli));
UINT cchStream = (UINT)uli.QuadPart / sizeof(OLECHAR);
// Get the HGLOBAL underlying the stream
HGLOBAL hGlobal = NULL;
RETURN_FAILED(GetHGlobalFromStream(spStm, &hGlobal));
assert(hGlobal);
// Lock the HGLOBAL
LPCOLESTR pszOut = reinterpret_cast<LPCOLESTR>(GlobalLock(hGlobal));
assert(pszOut);
// Create a BSTR from the byte stream
*pbstrOut = SysAllocStringLen(pszOut, cchStream);
// Unlock the HGLOBAL
GlobalUnlock(hGlobal);
// Indicate success or failure
return *pbstrOut ? S_OK : E_OUTOFMEMORY;
}
static HRESULT WINAPI httprequest_get_responseText(IXMLHTTPRequest *iface, BSTR *body)
{
httprequest *This = impl_from_IXMLHTTPRequest( iface );
HGLOBAL hglobal;
HRESULT hr;
TRACE("(%p)->(%p)\n", This, body);
if (!body) return E_INVALIDARG;
if (This->state != READYSTATE_COMPLETE) return E_FAIL;
hr = GetHGlobalFromStream(This->bsc->stream, &hglobal);
if (hr == S_OK)
{
xmlChar *ptr = GlobalLock(hglobal);
DWORD size = GlobalSize(hglobal);
xmlCharEncoding encoding = XML_CHAR_ENCODING_UTF8;
/* try to determine data encoding */
if (size >= 4)
{
encoding = xmlDetectCharEncoding(ptr, 4);
TRACE("detected encoding: %s\n", debugstr_a(xmlGetCharEncodingName(encoding)));
if ( encoding != XML_CHAR_ENCODING_UTF8 &&
encoding != XML_CHAR_ENCODING_UTF16LE &&
encoding != XML_CHAR_ENCODING_NONE )
{
FIXME("unsupported encoding: %s\n", debugstr_a(xmlGetCharEncodingName(encoding)));
GlobalUnlock(hglobal);
return E_FAIL;
}
}
/* without BOM assume UTF-8 */
if (encoding == XML_CHAR_ENCODING_UTF8 ||
encoding == XML_CHAR_ENCODING_NONE )
{
DWORD length = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)ptr, size, NULL, 0);
*body = SysAllocStringLen(NULL, length);
if (*body)
MultiByteToWideChar( CP_UTF8, 0, (LPCSTR)ptr, size, *body, length);
}
else
*body = SysAllocStringByteLen((LPCSTR)ptr, size);
if (!*body) hr = E_OUTOFMEMORY;
GlobalUnlock(hglobal);
}
return hr;
}
VAPI(VanillaBinary) VanillaSaveImageToBinary(VanillaImage Image, VanillaImageFormat ImageFormat) {
wchar_t* MineType;
switch (ImageFormat) {
case ImageFormatPNG:
MineType = L"image/png";
break;
case ImageFormatJPEG:
MineType = L"image/jpeg";
break;
default:
MineType = NULL;
break;
}
if (!MineType) {
return false;
}
CLSID Clsid;
GetImageCLSID(MineType, &Clsid);
VANILLA_ICONV;
IStream* Stream;
CreateStreamOnHGlobal(NULL, true, &Stream);
if (Image->Image->Save(Stream, &Clsid) != Gdiplus::Status::Ok) {
return NULL;
}
HGLOBAL HGlobal;
if (GetHGlobalFromStream(Stream, &HGlobal) != S_OK) {
Stream->Release();
return NULL;
}
VanillaInt Length = GlobalSize(HGlobal);
if (Length <= 0) {
Stream->Release();
return NULL;
}
VanillaBinary Binary = new VBinary;
Binary->Length = Length;
Binary->Address = (VanillaByte*)malloc(Length);
VanillaAny Address = GlobalLock(HGlobal);
memcpy(Binary->Address, Address, Length);
GlobalUnlock(HGlobal);
Stream->Release();
return Binary;
}
static HRESULT WINAPI httprequest_get_responseBody(IXMLHTTPRequest *iface, VARIANT *body)
{
httprequest *This = impl_from_IXMLHTTPRequest( iface );
HGLOBAL hglobal;
HRESULT hr;
TRACE("(%p)->(%p)\n", This, body);
if (!body) return E_INVALIDARG;
if (This->state != READYSTATE_COMPLETE) return E_FAIL;
hr = GetHGlobalFromStream(This->bsc->stream, &hglobal);
if (hr == S_OK)
{
void *ptr = GlobalLock(hglobal);
DWORD size = GlobalSize(hglobal);
SAFEARRAYBOUND bound;
SAFEARRAY *array;
bound.lLbound = 0;
bound.cElements = size;
array = SafeArrayCreate(VT_UI1, 1, &bound);
if (array)
{
void *dest;
V_VT(body) = VT_ARRAY | VT_UI1;
V_ARRAY(body) = array;
hr = SafeArrayAccessData(array, &dest);
if (hr == S_OK)
{
memcpy(dest, ptr, size);
SafeArrayUnaccessData(array);
}
else
{
VariantClear(body);
}
}
else
hr = E_FAIL;
GlobalUnlock(hglobal);
}
return hr;
}
static void test_writeendelement(void)
{
static const WCHAR aW[] = {'a',0};
static const WCHAR bW[] = {'b',0};
char *ptr;
IXmlWriter *writer;
IStream *stream;
HGLOBAL hglobal;
HRESULT hr;
hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = pCreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
hr = IXmlWriter_SetOutput(writer, (IUnknown*)stream);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteStartElement(writer, NULL, aW, NULL);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteStartElement(writer, NULL, bW, NULL);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteEndElement(writer);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteEndElement(writer);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = GetHGlobalFromStream(stream, &hglobal);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_Flush(writer);
ok(hr == S_OK, "got 0x%08x\n", hr);
ptr = GlobalLock(hglobal);
ok(!strncmp(ptr, "<a><b /></a>", 12), "got %s\n", ptr);
GlobalUnlock(hglobal);
IXmlWriter_Release(writer);
IStream_Release(stream);
}
static void check_output(IStream *stream, const char *expected, int line)
{
HGLOBAL hglobal;
int len = strlen(expected), size;
char *ptr;
HRESULT hr;
hr = GetHGlobalFromStream(stream, &hglobal);
ok_(__FILE__, line)(hr == S_OK, "got 0x%08x\n", hr);
size = GlobalSize(hglobal);
ptr = GlobalLock(hglobal);
if (size != len)
{
ok_(__FILE__, line)(0, "data size mismatch, expected %u, got %u\n", len, size);
ok_(__FILE__, line)(0, "got %s, expected %s\n", ptr, expected);
}
else
ok_(__FILE__, line)(!strncmp(ptr, expected, len), "got %s, expected %s\n", ptr, expected);
GlobalUnlock(hglobal);
}
STDMETHODIMP CByteArray::GetArray(/*[out,retval]*/ VARIANT *pVal)
{
HGLOBAL hGlobal;
ULARGE_INTEGER pos;
LARGE_INTEGER li;
li.QuadPart = 0;
m_stream->Seek(li, System::IO::STREAM_SEEK_CUR, &pos);
if (SUCCEEDED(GetHGlobalFromStream(m_stream, &hGlobal)))
{
void* data = GlobalLock(hGlobal);
SAFEARRAYBOUND rgsabound[1];
rgsabound[0].lLbound = 0;
rgsabound[0].cElements = (DWORD)pos.QuadPart;
SAFEARRAY* psa = SafeArrayCreate(VT_UI1, 1, rgsabound);
//sa = SafeArrayCreateVector(VT_I1, 0, (DWORD)pos.QuadPart);
void* pv;
SafeArrayAccessData(psa, (void**)&pv);
CopyMemory(pv, data, (DWORD)pos.QuadPart);
SafeArrayUnaccessData(psa);
GlobalUnlock(hGlobal);
VariantInit(pVal);
pVal->vt = VT_ARRAY | VT_UI1;
pVal->parray = psa;
return S_OK;
}
return E_FAIL;
}
static HRESULT WriteUsingWIC(const char* out_file_name, int use_stdout,
REFGUID container_guid,
uint8_t* rgb, int stride,
uint32_t width, uint32_t height, int has_alpha) {
HRESULT hr = S_OK;
IWICImagingFactory* factory = NULL;
IWICBitmapFrameEncode* frame = NULL;
IWICBitmapEncoder* encoder = NULL;
IStream* stream = NULL;
WICPixelFormatGUID pixel_format = has_alpha ? GUID_WICPixelFormat32bppBGRA
: GUID_WICPixelFormat24bppBGR;
IFS(CoInitialize(NULL));
IFS(CoCreateInstance(MAKE_REFGUID(CLSID_WICImagingFactory), NULL,
CLSCTX_INPROC_SERVER,
MAKE_REFGUID(IID_IWICImagingFactory),
(LPVOID*)&factory));
if (hr == REGDB_E_CLASSNOTREG) {
fprintf(stderr,
"Couldn't access Windows Imaging Component (are you running "
"Windows XP SP3 or newer?). PNG support not available. "
"Use -ppm or -pgm for available PPM and PGM formats.\n");
}
IFS(CreateOutputStream(out_file_name, use_stdout, &stream));
IFS(IWICImagingFactory_CreateEncoder(factory, container_guid, NULL,
&encoder));
IFS(IWICBitmapEncoder_Initialize(encoder, stream,
WICBitmapEncoderNoCache));
IFS(IWICBitmapEncoder_CreateNewFrame(encoder, &frame, NULL));
IFS(IWICBitmapFrameEncode_Initialize(frame, NULL));
IFS(IWICBitmapFrameEncode_SetSize(frame, width, height));
IFS(IWICBitmapFrameEncode_SetPixelFormat(frame, &pixel_format));
IFS(IWICBitmapFrameEncode_WritePixels(frame, height, stride,
height * stride, rgb));
IFS(IWICBitmapFrameEncode_Commit(frame));
IFS(IWICBitmapEncoder_Commit(encoder));
if (SUCCEEDED(hr) && use_stdout) {
HGLOBAL image;
IFS(GetHGlobalFromStream(stream, &image));
if (SUCCEEDED(hr)) {
HANDLE std_output = GetStdHandle(STD_OUTPUT_HANDLE);
DWORD mode;
const BOOL update_mode = GetConsoleMode(std_output, &mode);
const void* const image_mem = GlobalLock(image);
DWORD bytes_written = 0;
// Clear output processing if necessary, then output the image.
if (update_mode) SetConsoleMode(std_output, 0);
if (!WriteFile(std_output, image_mem, (DWORD)GlobalSize(image),
&bytes_written, NULL) ||
bytes_written != GlobalSize(image)) {
hr = E_FAIL;
}
if (update_mode) SetConsoleMode(std_output, mode);
GlobalUnlock(image);
}
}
if (frame != NULL) IUnknown_Release(frame);
if (encoder != NULL) IUnknown_Release(encoder);
if (factory != NULL) IUnknown_Release(factory);
if (stream != NULL) IUnknown_Release(stream);
return hr;
}
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();
}
STDMETHODIMP CDataCallback::BandedDataCallback(
LONG lReason,
LONG lStatus,
LONG lPercentComplete,
LONG lOffset,
LONG lLength,
LONG, LONG,
PBYTE pbBuffer
)
{
HRESULT hr;
// Parse the message
switch (lReason)
{
case IT_MSG_DATA_HEADER:
{
PWIA_DATA_CALLBACK_HEADER pHeader = (PWIA_DATA_CALLBACK_HEADER) pbBuffer;
// Determine if this is a BMP transfer
m_bBMP = pHeader->guidFormatID == WiaImgFmt_MEMORYBMP || pHeader->guidFormatID == WiaImgFmt_BMP;
// For WiaImgFmt_MEMORYBMP transfers, WIA does not send a BITMAPFILEHEADER before the data.
// In this program, we desire all BMP files to contain a BITMAPFILEHEADER, so add it manually
m_nHeaderSize = pHeader->guidFormatID == WiaImgFmt_MEMORYBMP ? sizeof(BITMAPFILEHEADER) : 0;
// Allocate memory for the image if the size is given in the header
if (pHeader != NULL && pHeader->lBufferSize != 0)
{
hr = ReAllocBuffer(m_nHeaderSize + pHeader->lBufferSize);
if (FAILED(hr))
{
return hr;
}
}
break;
}
case IT_MSG_DATA:
{
// Invoke the callback function
hr = m_pfnProgressCallback(lStatus, lPercentComplete, m_pProgressCallbackParam);
if (FAILED(hr) || hr == S_FALSE)
{
return hr;
}
// If the buffer is not allocated yet and this is the first block,
// and the transferred image is in BMP format, allocate the buffer
// according to the size information in the bitmap header
if (m_pStream == NULL && lOffset == 0 && m_bBMP)
{
LONG nBufferSize = BitmapUtil::GetBitmapSize(pbBuffer);
if (nBufferSize != 0)
{
hr = ReAllocBuffer(m_nHeaderSize + nBufferSize);
if (FAILED(hr))
{
return hr;
}
}
}
if (m_nHeaderSize + lOffset + lLength < 0)
{
return E_OUTOFMEMORY;
}
// If the transfer goes past the buffer, try to expand it
if (m_nHeaderSize + lOffset + lLength > m_nDataSize)
{
hr = ReAllocBuffer(m_nHeaderSize + lOffset + lLength);
if (FAILED(hr))
{
return hr;
}
}
// copy the transfer buffer
hr = CopyToBuffer(m_nHeaderSize + lOffset, pbBuffer, lLength);
if (FAILED(hr))
{
return hr;
}
break;
}
case IT_MSG_STATUS:
{
// Invoke the callback function
hr = m_pfnProgressCallback(lStatus, lPercentComplete, m_pProgressCallbackParam);
if (FAILED(hr) || hr == S_FALSE)
{
return hr;
}
break;
}
case IT_MSG_TERMINATION:
case IT_MSG_NEW_PAGE:
{
if (m_pStream != NULL)
{
// For BMP files, we should validate the the image header
// So, obtain the memory buffer from the stream
if (m_bBMP)
{
// Since the stream is created using CreateStreamOnHGlobal,
// we can get the memory buffer with GetHGlobalFromStream.
HGLOBAL hBuffer;
hr = GetHGlobalFromStream(m_pStream, &hBuffer);
if (FAILED(hr))
{
return hr;
}
PBITMAPFILEHEADER pBuffer = (PBITMAPFILEHEADER) GlobalLock(hBuffer);
if (pBuffer == NULL)
{
return HRESULT_FROM_WIN32(GetLastError());
}
// Some scroll-fed scanners may return 0 as the bitmap height
// In this case, calculate the image height and modify the header
BitmapUtil::FixBitmapHeight(pBuffer + 1, m_nDataSize, TRUE);
// For WiaImgFmt_MEMORYBMP transfers, the WIA service does not
// include a BITMAPFILEHEADER preceeding the bitmap data.
// In this case, fill in the BITMAPFILEHEADER structure.
if (m_nHeaderSize != 0)
{
BitmapUtil::FillBitmapFileHeader(pBuffer + 1, pBuffer);
}
GlobalUnlock(hBuffer);
}
// Store this buffer in the successfully transferred images array
hr = StoreBuffer();
if (FAILED(hr))
{
return hr;
}
}
break;
}
}
return S_OK;
}
static void test_omitxmldeclaration(void)
{
static const char prologversion[] = "<?xml version=\"1.0\"?>";
static const WCHAR versionW[] = {'v','e','r','s','i','o','n','=','"','1','.','0','"',0};
static const WCHAR xmlW[] = {'x','m','l',0};
IXmlWriter *writer;
HGLOBAL hglobal;
IStream *stream;
HRESULT hr;
char *ptr;
hr = CreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
stream = writer_set_output(writer);
hr = IXmlWriter_SetProperty(writer, XmlWriterProperty_OmitXmlDeclaration, TRUE);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_Flush(writer);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = GetHGlobalFromStream(stream, &hglobal);
ok(hr == S_OK, "got 0x%08x\n", hr);
ptr = GlobalLock(hglobal);
ok(!ptr, "got %p\n", ptr);
GlobalUnlock(hglobal);
/* one more time */
hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
IStream_Release(stream);
/* now add PI manually, and try to start a document */
stream = writer_set_output(writer);
hr = IXmlWriter_WriteProcessingInstruction(writer, xmlW, versionW);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_Flush(writer);
ok(hr == S_OK, "got 0x%08x\n", hr);
CHECK_OUTPUT(stream, prologversion);
hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_Flush(writer);
ok(hr == S_OK, "got 0x%08x\n", hr);
CHECK_OUTPUT(stream, prologversion);
hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
hr = IXmlWriter_Flush(writer);
ok(hr == S_OK, "got 0x%08x\n", hr);
CHECK_OUTPUT(stream, prologversion);
/* another attempt to add 'xml' PI */
hr = IXmlWriter_WriteProcessingInstruction(writer, xmlW, versionW);
ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
hr = IXmlWriter_Flush(writer);
ok(hr == S_OK, "got 0x%08x\n", hr);
IStream_Release(stream);
IXmlWriter_Release(writer);
}
static void test_writestartdocument(void)
{
static const char fullprolog[] = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
static const char prologversion[] = "<?xml version=\"1.0\"?>";
static const WCHAR versionW[] = {'v','e','r','s','i','o','n','=','"','1','.','0','"',0};
static const WCHAR xmlW[] = {'x','m','l',0};
IXmlWriter *writer;
HGLOBAL hglobal;
IStream *stream;
HRESULT hr;
char *ptr;
hr = pCreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
/* output not set */
hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
ok(hr == E_UNEXPECTED, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteProcessingInstruction(writer, xmlW, versionW);
ok(hr == E_UNEXPECTED, "got 0x%08x\n", hr);
hr = IXmlWriter_Flush(writer);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_SetOutput(writer, (IUnknown*)stream);
ok(hr == S_OK, "got 0x%08x\n", hr);
/* nothing written yet */
hr = IXmlWriter_Flush(writer);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_Flush(writer);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = GetHGlobalFromStream(stream, &hglobal);
ok(hr == S_OK, "got 0x%08x\n", hr);
ptr = GlobalLock(hglobal);
ok(!strncmp(ptr, fullprolog, strlen(fullprolog)), "got %s, expected %s\n", ptr, fullprolog);
GlobalUnlock(hglobal);
/* one more time */
hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
IStream_Release(stream);
/* now add PI manually, and try to start a document */
hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_SetOutput(writer, (IUnknown*)stream);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteProcessingInstruction(writer, xmlW, versionW);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
/* another attempt to add 'xml' PI */
hr = IXmlWriter_WriteProcessingInstruction(writer, xmlW, versionW);
ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
hr = IXmlWriter_Flush(writer);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = GetHGlobalFromStream(stream, &hglobal);
ok(hr == S_OK, "got 0x%08x\n", hr);
ptr = GlobalLock(hglobal);
ok(!strncmp(ptr, prologversion, strlen(prologversion)), "got %s\n", ptr);
GlobalUnlock(hglobal);
IStream_Release(stream);
IXmlWriter_Release(writer);
}
static void test_persist_save_data(const char *testname, IHlink *lnk,
const unsigned char *expected_data,
unsigned int expected_data_size,
const unsigned char *expected_data_alt,
unsigned int expected_data_alt_size)
{
HRESULT hr;
IStream *stream;
IPersistStream *ps;
HGLOBAL hglobal;
DWORD data_size;
const unsigned char *data;
DWORD i;
BOOL same;
unsigned int expected_data_win9x_size = 0;
hr = IHlink_QueryInterface(lnk, &IID_IPersistStream, (void **)&ps);
ok(hr == S_OK, "IHlink_QueryInterface failed with error 0x%08x\n", hr);
hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
ok(hr == S_OK, "CreateStreamOnHGlobal failed with error 0x%08x\n", hr);
hr = IPersistStream_Save(ps, stream, TRUE);
ok(hr == S_OK, "IPersistStream_Save failed with error 0x%08x\n", hr);
hr = GetHGlobalFromStream(stream, &hglobal);
ok(hr == S_OK, "GetHGlobalFromStream failed with error 0x%08x\n", hr);
data_size = GlobalSize(hglobal);
data = GlobalLock(hglobal);
if (expected_data_size % 4)
expected_data_win9x_size = 4 * ((expected_data_size / 4) + 1);
/* first check we have the right amount of data */
ok((data_size == expected_data_size) ||
(data_size == expected_data_alt_size) ||
broken(data_size == expected_data_win9x_size), /* Win9x and WinMe */
"%s: Size of saved data differs (expected %d or %d, actual %d)\n",
testname, expected_data_size, expected_data_alt_size, data_size);
same = TRUE;
/* then do a byte-by-byte comparison */
for (i = 0; i < min(data_size, expected_data_size); i++)
{
if ((expected_data[i] != data[i]) &&
(((expected_data != expected_hlink_data2) &&
(expected_data != expected_hlink_data3)) ||
((i < 52 || i >= 56) && (i < 80 || i >= 84))))
{
same = FALSE;
break;
}
}
if (!same && (expected_data_alt != expected_data))
{
/* then try the alternate data */
same = TRUE;
for (i = 0; i < min(data_size, expected_data_alt_size); i++)
{
if ((expected_data_alt[i] != data[i]) &&
(((expected_data_alt != expected_hlink_data2) &&
(expected_data_alt != expected_hlink_data3)) ||
((i < 52 || i >= 56) && (i < 80 || i >= 84))))
{
same = FALSE;
break;
}
}
}
ok(same, "%s: Saved data differs\n", testname);
if (!same)
{
for (i = 0; i < data_size; i++)
{
if (i % 8 == 0) printf(" ");
printf("0x%02x,", data[i]);
if (i % 8 == 7) printf("\n");
}
printf("\n");
}
GlobalUnlock(hglobal);
IStream_Release(stream);
IPersistStream_Release(ps);
}
static void test_bom(void)
{
static const WCHAR versionW[] = {'v','e','r','s','i','o','n','=','"','1','.','0','"',0};
static const WCHAR utf16W[] = {'u','t','f','-','1','6',0};
static const WCHAR xmlW[] = {'x','m','l',0};
static const WCHAR aW[] = {'a',0};
IXmlWriterOutput *output;
unsigned char *ptr;
IXmlWriter *writer;
IStream *stream;
HGLOBAL hglobal;
HRESULT hr;
hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = pCreateXmlWriterOutputWithEncodingName((IUnknown*)stream, NULL, utf16W, &output);
ok(hr == S_OK, "got %08x\n", hr);
hr = pCreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
hr = IXmlWriter_SetProperty(writer, XmlWriterProperty_OmitXmlDeclaration, TRUE);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_SetOutput(writer, output);
ok(hr == S_OK, "got 0x%08x\n", hr);
/* BOM is on by default */
hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_Flush(writer);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = GetHGlobalFromStream(stream, &hglobal);
ok(hr == S_OK, "got 0x%08x\n", hr);
ptr = GlobalLock(hglobal);
ok(ptr[0] == 0xff && ptr[1] == 0xfe, "got %x,%x\n", ptr[0], ptr[1]);
GlobalUnlock(hglobal);
IStream_Release(stream);
IUnknown_Release(output);
/* start with PI */
hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = pCreateXmlWriterOutputWithEncodingName((IUnknown*)stream, NULL, utf16W, &output);
ok(hr == S_OK, "got %08x\n", hr);
hr = IXmlWriter_SetOutput(writer, output);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteProcessingInstruction(writer, xmlW, versionW);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_Flush(writer);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = GetHGlobalFromStream(stream, &hglobal);
ok(hr == S_OK, "got 0x%08x\n", hr);
ptr = GlobalLock(hglobal);
ok(ptr[0] == 0xff && ptr[1] == 0xfe, "got %x,%x\n", ptr[0], ptr[1]);
GlobalUnlock(hglobal);
IUnknown_Release(output);
IStream_Release(stream);
/* start with element */
hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = pCreateXmlWriterOutputWithEncodingName((IUnknown*)stream, NULL, utf16W, &output);
ok(hr == S_OK, "got %08x\n", hr);
hr = IXmlWriter_SetOutput(writer, output);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteStartElement(writer, NULL, aW, NULL);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_Flush(writer);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = GetHGlobalFromStream(stream, &hglobal);
ok(hr == S_OK, "got 0x%08x\n", hr);
ptr = GlobalLock(hglobal);
ok(ptr[0] == 0xff && ptr[1] == 0xfe, "got %x,%x\n", ptr[0], ptr[1]);
GlobalUnlock(hglobal);
IUnknown_Release(output);
IStream_Release(stream);
/* WriteElementString */
hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = pCreateXmlWriterOutputWithEncodingName((IUnknown*)stream, NULL, utf16W, &output);
ok(hr == S_OK, "got %08x\n", hr);
hr = IXmlWriter_SetOutput(writer, output);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteElementString(writer, NULL, aW, NULL, NULL);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_Flush(writer);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = GetHGlobalFromStream(stream, &hglobal);
ok(hr == S_OK, "got 0x%08x\n", hr);
ptr = GlobalLock(hglobal);
ok(ptr[0] == 0xff && ptr[1] == 0xfe, "got %x,%x\n", ptr[0], ptr[1]);
GlobalUnlock(hglobal);
IUnknown_Release(output);
IStream_Release(stream);
IXmlWriter_Release(writer);
}
static void test_writestartelement(void)
{
static const WCHAR valueW[] = {'v','a','l','u','e',0};
static const char *str = "<a><b>value</b>";
static const WCHAR aW[] = {'a',0};
static const WCHAR bW[] = {'b',0};
char *ptr;
IXmlWriter *writer;
IStream *stream;
HGLOBAL hglobal;
HRESULT hr;
hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = pCreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
hr = IXmlWriter_WriteStartElement(writer, NULL, aW, NULL);
ok(hr == E_UNEXPECTED, "got 0x%08x\n", hr);
hr = IXmlWriter_SetOutput(writer, (IUnknown*)stream);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteStartElement(writer, aW, NULL, NULL);
ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteStartElement(writer, NULL, NULL, NULL);
ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteStartElement(writer, NULL, NULL, aW);
ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteStartElement(writer, NULL, aW, NULL);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = GetHGlobalFromStream(stream, &hglobal);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
hr = IXmlWriter_Flush(writer);
ok(hr == S_OK, "got 0x%08x\n", hr);
ptr = GlobalLock(hglobal);
ok(!strncmp(ptr, "<a", 2), "got %s\n", ptr);
GlobalUnlock(hglobal);
hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteStartElement(writer, NULL, NULL, NULL);
ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteProcessingInstruction(writer, aW, aW);
ok(hr == WR_E_INVALIDACTION, "got 0x%08x\n", hr);
IStream_Release(stream);
IXmlWriter_Release(writer);
/* WriteElementString */
hr = pCreateXmlWriter(&IID_IXmlWriter, (void**)&writer, NULL);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteElementString(writer, NULL, bW, NULL, valueW);
ok(hr == E_UNEXPECTED, "got 0x%08x\n", hr);
hr = IXmlWriter_SetOutput(writer, (IUnknown*)stream);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteStartElement(writer, NULL, aW, NULL);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_WriteElementString(writer, NULL, bW, NULL, valueW);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXmlWriter_Flush(writer);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = GetHGlobalFromStream(stream, &hglobal);
ok(hr == S_OK, "got 0x%08x\n", hr);
ptr = GlobalLock(hglobal);
ok(!strncmp(ptr, str, strlen(str)), "got %s\n", ptr);
GlobalUnlock(hglobal);
IStream_Release(stream);
IXmlWriter_Release(writer);
}
