msvcrt: Convert all the printf functions to use MS ABI varargs.
[wine] / dlls / mapi32 / tests / util.c
1 /*
2  * Unit test suite for MAPI utility functions
3  *
4  * Copyright 2004 Jon Griffiths
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "wine/test.h"
22 #include "windef.h"
23 #include "winbase.h"
24 #include "winuser.h"
25 #include "winerror.h"
26 #include "winnt.h"
27 #include "mapiutil.h"
28 #include "mapitags.h"
29
30 static HMODULE hMapi32 = 0;
31
32 static SCODE (WINAPI *pScInitMapiUtil)(ULONG);
33 static void  (WINAPI *pSwapPword)(PUSHORT,ULONG);
34 static void  (WINAPI *pSwapPlong)(PULONG,ULONG);
35 static void  (WINAPI *pHexFromBin)(LPBYTE,int,LPWSTR);
36 static void  (WINAPI *pFBinFromHex)(LPWSTR,LPBYTE);
37 static UINT  (WINAPI *pUFromSz)(LPCSTR);
38 static ULONG (WINAPI *pUlFromSzHex)(LPCSTR);
39 static ULONG (WINAPI *pCbOfEncoded)(LPCSTR);
40 static BOOL  (WINAPI *pIsBadBoundedStringPtr)(LPCSTR,ULONG);
41
42 static void test_SwapPword(void)
43 {
44     USHORT shorts[3];
45
46     pSwapPword = (void*)GetProcAddress(hMapi32, "SwapPword@8");
47     if (!pSwapPword)
48         return;
49
50     shorts[0] = 0xff01;
51     shorts[1] = 0x10ff;
52     shorts[2] = 0x2001;
53     pSwapPword(shorts, 2);
54     ok(shorts[0] == 0x01ff && shorts[1] == 0xff10 && shorts[2] == 0x2001,
55        "Expected {0x01ff,0xff10,0x2001}, got {0x%04x,0x%04x,0x%04x}\n",
56        shorts[0], shorts[1], shorts[2]);
57 }
58
59 static void test_SwapPlong(void)
60 {
61     ULONG longs[3];
62
63     pSwapPlong = (void*)GetProcAddress(hMapi32, "SwapPlong@8");
64     if (!pSwapPlong)
65         return;
66
67     longs[0] = 0xffff0001;
68     longs[1] = 0x1000ffff;
69     longs[2] = 0x20000001;
70     pSwapPlong(longs, 2);
71     ok(longs[0] == 0x0100ffff && longs[1] == 0xffff0010 && longs[2] == 0x20000001,
72        "Expected {0x0100ffff,0xffff0010,0x20000001}, got {0x%08x,0x%08x,0x%08x}\n",
73        longs[0], longs[1], longs[2]);
74 }
75
76 static void test_HexFromBin(void)
77 {
78     static char res[] =       { "000102030405060708090A0B0C0D0E0F101112131415161"
79       "718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A3B"
80       "3C3D3E3F404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F6"
81       "06162636465666768696A6B6C6D6E6F707172737475767778797A7B7C7D7E7F8081828384"
82       "85868788898A8B8C8D8E8F909192939495969798999A9B9C9D9E9FA0A1A2A3A4A5A6A7A8A"
83       "9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7C8C9CACBCCCD"
84       "CECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDFE0E1E2E3E4E5E6E7E8E9EAEBECEDEEEFF0F1F"
85       "2F3F4F5F6F7F8F9FAFBFCFDFE\0X" };
86     BYTE data[255];
87     WCHAR strw[256];
88     BOOL bOk;
89     int i;
90
91     pHexFromBin = (void*)GetProcAddress(hMapi32, "HexFromBin@12");
92     pFBinFromHex = (void*)GetProcAddress(hMapi32, "FBinFromHex@8");
93     if (!pHexFromBin || !pFBinFromHex)
94         return;
95
96     for (i = 0; i < 255; i++)
97         data[i] = i;
98     memset(strw, 'X', sizeof(strw));
99     pHexFromBin(data, sizeof(data), strw);
100
101     ok(memcmp(strw, res, sizeof(res) - 1) == 0, "HexFromBin: Result differs\n");
102
103     memset(data, 0, sizeof(data));
104     pFBinFromHex((LPWSTR)res, data);
105     bOk = TRUE;
106     for (i = 0; i < 255; i++)
107         if (data[i] != i)
108             bOk = FALSE;
109     ok(bOk == TRUE, "FBinFromHex: Result differs\n");
110 }
111
112 static void test_UFromSz(void)
113 {
114     pUFromSz = (void*)GetProcAddress(hMapi32, "UFromSz@4");
115     if (!pUFromSz)
116         return;
117
118     ok(pUFromSz("105679") == 105679u,
119        "UFromSz: expected 105679, got %d\n", pUFromSz("105679"));
120
121     ok(pUFromSz(" 4") == 0, "UFromSz: exected 0. got %d\n",
122        pUFromSz(" 4"));
123 }
124
125 static void test_UlFromSzHex(void)
126 {
127     pUlFromSzHex = (void*)GetProcAddress(hMapi32, "UlFromSzHex@4");
128     if (!pUlFromSzHex)
129         return;
130
131     ok(pUlFromSzHex("fF") == 0xffu,
132        "UlFromSzHex: expected 0xff, got 0x%x\n", pUlFromSzHex("fF"));
133
134     ok(pUlFromSzHex(" c") == 0, "UlFromSzHex: exected 0x0. got 0x%x\n",
135        pUlFromSzHex(" c"));
136 }
137
138 static void test_CbOfEncoded(void)
139 {
140     char buff[129];
141     unsigned int i;
142
143     pCbOfEncoded = (void*)GetProcAddress(hMapi32, "CbOfEncoded@4");
144     if (!pCbOfEncoded)
145         return;
146
147     for (i = 0; i < sizeof(buff) - 1; i++)
148     {
149         ULONG ulRet, ulExpected = (((i | 3) >> 2) + 1) * 3;
150
151         memset(buff, '\0', sizeof(buff));
152         memset(buff, '?', i);
153         ulRet = pCbOfEncoded(buff);
154         ok(ulRet == ulExpected, "CbOfEncoded(length %d): expected %d, got %d\n",
155            i, ulExpected, ulRet);
156     }
157 }
158
159 static void test_IsBadBoundedStringPtr(void)
160 {
161     pIsBadBoundedStringPtr = (void*)GetProcAddress(hMapi32, "IsBadBoundedStringPtr@8");
162     if (!pIsBadBoundedStringPtr)
163         return;
164
165     ok(pIsBadBoundedStringPtr(NULL, 0) == TRUE, "IsBadBoundedStringPtr: expected TRUE\n");
166     ok(pIsBadBoundedStringPtr("TEST", 4) == TRUE, "IsBadBoundedStringPtr: expected TRUE\n");
167     ok(pIsBadBoundedStringPtr("TEST", 5) == FALSE, "IsBadBoundedStringPtr: expected FALSE\n");
168 }
169
170 START_TEST(util)
171 {
172     SCODE ret;
173
174     hMapi32 = LoadLibraryA("mapi32.dll");
175
176     pScInitMapiUtil = (void*)GetProcAddress(hMapi32, "ScInitMapiUtil@4");
177
178     if (!pScInitMapiUtil)
179     {
180         skip("ScInitMapiUtil is not available\n");
181         FreeLibrary(hMapi32);
182         return;
183     }
184
185     SetLastError(0xdeadbeef);
186     ret = pScInitMapiUtil(0);
187     if ((ret != S_OK) && (GetLastError() == ERROR_PROC_NOT_FOUND))
188     {
189         skip("ScInitMapiUtil is not implemented\n");
190         FreeLibrary(hMapi32);
191         return;
192     }
193
194     test_SwapPword();
195     test_SwapPlong();
196     test_HexFromBin();
197     test_UFromSz();
198     test_UlFromSzHex();
199     test_CbOfEncoded();
200     test_IsBadBoundedStringPtr();
201
202     FreeLibrary(hMapi32);
203 }