clipboard.c File Reference

#include <stdio.h>
#include "wine/test.h"
#include "winbase.h"
#include "winerror.h"
#include "wingdi.h"
#include "winuser.h"
#include "winnls.h"

Include dependency graph for clipboard.c:

Go to the source code of this file.

Macros
#define	check_messages(a, b, c, d, e, f)   check_messages_(__LINE__,a,b,c,d,e,f)

Functions
static	BOOL (WINAPI *pAddClipboardFormatListener)(HWND hwnd)
static DWORD WINAPI	open_clipboard_thread (LPVOID arg)
static DWORD WINAPI	empty_clipboard_thread (LPVOID arg)
static DWORD WINAPI	open_and_empty_clipboard_thread (LPVOID arg)
static DWORD WINAPI	open_and_empty_clipboard_win_thread (LPVOID arg)
static DWORD WINAPI	set_clipboard_data_thread (LPVOID arg)
static void	set_clipboard_data_process (int arg)
static void	grab_clipboard_process (int arg)
static void	run_thread (LPTHREAD_START_ROUTINE func, void *arg, int line)
static void	run_process (const char *args)
static LRESULT CALLBACK	winproc_wrapper (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
static void	test_ClipboardOwner (void)
static void	test_RegisterClipboardFormatA (void)
static HGLOBAL	create_textA (void)
static HGLOBAL	create_textW (void)
static HANDLE	create_metafile (void)
static HENHMETAFILE	create_emf (void)
static HBITMAP	create_bitmap (void)
static HBITMAP	create_dib (BOOL v5)
static LRESULT CALLBACK	renderer_winproc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
static void	test_synthesized (void)
static DWORD WINAPI	clipboard_render_data_thread (void *param)
static LRESULT CALLBACK	clipboard_wnd_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
static void	get_clipboard_data_process (void)
static void	check_messages_ (int line, HWND win, UINT seq_diff, UINT draw, UINT update, UINT destroy, UINT render)
static DWORD WINAPI	clipboard_thread (void *param)
static void	test_messages (void)
static BOOL	is_moveable (HANDLE handle)
static BOOL	is_fixed (HANDLE handle)
static BOOL	is_freed (HANDLE handle)
static void	test_handles (HWND hwnd)
static DWORD WINAPI	test_handles_thread (void *arg)
static DWORD WINAPI	test_handles_thread2 (void *arg)
static void	test_handles_process (const char *str)
static void	test_handles_process_open (const char *str)
static void	test_handles_process_dib (const char *str)
static void	test_data_handles (void)
static void	test_GetUpdatedClipboardFormats (void)
static void	test_string_data (void)
static void	test_string_data_process (int i)
	START_TEST (clipboard)

Variables
static UINT	count
static UINT UINT *	out_count
static int	thread_from_line
static char *	argv0
static WNDPROC	old_proc
static CRITICAL_SECTION	clipboard_cs
static HWND	next_wnd
static UINT	wm_drawclipboard
static UINT	wm_clipboardupdate
static UINT	wm_destroyclipboard
static UINT	wm_renderformat
static UINT	nb_formats
static BOOL	cross_thread
static BOOL	do_render_format
static HANDLE	update_event
static UINT	old_seq
static UINT	format_id
static HBITMAP	bitmap
static HBITMAP	bitmap2
static HPALETTE	palette
static const LOGPALETTE	logpalette = { 0x300, 1, {{ 0x12, 0x34, 0x56, 0x78 }}}
struct {
char   strA [12]
WCHAR   strW [12]
UINT   len
}	test_data []

Macro Definition Documentation

check_messages

#define check_messages	(		a,
			b,
			c,
			d,
			e,
			f
	)		check_messages_(__LINE__,a,b,c,d,e,f)

Definition at line 1033 of file clipboard.c.

Function Documentation

BOOL()

static BOOL ( WINAPI *  pAddClipboardFormatListener )

static

check_messages_()

static void check_messages_ ( int  line, HWND  win, UINT  seq_diff, UINT  draw, UINT  update, UINT  destroy, UINT  render  )

static

Definition at line 1006 of file clipboard.c.

{
    MSG msg;
    UINT count, fmt, seq;
 
    seq = GetClipboardSequenceNumber();
    ok_(__FILE__, line)(seq - old_seq == seq_diff, "sequence diff %d\n", seq - old_seq);
    old_seq = seq;
 
    if (!cross_thread)
    {
        while (PeekMessageW( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageW( &msg );
    }
 
    if (update && !broken(!pAddClipboardFormatListener))
        ok(WaitForSingleObject(update_event, 1000) == WAIT_OBJECT_0, "wait failed\n");
 
    count = SendMessageA( win, WM_USER + 1, 0, 0 );
    ok_(__FILE__, line)(count == draw, "WM_DRAWCLIPBOARD %sreceived\n", draw ? "not " : "");
    count = SendMessageA( win, WM_USER + 2, 0, 0 );
    ok_(__FILE__, line)(count == update || broken(!pAddClipboardFormatListener),
                        "WM_CLIPBOARDUPDATE %sreceived\n", update ? "not " : "");
    count = SendMessageA( win, WM_USER + 3, 0, 0 );
    ok_(__FILE__, line)(count == destroy, "WM_DESTROYCLIPBOARD %sreceived\n", destroy ? "not " : "");
    fmt = SendMessageA( win, WM_USER + 4, 0, 0 );
    ok_(__FILE__, line)(fmt == render, "WM_RENDERFORMAT received %04x, expected %04x\n", fmt, render);
}

clipboard_render_data_thread()

static DWORD WINAPI clipboard_render_data_thread ( void *  param )

static

Definition at line 886 of file clipboard.c.

{
    HANDLE handle = SetClipboardData( CF_UNICODETEXT, create_textW() );
    ok( handle != 0, "SetClipboardData failed: %d\n", GetLastError() );
    return 0;
}

Referenced by clipboard_wnd_proc().

clipboard_thread()

static DWORD WINAPI clipboard_thread ( void *  param )

static

Definition at line 1035 of file clipboard.c.

{
    HWND ret, win = param;
    BOOL r;
    MSG msg;
    HANDLE handle;
    UINT count, fmt, formats;
 
    cross_thread = (GetWindowThreadProcessId( win, NULL ) != GetCurrentThreadId());
    trace( "%s-threaded test\n", cross_thread ? "multi" : "single" );
 
    old_seq = GetClipboardSequenceNumber();
 
    EnterCriticalSection(&clipboard_cs);
    SetLastError(0xdeadbeef);
    next_wnd = SetClipboardViewer(win);
    ok(GetLastError() == 0xdeadbeef, "GetLastError = %d\n", GetLastError());
    LeaveCriticalSection(&clipboard_cs);
 
    SetLastError( 0xdeadbeef );
    ret = SetClipboardViewer( (HWND)0xdead );
    ok( !ret, "SetClipboardViewer succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_WINDOW_HANDLE, "wrong error %u\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    r = ChangeClipboardChain( win, (HWND)0xdead );
    ok( !r, "ChangeClipboardChain succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_WINDOW_HANDLE, "wrong error %u\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    r = ChangeClipboardChain( (HWND)0xdead, next_wnd );
    ok( !r, "ChangeClipboardChain succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_WINDOW_HANDLE, "wrong error %u\n", GetLastError() );
 
    if (pAddClipboardFormatListener)
    {
        r = pAddClipboardFormatListener(win);
        ok( r, "AddClipboardFormatListener failed err %d\n", GetLastError());
        SetLastError( 0xdeadbeef );
        r = pAddClipboardFormatListener( win );
        ok( !r, "AddClipboardFormatListener succeeded\n" );
        ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %u\n", GetLastError() );
        SetLastError( 0xdeadbeef );
        r = pAddClipboardFormatListener( (HWND)0xdead );
        ok( !r, "AddClipboardFormatListener succeeded\n" );
        ok( GetLastError() == ERROR_INVALID_WINDOW_HANDLE, "wrong error %u\n", GetLastError() );
        r = pAddClipboardFormatListener( GetDesktopWindow() );
        ok( r, "AddClipboardFormatListener failed err %d\n", GetLastError());
        r = pRemoveClipboardFormatListener( GetDesktopWindow() );
        ok( r, "RemoveClipboardFormatListener failed err %d\n", GetLastError());
    }
 
    check_messages(win, 0, 1, 0, 0, 0);
 
    SetLastError( 0xdeadbeef );
    r = OpenClipboard( (HWND)0xdead );
    ok( !r, "OpenClipboard succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_WINDOW_HANDLE, "wrong error %u\n", GetLastError() );
 
    r = OpenClipboard(win);
    ok(r, "OpenClipboard failed: %d\n", GetLastError());
 
    check_messages(win, 0, 0, 0, 0, 0);
 
    r = EmptyClipboard();
    ok(r, "EmptyClipboard failed: %d\n", GetLastError());
 
    check_messages(win, 1, 0, 0, 0, 0);
 
    r = EmptyClipboard();
    ok(r, "EmptyClipboard failed: %d\n", GetLastError());
    /* sequence changes again, even though it was already empty */
    check_messages(win, 1, 0, 0, 1, 0);
    count = SendMessageA( win, WM_USER+5, 0, 0 );
    ok( !count, "wrong format count %u on WM_DESTROYCLIPBOARD\n", count );
 
    handle = SetClipboardData( CF_TEXT, create_textA() );
    ok(handle != 0, "SetClipboardData failed: %d\n", GetLastError());
 
    check_messages(win, 1, 0, 0, 0, 0);
 
    SetClipboardData( CF_UNICODETEXT, 0 );
 
    check_messages(win, 1, 0, 0, 0, 0);
 
    SetClipboardData( CF_UNICODETEXT, 0 );  /* same data again */
 
    check_messages(win, 1, 0, 0, 0, 0);
 
    ok( IsClipboardFormatAvailable( CF_TEXT ), "CF_TEXT available\n" );
    ok( IsClipboardFormatAvailable( CF_UNICODETEXT ), "CF_UNICODETEXT available\n" );
    ok( !IsClipboardFormatAvailable( CF_OEMTEXT ), "CF_OEMTEXT available\n" );
 
    EnterCriticalSection(&clipboard_cs);
    r = CloseClipboard();
    ok(r, "CloseClipboard failed: %d\n", GetLastError());
    LeaveCriticalSection(&clipboard_cs);
 
    check_messages(win, 2, 1, 1, 0, 0);
 
    r = OpenClipboard(win);
    ok(r, "OpenClipboard failed: %d\n", GetLastError());
 
    check_messages(win, 0, 0, 0, 0, 0);
 
    ok( IsClipboardFormatAvailable( CF_TEXT ), "CF_TEXT available\n" );
    ok( IsClipboardFormatAvailable( CF_UNICODETEXT ), "CF_UNICODETEXT available\n" );
    ok( IsClipboardFormatAvailable( CF_OEMTEXT ), "CF_OEMTEXT available\n" );
 
    ok( GetClipboardOwner() == win, "wrong owner %p\n", GetClipboardOwner());
    handle = GetClipboardData( CF_UNICODETEXT );
    ok( !handle, "got data for CF_UNICODETEXT\n" );
    fmt = SendMessageA( win, WM_USER+4, 0, 0 );
    ok( fmt == CF_UNICODETEXT, "WM_RENDERFORMAT received %04x\n", fmt );
 
    do_render_format = TRUE;
    handle = GetClipboardData( CF_OEMTEXT );
    ok( handle != NULL, "didn't get data for CF_OEMTEXT\n" );
    fmt = SendMessageA( win, WM_USER+4, 0, 0 );
    ok( fmt == CF_UNICODETEXT, "WM_RENDERFORMAT received %04x\n", fmt );
    do_render_format = FALSE;
 
    SetClipboardData( CF_WAVE, 0 );
    check_messages(win, 1, 0, 0, 0, 0);
 
    r = CloseClipboard();
    ok(r, "CloseClipboard failed: %d\n", GetLastError());
    /* no synthesized format, so CloseClipboard doesn't change the sequence */
    check_messages(win, 0, 1, 1, 0, 0);
 
    r = OpenClipboard(win);
    ok(r, "OpenClipboard failed: %d\n", GetLastError());
    r = CloseClipboard();
    ok(r, "CloseClipboard failed: %d\n", GetLastError());
    /* nothing changed */
    check_messages(win, 0, 0, 0, 0, 0);
 
    formats = CountClipboardFormats();
    r = OpenClipboard(0);
    ok(r, "OpenClipboard failed: %d\n", GetLastError());
    r = EmptyClipboard();
    ok(r, "EmptyClipboard failed: %d\n", GetLastError());
    r = CloseClipboard();
    ok(r, "CloseClipboard failed: %d\n", GetLastError());
 
    check_messages(win, 1, 1, 1, 1, 0);
    count = SendMessageA( win, WM_USER+5, 0, 0 );
    ok( count == formats, "wrong format count %u on WM_DESTROYCLIPBOARD\n", count );
 
    r = OpenClipboard(win);
    ok(r, "OpenClipboard failed: %d\n", GetLastError());
    SetClipboardData( CF_WAVE, GlobalAlloc( GMEM_FIXED, 1 ));
    check_messages(win, 1, 0, 0, 0, 0);
 
    EnterCriticalSection(&clipboard_cs);
    r = CloseClipboard();
    ok(r, "CloseClipboard failed: %d\n", GetLastError());
    LeaveCriticalSection(&clipboard_cs);
 
    check_messages(win, 0, 1, 1, 0, 0);
 
    run_process( "grab_clipboard 0" );
 
    if (!cross_thread)
    {
        /* in this case we get a cross-thread WM_DRAWCLIPBOARD */
        cross_thread = TRUE;
        while (PeekMessageW( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageW( &msg );
        cross_thread = FALSE;
    }
    check_messages(win, 1, 1, 1, 0, 0);
 
    r = OpenClipboard(0);
    ok(r, "OpenClipboard failed: %d\n", GetLastError());
    SetClipboardData( CF_WAVE, GlobalAlloc( GMEM_FIXED, 1 ));
    check_messages(win, 1, 0, 0, 0, 0);
 
    EnterCriticalSection(&clipboard_cs);
    r = CloseClipboard();
    ok(r, "CloseClipboard failed: %d\n", GetLastError());
    LeaveCriticalSection(&clipboard_cs);
 
    check_messages(win, 0, 1, 1, 0, 0);
 
    run_process( "grab_clipboard 1" );
 
    if (!cross_thread)
    {
        /* in this case we get a cross-thread WM_DRAWCLIPBOARD */
        cross_thread = TRUE;
        while (PeekMessageW( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageW( &msg );
        cross_thread = FALSE;
    }
    check_messages(win, 2, 1, 1, 0, 0);
 
    r = OpenClipboard(0);
    ok(r, "OpenClipboard failed: %d\n", GetLastError());
    SetClipboardData( CF_WAVE, GlobalAlloc( GMEM_FIXED, 1 ));
    check_messages(win, 1, 0, 0, 0, 0);
 
    EnterCriticalSection(&clipboard_cs);
    r = CloseClipboard();
    ok(r, "CloseClipboard failed: %d\n", GetLastError());
    LeaveCriticalSection(&clipboard_cs);
 
    check_messages(win, 0, 1, 1, 0, 0);
 
    if (cross_thread)
    {
        r = OpenClipboard( win );
        ok(r, "OpenClipboard failed: %d\n", GetLastError());
        r = EmptyClipboard();
        ok(r, "EmptyClipboard failed: %d\n", GetLastError());
        SetClipboardData( CF_TEXT, 0 );
        r = CloseClipboard();
        ok(r, "CloseClipboard failed: %d\n", GetLastError());
 
        do_render_format = TRUE;
        old_seq = GetClipboardSequenceNumber();
        run_process( "get_clipboard_data" );
        do_render_format = FALSE;
 
        check_messages(win, 0, 1, 1, 0, CF_TEXT);
    }
 
    r = PostMessageA(win, WM_USER, 0, 0);
    ok(r, "PostMessage failed: %d\n", GetLastError());
 
    if (pRemoveClipboardFormatListener)
    {
        r = pRemoveClipboardFormatListener(win);
        ok( r, "RemoveClipboardFormatListener failed err %d\n", GetLastError());
        SetLastError( 0xdeadbeef );
        r = pRemoveClipboardFormatListener(win);
        ok( !r, "RemoveClipboardFormatListener succeeded\n" );
        ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %u\n", GetLastError() );
        SetLastError( 0xdeadbeef );
        r = pRemoveClipboardFormatListener( (HWND)0xdead );
        ok( !r, "RemoveClipboardFormatListener succeeded\n" );
        ok( GetLastError() == ERROR_INVALID_WINDOW_HANDLE, "wrong error %u\n", GetLastError() );
    }
    return 0;
}

Referenced by test_messages().

clipboard_wnd_proc()

static LRESULT CALLBACK clipboard_wnd_proc ( HWND  hwnd, UINT  msg, WPARAM  wp, LPARAM  lp  )

static

Definition at line 904 of file clipboard.c.

{
    LRESULT ret;
    DWORD msg_flags = InSendMessageEx( NULL );
 
    switch(msg) {
    case WM_DRAWCLIPBOARD:
        ok( msg_flags == (cross_thread ? ISMEX_NOTIFY : ISMEX_NOSEND),
            "WM_DRAWCLIPBOARD wrong flags %x\n", msg_flags );
        EnterCriticalSection(&clipboard_cs);
        wm_drawclipboard++;
        LeaveCriticalSection(&clipboard_cs);
        break;
    case WM_CHANGECBCHAIN:
        ok( msg_flags == (cross_thread ? ISMEX_SEND : ISMEX_NOSEND),
            "WM_CHANGECBCHAIN wrong flags %x\n", msg_flags );
        if (next_wnd == (HWND)wp)
            next_wnd = (HWND)lp;
        else if (next_wnd)
            SendMessageA(next_wnd, msg, wp, lp);
        break;
    case WM_DESTROYCLIPBOARD:
        ok( msg_flags == (cross_thread ? ISMEX_SEND : ISMEX_NOSEND),
            "WM_DESTROYCLIPBOARD wrong flags %x\n", msg_flags );
        wm_destroyclipboard++;
        ok( GetClipboardOwner() == hwnd, "WM_DESTROYCLIPBOARD owner %p\n", GetClipboardOwner() );
        nb_formats = CountClipboardFormats();
        break;
    case WM_RENDERFORMAT:
        ok( !wm_renderformat, "multiple WM_RENDERFORMAT %04x / %04lx\n", wm_renderformat, wp );
        wm_renderformat = wp;
 
        if (do_render_format)
        {
            UINT seq, old_seq;
            HANDLE handle;
 
            old_seq = GetClipboardSequenceNumber();
            handle = SetClipboardData( CF_TEXT, create_textA() );
            ok( handle != 0, "SetClipboardData failed: %d\n", GetLastError() );
            seq = GetClipboardSequenceNumber();
            ok( seq == old_seq, "sequence changed\n" );
            old_seq = seq;
 
            handle = CreateThread( NULL, 0, clipboard_render_data_thread, NULL, 0, NULL );
            ok( handle != NULL, "CreateThread failed: %d\n", GetLastError() );
            ok( WaitForSingleObject(handle, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n" );
            CloseHandle( handle );
            seq = GetClipboardSequenceNumber();
            ok( seq == old_seq, "sequence changed\n" );
        }
 
        break;
    case WM_CLIPBOARDUPDATE:
        ok( msg_flags == ISMEX_NOSEND, "WM_CLIPBOARDUPDATE wrong flags %x\n", msg_flags );
        EnterCriticalSection(&clipboard_cs);
        wm_clipboardupdate++;
        SetEvent(update_event);
        LeaveCriticalSection(&clipboard_cs);
        break;
    case WM_USER:
        ChangeClipboardChain(hwnd, next_wnd);
        PostQuitMessage(0);
        break;
    case WM_USER+1:
        ret = wm_drawclipboard;
        wm_drawclipboard = 0;
        return ret;
    case WM_USER+2:
        ret = wm_clipboardupdate;
        wm_clipboardupdate = 0;
        return ret;
    case WM_USER+3:
        ret = wm_destroyclipboard;
        wm_destroyclipboard = 0;
        return ret;
    case WM_USER+4:
        ret = wm_renderformat;
        wm_renderformat = 0;
        return ret;
    case WM_USER+5:
        return nb_formats;
    }
 
    return DefWindowProcA(hwnd, msg, wp, lp);
}

create_bitmap()

static HBITMAP create_bitmap ( void  )

static

Definition at line 534 of file clipboard.c.

{
    HDC hdc = GetDC( 0 );
    UINT bpp = GetDeviceCaps( hdc, BITSPIXEL );
    ReleaseDC( 0, hdc );
    return CreateBitmap( 10, 10, 1, bpp, NULL );
}

Referenced by BITMAP_LoadImageW(), DataObject_GetData(), image_list_add_bitmap(), test_data_cache_cache(), test_imagelist_storage(), test_load_texture(), test_synthesized(), and test_texture_qi().

create_dib()

static HBITMAP create_dib ( BOOL  v5 )

static

Definition at line 542 of file clipboard.c.

{
    HANDLE ret;
    BITMAPINFOHEADER *hdr;
 
    ret = GlobalAlloc( GMEM_DDESHARE | GMEM_MOVEABLE | GMEM_ZEROINIT,
                       sizeof(BITMAPV5HEADER) + 256 * sizeof(RGBQUAD) + 16 * 16 * 4 );
    hdr = GlobalLock( ret );
    hdr->biSize = v5 ? sizeof(BITMAPV5HEADER) : sizeof(*hdr);
    hdr->biWidth = 16;
    hdr->biHeight = 16;
    hdr->biPlanes = 1;
    hdr->biBitCount = 32;
    hdr->biCompression = BI_RGB;
    if (v5)
    {
        BITMAPV5HEADER *hdr5 = (BITMAPV5HEADER *)hdr;
        hdr5->bV5RedMask = 0x0000ff;
        hdr5->bV5GreenMask = 0x00ff00;
        hdr5->bV5BlueMask = 0xff0000;
        hdr5->bV5AlphaMask = 0xff000000;
    }
    GlobalUnlock( ret );
    return ret;
}

Referenced by test_synthesized().

create_emf()

static HENHMETAFILE create_emf ( void  )

static

Definition at line 526 of file clipboard.c.

{
    const RECT rect = {0, 0, 100, 100};
    HDC hdc = CreateEnhMetaFileA(NULL, NULL, &rect, "HENHMETAFILE Ole Clipboard Test\0Test\0\0");
    ExtTextOutA(hdc, 0, 0, ETO_OPAQUE, &rect, "Test String", strlen("Test String"), NULL);
    return CloseEnhMetaFile(hdc);
}

create_metafile()

static HANDLE create_metafile ( void  )

static

Definition at line 508 of file clipboard.c.

{
    const RECT rect = {0, 0, 100, 100};
    METAFILEPICT *pict;
    HANDLE ret;
    HMETAFILE mf;
    HDC hdc = CreateMetaFileA( NULL );
    ExtTextOutA( hdc, 0, 0, ETO_OPAQUE, &rect, "Test String", strlen("Test String"), NULL );
    mf = CloseMetaFile( hdc );
    ret = GlobalAlloc( GMEM_DDESHARE | GMEM_MOVEABLE, sizeof(*pict) );
    pict = GlobalLock( ret );
    pict->mm = MM_TEXT;
    pict->xExt = pict->yExt = 100;
    pict->hMF = mf;
    GlobalUnlock( ret );
    return ret;
}

Referenced by test_data_handles(), and test_synthesized().

create_textA()

static HGLOBAL create_textA ( void  )

static

Definition at line 489 of file clipboard.c.

{
    HGLOBAL h = GlobalAlloc(GMEM_DDESHARE|GMEM_MOVEABLE, 10);
    char *p = GlobalLock(h);
    memcpy(p, "test\0\0\0\0\0", 10);
    GlobalUnlock(h);
    return h;
}

Referenced by clipboard_thread(), clipboard_wnd_proc(), test_data_handles(), test_handles(), and test_synthesized().

create_textW()

static HGLOBAL create_textW ( void  )

static

Definition at line 498 of file clipboard.c.

{
    static const WCHAR testW[] = {'t','e','s','t',0,0,0,0,0,0};
    HGLOBAL h = GlobalAlloc(GMEM_DDESHARE|GMEM_MOVEABLE, sizeof(testW));
    WCHAR *p = GlobalLock(h);
    memcpy(p, testW, sizeof(testW));
    GlobalUnlock(h);
    return h;
}

Referenced by clipboard_render_data_thread(), and test_synthesized().

empty_clipboard_thread()

static DWORD WINAPI empty_clipboard_thread ( LPVOID  arg )

static

Definition at line 47 of file clipboard.c.

{
    SetLastError( 0xdeadbeef );
    ok(!EmptyClipboard(), "%u: EmptyClipboard succeeded\n", thread_from_line );
    ok( GetLastError() == ERROR_CLIPBOARD_NOT_OPEN, "%u: wrong error %u\n",
        thread_from_line, GetLastError());
    return 0;
}

Referenced by test_ClipboardOwner().

get_clipboard_data_process()

static void get_clipboard_data_process ( void  )

static

Definition at line 991 of file clipboard.c.

{
    HANDLE data;
    BOOL r;
 
    r = OpenClipboard(0);
    ok(r, "OpenClipboard failed: %d\n", GetLastError());
    data = GetClipboardData( CF_UNICODETEXT );
    ok( data != NULL, "GetClipboardData failed: %d\n", GetLastError());
    r = CloseClipboard();
    ok(r, "CloseClipboard failed: %d\n", GetLastError());
}

Referenced by START_TEST().

grab_clipboard_process()

static void grab_clipboard_process ( int  arg )

static

Definition at line 128 of file clipboard.c.

{
    BOOL ret;
 
    SetLastError( 0xdeadbeef );
    ret = OpenClipboard( 0 );
    ok( ret, "OpenClipboard failed\n" );
    ret = EmptyClipboard();
    ok( ret, "EmptyClipboard failed\n" );
    if (arg)
    {
        HANDLE ret = SetClipboardData( CF_WAVE, GlobalAlloc( GMEM_DDESHARE | GMEM_ZEROINIT, 100 ));
        ok( ret != 0, "process %u: SetClipboardData failed err %u\n", arg, GetLastError() );
    }
}

Referenced by START_TEST().

is_fixed()

static BOOL is_fixed ( HANDLE  handle )

static

Definition at line 1331 of file clipboard.c.

{
    void *ptr = GlobalLock( handle );
    if (ptr) GlobalUnlock( handle );
    return ptr && ptr == handle;
}

Referenced by test_data_handles(), test_handles(), test_handles_process(), and test_handles_thread2().

is_freed()

static BOOL is_freed ( HANDLE  handle )

static

Definition at line 1338 of file clipboard.c.

{
    return !GlobalSize( handle );
}

Referenced by test_data_handles(), and test_handles().

is_moveable()

static BOOL is_moveable ( HANDLE  handle )

static

Definition at line 1324 of file clipboard.c.

{
    void *ptr = GlobalLock( handle );
    if (ptr) GlobalUnlock( handle );
    return ptr && ptr != handle;
}

Referenced by test_data_handles(), test_handles(), test_handles_process_open(), and test_handles_thread2().

open_and_empty_clipboard_thread()

static DWORD WINAPI open_and_empty_clipboard_thread ( LPVOID  arg )

static

Definition at line 56 of file clipboard.c.

{
    HWND hWnd = arg;
    ok(OpenClipboard(hWnd), "%u: OpenClipboard failed\n", thread_from_line);
    ok(EmptyClipboard(), "%u: EmptyClipboard failed\n", thread_from_line );
    return 0;
}

Referenced by test_ClipboardOwner().

open_and_empty_clipboard_win_thread()

static DWORD WINAPI open_and_empty_clipboard_win_thread ( LPVOID  arg )

static

Definition at line 64 of file clipboard.c.

{
    HWND hwnd = CreateWindowA( "static", NULL, WS_POPUP, 0, 0, 10, 10, 0, 0, 0, NULL );
    ok(OpenClipboard(hwnd), "%u: OpenClipboard failed\n", thread_from_line);
    ok(EmptyClipboard(), "%u: EmptyClipboard failed\n", thread_from_line );
    return 0;
}

Referenced by test_ClipboardOwner().

open_clipboard_thread()

static DWORD WINAPI open_clipboard_thread ( LPVOID  arg )

static

Definition at line 40 of file clipboard.c.

{
    HWND hWnd = arg;
    ok(OpenClipboard(hWnd), "%u: OpenClipboard failed\n", thread_from_line);
    return 0;
}

Referenced by test_ClipboardOwner().

renderer_winproc()

static LRESULT CALLBACK renderer_winproc ( HWND  hwnd, UINT  msg, WPARAM  wp, LPARAM  lp  )

static

Definition at line 568 of file clipboard.c.

{
    static UINT rendered;
    UINT ret;
 
    switch (msg)
    {
    case WM_RENDERFORMAT:
        if (wp < 32) rendered |= (1 << wp);
        break;
    case WM_USER:
        ret = rendered;
        rendered = 0;
        return ret;
    }
    return DefWindowProcA( hwnd, msg, wp, lp );
}

Referenced by test_synthesized().

run_process()

static void run_process ( const char *  args )

static

Definition at line 166 of file clipboard.c.

{
    char cmd[MAX_PATH];
    PROCESS_INFORMATION info;
    STARTUPINFOA startup;
 
    sprintf( cmd, "%s clipboard %s", argv0, args );
    memset( &startup, 0, sizeof(startup) );
    startup.cb = sizeof(startup);
    ok( CreateProcessA( NULL, cmd, NULL, NULL, FALSE, 0, NULL, NULL, &startup, &info ),
        "CreateProcess %s failed\n", cmd );
 
    winetest_wait_child_process( info.hProcess );
    CloseHandle( info.hProcess );
    CloseHandle( info.hThread );
}

Referenced by clipboard_thread(), test_ClipboardOwner(), test_data_handles(), and test_string_data().

run_thread()

static void run_thread ( LPTHREAD_START_ROUTINE  func, void *  arg, int  line  )

static

Definition at line 144 of file clipboard.c.

{
    DWORD ret;
    HANDLE thread;
 
    thread_from_line = line;
    thread = CreateThread(NULL, 0, func, arg, 0, NULL);
    ok(thread != NULL, "%u: CreateThread failed with error %d\n", line, GetLastError());
    for (;;)
    {
        ret = MsgWaitForMultipleObjectsEx( 1, &thread, 1000, QS_ALLINPUT, 0 );
        if (ret == WAIT_OBJECT_0 + 1)
        {
            MSG msg;
            while (PeekMessageW( &msg, 0, 0, 0, PM_REMOVE )) DispatchMessageW( &msg );
        }
        else break;
    }
    ok(ret == WAIT_OBJECT_0, "%u: expected WAIT_OBJECT_0, got %u\n", line, ret);
    CloseHandle(thread);
}

Referenced by test_ClipboardOwner(), and test_data_handles().

set_clipboard_data_process()

static void set_clipboard_data_process ( int  arg )

static

Definition at line 104 of file clipboard.c.

{
    HANDLE ret;
 
    SetLastError( 0xdeadbeef );
    if (arg)
    {
        ok( IsClipboardFormatAvailable( CF_WAVE ), "process %u: CF_WAVE not available\n", arg );
        ret = SetClipboardData( CF_WAVE, GlobalAlloc( GMEM_DDESHARE | GMEM_ZEROINIT, 100 ));
        ok( ret != 0, "process %u: SetClipboardData failed err %u\n", arg, GetLastError() );
    }
    else
    {
        SetClipboardData( CF_WAVE, 0 );
        ok( GetLastError() == ERROR_CLIPBOARD_NOT_OPEN, "process %u: wrong error %u\n",
            arg, GetLastError());
        ok( !IsClipboardFormatAvailable( CF_WAVE ), "process %u: SetClipboardData succeeded\n", arg );
        ret = SetClipboardData( CF_WAVE, GlobalAlloc( GMEM_DDESHARE | GMEM_ZEROINIT, 100 ));
        ok( !ret, "process %u: SetClipboardData succeeded\n", arg );
        ok( GetLastError() == ERROR_CLIPBOARD_NOT_OPEN, "process %u: wrong error %u\n",
            arg, GetLastError());
    }
}

Referenced by START_TEST().

set_clipboard_data_thread()

static DWORD WINAPI set_clipboard_data_thread ( LPVOID  arg )

static

Definition at line 72 of file clipboard.c.

{
    HWND hwnd = arg;
    HANDLE ret;
 
    SetLastError( 0xdeadbeef );
    if (GetClipboardOwner() == hwnd)
    {
        SetClipboardData( CF_WAVE, 0 );
        ok( IsClipboardFormatAvailable( CF_WAVE ), "%u: SetClipboardData failed\n", thread_from_line );
        ret = SetClipboardData( CF_WAVE, GlobalAlloc( GMEM_DDESHARE | GMEM_ZEROINIT, 100 ));
        ok( ret != 0, "%u: SetClipboardData failed err %u\n", thread_from_line, GetLastError() );
        SetLastError( 0xdeadbeef );
        ret = GetClipboardData( CF_WAVE );
        ok( !ret, "%u: GetClipboardData succeeded\n", thread_from_line );
        ok( GetLastError() == ERROR_CLIPBOARD_NOT_OPEN, "%u: wrong error %u\n",
            thread_from_line, GetLastError());
    }
    else
    {
        SetClipboardData( CF_WAVE, 0 );
        ok( GetLastError() == ERROR_CLIPBOARD_NOT_OPEN, "%u: wrong error %u\n",
            thread_from_line, GetLastError());
        ok( !IsClipboardFormatAvailable( CF_WAVE ), "%u: SetClipboardData succeeded\n", thread_from_line );
        ret = SetClipboardData( CF_WAVE, GlobalAlloc( GMEM_DDESHARE | GMEM_ZEROINIT, 100 ));
        ok( !ret, "%u: SetClipboardData succeeded\n", thread_from_line );
        ok( GetLastError() == ERROR_CLIPBOARD_NOT_OPEN, "%u: wrong error %u\n",
            thread_from_line, GetLastError());
    }
    return 0;
}

Referenced by test_ClipboardOwner().

START_TEST()

START_TEST

(

clipboard

)

Definition at line 2150 of file clipboard.c.

{
    char **argv;
    int argc = winetest_get_mainargs( &argv );
    HMODULE mod = GetModuleHandleA( "user32" );
 
    argv0 = argv[0];
    pAddClipboardFormatListener = (void *)GetProcAddress( mod, "AddClipboardFormatListener" );
    pRemoveClipboardFormatListener = (void *)GetProcAddress( mod, "RemoveClipboardFormatListener" );
    pGetUpdatedClipboardFormats = (void *)GetProcAddress( mod, "GetUpdatedClipboardFormats" );
 
    if (argc == 4 && !strcmp( argv[2], "set_clipboard_data" ))
    {
        set_clipboard_data_process( atoi( argv[3] ));
        return;
    }
    if (argc == 4 && !strcmp( argv[2], "grab_clipboard" ))
    {
        grab_clipboard_process( atoi( argv[3] ));
        return;
    }
    if (argc == 4 && !strcmp( argv[2], "handles" ))
    {
        test_handles_process( argv[3] );
        return;
    }
    if (argc == 4 && !strcmp( argv[2], "handles_open" ))
    {
        test_handles_process_open( argv[3] );
        return;
    }
    if (argc == 4 && !strcmp( argv[2], "handles_dib" ))
    {
        test_handles_process_dib( argv[3] );
        return;
    }
    if (argc == 4 && !strcmp( argv[2], "string_data" ))
    {
        test_string_data_process( atoi( argv[3] ));
        return;
    }
    if (argc == 3 && !strcmp( argv[2], "get_clipboard_data" ))
    {
        get_clipboard_data_process( );
        return;
    }
 
    test_RegisterClipboardFormatA();
    test_ClipboardOwner();
    test_synthesized();
    test_messages();
    test_data_handles();
    test_GetUpdatedClipboardFormats();
    test_string_data();
}

test_ClipboardOwner()

static void test_ClipboardOwner ( void  )

static

Definition at line 226 of file clipboard.c.

{
    HWND hWnd1, hWnd2;
    BOOL ret;
 
    SetLastError(0xdeadbeef);
    ok(!GetClipboardOwner() && GetLastError() == 0xdeadbeef,
       "could not perform clipboard test: clipboard already owned\n");
 
    hWnd1 = CreateWindowExA(0, "static", NULL, WS_POPUP,
                                 0, 0, 10, 10, 0, 0, 0, NULL);
    ok(hWnd1 != 0, "CreateWindowExA error %d\n", GetLastError());
    trace("hWnd1 = %p\n", hWnd1);
 
    hWnd2 = CreateWindowExA(0, "static", NULL, WS_POPUP,
                                 0, 0, 10, 10, 0, 0, 0, NULL);
    ok(hWnd2 != 0, "CreateWindowExA error %d\n", GetLastError());
    trace("hWnd2 = %p\n", hWnd2);
 
    SetLastError(0xdeadbeef);
    ok(!CloseClipboard(), "CloseClipboard should fail if clipboard wasn't open\n");
    ok(GetLastError() == ERROR_CLIPBOARD_NOT_OPEN || broken(GetLastError() == 0xdeadbeef), /* wow64 */
       "wrong error %u\n", GetLastError());
 
    ok(OpenClipboard(0), "OpenClipboard failed\n");
    ok(!GetClipboardOwner(), "clipboard should still be not owned\n");
    ok(!OpenClipboard(hWnd1), "OpenClipboard should fail since clipboard already opened\n");
    ok(OpenClipboard(0), "OpenClipboard again failed\n");
    ret = CloseClipboard();
    ok( ret, "CloseClipboard error %d\n", GetLastError());
 
    ok(OpenClipboard(hWnd1), "OpenClipboard failed\n");
    run_thread( open_clipboard_thread, hWnd1, __LINE__ );
    run_thread( empty_clipboard_thread, 0, __LINE__ );
    run_thread( set_clipboard_data_thread, hWnd1, __LINE__ );
    ok( !IsClipboardFormatAvailable( CF_WAVE ), "CF_WAVE available\n" );
    ok( !GetClipboardData( CF_WAVE ), "CF_WAVE data available\n" );
    run_process( "set_clipboard_data 0" );
    ok(!CloseClipboard(), "CloseClipboard should fail if clipboard wasn't open\n");
    ok(OpenClipboard(hWnd1), "OpenClipboard failed\n");
 
    SetLastError(0xdeadbeef);
    ret = OpenClipboard(hWnd2);
    ok(!ret && (GetLastError() == 0xdeadbeef || GetLastError() == ERROR_ACCESS_DENIED),
       "OpenClipboard should fail without setting last error value, or with ERROR_ACCESS_DENIED, got error %d\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    ok(!GetClipboardOwner() && GetLastError() == 0xdeadbeef, "clipboard should still be not owned\n");
    ret = EmptyClipboard();
    ok( ret, "EmptyClipboard error %d\n", GetLastError());
    ok(GetClipboardOwner() == hWnd1, "clipboard should be owned by %p, not by %p\n", hWnd1, GetClipboardOwner());
    run_thread( empty_clipboard_thread, 0, __LINE__ );
    run_thread( set_clipboard_data_thread, hWnd1, __LINE__ );
    ok( IsClipboardFormatAvailable( CF_WAVE ), "CF_WAVE not available\n" );
    ok( GetClipboardData( CF_WAVE ) != 0, "CF_WAVE data not available\n" );
    run_process( "set_clipboard_data 1" );
 
    SetLastError(0xdeadbeef);
    ret = OpenClipboard(hWnd2);
    ok(!ret && (GetLastError() == 0xdeadbeef || GetLastError() == ERROR_ACCESS_DENIED),
       "OpenClipboard should fail without setting last error value, or with ERROR_ACCESS_DENIED, got error %d\n", GetLastError());
 
    ret = CloseClipboard();
    ok( ret, "CloseClipboard error %d\n", GetLastError());
    ok(GetClipboardOwner() == hWnd1, "clipboard should still be owned\n");
 
    /* any window will do, even from a different process */
    ret = OpenClipboard( GetDesktopWindow() );
    ok( ret, "OpenClipboard error %d\n", GetLastError());
    ret = EmptyClipboard();
    ok( ret, "EmptyClipboard error %d\n", GetLastError());
    ok( GetClipboardOwner() == GetDesktopWindow(), "wrong owner %p/%p\n",
        GetClipboardOwner(), GetDesktopWindow() );
    run_thread( set_clipboard_data_thread, GetDesktopWindow(), __LINE__ );
    ok( IsClipboardFormatAvailable( CF_WAVE ), "CF_WAVE not available\n" );
    ok( GetClipboardData( CF_WAVE ) != 0, "CF_WAVE data not available\n" );
    run_process( "set_clipboard_data 2" );
    ret = CloseClipboard();
    ok( ret, "CloseClipboard error %d\n", GetLastError());
 
    ret = OpenClipboard( hWnd1 );
    ok( ret, "OpenClipboard error %d\n", GetLastError());
    ret = EmptyClipboard();
    ok( ret, "EmptyClipboard error %d\n", GetLastError());
    SetClipboardData( CF_WAVE, 0 );
    SetClipboardViewer( hWnd1 );
    ok( GetClipboardOwner() == hWnd1, "wrong owner %p/%p\n", GetClipboardOwner(), hWnd1 );
    ok( GetClipboardViewer() == hWnd1, "wrong viewer %p/%p\n", GetClipboardViewer(), hWnd1 );
    ok( GetOpenClipboardWindow() == hWnd1, "wrong open win %p/%p\n", GetOpenClipboardWindow(), hWnd1 );
    ok( IsClipboardFormatAvailable( CF_WAVE ), "CF_WAVE not available\n" );
 
    old_proc = (WNDPROC)SetWindowLongPtrA( hWnd1, GWLP_WNDPROC, (LONG_PTR)winproc_wrapper );
    ret = DestroyWindow(hWnd1);
    ok( ret, "DestroyWindow error %d\n", GetLastError());
    ret = DestroyWindow(hWnd2);
    ok( ret, "DestroyWindow error %d\n", GetLastError());
    SetLastError(0xdeadbeef);
    ok(!GetClipboardOwner() && GetLastError() == 0xdeadbeef, "clipboard should not be owned\n");
    ok(!GetClipboardViewer() && GetLastError() == 0xdeadbeef, "viewer still exists\n");
    ok(!GetOpenClipboardWindow() && GetLastError() == 0xdeadbeef, "clipboard should not be open\n");
    ok( !IsClipboardFormatAvailable( CF_WAVE ), "CF_WAVE available\n" );
 
    SetLastError( 0xdeadbeef );
    ret = CloseClipboard();
    ok( !ret, "CloseClipboard succeeded\n" );
    ok( GetLastError() == ERROR_CLIPBOARD_NOT_OPEN, "wrong error %u\n", GetLastError() );
 
    ret = OpenClipboard( 0 );
    ok( ret, "OpenClipboard error %d\n", GetLastError());
    run_thread( set_clipboard_data_thread, 0, __LINE__ );
    ok( IsClipboardFormatAvailable( CF_WAVE ), "CF_WAVE not available\n" );
    ok( GetClipboardData( CF_WAVE ) != 0, "CF_WAVE data not available\n" );
    run_process( "set_clipboard_data 3" );
    ret = CloseClipboard();
    ok( ret, "CloseClipboard error %d\n", GetLastError());
 
    run_thread( open_and_empty_clipboard_thread, 0, __LINE__ );
    ok( !GetOpenClipboardWindow(), "wrong open window %p\n", GetOpenClipboardWindow() );
    ok( !GetClipboardOwner(), "wrong owner window %p\n", GetClipboardOwner() );
 
    ret = OpenClipboard( 0 );
    ok( ret, "OpenClipboard error %d\n", GetLastError());
    run_thread( set_clipboard_data_thread, 0, __LINE__ );
    ok( IsClipboardFormatAvailable( CF_WAVE ), "CF_WAVE not available\n" );
    ok( GetClipboardData( CF_WAVE ) != 0, "CF_WAVE data not available\n" );
    run_process( "set_clipboard_data 4" );
    ret = EmptyClipboard();
    ok( ret, "EmptyClipboard error %d\n", GetLastError());
    ret = CloseClipboard();
    ok( ret, "CloseClipboard error %d\n", GetLastError());
 
    SetLastError( 0xdeadbeef );
    ok( !SetClipboardData( CF_WAVE, GlobalAlloc( GMEM_DDESHARE | GMEM_ZEROINIT, 100 )),
        "SetClipboardData succeeded\n" );
    ok( GetLastError() == ERROR_CLIPBOARD_NOT_OPEN, "wrong error %u\n", GetLastError() );
    ok( !IsClipboardFormatAvailable( CF_WAVE ), "SetClipboardData succeeded\n" );
 
    run_thread( open_and_empty_clipboard_thread, GetDesktopWindow(), __LINE__ );
    ok( !GetOpenClipboardWindow(), "wrong open window %p\n", GetOpenClipboardWindow() );
    ok( GetClipboardOwner() == GetDesktopWindow(), "wrong owner window %p / %p\n",
        GetClipboardOwner(), GetDesktopWindow() );
 
    run_thread( open_and_empty_clipboard_win_thread, 0, __LINE__ );
    ok( !GetOpenClipboardWindow(), "wrong open window %p\n", GetOpenClipboardWindow() );
    ok( !GetClipboardOwner(), "wrong owner window %p\n", GetClipboardOwner() );
}

Referenced by START_TEST().

test_data_handles()

static void test_data_handles ( void  )

static

Definition at line 1792 of file clipboard.c.

{
    BOOL r;
    char *ptr;
    HANDLE h, text;
    HWND hwnd = CreateWindowA( "static", NULL, WS_POPUP, 0, 0, 10, 10, 0, 0, 0, NULL );
    BITMAPINFO bmi;
    void *bits;
 
    ok( hwnd != 0, "window creation failed\n" );
    format_id = RegisterClipboardFormatA( "my_cool_clipboard_format" );
    test_handles( 0 );
    test_handles( GetDesktopWindow() );
    test_handles( hwnd );
    run_thread( test_handles_thread, hwnd, __LINE__ );
 
    bitmap = CreateBitmap( 13, 17, 1, 1, NULL );
    bitmap2 = CreateBitmap( 10, 10, 1, 1, NULL );
    palette = CreatePalette( &logpalette );
 
    r = OpenClipboard( hwnd );
    ok( r, "gle %d\n", GetLastError() );
    r = EmptyClipboard();
    ok( r, "gle %d\n", GetLastError() );
    h = SetClipboardData( CF_TEXT, create_textA() );
    ok( is_moveable( h ), "expected moveable mem %p\n", h );
    h = SetClipboardData( format_id, create_textA() );
    ok( is_moveable( h ), "expected moveable mem %p\n", h );
    h = SetClipboardData( CF_BITMAP, bitmap );
    ok( GetObjectType( h ) == OBJ_BITMAP, "expected bitmap %p\n", h );
    h = SetClipboardData( CF_DSPBITMAP, bitmap2 );
    ok( GetObjectType( h ) == OBJ_BITMAP, "expected bitmap %p\n", h );
    h = SetClipboardData( CF_PALETTE, palette );
    ok( GetObjectType( h ) == OBJ_PAL, "expected palette %p\n", h );
    h = SetClipboardData( CF_METAFILEPICT, create_metafile() );
    ok( is_moveable( h ), "expected moveable mem %p\n", h );
    trace( "metafile %p\n", h );
    h = SetClipboardData( CF_DSPMETAFILEPICT, create_metafile() );
    ok( is_moveable( h ), "expected moveable mem %p\n", h );
    trace( "metafile2 %p\n", h );
    h = SetClipboardData( CF_ENHMETAFILE, create_emf() );
    ok( GetObjectType( h ) == OBJ_ENHMETAFILE, "expected enhmetafile %p\n", h );
    trace( "enhmetafile %p\n", h );
    h = SetClipboardData( CF_DSPENHMETAFILE, create_emf() );
    ok( GetObjectType( h ) == OBJ_ENHMETAFILE, "expected enhmetafile %p\n", h );
    trace( "enhmetafile2 %p\n", h );
    h = SetClipboardData( CF_GDIOBJFIRST + 3, create_textA() );
    ok( is_moveable( h ), "expected moveable mem %p\n", h );
    h = SetClipboardData( CF_PRIVATEFIRST + 7, create_textA() );
    ok( is_moveable( h ), "expected moveable mem %p\n", h );
    r = CloseClipboard();
    ok( r, "gle %d\n", GetLastError() );
 
    run_thread( test_handles_thread2, 0, __LINE__ );
    run_process( "handles test" );
 
    r = OpenClipboard( hwnd );
    ok( r, "gle %d\n", GetLastError() );
    h = GetClipboardData( CF_TEXT );
    ok( is_moveable( h ), "expected moveable mem %p\n", h );
    h = GetClipboardData( format_id );
    ok( is_moveable( h ), "expected moveable mem %p\n", h );
    h = GetClipboardData( CF_GDIOBJFIRST + 3 );
    ok( is_moveable( h ), "expected moveable mem %p\n", h );
    h = GetClipboardData( CF_PRIVATEFIRST + 7 );
    ok( is_moveable( h ), "expected moveable mem %p\n", h );
 
    r = EmptyClipboard();
    ok( r, "gle %d\n", GetLastError() );
    text = create_textA();
    h = SetClipboardData( CF_TEXT, text );
    ok( is_moveable( h ), "expected moveable mem %p\n", h );
 
    run_process( "handles_open foobar" );
 
    ok( is_moveable( text ), "expected moveable mem %p\n", text );
    h = GetClipboardData( CF_TEXT );
    ok( is_fixed( h ), "expected fixed mem %p\n", h );
    ok( is_moveable( text ), "expected moveable mem %p\n", text );
    ptr = GlobalLock( h );
    ok( !strcmp( ptr, "foobar" ), "wrong data '%.8s'\n", ptr );
    GlobalUnlock( h );
 
    r = EmptyClipboard();
    ok( r, "gle %d\n", GetLastError() );
    ok( is_fixed( h ), "expected free mem %p\n", h );
    ok( is_freed( text ) || broken( is_moveable(text) ), /* w2003, w2008 */
        "expected free mem %p\n", text );
    r = CloseClipboard();
    ok( r, "gle %d\n", GetLastError() );
 
    /* test CF_BITMAP with a DIB section */
    memset( &bmi, 0, sizeof(bmi) );
    bmi.bmiHeader.biSize = sizeof( bmi.bmiHeader );
    bmi.bmiHeader.biWidth = 29;
    bmi.bmiHeader.biHeight = 13;
    bmi.bmiHeader.biPlanes = 1;
    bmi.bmiHeader.biBitCount = 32;
    bitmap = CreateDIBSection( 0, &bmi, DIB_RGB_COLORS, &bits, 0, 0 );
 
    r = OpenClipboard( hwnd );
    ok( r, "gle %d\n", GetLastError() );
    r = EmptyClipboard();
    ok( r, "gle %d\n", GetLastError() );
    h = SetClipboardData( CF_BITMAP, bitmap );
    ok( GetObjectType( h ) == OBJ_BITMAP, "expected bitmap %p\n", h );
    trace( "dibsection %p\n", h );
    r = CloseClipboard();
    ok( r, "gle %d\n", GetLastError() );
 
    run_process( "handles_dib dummy" );
 
    r = OpenClipboard( hwnd );
    ok( r, "gle %d\n", GetLastError() );
    ok( GetObjectType( bitmap ) == OBJ_BITMAP, "expected bitmap %p\n", bitmap );
    r = EmptyClipboard();
    ok( r, "gle %d\n", GetLastError() );
    ok( !GetObjectType( bitmap ), "expected deleted %p\n", bitmap );
    r = CloseClipboard();
    ok( r, "gle %d\n", GetLastError() );
 
    DestroyWindow( hwnd );
}

Referenced by START_TEST().

test_GetUpdatedClipboardFormats()

static void test_GetUpdatedClipboardFormats ( void  )

static

Definition at line 1916 of file clipboard.c.

{
    BOOL r;
    UINT count, formats[256];
 
    if (!pGetUpdatedClipboardFormats)
    {
        win_skip( "GetUpdatedClipboardFormats not supported\n" );
        return;
    }
 
    count = 0xdeadbeef;
    r = pGetUpdatedClipboardFormats( NULL, 0, &count );
    ok( r, "gle %d\n", GetLastError() );
    ok( !count, "wrong count %u\n", count );
 
    count = 0xdeadbeef;
    r = pGetUpdatedClipboardFormats( NULL, 256, &count );
    ok( r, "gle %d\n", GetLastError() );
    ok( !count, "wrong count %u\n", count );
 
    SetLastError( 0xdeadbeef );
    r = pGetUpdatedClipboardFormats( formats, 256, NULL );
    ok( !r, "succeeded\n" );
    ok( GetLastError() == ERROR_NOACCESS, "wrong error %u\n", GetLastError() );
 
    count = 0xdeadbeef;
    r = pGetUpdatedClipboardFormats( formats, 256, &count );
    ok( r, "gle %d\n", GetLastError() );
    ok( !count, "wrong count %u\n", count );
 
    r = OpenClipboard( 0 );
    ok( r, "gle %d\n", GetLastError() );
    r = EmptyClipboard();
    ok( r, "gle %d\n", GetLastError() );
 
    count = 0xdeadbeef;
    r = pGetUpdatedClipboardFormats( formats, 256, &count );
    ok( r, "gle %d\n", GetLastError() );
    ok( !count, "wrong count %u\n", count );
 
    SetClipboardData( CF_UNICODETEXT, 0 );
 
    count = 0xdeadbeef;
    memset( formats, 0xcc, sizeof(formats) );
    r = pGetUpdatedClipboardFormats( formats, 256, &count );
    ok( r, "gle %d\n", GetLastError() );
    ok( count == 1, "wrong count %u\n", count );
    ok( formats[0] == CF_UNICODETEXT, "wrong format %u\n", formats[0] );
    ok( formats[1] == 0xcccccccc, "wrong format %u\n", formats[1] );
 
    SetClipboardData( CF_TEXT, 0 );
    count = 0xdeadbeef;
    memset( formats, 0xcc, sizeof(formats) );
    r = pGetUpdatedClipboardFormats( formats, 256, &count );
    ok( r, "gle %d\n", GetLastError() );
    ok( count == 2, "wrong count %u\n", count );
    ok( formats[0] == CF_UNICODETEXT, "wrong format %u\n", formats[0] );
    ok( formats[1] == CF_TEXT, "wrong format %u\n", formats[1] );
    ok( formats[2] == 0xcccccccc, "wrong format %u\n", formats[2] );
 
    SetLastError( 0xdeadbeef );
    count = 0xdeadbeef;
    r = pGetUpdatedClipboardFormats( formats, 0, &count );
    ok( !r, "succeeded\n" );
    ok( GetLastError() == ERROR_INSUFFICIENT_BUFFER, "wrong error %u\n", GetLastError() );
    ok( count == 2, "wrong count %u\n", count );
 
    SetLastError( 0xdeadbeef );
    count = 0xdeadbeef;
    r = pGetUpdatedClipboardFormats( formats, 1, &count );
    ok( !r, "succeeded\n" );
    ok( GetLastError() == ERROR_INSUFFICIENT_BUFFER, "wrong error %u\n", GetLastError() );
    ok( count == 2, "wrong count %u\n", count );
 
    r = CloseClipboard();
    ok( r, "gle %d\n", GetLastError() );
 
    count = 0xdeadbeef;
    memset( formats, 0xcc, sizeof(formats) );
    r = pGetUpdatedClipboardFormats( formats, 256, &count );
    ok( r, "gle %d\n", GetLastError() );
    ok( count == 4, "wrong count %u\n", count );
    ok( formats[0] == CF_UNICODETEXT, "wrong format %u\n", formats[0] );
    ok( formats[1] == CF_TEXT, "wrong format %u\n", formats[1] );
    ok( formats[2] == CF_LOCALE, "wrong format %u\n", formats[2] );
    ok( formats[3] == CF_OEMTEXT, "wrong format %u\n", formats[3] );
    ok( formats[4] == 0xcccccccc, "wrong format %u\n", formats[4] );
 
    count = 0xdeadbeef;
    memset( formats, 0xcc, sizeof(formats) );
    r = pGetUpdatedClipboardFormats( formats, 2, &count );
    ok( !r, "gle %d\n", GetLastError() );
    ok( GetLastError() == ERROR_INSUFFICIENT_BUFFER, "wrong error %u\n", GetLastError() );
    ok( count == 4, "wrong count %u\n", count );
    ok( formats[0] == 0xcccccccc, "wrong format %u\n", formats[0] );
 
    count = 0xdeadbeef;
    r = pGetUpdatedClipboardFormats( NULL, 256, &count );
    ok( !r, "gle %d\n", GetLastError() );
    ok( GetLastError() == ERROR_NOACCESS, "wrong error %u\n", GetLastError() );
    ok( count == 4, "wrong count %u\n", count );
 
    count = 0xdeadbeef;
    r = pGetUpdatedClipboardFormats( NULL, 256, &count );
    ok( !r, "gle %d\n", GetLastError() );
    ok( GetLastError() == ERROR_NOACCESS, "wrong error %u\n", GetLastError() );
    ok( count == 4, "wrong count %u\n", count );
}

Referenced by START_TEST().

test_handles()

static void test_handles ( HWND  hwnd )

static

Definition at line 1348 of file clipboard.c.

{
    HGLOBAL h, htext, htext2, htext3, htext4, htext5;
    HGLOBAL hfixed, hfixed2, hmoveable, empty_fixed, empty_moveable;
    void *ptr;
    UINT format_id2 = RegisterClipboardFormatA( "another format" );
    BOOL r;
    HANDLE data;
    HBITMAP bitmap_temp;
    DWORD process;
    BOOL is_owner = (GetWindowThreadProcessId( hwnd, &process ) && process == GetCurrentProcessId());
 
    trace( "hwnd %p\n", hwnd );
    htext = create_textA();
    htext2 = create_textA();
    htext3 = create_textA();
    htext4 = create_textA();
    htext5 = create_textA();
    bitmap = CreateBitmap( 10, 10, 1, 1, NULL );
    bitmap2 = CreateBitmap( 10, 10, 1, 1, NULL );
    palette = CreatePalette( &logpalette );
 
    hfixed = GlobalAlloc( GMEM_FIXED, 17 );
    hfixed2 = GlobalAlloc( GMEM_FIXED, 17 );
    ok( is_fixed( hfixed ), "expected fixed mem %p\n", hfixed );
    ok( GlobalSize( hfixed ) == 17, "wrong size %lu\n", GlobalSize( hfixed ));
 
    hmoveable = GlobalAlloc( GMEM_MOVEABLE, 23 );
    ok( is_moveable( hmoveable ), "expected moveable mem %p\n", hmoveable );
    ok( GlobalSize( hmoveable ) == 23, "wrong size %lu\n", GlobalSize( hmoveable ));
 
    empty_fixed = GlobalAlloc( GMEM_FIXED, 0 );
    ok( is_fixed( empty_fixed ), "expected fixed mem %p\n", empty_fixed );
 
    empty_moveable = GlobalAlloc( GMEM_MOVEABLE, 0 );
    /* discarded handles can't be GlobalLock'ed */
    ok( is_freed( empty_moveable ), "expected free mem %p\n", empty_moveable );
 
    r = OpenClipboard( hwnd );
    ok( r, "gle %d\n", GetLastError() );
    r = EmptyClipboard();
    ok( r, "gle %d\n", GetLastError() );
 
    h = SetClipboardData( CF_TEXT, htext );
    ok( h == htext, "got %p\n", h );
    ok( is_moveable( h ), "expected moveable mem %p\n", h );
    h = SetClipboardData( format_id, htext2 );
    ok( h == htext2, "got %p\n", h );
    ok( is_moveable( h ), "expected moveable mem %p\n", h );
    bitmap_temp = CreateBitmap( 10, 10, 1, 1, NULL );
    h = SetClipboardData( CF_BITMAP, bitmap_temp );
    ok( h == bitmap_temp, "got %p\n", h );
    ok( GetObjectType( h ) == OBJ_BITMAP, "expected bitmap %p\n", h );
    h = SetClipboardData( CF_BITMAP, bitmap );
    ok( h == bitmap, "got %p\n", h );
    ok( GetObjectType( h ) == OBJ_BITMAP, "expected bitmap %p\n", h );
    ok( !GetObjectType( bitmap_temp ), "expected free object %p\n", bitmap_temp );
    h = SetClipboardData( CF_DSPBITMAP, bitmap2 );
    ok( h == bitmap2, "got %p\n", h );
    ok( GetObjectType( h ) == OBJ_BITMAP, "expected bitmap %p\n", h );
    h = SetClipboardData( CF_PALETTE, palette );
    ok( h == palette, "got %p\n", h );
    ok( GetObjectType( h ) == OBJ_PAL, "expected palette %p\n", h );
    h = SetClipboardData( CF_GDIOBJFIRST + 3, htext3 );
    ok( h == htext3, "got %p\n", h );
    ok( is_moveable( h ), "expected moveable mem %p\n", h );
    h = SetClipboardData( CF_PRIVATEFIRST + 7, htext5 );
    ok( h == htext5, "got %p\n", h );
    ok( is_moveable( h ), "expected moveable mem %p\n", h );
    h = SetClipboardData( format_id2, empty_moveable );
    ok( !h, "got %p\n", h );
    GlobalFree( empty_moveable );
 
    if (0)  /* crashes on vista64 */
    {
        ptr = HeapAlloc( GetProcessHeap(), 0, 0 );
        h = SetClipboardData( format_id2, ptr );
        ok( !h, "got %p\n", h );
        HeapFree( GetProcessHeap(), 0, ptr );
    }
 
    h = SetClipboardData( format_id2, empty_fixed );
    ok( h == empty_fixed, "got %p\n", h );
    ok( is_fixed( h ), "expected fixed mem %p\n", h );
    h = SetClipboardData( 0xdeadbeef, hfixed2 );
    ok( h == hfixed2, "got %p\n", h );
    ok( is_fixed( h ), "expected fixed mem %p\n", h );
    h = SetClipboardData( 0xdeadbabe, hmoveable );
    ok( h == hmoveable, "got %p\n", h );
    ok( is_moveable( h ), "expected moveable mem %p\n", h );
 
    ptr = HeapAlloc( GetProcessHeap(), 0, 37 );
    h = SetClipboardData( 0xdeadfade, ptr );
    ok( h == ptr || !h, "got %p\n", h );
    if (!h)  /* heap blocks are rejected on >= win8 */
    {
        HeapFree( GetProcessHeap(), 0, ptr );
        ptr = NULL;
    }
 
    data = GetClipboardData( CF_TEXT );
    ok( data == htext, "wrong data %p\n", data );
    ok( is_moveable( data ), "expected moveable mem %p\n", data );
 
    data = GetClipboardData( format_id );
    ok( data == htext2, "wrong data %p, cf %08x\n", data, format_id );
    ok( is_moveable( data ), "expected moveable mem %p\n", data );
 
    data = GetClipboardData( CF_GDIOBJFIRST + 3 );
    ok( data == htext3, "wrong data %p\n", data );
    ok( is_moveable( data ), "expected moveable mem %p\n", data );
 
    data = GetClipboardData( CF_PRIVATEFIRST + 7 );
    ok( data == htext5, "wrong data %p\n", data );
    ok( is_moveable( data ), "expected moveable mem %p\n", data );
 
    data = GetClipboardData( format_id2 );
    ok( data == empty_fixed, "wrong data %p\n", data );
    ok( is_fixed( data ), "expected fixed mem %p\n", data );
 
    data = GetClipboardData( 0xdeadbeef );
    ok( data == hfixed2, "wrong data %p\n", data );
    ok( is_fixed( data ), "expected fixed mem %p\n", data );
 
    data = GetClipboardData( 0xdeadbabe );
    ok( data == hmoveable, "wrong data %p\n", data );
    ok( is_moveable( data ), "expected moveable mem %p\n", data );
 
    data = GetClipboardData( 0xdeadfade );
    ok( data == ptr, "wrong data %p\n", data );
 
    h = SetClipboardData( CF_PRIVATEFIRST + 7, htext4 );
    ok( h == htext4, "got %p\n", h );
    ok( is_moveable( h ), "expected moveable mem %p\n", h );
    ok( is_freed( htext5 ), "expected freed mem %p\n", htext5 );
 
    h = SetClipboardData( 0xdeadbeef, hfixed );
    ok( h == hfixed, "got %p\n", h );
    ok( is_fixed( h ), "expected fixed mem %p\n", h );
    if (0) /* this test is unreliable / crashes */
        ok( is_freed( hfixed2 ), "expected freed mem %p\n", hfixed2 );
 
    r = CloseClipboard();
    ok( r, "gle %d\n", GetLastError() );
 
    /* data handles are still valid */
    ok( is_moveable( htext ), "expected moveable mem %p\n", htext );
    ok( is_moveable( htext2 ), "expected moveable mem %p\n", htext2 );
    ok( is_moveable( htext3 ), "expected moveable mem %p\n", htext3 );
    ok( is_moveable( htext4 ), "expected moveable mem %p\n", htext4 );
    ok( GetObjectType( bitmap ) == OBJ_BITMAP, "expected bitmap %p\n", bitmap );
    ok( GetObjectType( bitmap2 ) == OBJ_BITMAP, "expected bitmap %p\n", bitmap2 );
    ok( GetObjectType( palette ) == OBJ_PAL, "expected palette %p\n", palette );
    ok( is_fixed( hfixed ), "expected fixed mem %p\n", hfixed );
    ok( is_moveable( hmoveable ), "expected moveable mem %p\n", hmoveable );
    ok( is_fixed( empty_fixed ), "expected fixed mem %p\n", empty_fixed );
 
    r = OpenClipboard( hwnd );
    ok( r, "gle %d\n", GetLastError() );
 
    /* and now they are freed, unless we are the owner */
    if (!is_owner)
    {
        ok( is_freed( htext ), "expected freed mem %p\n", htext );
        ok( is_freed( htext2 ), "expected freed mem %p\n", htext2 );
        ok( is_freed( htext3 ), "expected freed mem %p\n", htext3 );
        ok( is_freed( htext4 ), "expected freed mem %p\n", htext4 );
        ok( is_freed( hmoveable ), "expected freed mem %p\n", hmoveable );
 
        data = GetClipboardData( CF_TEXT );
        ok( is_fixed( data ), "expected fixed mem %p\n", data );
 
        data = GetClipboardData( format_id );
        ok( is_fixed( data ), "expected fixed mem %p\n", data );
 
        data = GetClipboardData( CF_GDIOBJFIRST + 3 );
        ok( is_fixed( data ), "expected fixed mem %p\n", data );
 
        data = GetClipboardData( CF_PRIVATEFIRST + 7 );
        ok( is_fixed( data ), "expected fixed mem %p\n", data );
 
        data = GetClipboardData( format_id2 );
        ok( is_fixed( data ), "expected fixed mem %p\n", data );
        ok( GlobalSize( data ) == 1, "wrong size %lu\n", GlobalSize( data ));
 
        data = GetClipboardData( 0xdeadbeef );
        ok( is_fixed( data ), "expected fixed mem %p\n", data );
        ok( GlobalSize( data ) == 17, "wrong size %lu\n", GlobalSize( data ));
 
        data = GetClipboardData( 0xdeadbabe );
        ok( is_fixed( data ), "expected fixed mem %p\n", data );
        ok( GlobalSize( data ) == 23, "wrong size %lu\n", GlobalSize( data ));
 
        data = GetClipboardData( 0xdeadfade );
        ok( is_fixed( data ) || !ptr, "expected fixed mem %p\n", data );
        if (ptr) ok( GlobalSize( data ) == 37, "wrong size %lu\n", GlobalSize( data ));
    }
    else
    {
        ok( is_moveable( htext ), "expected moveable mem %p\n", htext );
        ok( is_moveable( htext2 ), "expected moveable mem %p\n", htext2 );
        ok( is_moveable( htext3 ), "expected moveable mem %p\n", htext3 );
        ok( is_moveable( htext4 ), "expected moveable mem %p\n", htext4 );
        ok( is_moveable( hmoveable ), "expected moveable mem %p\n", hmoveable );
 
        data = GetClipboardData( CF_TEXT );
        ok( data == htext, "wrong data %p\n", data );
 
        data = GetClipboardData( format_id );
        ok( data == htext2, "wrong data %p, cf %08x\n", data, format_id );
 
        data = GetClipboardData( CF_GDIOBJFIRST + 3 );
        ok( data == htext3, "wrong data %p\n", data );
 
        data = GetClipboardData( CF_PRIVATEFIRST + 7 );
        ok( data == htext4, "wrong data %p\n", data );
 
        data = GetClipboardData( format_id2 );
        ok( data == empty_fixed, "wrong data %p\n", data );
 
        data = GetClipboardData( 0xdeadbeef );
        ok( data == hfixed, "wrong data %p\n", data );
 
        data = GetClipboardData( 0xdeadbabe );
        ok( data == hmoveable, "wrong data %p\n", data );
 
        data = GetClipboardData( 0xdeadfade );
        ok( data == ptr, "wrong data %p\n", data );
    }
 
    data = GetClipboardData( CF_OEMTEXT );
    ok( is_fixed( data ), "expected fixed mem %p\n", data );
    data = GetClipboardData( CF_UNICODETEXT );
    ok( is_fixed( data ), "expected fixed mem %p\n", data );
    data = GetClipboardData( CF_LOCALE );
    ok( is_fixed( data ), "expected fixed mem %p\n", data );
    data = GetClipboardData( CF_BITMAP );
    ok( data == bitmap, "expected bitmap %p\n", data );
    data = GetClipboardData( CF_DSPBITMAP );
    ok( data == bitmap2, "expected bitmap %p\n", data );
    data = GetClipboardData( CF_PALETTE );
    ok( data == palette, "expected palette %p\n", data );
    data = GetClipboardData( CF_DIB );
    ok( is_fixed( data ), "expected fixed mem %p\n", data );
    data = GetClipboardData( CF_DIBV5 );
    ok( is_fixed( data ), "expected fixed mem %p\n", data );
 
    ok( GetObjectType( bitmap ) == OBJ_BITMAP, "expected bitmap %p\n", bitmap );
    ok( GetObjectType( bitmap2 ) == OBJ_BITMAP, "expected bitmap %p\n", bitmap2 );
    ok( GetObjectType( palette ) == OBJ_PAL, "expected palette %p\n", palette );
    ok( is_fixed( hfixed ), "expected fixed mem %p\n", hfixed );
    ok( is_fixed( empty_fixed ), "expected fixed mem %p\n", empty_fixed );
 
    r = EmptyClipboard();
    ok( r, "gle %d\n", GetLastError() );
 
    /* w2003, w2008 don't seem to free the data here */
    ok( is_freed( htext ) || broken( !is_freed( htext )), "expected freed mem %p\n", htext );
    ok( is_freed( htext2 ) || broken( !is_freed( htext2 )), "expected freed mem %p\n", htext2 );
    ok( is_freed( htext3 ) || broken( !is_freed( htext3 )), "expected freed mem %p\n", htext3 );
    ok( is_freed( htext4 ) || broken( !is_freed( htext4 )), "expected freed mem %p\n", htext4 );
    ok( is_freed( hmoveable ) || broken( !is_freed( hmoveable )), "expected freed mem %p\n", hmoveable );
    ok( is_fixed( empty_fixed ), "expected fixed mem %p\n", empty_fixed );
    ok( is_fixed( hfixed ), "expected fixed mem %p\n", hfixed );
    ok( !GetObjectType( bitmap ), "expected freed handle %p\n", bitmap );
    ok( !GetObjectType( bitmap2 ), "expected freed handle %p\n", bitmap2 );
    ok( !GetObjectType( palette ), "expected freed handle %p\n", palette );
 
    r = CloseClipboard();
    ok( r, "gle %d\n", GetLastError() );
}

test_handles_process()

static void test_handles_process ( const char *  str )

static

Definition at line 1678 of file clipboard.c.

{
    BOOL r;
    HANDLE h;
    char *ptr;
    BITMAP bm;
    PALETTEENTRY entry;
    BYTE buffer[1024];
 
    format_id = RegisterClipboardFormatA( "my_cool_clipboard_format" );
    r = OpenClipboard( 0 );
    ok( r, "gle %d\n", GetLastError() );
    h = GetClipboardData( CF_TEXT );
    ok( is_fixed( h ), "expected fixed mem %p\n", h );
    ptr = GlobalLock( h );
    ok( !strcmp( str, ptr ), "wrong data '%.5s'\n", ptr );
    GlobalUnlock( h );
    h = GetClipboardData( format_id );
    ok( is_fixed( h ), "expected fixed mem %p\n", h );
    ptr = GlobalLock( h );
    if (ptr) ok( !strcmp( str, ptr ), "wrong data '%.5s'\n", ptr );
    GlobalUnlock( h );
    h = GetClipboardData( CF_GDIOBJFIRST + 3 );
    ok( is_fixed( h ), "expected fixed mem %p\n", h );
    ptr = GlobalLock( h );
    ok( !strcmp( str, ptr ), "wrong data '%.5s'\n", ptr );
    GlobalUnlock( h );
    trace( "gdiobj %p\n", h );
    h = GetClipboardData( CF_PRIVATEFIRST + 7 );
    ok( is_fixed( h ), "expected fixed mem %p\n", h );
    ptr = GlobalLock( h );
    ok( !strcmp( str, ptr ), "wrong data '%.5s'\n", ptr );
    GlobalUnlock( h );
    trace( "private %p\n", h );
    h = GetClipboardData( CF_BITMAP );
    ok( GetObjectType( h ) == OBJ_BITMAP, "expected bitmap %p\n", h );
    ok( GetObjectW( h, sizeof(bm), &bm ) == sizeof(bm), "GetObject %p failed\n", h );
    ok( bm.bmWidth == 13 && bm.bmHeight == 17, "wrong bitmap %ux%u\n", bm.bmWidth, bm.bmHeight );
    trace( "bitmap %p\n", h );
    h = GetClipboardData( CF_DSPBITMAP );
    ok( !GetObjectType( h ), "expected invalid object %p\n", h );
    trace( "bitmap2 %p\n", h );
    h = GetClipboardData( CF_PALETTE );
    ok( GetObjectType( h ) == OBJ_PAL, "expected palette %p\n", h );
    ok( GetPaletteEntries( h, 0, 1, &entry ) == 1, "GetPaletteEntries %p failed\n", h );
    ok( entry.peRed == 0x12 && entry.peGreen == 0x34 && entry.peBlue == 0x56,
        "wrong color %02x,%02x,%02x\n", entry.peRed, entry.peGreen, entry.peBlue );
    trace( "palette %p\n", h );
    h = GetClipboardData( CF_METAFILEPICT );
    ok( is_fixed( h ), "expected fixed mem %p\n", h );
#ifdef __REACTOS__
    if (h != NULL)
#endif
    ok( GetObjectType( ((METAFILEPICT *)h)->hMF ) == OBJ_METAFILE,
        "wrong object %p\n", ((METAFILEPICT *)h)->hMF );
    trace( "metafile %p\n", h );
    h = GetClipboardData( CF_DSPMETAFILEPICT );
    ok( is_fixed( h ), "expected fixed mem %p\n", h );
#ifdef __REACTOS__
    if (h != NULL)
#endif
    ok( GetObjectType( ((METAFILEPICT *)h)->hMF ) == OBJ_METAFILE,
        "wrong object %p\n", ((METAFILEPICT *)h)->hMF );
    trace( "metafile2 %p\n", h );
    h = GetClipboardData( CF_ENHMETAFILE );
    ok( GetObjectType( h ) == OBJ_ENHMETAFILE, "expected enhmetafile %p\n", h );
    ok( GetEnhMetaFileBits( h, sizeof(buffer), buffer ) > sizeof(ENHMETAHEADER),
        "GetEnhMetaFileBits failed on %p\n", h );
    ok( ((ENHMETAHEADER *)buffer)->nRecords == 3,
        "wrong records %u\n", ((ENHMETAHEADER *)buffer)->nRecords );
    trace( "enhmetafile %p\n", h );
    h = GetClipboardData( CF_DSPENHMETAFILE );
    ok( GetObjectType( h ) == OBJ_ENHMETAFILE, "expected enhmetafile %p\n", h );
    ok( GetEnhMetaFileBits( h, sizeof(buffer), buffer ) > sizeof(ENHMETAHEADER),
        "GetEnhMetaFileBits failed on %p\n", h );
    ok( ((ENHMETAHEADER *)buffer)->nRecords == 3,
        "wrong records %u\n", ((ENHMETAHEADER *)buffer)->nRecords );
    trace( "enhmetafile2 %p\n", h );
    h = GetClipboardData( CF_DIB );
    ok( is_fixed( h ), "expected fixed mem %p\n", h );
    h = GetClipboardData( CF_DIBV5 );
    ok( is_fixed( h ), "expected fixed mem %p\n", h );
    r = CloseClipboard();
    ok( r, "gle %d\n", GetLastError() );
}

Referenced by START_TEST().

test_handles_process_dib()

static void test_handles_process_dib ( const char *  str )

static

Definition at line 1778 of file clipboard.c.

{
    BOOL r;
    HANDLE h;
 
    r = OpenClipboard( 0 );
    ok( r, "gle %d\n", GetLastError() );
    h = GetClipboardData( CF_BITMAP );
    ok( !GetObjectType( h ), "expected invalid object %p\n", h );
    trace( "dibsection %p\n", h );
    r = CloseClipboard();
    ok( r, "gle %d\n", GetLastError() );
}

Referenced by START_TEST().

test_handles_process_open()

static void test_handles_process_open ( const char *  str )

static

Definition at line 1764 of file clipboard.c.

{
    HANDLE h, text = GlobalAlloc( GMEM_DDESHARE|GMEM_MOVEABLE, strlen(str) + 1 );
    char *ptr = GlobalLock( text );
 
    strcpy( ptr, str );
    GlobalUnlock( text );
 
    /* clipboard already open by parent process */
    h = SetClipboardData( CF_TEXT,  text );
    ok( h == text, "wrong mem %p / %p\n", h, text );
    ok( is_moveable( h ), "expected moveable mem %p\n", h );
}

Referenced by START_TEST().

test_handles_thread()

static DWORD WINAPI test_handles_thread ( void *  arg )

static

Definition at line 1620 of file clipboard.c.

{
    trace( "running from different thread\n" );
    test_handles( (HWND)arg );
    return 0;
}

Referenced by test_data_handles().

test_handles_thread2()

static DWORD WINAPI test_handles_thread2 ( void *  arg )

static

Definition at line 1627 of file clipboard.c.

{
    BOOL r;
    HANDLE h;
    char *ptr;
 
    r = OpenClipboard( 0 );
    ok( r, "gle %d\n", GetLastError() );
    h = GetClipboardData( CF_TEXT );
    ok( is_moveable( h ), "expected moveable mem %p\n", h );
    ptr = GlobalLock( h );
    if (ptr) ok( !strcmp( "test", ptr ), "wrong data '%.5s'\n", ptr );
    GlobalUnlock( h );
    h = GetClipboardData( format_id );
    ok( is_moveable( h ), "expected moveable mem %p\n", h );
    ptr = GlobalLock( h );
    if (ptr) ok( !strcmp( "test", ptr ), "wrong data '%.5s'\n", ptr );
    GlobalUnlock( h );
    h = GetClipboardData( CF_GDIOBJFIRST + 3 );
    ok( is_moveable( h ), "expected moveable mem %p\n", h );
    ptr = GlobalLock( h );
    if (ptr) ok( !strcmp( "test", ptr ), "wrong data '%.5s'\n", ptr );
    GlobalUnlock( h );
    trace( "gdiobj %p\n", h );
    h = GetClipboardData( CF_PRIVATEFIRST + 7 );
    ok( is_moveable( h ), "expected moveable mem %p\n", h );
    ptr = GlobalLock( h );
    if (ptr) ok( !strcmp( "test", ptr ), "wrong data '%.5s'\n", ptr );
    GlobalUnlock( h );
    trace( "private %p\n", h );
    h = GetClipboardData( CF_BITMAP );
    ok( GetObjectType( h ) == OBJ_BITMAP, "expected bitmap %p\n", h );
    ok( h == bitmap, "different bitmap %p / %p\n", h, bitmap );
    trace( "bitmap %p\n", h );
    h = GetClipboardData( CF_DSPBITMAP );
    ok( GetObjectType( h ) == OBJ_BITMAP, "expected bitmap %p\n", h );
    ok( h == bitmap2, "different bitmap %p / %p\n", h, bitmap2 );
    trace( "bitmap2 %p\n", h );
    h = GetClipboardData( CF_PALETTE );
    ok( GetObjectType( h ) == OBJ_PAL, "expected palette %p\n", h );
    ok( h == palette, "different palette %p / %p\n", h, palette );
    trace( "palette %p\n", h );
    h = GetClipboardData( CF_DIB );
    ok( is_fixed( h ), "expected fixed mem %p\n", h );
    h = GetClipboardData( CF_DIBV5 );
    ok( is_fixed( h ), "expected fixed mem %p\n", h );
    r = CloseClipboard();
    ok( r, "gle %d\n", GetLastError() );
    return 0;
}

Referenced by test_data_handles().

test_messages()

static void test_messages ( void  )

static

Definition at line 1277 of file clipboard.c.

{
    WNDCLASSA cls;
    HWND win;
    MSG msg;
    HANDLE thread;
    DWORD tid;
 
    InitializeCriticalSection(&clipboard_cs);
    update_event = CreateEventW(NULL, FALSE, FALSE, NULL);
 
    memset(&cls, 0, sizeof(cls));
    cls.lpfnWndProc = clipboard_wnd_proc;
    cls.hInstance = GetModuleHandleA(NULL);
    cls.lpszClassName = "clipboard_test";
    RegisterClassA(&cls);
 
    win = CreateWindowA("clipboard_test", NULL, 0, 0, 0, 0, 0, NULL, 0, NULL, 0);
    ok(win != NULL, "CreateWindow failed: %d\n", GetLastError());
 
    thread = CreateThread(NULL, 0, clipboard_thread, (void*)win, 0, &tid);
    ok(thread != NULL, "CreateThread failed: %d\n", GetLastError());
 
    while(GetMessageA(&msg, NULL, 0, 0))
    {
        ok( msg.message != WM_DRAWCLIPBOARD, "WM_DRAWCLIPBOARD was posted\n" );
        TranslateMessage(&msg);
        DispatchMessageA(&msg);
    }
 
    ok(WaitForSingleObject(thread, INFINITE) == WAIT_OBJECT_0, "WaitForSingleObject failed\n");
    CloseHandle(thread);
 
    DestroyWindow( win );
 
    /* same tests again but inside a single thread */
 
    win = CreateWindowA( "clipboard_test", NULL, 0, 0, 0, 0, 0, NULL, 0, NULL, 0 );
    ok( win != NULL, "CreateWindow failed: %d\n", GetLastError() );
 
    clipboard_thread( win );
    DestroyWindow( win );
 
    UnregisterClassA("clipboard_test", GetModuleHandleA(NULL));
    DeleteCriticalSection(&clipboard_cs);
}

Referenced by START_TEST().

test_RegisterClipboardFormatA()

static void test_RegisterClipboardFormatA ( void  )

static

Definition at line 373 of file clipboard.c.

{
    ATOM atom_id;
    UINT format_id, format_id2;
    char buf[256];
    int len;
    BOOL ret;
    HANDLE handle;
 
    format_id = RegisterClipboardFormatA("my_cool_clipboard_format");
    ok(format_id > 0xc000 && format_id < 0xffff, "invalid clipboard format id %04x\n", format_id);
 
    format_id2 = RegisterClipboardFormatA("MY_COOL_CLIPBOARD_FORMAT");
    ok(format_id2 == format_id, "invalid clipboard format id %04x\n", format_id2);
 
    len = GetClipboardFormatNameA(format_id, buf, 256);
    ok(len == lstrlenA("my_cool_clipboard_format"), "wrong format name length %d\n", len);
    ok(!lstrcmpA(buf, "my_cool_clipboard_format"), "wrong format name \"%s\"\n", buf);
 
    len = GetClipboardFormatNameA(format_id, NULL, 0);
    ok(len == 0, "wrong format name length %d\n", len);
 
    lstrcpyA(buf, "foo");
    SetLastError(0xdeadbeef);
    len = GetAtomNameA((ATOM)format_id, buf, 256);
    ok(len == 0, "GetAtomNameA should fail\n");
    ok(GetLastError() == ERROR_INVALID_HANDLE, "err %d\n", GetLastError());
 
todo_wine
{
    lstrcpyA(buf, "foo");
    SetLastError(0xdeadbeef);
    len = GlobalGetAtomNameA((ATOM)format_id, buf, 256);
    ok(len == 0, "GlobalGetAtomNameA should fail\n");
    ok(GetLastError() == ERROR_INVALID_HANDLE, "err %d\n", GetLastError());
}
 
    SetLastError(0xdeadbeef);
    atom_id = FindAtomA("my_cool_clipboard_format");
    ok(atom_id == 0, "FindAtomA should fail\n");
    ok(GetLastError() == ERROR_FILE_NOT_FOUND, "err %d\n", GetLastError());
 
    if (0)
    {
    /* this relies on the clipboard and global atom table being different */
    SetLastError(0xdeadbeef);
    atom_id = GlobalFindAtomA("my_cool_clipboard_format");
    ok(atom_id == 0, "GlobalFindAtomA should fail\n");
    ok(GetLastError() == ERROR_FILE_NOT_FOUND, "err %d\n", GetLastError());
    }
 
    for (format_id = 0; format_id < 0x10fff; format_id++)
    {
        SetLastError(0xdeadbeef);
        len = GetClipboardFormatNameA(format_id, buf, 256);
 
        if (format_id < 0xc000 || format_id > 0xffff)
            ok(!len, "GetClipboardFormatNameA should fail, but it returned %d (%s)\n", len, buf);
        else if (len && winetest_debug > 1)
            trace("%04x: %s\n", format_id, len ? buf : "");
    }
 
    ret = OpenClipboard(0);
    ok( ret, "OpenClipboard error %d\n", GetLastError());
 
    /* try some invalid/unregistered formats */
    SetLastError( 0xdeadbeef );
    handle = SetClipboardData( 0, GlobalAlloc( GMEM_DDESHARE | GMEM_MOVEABLE, 1 ));
    ok( !handle, "SetClipboardData succeeded\n" );
    ok( GetLastError() == ERROR_CLIPBOARD_NOT_OPEN, "wrong error %u\n", GetLastError());
    handle = SetClipboardData( 0x1234, GlobalAlloc( GMEM_DDESHARE | GMEM_MOVEABLE, 1 ));
    ok( handle != 0, "SetClipboardData failed err %d\n", GetLastError());
    handle = SetClipboardData( 0x123456, GlobalAlloc( GMEM_DDESHARE | GMEM_MOVEABLE, 1 ));
    ok( handle != 0, "SetClipboardData failed err %d\n", GetLastError());
    handle = SetClipboardData( 0xffff8765, GlobalAlloc( GMEM_DDESHARE | GMEM_MOVEABLE, 1 ));
    ok( handle != 0, "SetClipboardData failed err %d\n", GetLastError());
 
    ok( IsClipboardFormatAvailable( 0x1234 ), "format missing\n" );
    ok( IsClipboardFormatAvailable( 0x123456 ), "format missing\n" );
    ok( IsClipboardFormatAvailable( 0xffff8765 ), "format missing\n" );
    ok( !IsClipboardFormatAvailable( 0 ), "format available\n" );
    ok( !IsClipboardFormatAvailable( 0x3456 ), "format available\n" );
    ok( !IsClipboardFormatAvailable( 0x8765 ), "format available\n" );
 
    trace("# of formats available: %d\n", CountClipboardFormats());
 
    format_id = 0;
    while ((format_id = EnumClipboardFormats(format_id)))
    {
        ok(IsClipboardFormatAvailable(format_id), "format %04x was listed as available\n", format_id);
        len = GetClipboardFormatNameA(format_id, buf, 256);
        trace("%04x: %s\n", format_id, len ? buf : "");
    }
 
    ret = EmptyClipboard();
    ok( ret, "EmptyClipboard error %d\n", GetLastError());
    ret =CloseClipboard();
    ok( ret, "CloseClipboard error %d\n", GetLastError());
 
    if (CountClipboardFormats())
    {
        SetLastError(0xdeadbeef);
        ok(!EnumClipboardFormats(0), "EnumClipboardFormats should fail if clipboard wasn't open\n");
        ok(GetLastError() == ERROR_CLIPBOARD_NOT_OPEN,
           "Last error should be set to ERROR_CLIPBOARD_NOT_OPEN, not %d\n", GetLastError());
    }
 
    SetLastError(0xdeadbeef);
    ok(!EmptyClipboard(), "EmptyClipboard should fail if clipboard wasn't open\n");
    ok(GetLastError() == ERROR_CLIPBOARD_NOT_OPEN || broken(GetLastError() == 0xdeadbeef), /* wow64 */
       "Wrong error %u\n", GetLastError());
 
    format_id = RegisterClipboardFormatA("#1234");
    ok(format_id == 1234, "invalid clipboard format id %04x\n", format_id);
}

Referenced by START_TEST().

test_string_data()

static void test_string_data ( void  )

static

Definition at line 2048 of file clipboard.c.

{
    UINT i;
    BOOL r;
    HANDLE data;
    char cmd[16];
    char bufferA[12];
    WCHAR bufferW[12];
 
    for (i = 0; i < ARRAY_SIZE(test_data); i++)
    {
        /* 1-byte Unicode strings crash on Win64 */
#ifdef _WIN64
        if (!test_data[i].strA[0] && test_data[i].len < sizeof(WCHAR)) continue;
#endif
        r = OpenClipboard( 0 );
        ok( r, "gle %d\n", GetLastError() );
        r = EmptyClipboard();
        ok( r, "gle %d\n", GetLastError() );
        data = GlobalAlloc( GMEM_FIXED, test_data[i].len );
        if (test_data[i].strA[0])
        {
            memcpy( data, test_data[i].strA, test_data[i].len );
            SetClipboardData( CF_TEXT, data );
            memcpy( bufferA, test_data[i].strA, test_data[i].len );
            bufferA[test_data[i].len - 1] = 0;
            ok( !memcmp( data, bufferA, test_data[i].len ),
                "%u: wrong data %.*s\n", i, test_data[i].len, (char *)data );
        }
        else
        {
            memcpy( data, test_data[i].strW, test_data[i].len );
            SetClipboardData( CF_UNICODETEXT, data );
            memcpy( bufferW, test_data[i].strW, test_data[i].len );
            bufferW[(test_data[i].len + 1) / sizeof(WCHAR) - 1] = 0;
            ok( !memcmp( data, bufferW, test_data[i].len ),
                "%u: wrong data %s\n", i, wine_dbgstr_wn( data, (test_data[i].len + 1) / sizeof(WCHAR) ));
        }
        r = CloseClipboard();
        ok( r, "gle %d\n", GetLastError() );
        sprintf( cmd, "string_data %u", i );
        run_process( cmd );
    }
}

Referenced by START_TEST().

test_string_data_process()

static void test_string_data_process ( int  i )

static

Definition at line 2093 of file clipboard.c.

{
    BOOL r;
    HANDLE data;
    UINT len, len2;
    char bufferA[12];
    WCHAR bufferW[12];
 
    r = OpenClipboard( 0 );
    ok( r, "gle %d\n", GetLastError() );
    if (test_data[i].strA[0])
    {
        data = GetClipboardData( CF_TEXT );
        ok( data != 0, "%u: could not get data\n", i );
        len = GlobalSize( data );
        ok( len == test_data[i].len, "%u: wrong size %u / %u\n", i, len, test_data[i].len );
        memcpy( bufferA, test_data[i].strA, test_data[i].len );
        bufferA[test_data[i].len - 1] = 0;
        ok( !memcmp( data, bufferA, len ), "%u: wrong data %.*s\n", i, len, (char *)data );
        data = GetClipboardData( CF_UNICODETEXT );
        ok( data != 0, "%u: could not get data\n", i );
        len = GlobalSize( data );
        len2 = MultiByteToWideChar( CP_ACP, 0, bufferA, test_data[i].len, bufferW, 12 );
        ok( len == len2 * sizeof(WCHAR), "%u: wrong size %u / %u\n", i, len, len2 );
        ok( !memcmp( data, bufferW, len ), "%u: wrong data %s\n", i, wine_dbgstr_wn( data, len2 ));
    }
    else
    {
        data = GetClipboardData( CF_UNICODETEXT );
        ok( data != 0, "%u: could not get data\n", i );
        len = GlobalSize( data );
        ok( len == test_data[i].len, "%u: wrong size %u / %u\n", i, len, test_data[i].len );
        memcpy( bufferW, test_data[i].strW, test_data[i].len );
        bufferW[(test_data[i].len + 1) / sizeof(WCHAR) - 1] = 0;
        ok( !memcmp( data, bufferW, len ),
            "%u: wrong data %s\n", i, wine_dbgstr_wn( data, (len + 1) / sizeof(WCHAR) ));
        data = GetClipboardData( CF_TEXT );
        if (test_data[i].len >= sizeof(WCHAR))
        {
            ok( data != 0, "%u: could not get data\n", i );
            len = GlobalSize( data );
            len2 = WideCharToMultiByte( CP_ACP, 0, bufferW, test_data[i].len / sizeof(WCHAR),
                                        bufferA, 12, NULL, NULL );
            bufferA[len2 - 1] = 0;
            ok( len == len2, "%u: wrong size %u / %u\n", i, len, len2 );
            ok( !memcmp( data, bufferA, len ), "%u: wrong data %.*s\n", i, len, (char *)data );
        }
        else
        {
            ok( !data, "%u: got data for empty string\n", i );
            ok( IsClipboardFormatAvailable( CF_TEXT ), "%u: text not available\n", i );
        }
    }
    r = CloseClipboard();
    ok( r, "gle %d\n", GetLastError() );
}

Referenced by START_TEST().

test_synthesized()

static void test_synthesized ( void  )

static

Definition at line 586 of file clipboard.c.

{
    static const struct test
    {
        UINT format;
        UINT expected[8];
    } tests[] =
    {
/* 0 */ { CF_TEXT, { CF_TEXT, CF_LOCALE, CF_OEMTEXT, CF_UNICODETEXT }},
        { CF_OEMTEXT, { CF_OEMTEXT, CF_LOCALE, CF_TEXT, CF_UNICODETEXT }},
        { CF_UNICODETEXT, { CF_UNICODETEXT, CF_LOCALE, CF_TEXT, CF_OEMTEXT }},
        { CF_ENHMETAFILE, { CF_ENHMETAFILE, CF_METAFILEPICT }},
        { CF_METAFILEPICT, { CF_METAFILEPICT, CF_ENHMETAFILE }},
/* 5 */ { CF_BITMAP, { CF_BITMAP, CF_DIB, CF_DIBV5 }},
        { CF_DIB, { CF_DIB, CF_BITMAP, CF_DIBV5 }},
        { CF_DIBV5, { CF_DIBV5, CF_BITMAP, CF_DIB }},
    };
 
    HGLOBAL h, htext;
    HENHMETAFILE emf;
    BOOL r;
    UINT cf, i, j, count, rendered, seq, old_seq;
    HANDLE data;
    HWND hwnd;
 
    hwnd = CreateWindowA( "static", NULL, WS_POPUP, 0, 0, 10, 10, 0, 0, 0, NULL );
    SetWindowLongPtrA( hwnd, GWLP_WNDPROC, (LONG_PTR)renderer_winproc );
 
    htext = create_textA();
    emf = create_emf();
 
    r = OpenClipboard(NULL);
    ok(r, "gle %d\n", GetLastError());
    r = EmptyClipboard();
    ok(r, "gle %d\n", GetLastError());
    h = SetClipboardData(CF_TEXT, htext);
    ok(h == htext, "got %p\n", h);
    h = SetClipboardData(CF_ENHMETAFILE, emf);
    ok(h == emf, "got %p\n", h);
    r = CloseClipboard();
    ok(r, "gle %d\n", GetLastError());
 
    count = CountClipboardFormats();
    ok( count == 6, "count %u\n", count );
    r = IsClipboardFormatAvailable( CF_TEXT );
    ok( r, "CF_TEXT not available err %d\n", GetLastError());
    r = IsClipboardFormatAvailable( CF_LOCALE );
    ok( r, "CF_LOCALE not available err %d\n", GetLastError());
    r = IsClipboardFormatAvailable( CF_OEMTEXT );
    ok( r, "CF_OEMTEXT not available err %d\n", GetLastError());
    r = IsClipboardFormatAvailable( CF_UNICODETEXT );
    ok( r, "CF_UNICODETEXT not available err %d\n", GetLastError());
    r = IsClipboardFormatAvailable( CF_ENHMETAFILE );
    ok( r, "CF_ENHMETAFILE not available err %d\n", GetLastError());
    r = IsClipboardFormatAvailable( CF_METAFILEPICT );
    ok( r, "CF_METAFILEPICT not available err %d\n", GetLastError());
 
    r = OpenClipboard(NULL);
    ok(r, "gle %d\n", GetLastError());
    cf = EnumClipboardFormats(0);
    ok(cf == CF_TEXT, "cf %08x\n", cf);
    data = GetClipboardData(cf);
    ok(data != NULL, "couldn't get data, cf %08x\n", cf);
 
    cf = EnumClipboardFormats(cf);
    ok(cf == CF_ENHMETAFILE, "cf %08x\n", cf);
    data = GetClipboardData(cf);
    ok(data != NULL, "couldn't get data, cf %08x\n", cf);
 
    cf = EnumClipboardFormats(cf);
    ok(cf == CF_LOCALE, "cf %08x\n", cf);
    data = GetClipboardData(cf);
    ok(data != NULL, "couldn't get data, cf %08x\n", cf);
 
    cf = EnumClipboardFormats(cf);
    ok(cf == CF_OEMTEXT, "cf %08x\n", cf);
    data = GetClipboardData(cf);
    ok(data != NULL, "couldn't get data, cf %08x\n", cf);
 
    cf = EnumClipboardFormats(cf);
    ok(cf == CF_UNICODETEXT, "cf %08x\n", cf);
 
    cf = EnumClipboardFormats(cf);
    ok(cf == CF_METAFILEPICT, "cf %08x\n", cf);
    data = GetClipboardData(cf);
    ok(data != NULL, "couldn't get data, cf %08x\n", cf);
 
    cf = EnumClipboardFormats(cf);
    ok(cf == 0, "cf %08x\n", cf);
 
    r = EmptyClipboard();
    ok(r, "gle %d\n", GetLastError());
 
    SetClipboardData( CF_UNICODETEXT, create_textW() );
    SetClipboardData( CF_TEXT, create_textA() );
    SetClipboardData( CF_OEMTEXT, create_textA() );
    r = CloseClipboard();
    ok(r, "gle %d\n", GetLastError());
 
    r = OpenClipboard( NULL );
    ok(r, "gle %d\n", GetLastError());
    SetLastError( 0xdeadbeef );
    cf = EnumClipboardFormats(0);
    ok( cf == CF_UNICODETEXT, "cf %08x\n", cf );
    ok( GetLastError() == ERROR_SUCCESS, "wrong error %u\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    cf = EnumClipboardFormats(cf);
    ok( cf == CF_TEXT, "cf %08x\n", cf );
    ok( GetLastError() == ERROR_SUCCESS, "wrong error %u\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    cf = EnumClipboardFormats(cf);
    ok( cf == CF_OEMTEXT, "cf %08x\n", cf );
    ok( GetLastError() == ERROR_SUCCESS, "wrong error %u\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    cf = EnumClipboardFormats(cf);
    ok( cf == CF_LOCALE, "cf %08x\n", cf );
    ok( GetLastError() == ERROR_SUCCESS, "wrong error %u\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    cf = EnumClipboardFormats( cf );
    ok( cf == 0, "cf %08x\n", cf );
    ok( GetLastError() == ERROR_SUCCESS, "wrong error %u\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    cf = EnumClipboardFormats( 0xdead );
    ok( cf == 0, "cf %08x\n", cf );
    ok( GetLastError() == ERROR_SUCCESS, "wrong error %u\n", GetLastError() );
 
    r = EmptyClipboard();
    ok(r, "gle %d\n", GetLastError());
 
    r = CloseClipboard();
    ok(r, "gle %d\n", GetLastError());
 
    for (i = 0; i < ARRAY_SIZE(tests); i++)
    {
        r = OpenClipboard(NULL);
        ok(r, "%u: gle %d\n", i, GetLastError());
        r = EmptyClipboard();
        ok(r, "%u: gle %d\n", i, GetLastError());
 
        switch (tests[i].format)
        {
        case CF_TEXT:
        case CF_OEMTEXT:
            SetClipboardData( tests[i].format, create_textA() );
            break;
        case CF_UNICODETEXT:
            SetClipboardData( CF_UNICODETEXT, create_textW() );
            break;
        case CF_ENHMETAFILE:
            SetClipboardData( CF_ENHMETAFILE, create_emf() );
            break;
        case CF_METAFILEPICT:
            SetClipboardData( CF_METAFILEPICT, create_metafile() );
            break;
        case CF_BITMAP:
            SetClipboardData( CF_BITMAP, create_bitmap() );
            break;
        case CF_DIB:
        case CF_DIBV5:
            SetClipboardData( tests[i].format, create_dib( tests[i].format == CF_DIBV5 ));
            break;
        }
 
        count = CountClipboardFormats();
        ok( count == 1, "%u: count %u\n", i, count );
 
        r = CloseClipboard();
        ok(r, "%u: gle %d\n", i, GetLastError());
 
        count = CountClipboardFormats();
        for (j = 0; tests[i].expected[j]; j++)
        {
            r = IsClipboardFormatAvailable( tests[i].expected[j] );
            ok( r, "%u: %04x not available\n", i, tests[i].expected[j] );
        }
        ok( count == j, "%u: count %u instead of %u\n", i, count, j );
 
        r = OpenClipboard( hwnd );
        ok(r, "%u: gle %d\n", i, GetLastError());
        cf = 0;
        for (j = 0; tests[i].expected[j]; j++)
        {
            cf = EnumClipboardFormats( cf );
            ok(cf == tests[i].expected[j], "%u.%u: got %04x instead of %04x\n",
               i, j, cf, tests[i].expected[j] );
            if (cf != tests[i].expected[j]) break;
            old_seq = GetClipboardSequenceNumber();
            data = GetClipboardData( cf );
            ok(data != NULL ||
               broken( tests[i].format == CF_DIBV5 && cf == CF_DIB ), /* >= Vista */
               "%u: couldn't get data, cf %04x err %d\n", i, cf, GetLastError());
            seq = GetClipboardSequenceNumber();
            ok(seq == old_seq, "sequence changed (test %d %d)\n", i, cf);
            switch (cf)
            {
            case CF_LOCALE:
            {
                UINT *ptr = GlobalLock( data );
                ok( GlobalSize( data ) == sizeof(*ptr), "%u: size %lu\n", i, GlobalSize( data ));
                ok( *ptr == GetUserDefaultLCID() ||
                    broken( *ptr == MAKELANGID( LANG_ENGLISH, SUBLANG_DEFAULT )),
                    "%u: CF_LOCALE %08x/%08x\n", i, *ptr, GetUserDefaultLCID() );
                GlobalUnlock( data );
                break;
            }
            case CF_TEXT:
            case CF_OEMTEXT:
                ok( GlobalSize( data ) == 10, "wrong len %ld\n", GlobalSize( data ));
                break;
            case CF_UNICODETEXT:
                ok( GlobalSize( data ) == 10 * sizeof(WCHAR), "wrong len %ld\n", GlobalSize( data ));
                break;
            }
        }
        if (!tests[i].expected[j])
        {
            cf = EnumClipboardFormats( cf );
            ok(cf == 0, "%u: cf %04x\n", i, cf);
        }
 
        /* now with delayed rendering */
 
        r = EmptyClipboard();
        ok(r, "%u: gle %d\n", i, GetLastError());
 
        rendered = SendMessageA( hwnd, WM_USER, 0, 0 );
        ok( !rendered, "%u: formats %08x have been rendered\n", i, rendered );
 
        SetClipboardData( tests[i].format, 0 );
        rendered = SendMessageA( hwnd, WM_USER, 0, 0 );
        ok( !rendered, "%u: formats %08x have been rendered\n", i, rendered );
 
        count = CountClipboardFormats();
        ok( count == 1, "%u: count %u\n", i, count );
 
        r = CloseClipboard();
        ok(r, "%u: gle %d\n", i, GetLastError());
        rendered = SendMessageA( hwnd, WM_USER, 0, 0 );
        ok( !rendered, "%u: formats %08x have been rendered\n", i, rendered );
 
        count = CountClipboardFormats();
        for (j = 0; tests[i].expected[j]; j++)
        {
            r = IsClipboardFormatAvailable( tests[i].expected[j] );
            ok( r, "%u: %04x not available\n", i, tests[i].expected[j] );
        }
        ok( count == j, "%u: count %u instead of %u\n", i, count, j );
        rendered = SendMessageA( hwnd, WM_USER, 0, 0 );
        ok( !rendered, "%u: formats %08x have been rendered\n", i, rendered );
 
        r = OpenClipboard(NULL);
        ok(r, "%u: gle %d\n", i, GetLastError());
        cf = 0;
        for (j = 0; tests[i].expected[j]; j++)
        {
            cf = EnumClipboardFormats( cf );
            ok(cf == tests[i].expected[j], "%u.%u: got %04x instead of %04x\n",
               i, j, cf, tests[i].expected[j] );
            if (cf != tests[i].expected[j]) break;
            rendered = SendMessageA( hwnd, WM_USER, 0, 0 );
            ok( !rendered, "%u.%u: formats %08x have been rendered\n", i, j, rendered );
            data = GetClipboardData( cf );
            rendered = SendMessageA( hwnd, WM_USER, 0, 0 );
            if (cf == CF_LOCALE)
            {
                ok(data != NULL, "%u: CF_LOCALE no data\n", i);
                ok( !rendered, "%u.%u: formats %08x have been rendered\n", i, j, rendered );
            }
            else
            {
                ok(!data, "%u: format %04x got data %p\n", i, cf, data);
                ok( rendered == (1 << tests[i].format),
                    "%u.%u: formats %08x have been rendered\n", i, j, rendered );
                /* try to render a second time */
                data = GetClipboardData( cf );
                rendered = SendMessageA( hwnd, WM_USER, 0, 0 );
                ok( rendered == (1 << tests[i].format),
                    "%u.%u: formats %08x have been rendered\n", i, j, rendered );
            }
        }
        if (!tests[i].expected[j])
        {
            cf = EnumClipboardFormats( cf );
            ok(cf == 0, "%u: cf %04x\n", i, cf);
        }
        r = CloseClipboard();
        ok(r, "%u: gle %d\n", i, GetLastError());
        rendered = SendMessageA( hwnd, WM_USER, 0, 0 );
        ok( !rendered, "%u: formats %08x have been rendered\n", i, rendered );
    }
 
    r = OpenClipboard(NULL);
    ok(r, "gle %d\n", GetLastError());
    r = EmptyClipboard();
    ok(r, "gle %d\n", GetLastError());
    r = CloseClipboard();
    ok(r, "gle %d\n", GetLastError());
    DestroyWindow( hwnd );
}

Referenced by START_TEST().

winproc_wrapper()

static LRESULT CALLBACK winproc_wrapper ( HWND  hwnd, UINT  msg, WPARAM  wp, LPARAM  lp  )

static

Definition at line 184 of file clipboard.c.

{
    static int wm_renderallformats;
    static int wm_drawclipboard;
    static int seqno;
    DWORD msg_flags = InSendMessageEx( NULL );
 
    if (!seqno) seqno = GetClipboardSequenceNumber();
 
    trace( "%p msg %04x\n", hwnd, msg );
    if (!wm_renderallformats)
    {
        ok( GetClipboardOwner() == hwnd, "%04x: wrong owner %p/%p\n", msg, GetClipboardOwner(), hwnd );
        ok( seqno == GetClipboardSequenceNumber(), "%04x: seqno changed\n", msg );
    }
    else
    {
        ok( !GetClipboardOwner(), "%04x: wrong owner %p\n", msg, GetClipboardOwner() );
        ok( seqno + 1 == GetClipboardSequenceNumber(), "%04x: seqno unchanged\n", msg );
    }
    ok( GetClipboardViewer() == hwnd, "%04x: wrong viewer %p/%p\n", msg, GetClipboardViewer(), hwnd );
    ok( GetOpenClipboardWindow() == hwnd, "%04x: wrong open win %p/%p\n",
        msg, GetOpenClipboardWindow(), hwnd );
 
    switch (msg)
    {
    case WM_DESTROY:
        ok( wm_renderallformats, "didn't receive WM_RENDERALLFORMATS before WM_DESTROY\n" );
        ok( wm_drawclipboard, "didn't receive WM_DRAWCLIPBOARD before WM_DESTROY\n" );
        break;
    case WM_DRAWCLIPBOARD:
        ok( msg_flags == ISMEX_NOSEND, "WM_DRAWCLIPBOARD wrong flags %x\n", msg_flags );
        wm_drawclipboard++;
        break;
    case WM_RENDERALLFORMATS:
        ok( msg_flags == ISMEX_NOSEND, "WM_RENDERALLFORMATS wrong flags %x\n", msg_flags );
        wm_renderallformats++;
        break;
    }
    return old_proc( hwnd, msg, wp, lp );
}

Referenced by test_ClipboardOwner().

Variable Documentation

argv0

char* argv0

static

Definition at line 38 of file clipboard.c.

Referenced by run_process(), and START_TEST().

bitmap

HBITMAP bitmap

static

Definition at line 1344 of file clipboard.c.

bitmap2

HBITMAP bitmap2

static

Definition at line 1344 of file clipboard.c.

Referenced by test_colorkey(), test_colormatrix(), test_createbitmapfromsource(), test_data_handles(), test_gamma(), test_getthumbnail(), test_handles(), test_handles_thread2(), and test_remaptable().

clipboard_cs

CRITICAL_SECTION clipboard_cs

static

Definition at line 893 of file clipboard.c.

Referenced by clipboard_thread(), clipboard_wnd_proc(), and test_messages().

count

UINT count

Definition at line 35 of file clipboard.c.

cross_thread

BOOL cross_thread

static

Definition at line 900 of file clipboard.c.

Referenced by check_messages_(), clipboard_thread(), and clipboard_wnd_proc().

do_render_format

BOOL do_render_format

static

Definition at line 901 of file clipboard.c.

Referenced by clipboard_thread(), and clipboard_wnd_proc().

format_id

UINT format_id

static

Definition at line 1343 of file clipboard.c.

Referenced by append_decl_element(), buffer_init(), compute_texture_matrix(), ddraw_surface7_SetSurfaceDesc(), debug_d3dformat(), get_format_idx(), get_format_internal(), init_typeless_formats(), test_data_handles(), test_handles(), test_handles_process(), test_handles_thread2(), test_RegisterClipboardFormatA(), wined3d_adapter_init_fb_cfgs(), wined3d_calculate_format_pitch(), wined3d_cs_emit_set_index_buffer(), wined3d_device_resolve_sub_resource(), wined3d_device_set_index_buffer(), wined3d_enum_adapter_modes(), wined3d_format_convert_from_float(), wined3d_get_adapter_mode_count(), wined3d_get_format(), wined3d_swapchain_apply_sample_count_override(), wined3d_swapchain_resize_buffers(), and wined3d_texture_update_desc().

len

UINT len

Definition at line 2030 of file clipboard.c.

Referenced by test_RegisterClipboardFormatA(), and test_string_data_process().

logpalette

const LOGPALETTE logpalette = { 0x300, 1, {{ 0x12, 0x34, 0x56, 0x78 }}}

static

Definition at line 1346 of file clipboard.c.

Referenced by OleDuplicateData(), test_data_handles(), test_DIB_PAL_COLORS(), test_handles(), and test_palette_entries().

nb_formats

UINT nb_formats

static

Definition at line 899 of file clipboard.c.

Referenced by clipboard_wnd_proc().

next_wnd

HWND next_wnd

static

Definition at line 894 of file clipboard.c.

old_proc

WNDPROC old_proc

static

Definition at line 183 of file clipboard.c.

Referenced by subclass_margin_edits(), test_ClipboardOwner(), test_SetWindowPos(), and winproc_wrapper().

old_seq

UINT old_seq

static

Definition at line 1004 of file clipboard.c.

Referenced by check_messages_(), clipboard_thread(), clipboard_wnd_proc(), and test_synthesized().

out_count

UINT UINT* out_count

Definition at line 35 of file clipboard.c.

Referenced by ConvertJapaneseUnicodeToJIS(), ConvertJISJapaneseToUnicode(), ConvertUnknownJapaneseToUnicode(), linear_vari_process(), test_propertybag_getpropertyinfo(), and zoh_vari_process().

palette

HPALETTE palette

static

Definition at line 1345 of file clipboard.c.

Referenced by BitmapClipper_CopyPalette(), BitmapTestSrc_CopyPalette(), BmpEncoder_SetPalette(), BmpFrameDecode_ReadRLE4(), BmpFrameDecode_ReadRLE8(), BmpFrameEncode_SetPalette(), check_halftone_palette(), ComponentFactory_CreatePalette(), convert_argb_pixels(), convert_p8_uint_b8g8r8a8_unorm(), copypixels_to_32bppBGRA(), create_bitmap_from_source_rect(), create_optimal_palette(), d3drm_image_load_8(), d3drm_image_palettise(), d3drm_texture1_Changed(), d3drm_texture2_Changed(), D3DXCreateCubeTextureFromFileExA(), D3DXCreateCubeTextureFromFileExW(), D3DXCreateCubeTextureFromFileInMemoryEx(), D3DXCreateTextureFromFileExA(), D3DXCreateTextureFromFileExW(), D3DXCreateTextureFromFileInMemoryEx(), D3DXCreateTextureFromResourceExA(), D3DXCreateTextureFromResourceExW(), D3DXCreateVolumeTextureFromFileExA(), D3DXCreateVolumeTextureFromFileExW(), D3DXCreateVolumeTextureFromFileInMemoryEx(), D3DXFilterTexture(), D3DXLoadSurfaceFromFileInMemory(), ddraw1_CreatePalette(), ddraw2_CreatePalette(), ddraw4_CreatePalette(), ddraw_palette_GetCaps(), ddraw_palette_GetEntries(), ddraw_palette_init(), ddraw_palette_Release(), ddraw_palette_SetEntries(), ddraw_surface1_GetPalette(), ddraw_surface1_SetPalette(), ddraw_surface2_GetPalette(), ddraw_surface2_SetPalette(), ddraw_surface3_GetPalette(), ddraw_surface3_SetPalette(), ddraw_surface4_GetPalette(), ddraw_surface4_SetPalette(), ddraw_surface7_GetDC(), ddraw_surface7_GetPalette(), ddraw_surface7_SetPalette(), ddraw_surface_set_palette(), DECLARE_INTERFACE_(), decode_frame_wic(), DirectDrawMediaStreamImpl_IDirectDrawMediaStream_GetFormat(), EMFDC_SelectPalette(), FormatConverter_CopyPalette(), FormatConverter_Initialize(), GdipBitmapConvertFormat(), GdipCreateBitmapFromHBITMAP(), GdipGetImageAttributesAdjustedPalette(), GdipGetImagePalette(), GdipInitializePalette(), GdipSetImagePalette(), get_bitmap_info(), get_gif_palette(), get_palette(), get_palette_index(), Image::GetPalette(), gif_metadata_reader(), GifDecoder_CopyPalette(), GifEncoder_SetPalette(), GifFrameEncode_SetPalette(), ImagingFactory_CreateBitmapFromHBITMAP(), IMILBitmapImpl_CopyPalette(), IMILBitmapImpl_SetPalette(), IMILBitmapScaler_CopyPalette(), index_to_rgba(), InitBitmap(), load_cube_texture_from_dds(), load_texture_from_dds(), load_volume_texture_from_dds(), metadc_create_palette(), METADC_SelectPalette(), metafile_deserialize_image(), NtGdiDdDDICreateDCFromMemory(), palette_sample(), PaletteImpl_Create(), PaletteImpl_InitializeFromBitmap(), point_filter_argb_pixels(), Image::SetPalette(), setpixel_1bppIndexed(), setpixel_4bppIndexed(), setpixel_8bppIndexed(), surface_load_texture(), test_bitmap_scaler(), test_bitmapbits(), test_converter_8bppIndexed(), test_createbitmap(), test_CreateBitmapFromHBITMAP(), test_createbitmapfromsource(), test_custom_palette(), test_D3DXLoadSurface(), test_data_handles(), test_decode_1bpp(), test_decode_24bpp(), test_decode_4bpp(), test_decode_rle4(), test_decode_rle8(), test_default_handler(), test_encoder(), test_GdipInitializePalette(), test_getadjustedpalette(), test_global_gif_palette(), test_global_gif_palette_2frames(), test_handles(), test_handles_thread2(), test_local_gif_palette(), test_media_streams(), test_multi_encoder(), test_multiframegif(), test_palette(), test_palette_brush(), test_palette_from_bitmap(), test_png_palette(), test_predefined_palette(), test_set_frame_palette(), test_SetDIBits(), test_SetDIBitsToDevice(), test_tiff_1bpp_palette(), test_tiff_4bps_bgra(), test_tiff_8bpp_alpha(), test_tiff_8bpp_palette(), test_tiff_palette(), upload_palette(), wined3d_colour_from_ddraw_colour(), wined3d_palette_apply_to_dc(), wined3d_palette_create(), wined3d_palette_decref(), wined3d_palette_get_entries(), wined3d_palette_incref(), wined3d_palette_init(), wined3d_palette_set_entries(), and wined3d_swapchain_set_palette().

strA

char strA[12]

Definition at line 2028 of file clipboard.c.

Referenced by AnsiToUnicode(), decodeBase64WithLenFmtW(), enum_compartments(), FD31_MapStringPairsToW(), GetMultiByteString(), GetMultiByteStringN(), GetWideString(), GetWideStringN(), LHashValOfNameSys(), REGPROC_write_line(), secure_proxy_connect(), strcmp_aw(), test_basetypes(), test_crtGetStringTypeW(), test_IMLangConvertCharset(), test_overlapped_buffers(), test_string_data(), test_string_data_process(), and UnicodeToAnsi().

strW

WCHAR strW[12]

Definition at line 2029 of file clipboard.c.

Referenced by AnsiToUnicode(), CharLowerBuffA(), CharUpperBuffA(), check_convertible(), decodeBase64WithLenFmtW(), DrawCaptionTempA(), encode_compare_base64_W(), FD31_DupToW(), FilenameA2W(), FilenameW2A_FitOrFail(), FONT_mbtowc(), get_clr_version(), get_nt_pathW(), GetMultiByteString(), GetMultiByteStringN(), GetTabbedTextExtentA(), GetWideString(), GetWideStringN(), LISTVIEW_FindItemA(), MONTHCAL_PaintTitle(), msi_strequal(), msi_strprefix(), MsiPreviewDialogA(), SetLocaleInfoA(), SHGetObjectCompatFlags(), strdupW(), SymMatchStringA(), TabbedTextOutA(), test_basetypes(), test_commandline2argv(), test_CryptBinaryToString(), test_EM_GETLINE(), test_getstring(), test_IMLangConvertCharset(), test_margins_default(), test_overlapped_buffers(), test_RtlHashUnicodeString(), test_string_data(), test_string_data_process(), UnicodeToAnsi(), write_string(), and xmlstrdupW().

const struct { ... } test_data[]

Initial value:

=
{
    { "foo", {0}, 3 },      
    { "foo", {0}, 4 },
    { "foo\0bar", {0}, 7 },
    { "foo\0bar", {0}, 8 },
    { "", {'f','o','o'}, 3 * sizeof(WCHAR) },
    { "", {'f','o','o',0}, 4 * sizeof(WCHAR) },     
    { "", {'f','o','o',0,'b','a','r'}, 7 * sizeof(WCHAR) },
    { "", {'f','o','o',0,'b','a','r',0}, 8 * sizeof(WCHAR) },
    { "", {'f','o','o'}, 1 },
    { "", {'f','o','o'}, 2 },
    { "", {'f','o','o'}, 5 },     
    { "", {'f','o','o',0}, 7 },
    { "", {'f','o','o',0}, 9 },
}

thread_from_line

int thread_from_line

static

Definition at line 37 of file clipboard.c.

Referenced by empty_clipboard_thread(), open_and_empty_clipboard_thread(), open_and_empty_clipboard_win_thread(), open_clipboard_thread(), run_thread(), and set_clipboard_data_thread().

update_event

HANDLE update_event

static

Definition at line 902 of file clipboard.c.

Referenced by check_messages_(), clipboard_wnd_proc(), and test_messages().

wm_clipboardupdate

UINT wm_clipboardupdate

static

Definition at line 896 of file clipboard.c.

Referenced by clipboard_wnd_proc().

wm_destroyclipboard

UINT wm_destroyclipboard

static

Definition at line 897 of file clipboard.c.

Referenced by clipboard_wnd_proc().

wm_drawclipboard

UINT wm_drawclipboard

static

Definition at line 895 of file clipboard.c.

wm_renderformat

UINT wm_renderformat

static

Definition at line 898 of file clipboard.c.

Referenced by clipboard_wnd_proc().