ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Sweden-Number/dlls/gdiplus/tests/image.c

831 lines
25 KiB
C
Raw Blame History

/*
* Unit test suite for images
*
* Copyright (C) 2007 Google (Evan Stade)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#define COBJMACROS
#include <math.h>
#include "initguid.h"
#include "windows.h"
#include "gdiplus.h"
#include "wine/test.h"
#define expect(expected, got) ok(((UINT)got) == ((UINT)expected), "Expected %.8x, got %.8x\n", (UINT)expected, (UINT)got)
#define expectf(expected, got) ok(fabs(expected - got) < 0.0001, "Expected %.2f, got %.2f\n", expected, got)
static void expect_rawformat(REFGUID expected, GpImage *img, int line, BOOL todo)
{
GUID raw;
WCHAR bufferW[39];
char buffer[39];
char buffer2[39];
GpStatus stat;
stat = GdipGetImageRawFormat(img, &raw);
ok_(__FILE__, line)(stat == Ok, "GdipGetImageRawFormat failed with %d\n", stat);
if(stat != Ok) return;
StringFromGUID2(&raw, bufferW, sizeof(bufferW)/sizeof(bufferW[0]));
WideCharToMultiByte(CP_ACP, 0, bufferW, sizeof(bufferW)/sizeof(bufferW[0]), buffer, sizeof(buffer), NULL, NULL);
StringFromGUID2(expected, bufferW, sizeof(bufferW)/sizeof(bufferW[0]));
WideCharToMultiByte(CP_ACP, 0, bufferW, sizeof(bufferW)/sizeof(bufferW[0]), buffer2, sizeof(buffer2), NULL, NULL);
if(todo)
todo_wine ok_(__FILE__, line)(IsEqualGUID(&raw, expected), "Expected format %s, got %s\n", buffer2, buffer);
else
ok_(__FILE__, line)(IsEqualGUID(&raw, expected), "Expected format %s, got %s\n", buffer2, buffer);
}
static void test_bufferrawformat(void* buff, int size, REFGUID expected, int line, BOOL todo)
{
LPSTREAM stream;
HGLOBAL hglob;
LPBYTE data;
HRESULT hres;
GpStatus stat;
GpBitmap *bmp;
hglob = GlobalAlloc (0, size);
data = GlobalLock (hglob);
memcpy(data, buff, size);
GlobalUnlock(hglob); data = NULL;
hres = CreateStreamOnHGlobal(hglob, TRUE, &stream);
ok_(__FILE__, line)(hres == S_OK, "Failed to create a stream\n");
if(hres != S_OK) return;
stat = GdipCreateBitmapFromStream(stream, &bmp);
ok_(__FILE__, line)(stat == Ok, "Failed to create a Bitmap\n");
if(stat != Ok){
IStream_Release(stream);
return;
}
expect_rawformat(expected, (GpImage*)bmp, line, todo);
GdipDisposeImage((GpImage*)bmp);
IStream_Release(stream);
}
static void test_Scan0(void)
{
GpBitmap *bm;
GpStatus stat;
BYTE buff[360];
bm = NULL;
stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat24bppRGB, NULL, &bm);
expect(Ok, stat);
ok(NULL != bm, "Expected bitmap to be initialized\n");
if (stat == Ok)
GdipDisposeImage((GpImage*)bm);
bm = (GpBitmap*)0xdeadbeef;
stat = GdipCreateBitmapFromScan0(10, -10, 10, PixelFormat24bppRGB, NULL, &bm);
expect(InvalidParameter, stat);
ok( !bm, "expected null bitmap\n" );
bm = (GpBitmap*)0xdeadbeef;
stat = GdipCreateBitmapFromScan0(-10, 10, 10, PixelFormat24bppRGB, NULL, &bm);
expect(InvalidParameter, stat);
ok( !bm, "expected null bitmap\n" );
bm = (GpBitmap*)0xdeadbeef;
stat = GdipCreateBitmapFromScan0(10, 0, 10, PixelFormat24bppRGB, NULL, &bm);
expect(InvalidParameter, stat);
ok( !bm, "expected null bitmap\n" );
bm = NULL;
stat = GdipCreateBitmapFromScan0(10, 10, 12, PixelFormat24bppRGB, buff, &bm);
expect(Ok, stat);
ok(NULL != bm, "Expected bitmap to be initialized\n");
if (stat == Ok)
GdipDisposeImage((GpImage*)bm);
bm = (GpBitmap*) 0xdeadbeef;
stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat24bppRGB, buff, &bm);
expect(InvalidParameter, stat);
ok( !bm, "expected null bitmap\n" );
bm = (GpBitmap*)0xdeadbeef;
stat = GdipCreateBitmapFromScan0(10, 10, 0, PixelFormat24bppRGB, buff, &bm);
expect(InvalidParameter, stat);
ok( bm == (GpBitmap*)0xdeadbeef, "expected deadbeef bitmap\n" );
bm = NULL;
stat = GdipCreateBitmapFromScan0(10, 10, -8, PixelFormat24bppRGB, buff, &bm);
expect(Ok, stat);
ok(NULL != bm, "Expected bitmap to be initialized\n");
if (stat == Ok)
GdipDisposeImage((GpImage*)bm);
bm = (GpBitmap*)0xdeadbeef;
stat = GdipCreateBitmapFromScan0(10, 10, -10, PixelFormat24bppRGB, buff, &bm);
expect(InvalidParameter, stat);
ok( !bm, "expected null bitmap\n" );
}
static void test_GetImageDimension(void)
{
GpBitmap *bm;
GpStatus stat;
const REAL WIDTH = 10.0, HEIGHT = 20.0;
REAL w,h;
bm = (GpBitmap*)0xdeadbeef;
stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB,NULL, &bm);
expect(Ok,stat);
ok((GpBitmap*)0xdeadbeef != bm, "Expected bitmap to not be 0xdeadbeef\n");
ok(NULL != bm, "Expected bitmap to not be NULL\n");
stat = GdipGetImageDimension(NULL,&w,&h);
expect(InvalidParameter, stat);
stat = GdipGetImageDimension((GpImage*)bm,NULL,&h);
expect(InvalidParameter, stat);
stat = GdipGetImageDimension((GpImage*)bm,&w,NULL);
expect(InvalidParameter, stat);
w = -1;
h = -1;
stat = GdipGetImageDimension((GpImage*)bm,&w,&h);
expect(Ok, stat);
expectf(WIDTH, w);
expectf(HEIGHT, h);
GdipDisposeImage((GpImage*)bm);
}
static void test_GdipImageGetFrameDimensionsCount(void)
{
GpBitmap *bm;
GpStatus stat;
const REAL WIDTH = 10.0, HEIGHT = 20.0;
UINT w;
bm = (GpBitmap*)0xdeadbeef;
stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB,NULL, &bm);
expect(Ok,stat);
ok((GpBitmap*)0xdeadbeef != bm, "Expected bitmap to not be 0xdeadbeef\n");
ok(NULL != bm, "Expected bitmap to not be NULL\n");
stat = GdipImageGetFrameDimensionsCount(NULL,&w);
expect(InvalidParameter, stat);
stat = GdipImageGetFrameDimensionsCount((GpImage*)bm,NULL);
expect(InvalidParameter, stat);
w = -1;
stat = GdipImageGetFrameDimensionsCount((GpImage*)bm,&w);
expect(Ok, stat);
expect(1, w);
GdipDisposeImage((GpImage*)bm);
}
static void test_LoadingImages(void)
{
GpStatus stat;
stat = GdipCreateBitmapFromFile(0, 0);
expect(InvalidParameter, stat);
stat = GdipCreateBitmapFromFile(0, (GpBitmap**)0xdeadbeef);
expect(InvalidParameter, stat);
stat = GdipLoadImageFromFile(0, 0);
expect(InvalidParameter, stat);
stat = GdipLoadImageFromFile(0, (GpImage**)0xdeadbeef);
expect(InvalidParameter, stat);
stat = GdipLoadImageFromFileICM(0, 0);
expect(InvalidParameter, stat);
stat = GdipLoadImageFromFileICM(0, (GpImage**)0xdeadbeef);
expect(InvalidParameter, stat);
}
static void test_SavingImages(void)
{
GpStatus stat;
GpBitmap *bm;
UINT n;
UINT s;
const REAL WIDTH = 10.0, HEIGHT = 20.0;
REAL w, h;
ImageCodecInfo *codecs;
static const CHAR filenameA[] = "a.bmp";
static const WCHAR filename[] = { 'a','.','b','m','p',0 };
codecs = NULL;
stat = GdipSaveImageToFile(0, 0, 0, 0);
expect(InvalidParameter, stat);
bm = NULL;
stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
expect(Ok, stat);
if (!bm)
return;
/* invalid params */
stat = GdipSaveImageToFile((GpImage*)bm, 0, 0, 0);
expect(InvalidParameter, stat);
stat = GdipSaveImageToFile((GpImage*)bm, filename, 0, 0);
expect(InvalidParameter, stat);
/* encoder tests should succeed -- already tested */
stat = GdipGetImageEncodersSize(&n, &s);
if (stat != Ok || n == 0) goto cleanup;
codecs = GdipAlloc(s);
if (!codecs) goto cleanup;
stat = GdipGetImageEncoders(n, s, codecs);
if (stat != Ok) goto cleanup;
stat = GdipSaveImageToFile((GpImage*)bm, filename, &codecs[0].Clsid, 0);
expect(stat, Ok);
GdipDisposeImage((GpImage*)bm);
bm = 0;
/* re-load and check image stats */
stat = GdipLoadImageFromFile(filename, (GpImage**)&bm);
expect(stat, Ok);
if (stat != Ok) goto cleanup;
stat = GdipGetImageDimension((GpImage*)bm, &w, &h);
if (stat != Ok) goto cleanup;
expectf(WIDTH, w);
expectf(HEIGHT, h);
cleanup:
GdipFree(codecs);
if (bm)
GdipDisposeImage((GpImage*)bm);
ok(DeleteFileA(filenameA), "Delete failed.\n");
}
static void test_encoders(void)
{
GpStatus stat;
UINT n;
UINT s;
ImageCodecInfo *codecs;
int i;
int bmp_found;
static const CHAR bmp_format[] = "BMP";
stat = GdipGetImageEncodersSize(&n, &s);
expect(stat, Ok);
codecs = GdipAlloc(s);
if (!codecs)
return;
stat = GdipGetImageEncoders(n, s, NULL);
expect(GenericError, stat);
stat = GdipGetImageEncoders(0, s, codecs);
expect(GenericError, stat);
stat = GdipGetImageEncoders(n, s-1, codecs);
expect(GenericError, stat);
stat = GdipGetImageEncoders(n, s+1, codecs);
expect(GenericError, stat);
stat = GdipGetImageEncoders(n, s, codecs);
expect(stat, Ok);
bmp_found = FALSE;
for (i = 0; i < n; i++)
{
CHAR desc[32];
WideCharToMultiByte(CP_ACP, 0, codecs[i].FormatDescription, -1,
desc, 32, 0, 0);
if (CompareStringA(LOCALE_SYSTEM_DEFAULT, 0,
desc, -1,
bmp_format, -1) == CSTR_EQUAL) {
bmp_found = TRUE;
break;
}
}
if (!bmp_found)
ok(FALSE, "No BMP codec found.\n");
GdipFree(codecs);
}
static void test_LockBits(void)
{
GpStatus stat;
GpBitmap *bm;
GpRect rect;
BitmapData bd;
const INT WIDTH = 10, HEIGHT = 20;
bm = NULL;
stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
expect(Ok, stat);
rect.X = 2;
rect.Y = 3;
rect.Width = 4;
rect.Height = 5;
/* read-only */
stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead, PixelFormat24bppRGB, &bd);
expect(Ok, stat);
if (stat == Ok) {
stat = GdipBitmapUnlockBits(bm, &bd);
expect(Ok, stat);
}
/* read-only, with NULL rect -> whole bitmap lock */
stat = GdipBitmapLockBits(bm, NULL, ImageLockModeRead, PixelFormat24bppRGB, &bd);
expect(Ok, stat);
expect(bd.Width, WIDTH);
expect(bd.Height, HEIGHT);
if (stat == Ok) {
stat = GdipBitmapUnlockBits(bm, &bd);
expect(Ok, stat);
}
/* read-only, consecutive */
stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead, PixelFormat24bppRGB, &bd);
expect(Ok, stat);
if (stat == Ok) {
stat = GdipBitmapUnlockBits(bm, &bd);
expect(Ok, stat);
}
stat = GdipDisposeImage((GpImage*)bm);
expect(Ok, stat);
stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
expect(Ok, stat);
/* read x2 */
stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead, PixelFormat24bppRGB, &bd);
expect(Ok, stat);
stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead, PixelFormat24bppRGB, &bd);
expect(WrongState, stat);
stat = GdipBitmapUnlockBits(bm, &bd);
expect(Ok, stat);
stat = GdipDisposeImage((GpImage*)bm);
expect(Ok, stat);
stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
expect(Ok, stat);
/* write, no modification */
stat = GdipBitmapLockBits(bm, &rect, ImageLockModeWrite, PixelFormat24bppRGB, &bd);
expect(Ok, stat);
if (stat == Ok) {
stat = GdipBitmapUnlockBits(bm, &bd);
expect(Ok, stat);
}
/* write, consecutive */
stat = GdipBitmapLockBits(bm, &rect, ImageLockModeWrite, PixelFormat24bppRGB, &bd);
expect(Ok, stat);
if (stat == Ok) {
stat = GdipBitmapUnlockBits(bm, &bd);
expect(Ok, stat);
}
stat = GdipDisposeImage((GpImage*)bm);
expect(Ok, stat);
stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
expect(Ok, stat);
/* write, modify */
stat = GdipBitmapLockBits(bm, &rect, ImageLockModeWrite, PixelFormat24bppRGB, &bd);
expect(Ok, stat);
if (stat == Ok) {
if (bd.Scan0)
((char*)bd.Scan0)[2] = 0xff;
stat = GdipBitmapUnlockBits(bm, &bd);
expect(Ok, stat);
}
stat = GdipDisposeImage((GpImage*)bm);
expect(Ok, stat);
/* dispose locked */
stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
expect(Ok, stat);
stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead, PixelFormat24bppRGB, &bd);
expect(Ok, stat);
stat = GdipDisposeImage((GpImage*)bm);
expect(Ok, stat);
}
static void test_GdipCreateBitmapFromHBITMAP(void)
{
GpBitmap* gpbm = NULL;
HBITMAP hbm = NULL;
HPALETTE hpal = NULL;
GpStatus stat;
BYTE buff[1000];
LOGPALETTE* LogPal = NULL;
REAL width, height;
const REAL WIDTH1 = 5;
const REAL HEIGHT1 = 15;
const REAL WIDTH2 = 10;
const REAL HEIGHT2 = 20;
HDC hdc;
BITMAPINFO bmi;
stat = GdipCreateBitmapFromHBITMAP(NULL, NULL, NULL);
expect(InvalidParameter, stat);
hbm = CreateBitmap(WIDTH1, HEIGHT1, 1, 1, NULL);
stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, NULL);
expect(InvalidParameter, stat);
stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, &gpbm);
expect(Ok, stat);
expect(Ok, GdipGetImageDimension((GpImage*) gpbm, &width, &height));
expectf(WIDTH1, width);
expectf(HEIGHT1, height);
if (stat == Ok)
GdipDisposeImage((GpImage*)gpbm);
DeleteObject(hbm);
hbm = CreateBitmap(WIDTH2, HEIGHT2, 1, 1, &buff);
stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, &gpbm);
expect(Ok, stat);
/* raw format */
expect_rawformat(&ImageFormatMemoryBMP, (GpImage*)gpbm, __LINE__, FALSE);
expect(Ok, GdipGetImageDimension((GpImage*) gpbm, &width, &height));
expectf(WIDTH2, width);
expectf(HEIGHT2, height);
if (stat == Ok)
GdipDisposeImage((GpImage*)gpbm);
DeleteObject(hbm);
hdc = CreateCompatibleDC(0);
ok(hdc != NULL, "CreateCompatibleDC failed\n");
bmi.bmiHeader.biSize = sizeof(bmi.bmiHeader);
bmi.bmiHeader.biHeight = HEIGHT1;
bmi.bmiHeader.biWidth = WIDTH1;
bmi.bmiHeader.biBitCount = 24;
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biCompression = BI_RGB;
hbm = CreateDIBSection(hdc, &bmi, DIB_RGB_COLORS, NULL, NULL, 0);
ok(hbm != NULL, "CreateDIBSection failed\n");
stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, &gpbm);
expect(Ok, stat);
expect(Ok, GdipGetImageDimension((GpImage*) gpbm, &width, &height));
expectf(WIDTH1, width);
expectf(HEIGHT1, height);
if (stat == Ok)
GdipDisposeImage((GpImage*)gpbm);
LogPal = GdipAlloc(sizeof(LOGPALETTE));
ok(LogPal != NULL, "unable to allocate LOGPALETTE\n");
LogPal->palVersion = 0x300;
hpal = CreatePalette(LogPal);
ok(hpal != NULL, "CreatePalette failed\n");
GdipFree(LogPal);
stat = GdipCreateBitmapFromHBITMAP(hbm, hpal, &gpbm);
todo_wine
{
expect(Ok, stat);
}
if (stat == Ok)
GdipDisposeImage((GpImage*)gpbm);
DeleteObject(hpal);
DeleteObject(hbm);
}
static void test_GdipGetImageFlags(void)
{
GpImage *img;
GpStatus stat;
UINT flags;
img = (GpImage*)0xdeadbeef;
stat = GdipGetImageFlags(NULL, NULL);
expect(InvalidParameter, stat);
stat = GdipGetImageFlags(NULL, &flags);
expect(InvalidParameter, stat);
stat = GdipGetImageFlags(img, NULL);
expect(InvalidParameter, stat);
}
static void test_GdipCloneImage(void)
{
GpStatus stat;
GpRectF rectF;
GpUnit unit;
GpBitmap *bm;
GpImage *image_src, *image_dest = NULL;
const INT WIDTH = 10, HEIGHT = 20;
/* Create an image, clone it, delete the original, make sure the copy works */
stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
expect(Ok, stat);
expect_rawformat(&ImageFormatMemoryBMP, (GpImage*)bm, __LINE__, FALSE);
image_src = ((GpImage*)bm);
stat = GdipCloneImage(image_src, &image_dest);
expect(Ok, stat);
expect_rawformat(&ImageFormatMemoryBMP, image_dest, __LINE__, FALSE);
stat = GdipDisposeImage((GpImage*)bm);
expect(Ok, stat);
stat = GdipGetImageBounds(image_dest, &rectF, &unit);
expect(Ok, stat);
/* Treat FP values carefully */
expectf((REAL)WIDTH, rectF.Width);
expectf((REAL)HEIGHT, rectF.Height);
stat = GdipDisposeImage(image_dest);
expect(Ok, stat);
}
static void test_testcontrol(void)
{
GpStatus stat;
DWORD param;
param = 0;
stat = GdipTestControl(TestControlGetBuildNumber, &param);
expect(Ok, stat);
ok(param != 0, "Build number expected, got %u\n", param);
}
static void test_fromhicon(void)
{
static const BYTE bmp_bits[1024];
HBITMAP hbmMask, hbmColor;
ICONINFO info;
HICON hIcon;
GpStatus stat;
GpBitmap *bitmap = NULL;
UINT dim;
ImageType type;
PixelFormat format;
/* NULL */
stat = GdipCreateBitmapFromHICON(NULL, NULL);
expect(InvalidParameter, stat);
stat = GdipCreateBitmapFromHICON(NULL, &bitmap);
expect(InvalidParameter, stat);
/* color icon 1 bit */
hbmMask = CreateBitmap(16, 16, 1, 1, bmp_bits);
ok(hbmMask != 0, "CreateBitmap failed\n");
hbmColor = CreateBitmap(16, 16, 1, 1, bmp_bits);
ok(hbmColor != 0, "CreateBitmap failed\n");
info.fIcon = TRUE;
info.xHotspot = 8;
info.yHotspot = 8;
info.hbmMask = hbmMask;
info.hbmColor = hbmColor;
hIcon = CreateIconIndirect(&info);
ok(hIcon != 0, "CreateIconIndirect failed\n");
DeleteObject(hbmMask);
DeleteObject(hbmColor);
stat = GdipCreateBitmapFromHICON(hIcon, &bitmap);
ok(stat == Ok ||
broken(stat == InvalidParameter), /* Win98 */
"Expected Ok, got %.8x\n", stat);
if(stat == Ok){
/* check attributes */
stat = GdipGetImageHeight((GpImage*)bitmap, &dim);
expect(Ok, stat);
expect(16, dim);
stat = GdipGetImageWidth((GpImage*)bitmap, &dim);
expect(Ok, stat);
expect(16, dim);
stat = GdipGetImageType((GpImage*)bitmap, &type);
expect(Ok, stat);
expect(ImageTypeBitmap, type);
stat = GdipGetImagePixelFormat((GpImage*)bitmap, &format);
expect(PixelFormat32bppARGB, format);
/* raw format */
expect_rawformat(&ImageFormatMemoryBMP, (GpImage*)bitmap, __LINE__, FALSE);
GdipDisposeImage((GpImage*)bitmap);
}
DestroyIcon(hIcon);
/* color icon 8 bpp */
hbmMask = CreateBitmap(16, 16, 1, 8, bmp_bits);
ok(hbmMask != 0, "CreateBitmap failed\n");
hbmColor = CreateBitmap(16, 16, 1, 8, bmp_bits);
ok(hbmColor != 0, "CreateBitmap failed\n");
info.fIcon = TRUE;
info.xHotspot = 8;
info.yHotspot = 8;
info.hbmMask = hbmMask;
info.hbmColor = hbmColor;
hIcon = CreateIconIndirect(&info);
ok(hIcon != 0, "CreateIconIndirect failed\n");
DeleteObject(hbmMask);
DeleteObject(hbmColor);
stat = GdipCreateBitmapFromHICON(hIcon, &bitmap);
expect(Ok, stat);
if(stat == Ok){
/* check attributes */
stat = GdipGetImageHeight((GpImage*)bitmap, &dim);
expect(Ok, stat);
expect(16, dim);
stat = GdipGetImageWidth((GpImage*)bitmap, &dim);
expect(Ok, stat);
expect(16, dim);
stat = GdipGetImageType((GpImage*)bitmap, &type);
expect(Ok, stat);
expect(ImageTypeBitmap, type);
stat = GdipGetImagePixelFormat((GpImage*)bitmap, &format);
expect(PixelFormat32bppARGB, format);
/* raw format */
expect_rawformat(&ImageFormatMemoryBMP, (GpImage*)bitmap, __LINE__, FALSE);
GdipDisposeImage((GpImage*)bitmap);
}
DestroyIcon(hIcon);
}
/* 1x1 pixel png */
static const unsigned char pngimage[285] = {
0x89,0x50,0x4e,0x47,0x0d,0x0a,0x1a,0x0a,0x00,0x00,0x00,0x0d,0x49,0x48,0x44,0x52,
0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x08,0x02,0x00,0x00,0x00,0x90,0x77,0x53,
0xde,0x00,0x00,0x00,0x09,0x70,0x48,0x59,0x73,0x00,0x00,0x0b,0x13,0x00,0x00,0x0b,
0x13,0x01,0x00,0x9a,0x9c,0x18,0x00,0x00,0x00,0x07,0x74,0x49,0x4d,0x45,0x07,0xd5,
0x06,0x03,0x0f,0x07,0x2d,0x12,0x10,0xf0,0xfd,0x00,0x00,0x00,0x0c,0x49,0x44,0x41,
0x54,0x08,0xd7,0x63,0xf8,0xff,0xff,0x3f,0x00,0x05,0xfe,0x02,0xfe,0xdc,0xcc,0x59,
0xe7,0x00,0x00,0x00,0x00,0x49,0x45,0x4e,0x44,0xae,0x42,0x60,0x82
};
/* 1x1 pixel gif */
static const unsigned char gifimage[35] = {
0x47,0x49,0x46,0x38,0x37,0x61,0x01,0x00,0x01,0x00,0x80,0x00,0x00,0xff,0xff,0xff,
0xff,0xff,0xff,0x2c,0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x02,0x02,0x44,
0x01,0x00,0x3b
};
/* 1x1 pixel bmp */
static const unsigned char bmpimage[66] = {
0x42,0x4d,0x42,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3e,0x00,0x00,0x00,0x28,0x00,
0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x00,
0x00,0x00,0x04,0x00,0x00,0x00,0x12,0x0b,0x00,0x00,0x12,0x0b,0x00,0x00,0x02,0x00,
0x00,0x00,0x02,0x00,0x00,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x00,0x00,
0x00,0x00
};
/* 1x1 pixel jpg */
static const unsigned char jpgimage[285] = {
0xff,0xd8,0xff,0xe0,0x00,0x10,0x4a,0x46,0x49,0x46,0x00,0x01,0x01,0x01,0x01,0x2c,
0x01,0x2c,0x00,0x00,0xff,0xdb,0x00,0x43,0x00,0x05,0x03,0x04,0x04,0x04,0x03,0x05,
0x04,0x04,0x04,0x05,0x05,0x05,0x06,0x07,0x0c,0x08,0x07,0x07,0x07,0x07,0x0f,0x0b,
0x0b,0x09,0x0c,0x11,0x0f,0x12,0x12,0x11,0x0f,0x11,0x11,0x13,0x16,0x1c,0x17,0x13,
0x14,0x1a,0x15,0x11,0x11,0x18,0x21,0x18,0x1a,0x1d,0x1d,0x1f,0x1f,0x1f,0x13,0x17,
0x22,0x24,0x22,0x1e,0x24,0x1c,0x1e,0x1f,0x1e,0xff,0xdb,0x00,0x43,0x01,0x05,0x05,
0x05,0x07,0x06,0x07,0x0e,0x08,0x08,0x0e,0x1e,0x14,0x11,0x14,0x1e,0x1e,0x1e,0x1e,
0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,
0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,
0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0xff,0xc0,
0x00,0x11,0x08,0x00,0x01,0x00,0x01,0x03,0x01,0x22,0x00,0x02,0x11,0x01,0x03,0x11,
0x01,0xff,0xc4,0x00,0x15,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0xff,0xc4,0x00,0x14,0x10,0x01,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xc4,
0x00,0x14,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0xff,0xc4,0x00,0x14,0x11,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xda,0x00,0x0c,0x03,0x01,
0x00,0x02,0x11,0x03,0x11,0x00,0x3f,0x00,0xb2,0xc0,0x07,0xff,0xd9
};
static void test_getrawformat(void)
{
test_bufferrawformat((void*)pngimage, sizeof(pngimage), &ImageFormatPNG, __LINE__, FALSE);
test_bufferrawformat((void*)gifimage, sizeof(gifimage), &ImageFormatGIF, __LINE__, FALSE);
test_bufferrawformat((void*)bmpimage, sizeof(bmpimage), &ImageFormatBMP, __LINE__, FALSE);
test_bufferrawformat((void*)jpgimage, sizeof(jpgimage), &ImageFormatJPEG, __LINE__, FALSE);
}
static void test_createhbitmap(void)
{
GpStatus stat;
GpBitmap *bitmap;
HBITMAP hbitmap, oldhbitmap;
BITMAP bm;
int ret;
HDC hdc;
COLORREF pixel;
BYTE bits[640];
memset(bits, 0x68, 640);
/* create Bitmap */
stat = GdipCreateBitmapFromScan0(10, 20, 32, PixelFormat24bppRGB, bits, &bitmap);
expect(Ok, stat);
/* test NULL values */
stat = GdipCreateHBITMAPFromBitmap(NULL, &hbitmap, 0);
expect(InvalidParameter, stat);
stat = GdipCreateHBITMAPFromBitmap(bitmap, NULL, 0);
expect(InvalidParameter, stat);
/* create HBITMAP */
stat = GdipCreateHBITMAPFromBitmap(bitmap, &hbitmap, 0);
expect(Ok, stat);
if (stat == Ok)
{
ret = GetObjectA(hbitmap, sizeof(BITMAP), &bm);
expect(sizeof(BITMAP), ret);
expect(0, bm.bmType);
expect(10, bm.bmWidth);
expect(20, bm.bmHeight);
expect(40, bm.bmWidthBytes);
expect(1, bm.bmPlanes);
expect(32, bm.bmBitsPixel);
ok(bm.bmBits != NULL, "got DDB, expected DIB\n");
hdc = CreateCompatibleDC(NULL);
oldhbitmap = SelectObject(hdc, hbitmap);
pixel = GetPixel(hdc, 5, 5);
SelectObject(hdc, oldhbitmap);
DeleteDC(hdc);
expect(0x686868, pixel);
DeleteObject(hbitmap);
}
stat = GdipDisposeImage((GpImage*)bitmap);
expect(Ok, stat);
}
START_TEST(image)
{
struct GdiplusStartupInput gdiplusStartupInput;
ULONG_PTR gdiplusToken;
gdiplusStartupInput.GdiplusVersion = 1;
gdiplusStartupInput.DebugEventCallback = NULL;
gdiplusStartupInput.SuppressBackgroundThread = 0;
gdiplusStartupInput.SuppressExternalCodecs = 0;
GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
test_Scan0();
test_GetImageDimension();
test_GdipImageGetFrameDimensionsCount();
test_LoadingImages();
test_SavingImages();
test_encoders();
test_LockBits();
test_GdipCreateBitmapFromHBITMAP();
test_GdipGetImageFlags();
test_GdipCloneImage();
test_testcontrol();
test_fromhicon();
test_getrawformat();
test_createhbitmap();
GdiplusShutdown(gdiplusToken);
}
Reference in New Issue View Git Blame Copy Permalink