VirtualBox

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

Last change on this file since 44528 was 44528, checked in by vboxsync, 12 years ago

header (C) fixes
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 18.6 KB
Line 
1/* $Id: tstNoCrt-1.cpp 44528 2013-02-04 14:27:54Z 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
43typedef 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*******************************************************************************/
54static unsigned g_cErrors = 0;
55
56
57static 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
64static 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
93static 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
101static 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
116int 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.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette