tstNoCrt-1.cpp@ 86669

Last change on this file since 86669 was 82968, checked in by vboxsync, 5 years ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 19.0 KB

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

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

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

Download in other formats: