tstNoCrt-1.cpp@ 53401

Last change on this file since 53401 was 48935, checked in by vboxsync, 11 years ago
Runtime: Whitespace and svn:keyword cleanups by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 18.6 KB

Line
1	/* $Id: tstNoCrt-1.cpp 48935 2013-10-07 21:19:37Z vboxsync $ */
2	/** @file
3	* IPRT Testcase - Testcase for the No-CRT assembly bits.
4	*/
5
6	/*
7	* Copyright (C) 2008-2011 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27	/*******************************************************************************
28	* Header Files *
29	*******************************************************************************/
30	#include <iprt/nocrt/string.h>
31	#include <iprt/stream.h>
32	#include <iprt/initterm.h>
33	#include <iprt/string.h>
34	#ifdef RT_WITHOUT_NOCRT_WRAPPERS
35	# error "Build error."
36	#endif
37
38
39	/*******************************************************************************
40	* Structures and Typedefs *
41	*******************************************************************************/
42	#define TSTBUF_SIZE 8192
43	typedef struct TSTBUF
44	{
45	uint8_t abHeadFence[2048];
46	uint8_t abBuf[TSTBUF_SIZE];
47	uint8_t abTailFence[2048];
48	} TSTBUF, *PTSTBUF;
49
50
51	/*******************************************************************************
52	* Global Variables *
53	*******************************************************************************/
54	static unsigned g_cErrors = 0;
55
56
57	static void my_memset(void *pv, int ch, size_t cb)
58	{
59	uint8_t pb = (uint8_t )pv;
60	while (cb--)
61	*pb++ = ch;
62	}
63
64	static void my_memcheck(const void pv, int ch, size_t cb, const char pszDesc)
65	{
66	uint8_t pb = (uint8_t )pv;
67	while (cb--)
68	{
69	if (*pb != (uint8_t)ch)
70	{
71	g_cErrors++;
72	size_t off;
73	for (off = 1; off < cb && pb[off] != (uint8_t)ch; off++)
74	/* nandemonai */;
75	off--;
76	pb += off;
77	cb -= off;
78	if (off)
79	RTPrintf("tstNoCrt-1: %s: %p:%p - %02x instead of %02x\n",
80	pszDesc, (uintptr_t)pb - (uintptr_t)pv,
81	(uint8_t )pb - (uint8_t )pv + off, *pb, (uint8_t)ch);
82	else
83	RTPrintf("tstNoCrt-1: %s: %p - %02x instead of %02x\n",
84	pszDesc, (uint8_t )pb - (uint8_t )pv, *pb, (uint8_t)ch);
85	}
86
87	/* next*/
88	pb++;
89	}
90	}
91
92
93	static void TstBufInit(PTSTBUF pBuf, int ch)
94	{
95	my_memset(pBuf->abHeadFence, 0x55, sizeof(pBuf->abHeadFence));
96	my_memset(pBuf->abBuf, ch, sizeof(pBuf->abBuf));
97	my_memset(pBuf->abTailFence, 0x77, sizeof(pBuf->abHeadFence));
98	}
99
100
101	static void TstBufCheck(PTSTBUF pBuf, const char *pszDesc)
102	{
103	my_memcheck(pBuf->abHeadFence, 0x55, sizeof(pBuf->abHeadFence), pszDesc);
104	my_memcheck(pBuf->abTailFence, 0x77, sizeof(pBuf->abTailFence), pszDesc);
105	}
106
107
108	#if 0 /* enable this to test the testcase. */
109	# undef RT_NOCRT
110	# define RT_NOCRT(a) a
111	# ifdef _MSC_VER
112	# define mempcpy nocrt_mempcpy
113	# endif
114	#endif
115
116	int main()
117	{
118	/*
119	* Prologue.
120	*/
121	RTR3InitExeNoArguments(0);
122	RTPrintf("tstNoCrt-1: TESTING...\n");
123
124	/*
125	* Sanity.
126	*/
127	TSTBUF Buf1;
128	TstBufInit(&Buf1, 1);
129	my_memcheck(Buf1.abBuf, 1, TSTBUF_SIZE, "sanity buf1");
130	TstBufCheck(&Buf1, "sanity buf1");
131
132	TSTBUF Buf2;
133	TstBufInit(&Buf2, 2);
134	my_memcheck(Buf2.abBuf, 2, TSTBUF_SIZE, "sanity buf2");
135	TstBufCheck(&Buf2, "sanity buf2");
136	if (g_cErrors)
137	{
138	RTPrintf("tstNoCrt-1: FAILED - fatal sanity error\n");
139	return 1;
140	}
141
142	#define CHECK_CCH(expect) \
143	do \
144	{ \
145	if (cch != (expect)) \
146	{ \
147	RTPrintf("tstNoCrt-1(%d): cb=%zu expected=%zu\n", __LINE__, cch, (expect)); \
148	g_cErrors++; \
149	} \
150	} while (0)
151	size_t cch;
152
153	#define CHECK_PV(expect) \
154	do \
155	{ \
156	if (pv != (expect)) \
157	{ \
158	RTPrintf("tstNoCrt-1(%d): pv=%p expected=%p\n", __LINE__, pv, (expect)); \
159	g_cErrors++; \
160	} \
161	} while (0)
162	void *pv;
163
164	#define CHECK_DIFF(op) \
165	do \
166	{ \
167	if (!(iDiff op 0)) \
168	{ \
169	RTPrintf("tstNoCrt-1(%d): iDiff=%d expected: %s 0\n", __LINE__, iDiff, #op); \
170	g_cErrors++; \
171	} \
172	} while (0)
173	int iDiff;
174
175	static char s_szTest1[] = "0123456789abcdef";
176	static char s_szTest2[] = "0123456789abcdef";
177	static char s_szTest3[] = "fedcba9876543210";
178
179	/*
180	* memcpy.
181	*/
182	RTPrintf("tstNoCrt-1: memcpy\n");
183	TstBufInit(&Buf1, 1);
184	TstBufInit(&Buf2, 2);
185	pv = RT_NOCRT(memcpy)(Buf1.abBuf, Buf2.abBuf, TSTBUF_SIZE); CHECK_PV(Buf1.abBuf);
186	my_memcheck(Buf1.abBuf, 2, TSTBUF_SIZE, "memcpy1-dst");
187	my_memcheck(Buf2.abBuf, 2, TSTBUF_SIZE, "memcpy1-src");
188	TstBufCheck(&Buf1, "memcpy1");
189	TstBufCheck(&Buf2, "memcpy1");
190
191	TstBufInit(&Buf1, 3);
192	TstBufInit(&Buf2, 4);
193	pv = RT_NOCRT(memcpy)(Buf2.abBuf, Buf1.abBuf, TSTBUF_SIZE); CHECK_PV(Buf2.abBuf);
194	my_memcheck(Buf1.abBuf, 3, TSTBUF_SIZE, "memcpy2-dst");
195	my_memcheck(Buf2.abBuf, 3, TSTBUF_SIZE, "memcpy2-src");
196	TstBufCheck(&Buf1, "memcpy2");
197	TstBufCheck(&Buf2, "memcpy2");
198
199	TstBufInit(&Buf1, 5);
200	TstBufInit(&Buf2, 6);
201	pv = RT_NOCRT(memcpy)(Buf2.abBuf, Buf1.abBuf, 0); CHECK_PV(Buf2.abBuf);
202	my_memcheck(Buf1.abBuf, 5, TSTBUF_SIZE, "memcpy3-dst");
203	my_memcheck(Buf2.abBuf, 6, TSTBUF_SIZE, "memcpy3-src");
204	TstBufCheck(&Buf1, "memcpy3-dst");
205	TstBufCheck(&Buf2, "memcpy3-src");
206
207	for (unsigned off1 = 0; off1 <= 128; off1++)
208	{
209	for (unsigned off2 = 0; off2 <= 256; off2++)
210	{
211	char sz[32];
212	RTStrPrintf(sz, sizeof(sz), "memcpy4-%d-%d", off1, off2);
213	TstBufInit(&Buf1, 1);
214	TstBufInit(&Buf2, 2);
215	size_t cb = off2;
216	pv = RT_NOCRT(memcpy)(&Buf2.abBuf[off2], &Buf1.abBuf[off1], cb); CHECK_PV(&Buf2.abBuf[off2]);
217	my_memcheck(Buf1.abBuf, 1, TSTBUF_SIZE, sz);
218	my_memcheck(Buf2.abBuf, 2, off2, sz);
219	my_memcheck(&Buf2.abBuf[off2], 1, cb, sz);
220	my_memcheck(&Buf2.abBuf[off2 + cb], 2, TSTBUF_SIZE - cb - off2, sz);
221	TstBufCheck(&Buf1, sz);
222	TstBufCheck(&Buf2, sz);
223	}
224	}
225
226	/*
227	* mempcpy.
228	*/
229	RTPrintf("tstNoCrt-1: mempcpy\n");
230	TstBufInit(&Buf1, 1);
231	TstBufInit(&Buf2, 2);
232	pv = RT_NOCRT(mempcpy)(Buf1.abBuf, Buf2.abBuf, TSTBUF_SIZE); CHECK_PV(&Buf1.abBuf[TSTBUF_SIZE]);
233	my_memcheck(Buf1.abBuf, 2, TSTBUF_SIZE, "mempcpy1-dst");
234	my_memcheck(Buf2.abBuf, 2, TSTBUF_SIZE, "mempcpy1-src");
235	TstBufCheck(&Buf1, "mempcpy1");
236	TstBufCheck(&Buf2, "mempcpy1");
237
238	TstBufInit(&Buf1, 3);
239	TstBufInit(&Buf2, 4);
240	pv = RT_NOCRT(mempcpy)(Buf2.abBuf, Buf1.abBuf, TSTBUF_SIZE); CHECK_PV(&Buf2.abBuf[TSTBUF_SIZE]);
241	my_memcheck(Buf1.abBuf, 3, TSTBUF_SIZE, "mempcpy2-dst");
242	my_memcheck(Buf2.abBuf, 3, TSTBUF_SIZE, "mempcpy2-src");
243	TstBufCheck(&Buf1, "mempcpy2");
244	TstBufCheck(&Buf2, "mempcpy2");
245
246	TstBufInit(&Buf1, 5);
247	TstBufInit(&Buf2, 6);
248	pv = RT_NOCRT(mempcpy)(Buf2.abBuf, Buf1.abBuf, 0); CHECK_PV(Buf2.abBuf);
249	my_memcheck(Buf1.abBuf, 5, TSTBUF_SIZE, "mempcpy3-dst");
250	my_memcheck(Buf2.abBuf, 6, TSTBUF_SIZE, "mempcpy3-src");
251	TstBufCheck(&Buf1, "mempcpy3-dst");
252	TstBufCheck(&Buf2, "mempcpy3-src");
253
254	for (unsigned off1 = 0; off1 <= 128; off1++)
255	{
256	for (unsigned off2 = 0; off2 <= 256; off2++)
257	{
258	char sz[32];
259	RTStrPrintf(sz, sizeof(sz), "mempcpy4-%d-%d", off1, off2);
260	TstBufInit(&Buf1, 1);
261	TstBufInit(&Buf2, 2);
262	size_t cb = off2;
263	pv = RT_NOCRT(mempcpy)(&Buf2.abBuf[off2], &Buf1.abBuf[off1], cb); CHECK_PV(&Buf2.abBuf[off2 + cb]);
264	my_memcheck(Buf1.abBuf, 1, TSTBUF_SIZE, sz);
265	my_memcheck(Buf2.abBuf, 2, off2, sz);
266	my_memcheck(&Buf2.abBuf[off2], 1, cb, sz);
267	my_memcheck(&Buf2.abBuf[off2 + cb], 2, TSTBUF_SIZE - cb - off2, sz);
268	TstBufCheck(&Buf1, sz);
269	TstBufCheck(&Buf2, sz);
270	}
271	}
272
273	/*
274	* memmove.
275	*/
276	RTPrintf("tstNoCrt-1: memmove\n");
277	TstBufInit(&Buf1, 1);
278	TstBufInit(&Buf2, 2);
279	pv = RT_NOCRT(memmove)(Buf1.abBuf, Buf2.abBuf, TSTBUF_SIZE); CHECK_PV(Buf1.abBuf);
280	my_memcheck(Buf1.abBuf, 2, TSTBUF_SIZE, "memmove1-dst");
281	my_memcheck(Buf2.abBuf, 2, TSTBUF_SIZE, "memmove1-src");
282	TstBufCheck(&Buf1, "memmove1");
283	TstBufCheck(&Buf2, "memmove1");
284
285	TstBufInit(&Buf1, 3);
286	TstBufInit(&Buf2, 4);
287	pv = RT_NOCRT(memmove)(Buf2.abBuf, Buf1.abBuf, TSTBUF_SIZE); CHECK_PV(Buf2.abBuf);
288	my_memcheck(Buf1.abBuf, 3, TSTBUF_SIZE, "memmove2-dst");
289	my_memcheck(Buf2.abBuf, 3, TSTBUF_SIZE, "memmove2-src");
290	TstBufCheck(&Buf1, "memmove2");
291	TstBufCheck(&Buf2, "memmove2");
292
293	TstBufInit(&Buf1, 5);
294	TstBufInit(&Buf2, 6);
295	pv = RT_NOCRT(memmove)(Buf2.abBuf, Buf1.abBuf, 0); CHECK_PV(Buf2.abBuf);
296	my_memcheck(Buf1.abBuf, 5, TSTBUF_SIZE, "memmove3-dst");
297	my_memcheck(Buf2.abBuf, 6, TSTBUF_SIZE, "memmove3-src");
298	TstBufCheck(&Buf1, "memmove3-dst");
299	TstBufCheck(&Buf2, "memmove3-src");
300
301	for (unsigned off1 = 1; off1 <= 128; off1++)
302	{
303	for (unsigned off2 = 0; off2 <= 256; off2++)
304	{
305	/* forward */
306	char sz[32];
307	RTStrPrintf(sz, sizeof(sz), "memmove4-%d-%d", off1, off2);
308	TstBufInit(&Buf1, off1 + 1);
309	my_memset(Buf1.abBuf, off1, off1);
310	pv = RT_NOCRT(memmove)(Buf1.abBuf, &Buf1.abBuf[off2], TSTBUF_SIZE - off2); CHECK_PV(Buf1.abBuf);
311	if (off2 < off1)
312	{
313	unsigned cbLead = off1 - off2;
314	my_memcheck(Buf1.abBuf, off1, cbLead, sz);
315	my_memcheck(&Buf1.abBuf[cbLead], off1 + 1, TSTBUF_SIZE - cbLead, sz);
316	}
317	else
318	my_memcheck(Buf1.abBuf, off1 + 1, TSTBUF_SIZE, sz);
319	TstBufCheck(&Buf1, sz);
320
321	/* backward */
322	RTStrPrintf(sz, sizeof(sz), "memmove5-%d-%d", off1, off2);
323	TstBufInit(&Buf1, off1 + 1);
324	my_memset(&Buf1.abBuf[TSTBUF_SIZE - off1], off1, off1);
325	pv = RT_NOCRT(memmove)(&Buf1.abBuf[off2], Buf1.abBuf, TSTBUF_SIZE - off2); CHECK_PV(&Buf1.abBuf[off2]);
326	if (off2 < off1)
327	{
328	unsigned cbLead = off1 - off2;
329	my_memcheck(&Buf1.abBuf[TSTBUF_SIZE - cbLead], off1, cbLead, sz);
330	my_memcheck(Buf1.abBuf, off1 + 1, TSTBUF_SIZE - cbLead, sz);
331	}
332	else
333	my_memcheck(Buf1.abBuf, off1 + 1, TSTBUF_SIZE, sz);
334	TstBufCheck(&Buf1, sz);
335	/* small unaligned */
336	RTStrPrintf(sz, sizeof(sz), "memmove6-%d-%d", off1, off2);
337	TstBufInit(&Buf1, 1);
338	TstBufInit(&Buf2, 2);
339	size_t cb = off2;
340	pv = RT_NOCRT(memmove)(&Buf2.abBuf[off2], &Buf1.abBuf[off1], cb); CHECK_PV(&Buf2.abBuf[off2]);
341	my_memcheck(Buf1.abBuf, 1, TSTBUF_SIZE, sz);
342	my_memcheck(Buf2.abBuf, 2, off2, sz);
343	my_memcheck(&Buf2.abBuf[off2], 1, cb, sz);
344	my_memcheck(&Buf2.abBuf[off2 + cb], 2, TSTBUF_SIZE - cb - off2, sz);
345	TstBufCheck(&Buf1, sz);
346	TstBufCheck(&Buf2, sz);
347	}
348	}
349
350	/*
351	* memset
352	*/
353	RTPrintf("tstNoCrt-1: memset\n");
354	TstBufInit(&Buf1, 1);
355	pv = RT_NOCRT(memset)(Buf1.abBuf, 0, TSTBUF_SIZE); CHECK_PV(Buf1.abBuf);
356	my_memcheck(Buf1.abBuf, 0, TSTBUF_SIZE, "memset-1");
357	TstBufCheck(&Buf1, "memset-1");
358
359	TstBufInit(&Buf1, 1);
360	pv = RT_NOCRT(memset)(Buf1.abBuf, 0xff, TSTBUF_SIZE); CHECK_PV(Buf1.abBuf);
361	my_memcheck(Buf1.abBuf, 0xff, TSTBUF_SIZE, "memset-2");
362	TstBufCheck(&Buf1, "memset-2");
363
364	TstBufInit(&Buf1, 1);
365	pv = RT_NOCRT(memset)(Buf1.abBuf, 0xff, 0); CHECK_PV(Buf1.abBuf);
366	my_memcheck(Buf1.abBuf, 1, TSTBUF_SIZE, "memset-3");
367	TstBufCheck(&Buf1, "memset-3");
368
369	for (unsigned off = 0; off < 256; off++)
370	{
371	/* move start byte by byte. */
372	char sz[32];
373	RTStrPrintf(sz, sizeof(sz), "memset4-%d", off);
374	TstBufInit(&Buf1, 0);
375	pv = RT_NOCRT(memset)(&Buf1.abBuf[off], off, TSTBUF_SIZE - off); CHECK_PV(&Buf1.abBuf[off]);
376	my_memcheck(Buf1.abBuf, 0, off, sz);
377	my_memcheck(&Buf1.abBuf[off], off, TSTBUF_SIZE - off, sz);
378	TstBufCheck(&Buf1, sz);
379
380	/* move end byte by byte. */
381	RTStrPrintf(sz, sizeof(sz), "memset5-%d", off);
382	TstBufInit(&Buf1, 0);
383	pv = RT_NOCRT(memset)(Buf1.abBuf, off, TSTBUF_SIZE - off); CHECK_PV(Buf1.abBuf);
384	my_memcheck(Buf1.abBuf, off, TSTBUF_SIZE - off, sz);
385	my_memcheck(&Buf1.abBuf[TSTBUF_SIZE - off], 0, off, sz);
386	TstBufCheck(&Buf1, sz);
387
388	/* move both start and size byte by byte. */
389	RTStrPrintf(sz, sizeof(sz), "memset6-%d", off);
390	TstBufInit(&Buf1, 0);
391	pv = RT_NOCRT(memset)(&Buf1.abBuf[off], off, off); CHECK_PV(&Buf1.abBuf[off]);
392	my_memcheck(Buf1.abBuf, 0, off, sz);
393	my_memcheck(&Buf1.abBuf[off], off, off, sz);
394	my_memcheck(&Buf1.abBuf[off * 2], 0, TSTBUF_SIZE - off * 2, sz);
395	TstBufCheck(&Buf1, sz);
396	}
397
398	/*
399	* strcpy (quick smoke testing).
400	*/
401	RTPrintf("tstNoCrt-1: strcpy\n");
402	TstBufInit(&Buf1, 1);
403	const char *pszSrc = s_szTest1;
404	char pszDst = (char )&Buf1.abBuf[0];
405	pv = RT_NOCRT(strcpy)(pszDst, pszSrc);
406	CHECK_PV(pszDst);
407	TstBufCheck(&Buf1, "strcpy 1");
408	iDiff = RT_NOCRT(strcmp)(pszDst, pszSrc); CHECK_DIFF( == );
409
410	pszSrc = s_szTest1;
411	for (unsigned i = 0; i < sizeof(s_szTest1) / 2; i++)
412	{
413	pszSrc++;
414	TstBufInit(&Buf1, 2);
415	pszDst = (char *)&Buf1.abBuf[sizeof(Buf1.abBuf) - strlen(pszSrc) - 1];
416	pv = RT_NOCRT(strcpy)(pszDst, pszSrc);
417	CHECK_PV(pszDst);
418	TstBufCheck(&Buf1, "strcpy 3");
419	iDiff = RT_NOCRT(strcmp)(pszDst, pszSrc); CHECK_DIFF( == );
420	}
421
422
423	/*
424	* memchr & strchr.
425	*/
426	RTPrintf("tstNoCrt-1: memchr\n");
427	pv = RT_NOCRT(memchr)(&s_szTest1[0x00], 'f', sizeof(s_szTest1)); CHECK_PV(&s_szTest1[0xf]);
428	pv = RT_NOCRT(memchr)(&s_szTest1[0x0f], 'f', sizeof(s_szTest1)); CHECK_PV(&s_szTest1[0xf]);
429	pv = RT_NOCRT(memchr)(&s_szTest1[0x03], 0, sizeof(s_szTest1)); CHECK_PV(&s_szTest1[0x10]);
430	pv = RT_NOCRT(memchr)(&s_szTest1[0x10], 0, sizeof(s_szTest1)); CHECK_PV(&s_szTest1[0x10]);
431	pv = RT_NOCRT(memchr)(&s_szTest1, 0, ~(size_t)0); CHECK_PV(&s_szTest1[0x10]);
432	pv = RT_NOCRT(memchr)(&s_szTest1, 0, ~(size_t)1); CHECK_PV(&s_szTest1[0x10]);
433	pv = RT_NOCRT(memchr)(&s_szTest1, 0, ~(size_t)16); CHECK_PV(&s_szTest1[0x10]);
434	for (unsigned i = 0; i < sizeof(s_szTest1); i++)
435	for (unsigned j = 0; j <= i; j++)
436	{
437	pv = RT_NOCRT(memchr)(&s_szTest1[j], s_szTest1[i], sizeof(s_szTest1));
438	CHECK_PV(&s_szTest1[i]);
439	}
440
441	RTPrintf("tstNoCrt-1: strchr\n");
442	pv = RT_NOCRT(strchr)(&s_szTest1[0x00], 'f'); CHECK_PV(&s_szTest1[0xf]);
443	pv = RT_NOCRT(strchr)(&s_szTest1[0x0f], 'f'); CHECK_PV(&s_szTest1[0xf]);
444	pv = RT_NOCRT(strchr)(&s_szTest1[0x03], 0); CHECK_PV(&s_szTest1[0x10]);
445	pv = RT_NOCRT(strchr)(&s_szTest1[0x10], 0); CHECK_PV(&s_szTest1[0x10]);
446	for (unsigned i = 0; i < sizeof(s_szTest1); i++)
447	for (unsigned j = 0; j <= i; j++)
448	{
449	pv = RT_NOCRT(strchr)(&s_szTest1[j], s_szTest1[i]);
450	CHECK_PV(&s_szTest1[i]);
451	}
452
453	/*
454	* Some simple memcmp/strcmp checks.
455	*/
456	RTPrintf("tstNoCrt-1: memcmp\n");
457	iDiff = RT_NOCRT(memcmp)(s_szTest1, s_szTest1, sizeof(s_szTest1)); CHECK_DIFF( == );
458	iDiff = RT_NOCRT(memcmp)(s_szTest1, s_szTest2, sizeof(s_szTest1)); CHECK_DIFF( == );
459	iDiff = RT_NOCRT(memcmp)(s_szTest2, s_szTest1, sizeof(s_szTest1)); CHECK_DIFF( == );
460	iDiff = RT_NOCRT(memcmp)(s_szTest3, s_szTest3, sizeof(s_szTest1)); CHECK_DIFF( == );
461	iDiff = RT_NOCRT(memcmp)(s_szTest1, s_szTest3, sizeof(s_szTest1)); CHECK_DIFF( < );
462	iDiff = RT_NOCRT(memcmp)(s_szTest3, s_szTest1, sizeof(s_szTest1)); CHECK_DIFF( > );
463	iDiff = RT_NOCRT(memcmp)("1234", "1a34", 4); CHECK_DIFF( < );
464
465	RTPrintf("tstNoCrt-1: strcmp\n");
466	iDiff = RT_NOCRT(strcmp)(s_szTest1, s_szTest1); CHECK_DIFF( == );
467	iDiff = RT_NOCRT(strcmp)(s_szTest1, s_szTest2); CHECK_DIFF( == );
468	iDiff = RT_NOCRT(strcmp)(s_szTest2, s_szTest1); CHECK_DIFF( == );
469	iDiff = RT_NOCRT(strcmp)(s_szTest3, s_szTest3); CHECK_DIFF( == );
470	iDiff = RT_NOCRT(strcmp)(s_szTest1, s_szTest3); CHECK_DIFF( < );
471	iDiff = RT_NOCRT(strcmp)(s_szTest3, s_szTest1); CHECK_DIFF( > );
472
473	/*
474	* Some simple strlen checks.
475	*/
476	RTPrintf("tstNoCrt-1: strlen\n");
477	cch = RT_NOCRT(strlen)(""); CHECK_CCH(0);
478	cch = RT_NOCRT(strlen)("1"); CHECK_CCH(1);
479	cch = RT_NOCRT(strlen)("12"); CHECK_CCH(2);
480	cch = RT_NOCRT(strlen)("123"); CHECK_CCH(3);
481	cch = RT_NOCRT(strlen)("1234"); CHECK_CCH(4);
482	cch = RT_NOCRT(strlen)("12345"); CHECK_CCH(5);
483	cch = RT_NOCRT(strlen)(s_szTest1); CHECK_CCH(sizeof(s_szTest1) - 1);
484	cch = RT_NOCRT(strlen)(&s_szTest1[1]); CHECK_CCH(sizeof(s_szTest1) - 1 - 1);
485	cch = RT_NOCRT(strlen)(&s_szTest1[2]); CHECK_CCH(sizeof(s_szTest1) - 1 - 2);
486	cch = RT_NOCRT(strlen)(&s_szTest1[3]); CHECK_CCH(sizeof(s_szTest1) - 1 - 3);
487	cch = RT_NOCRT(strlen)(&s_szTest1[4]); CHECK_CCH(sizeof(s_szTest1) - 1 - 4);
488	cch = RT_NOCRT(strlen)(&s_szTest1[5]); CHECK_CCH(sizeof(s_szTest1) - 1 - 5);
489	cch = RT_NOCRT(strlen)(&s_szTest1[6]); CHECK_CCH(sizeof(s_szTest1) - 1 - 6);
490	cch = RT_NOCRT(strlen)(&s_szTest1[7]); CHECK_CCH(sizeof(s_szTest1) - 1 - 7);
491	cch = RT_NOCRT(strlen)(s_szTest2); CHECK_CCH(sizeof(s_szTest2) - 1);
492	cch = RT_NOCRT(strlen)(s_szTest3); CHECK_CCH(sizeof(s_szTest3) - 1);
493
494	/*
495	* Summary.
496	*/
497	if (!g_cErrors)
498	RTPrintf("tstNoCrt-1: SUCCESS\n");
499	else
500	RTPrintf("tstNoCrt-1: FAILURE - %d errors\n", g_cErrors);
501	return !!g_cErrors;
502	}
503

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Runtime/testcase/tstNoCrt-1.cpp@ 53401

Download in other formats: