VirtualBox

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

Last change on this file since 62584 was 62477, checked in by vboxsync, 8 years ago

(C) 2016
  • 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 62477 2016-07-22 18:27:37Z vboxsync $ */
2/** @file
3 * IPRT Testcase - Testcase for the No-CRT assembly bits.
4 */
5
6/*
7 * Copyright (C) 2008-2016 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
44typedef 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*********************************************************************************************************************************/
55static unsigned g_cErrors = 0;
56
57
58static 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
65static 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
94static 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
102static 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
117int 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.

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