util.c File Reference

#include "wine/test.h"
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "winerror.h"
#include "winnt.h"
#include "mapiutil.h"
#include "mapitags.h"
#include "mapi32_test.h"

Include dependency graph for util.c:

Go to the source code of this file.

Functions
static	SCODE (WINAPI *pScInitMapiUtil)(ULONG)
static	void (WINAPI *pDeinitMapiUtil)(void)
static	BOOL (WINAPI *pFBinFromHex)(LPWSTR
static	UINT (WINAPI *pUFromSz)(LPCSTR)
static	ULONG (WINAPI *pUlFromSzHex)(LPCSTR)
static void	init_function_pointers (void)
static void	test_SwapPword (void)
static void	test_SwapPlong (void)
static void	test_HexFromBin (void)
static void	test_UFromSz (void)
static void	test_UlFromSzHex (void)
static void	test_CbOfEncoded (void)
static void	test_IsBadBoundedStringPtr (void)
	START_TEST (util)

Variables
static HMODULE	hMapi32 = 0
static	ULONG
static	int
static	LPWSTR
static	LPBYTE

Function Documentation

BOOL()

static BOOL ( WINAPI *  pFBinFromHex )

static

init_function_pointers()

static void init_function_pointers ( void  )

static

Definition at line 46 of file util.c.

{
    hMapi32 = LoadLibraryA("mapi32.dll");
 
    pScInitMapiUtil = (void*)GetProcAddress(hMapi32, "ScInitMapiUtil@4");
    pDeinitMapiUtil = (void*)GetProcAddress(hMapi32, "DeinitMapiUtil@0");
    pSwapPword = (void*)GetProcAddress(hMapi32, "SwapPword@8");
    pSwapPlong = (void*)GetProcAddress(hMapi32, "SwapPlong@8");
    pHexFromBin = (void*)GetProcAddress(hMapi32, "HexFromBin@12");
    pFBinFromHex = (void*)GetProcAddress(hMapi32, "FBinFromHex@8");
    pUFromSz = (void*)GetProcAddress(hMapi32, "UFromSz@4");
    pUlFromSzHex = (void*)GetProcAddress(hMapi32, "UlFromSzHex@4");
    pCbOfEncoded = (void*)GetProcAddress(hMapi32, "CbOfEncoded@4");
    pIsBadBoundedStringPtr = (void*)GetProcAddress(hMapi32, "IsBadBoundedStringPtr@8");
    pMAPIInitialize = (void*)GetProcAddress(hMapi32, "MAPIInitialize");
    pMAPIUninitialize = (void*)GetProcAddress(hMapi32, "MAPIUninitialize");
}

Referenced by START_TEST().

SCODE()

static SCODE ( WINAPI *  pScInitMapiUtil )

static

START_TEST()

START_TEST

(

util

)

Definition at line 206 of file util.c.

{
    SCODE ret;
 
    if (!HaveDefaultMailClient())
    {
        win_skip("No default mail client installed\n");
        return;
    }
 
    init_function_pointers();
 
    if (!pScInitMapiUtil || !pDeinitMapiUtil)
    {
        win_skip("MAPI utility initialization functions are not available\n");
        FreeLibrary(hMapi32);
        return;
    }
 
    SetLastError(0xdeadbeef);
    ret = pScInitMapiUtil(0);
    if ((ret != S_OK) && (GetLastError() == ERROR_PROC_NOT_FOUND))
    {
        win_skip("ScInitMapiUtil is not implemented\n");
        FreeLibrary(hMapi32);
        return;
    }
    else if ((ret == E_FAIL) && (GetLastError() == ERROR_INVALID_HANDLE))
    {
        win_skip("ScInitMapiUtil doesn't work on some Win98 and WinME systems\n");
        FreeLibrary(hMapi32);
        return;
    }
 
    test_SwapPword();
    test_SwapPlong();
 
    /* We call MAPIInitialize here for the benefit of native extended MAPI
     * providers which crash in the HexFromBin tests when MAPIInitialize has
     * not been called. Since MAPIInitialize is irrelevant for HexFromBin on
     * Wine, we do not care whether MAPIInitialize succeeds. */
    if (pMAPIInitialize)
        ret = pMAPIInitialize(NULL);
    test_HexFromBin();
    if (pMAPIUninitialize && ret == S_OK)
        pMAPIUninitialize();
 
    test_UFromSz();
    test_UlFromSzHex();
    test_CbOfEncoded();
    test_IsBadBoundedStringPtr();
 
    pDeinitMapiUtil();
    FreeLibrary(hMapi32);
}

test_CbOfEncoded()

static void test_CbOfEncoded ( void  )

static

Definition at line 169 of file util.c.

{
    char buff[129];
    unsigned int i;
 
    if (!pCbOfEncoded)
    {
        win_skip("CbOfEncoded is not available\n");
        return;
    }
 
    for (i = 0; i < sizeof(buff) - 1; i++)
    {
        ULONG ulRet, ulExpected = (((i | 3) >> 2) + 1) * 3;
 
        memset(buff, '\0', sizeof(buff));
        memset(buff, '?', i);
        ulRet = pCbOfEncoded(buff);
        ok(ulRet == ulExpected,
           "CbOfEncoded(length %d): expected %d, got %d\n",
           i, ulExpected, ulRet);
    }
}

Referenced by START_TEST().

test_HexFromBin()

static void test_HexFromBin ( void  )

static

Definition at line 102 of file util.c.

{
    static char res[] =       { "000102030405060708090A0B0C0D0E0F101112131415161"
      "718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A3B"
      "3C3D3E3F404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F6"
      "06162636465666768696A6B6C6D6E6F707172737475767778797A7B7C7D7E7F8081828384"
      "85868788898A8B8C8D8E8F909192939495969798999A9B9C9D9E9FA0A1A2A3A4A5A6A7A8A"
      "9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7C8C9CACBCCCD"
      "CECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDFE0E1E2E3E4E5E6E7E8E9EAEBECEDEEEFF0F1F"
      "2F3F4F5F6F7F8F9FAFBFCFDFE\0X" };
    BYTE data[255];
    WCHAR strw[256];
    BOOL bOk;
    int i;
 
    if (!pHexFromBin || !pFBinFromHex)
    {
        win_skip("Hexadecimal conversion functions are not available\n");
        return;
    }
 
    for (i = 0; i < 255; i++)
        data[i] = i;
    memset(strw, 'X', sizeof(strw));
    pHexFromBin(data, sizeof(data), strw);
 
    ok(memcmp(strw, res, sizeof(res) - 1) == 0, "HexFromBin: Result differs\n");
 
    memset(data, 0, sizeof(data));
    pFBinFromHex((LPWSTR)res, data);
    bOk = TRUE;
    for (i = 0; i < 255; i++)
        if (data[i] != i)
            bOk = FALSE;
    ok(bOk == TRUE, "FBinFromHex: Result differs\n");
}

Referenced by START_TEST().

test_IsBadBoundedStringPtr()

static void test_IsBadBoundedStringPtr ( void  )

static

Definition at line 193 of file util.c.

{
    if (!pIsBadBoundedStringPtr)
    {
        win_skip("IsBadBoundedStringPtr is not available\n");
        return;
    }
 
    ok(pIsBadBoundedStringPtr(NULL, 0) == TRUE, "IsBadBoundedStringPtr: expected TRUE\n");
    ok(pIsBadBoundedStringPtr("TEST", 4) == TRUE, "IsBadBoundedStringPtr: expected TRUE\n");
    ok(pIsBadBoundedStringPtr("TEST", 5) == FALSE, "IsBadBoundedStringPtr: expected FALSE\n");
}

Referenced by START_TEST().

test_SwapPlong()

static void test_SwapPlong ( void  )

static

Definition at line 83 of file util.c.

{
    ULONG longs[3];
 
    if (!pSwapPlong)
    {
        win_skip("SwapPlong is not available\n");
        return;
    }
 
    longs[0] = 0xffff0001;
    longs[1] = 0x1000ffff;
    longs[2] = 0x20000001;
    pSwapPlong(longs, 2);
    ok((longs[0] == 0x0100ffff && longs[1] == 0xffff0010 && longs[2] == 0x20000001),
       "Expected {0x0100ffff,0xffff0010,0x20000001}, got {0x%08x,0x%08x,0x%08x}\n",
       longs[0], longs[1], longs[2]);
}

Referenced by START_TEST().

test_SwapPword()

static void test_SwapPword ( void  )

static

Definition at line 64 of file util.c.

{
    USHORT shorts[3];
 
    if (!pSwapPword)
    {
        win_skip("SwapPword is not available\n");
        return;
    }
 
    shorts[0] = 0xff01;
    shorts[1] = 0x10ff;
    shorts[2] = 0x2001;
    pSwapPword(shorts, 2);
    ok((shorts[0] == 0x01ff && shorts[1] == 0xff10 && shorts[2] == 0x2001),
       "Expected {0x01ff,0xff10,0x2001}, got {0x%04x,0x%04x,0x%04x}\n",
       shorts[0], shorts[1], shorts[2]);
}

Referenced by START_TEST().

test_UFromSz()

static void test_UFromSz ( void  )

static

Definition at line 139 of file util.c.

{
    if (!pUFromSz)
    {
        win_skip("UFromSz is not available\n");
        return;
    }
 
    ok(pUFromSz("105679") == 105679u,
       "UFromSz: expected 105679, got %d\n", pUFromSz("105679"));
 
    ok(pUFromSz(" 4") == 0, "UFromSz: expected 0. got %d\n",
       pUFromSz(" 4"));
}

Referenced by START_TEST().

test_UlFromSzHex()

static void test_UlFromSzHex ( void  )

static

Definition at line 154 of file util.c.

{
    if (!pUlFromSzHex)
    {
        win_skip("UlFromSzHex is not available\n");
        return;
    }
 
    ok(pUlFromSzHex("fF") == 0xffu,
       "UlFromSzHex: expected 0xff, got 0x%x\n", pUlFromSzHex("fF"));
 
    ok(pUlFromSzHex(" c") == 0, "UlFromSzHex: expected 0x0. got 0x%x\n",
       pUlFromSzHex(" c"));
}

Referenced by START_TEST().

UINT()

static UINT ( WINAPI *  pUFromSz )

static

ULONG()

static ULONG ( WINAPI *  pUlFromSzHex )

static

void()

static void ( WINAPI *  pDeinitMapiUtil )

static

Variable Documentation

hMapi32

HMODULE hMapi32 = 0

static

Definition at line 31 of file util.c.

Referenced by init_function_pointers(), and START_TEST().

int

int

Definition at line 37 of file util.c.

LPBYTE

LPBYTE

Definition at line 38 of file util.c.

LPWSTR

LPWSTR

Definition at line 37 of file util.c.

ULONG

ULONG

Definition at line 35 of file util.c.