VirtualBox

source: vbox/trunk/src/VBox/Runtime/testcase/tstStrToNum.cpp@ 1

Last change on this file since 1 was 1, checked in by vboxsync, 55 years ago

import
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 9.5 KB
Line 
1/* $Id: tstStrToNum.cpp 1 1970-01-01 00:00:00Z vboxsync $ */
2/** @file
3 * InnoTek Portable Runtime Testcase - String To Number Conversion.
4 */
5
6/*
7 * Copyright (C) 2006 InnoTek Systemberatung GmbH
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 as published by the Free Software Foundation,
13 * in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14 * distribution. VirtualBox OSE is distributed in the hope that it will
15 * be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * If you received this file as part of a commercial VirtualBox
18 * distribution, then only the terms of your commercial VirtualBox
19 * license agreement apply instead of the previous paragraph.
20 */
21
22#include <iprt/string.h>
23#include <iprt/stream.h>
24#include <iprt/err.h>
25
26struct TstI64
27{
28 const char *psz;
29 unsigned uBase;
30 int rc;
31 int64_t Result;
32};
33
34struct TstU64
35{
36 const char *psz;
37 unsigned uBase;
38 int rc;
39 uint64_t Result;
40};
41
42struct TstI32
43{
44 const char *psz;
45 unsigned uBase;
46 int rc;
47 int32_t Result;
48};
49
50struct TstU32
51{
52 const char *psz;
53 unsigned uBase;
54 int rc;
55 uint32_t Result;
56};
57
58
59#define TEST(Test, Type, Fmt, Fun) \
60 do \
61 { \
62 Type Result; \
63 int rc = Fun(Test.psz, NULL, Test.uBase, &Result); \
64 if (Result != Test.Result) \
65 { \
66 RTPrintf("failure: '%s' -> " Fmt " expected " Fmt ". (%s)\n", Test.psz, Result, Test.Result, #Fun); \
67 cErrors++; \
68 } \
69 else if (rc != Test.rc) \
70 { \
71 RTPrintf("failure: '%s' -> rc=%Vrc expected %Vrc. (%s)\n", Test.psz, rc, Test.rc, #Fun); \
72 cErrors++; \
73 } \
74 } while (0)
75
76
77#define RUN_TESTS(aTests, Type, Fmt, Fun) \
78 do \
79 { \
80 for (unsigned iTest = 0; iTest < ELEMENTS(aTests); iTest++) \
81 { \
82 TEST(aTests[iTest], Type, Fmt, Fun); \
83 } \
84 } while (0)
85
86int main()
87{
88 int cErrors = 0;
89 static const struct TstU64 aTstU64[] =
90 {
91 { "0", 0, VINF_SUCCESS, 0 },
92 { "1", 0, VINF_SUCCESS, 1 },
93 { "-1", 0, VWRN_NEGATIVE_UNSIGNED, ~0ULL },
94 { "0x", 0, VINF_SUCCESS, 0 },
95 { "0x1", 0, VINF_SUCCESS, 1 },
96 { "0x0fffffffffffffff", 0, VINF_SUCCESS, 0x0fffffffffffffffULL },
97 { "0x0ffffffffffffffffffffff",0, VWRN_NUMBER_TOO_BIG, 0xffffffffffffffffULL },
98 { "asdfasdfasdf", 0, VERR_NO_DIGITS, 0 },
99 { "0x111111111", 0, VINF_SUCCESS, 0x111111111ULL },
100 };
101 RUN_TESTS(aTstU64, uint64_t, "%#llx", RTStrToUInt64Ex);
102
103 static const struct TstI64 aTstI64[] =
104 {
105 { "0", 0, VINF_SUCCESS, 0 },
106 { "1", 0, VINF_SUCCESS, 1 },
107 { "-1", 0, VINF_SUCCESS, -1 },
108 { "-1", 10, VINF_SUCCESS, -1 },
109 { "-31", 0, VINF_SUCCESS, -31 },
110 { "-31", 10, VINF_SUCCESS, -31 },
111 { "-32", 0, VINF_SUCCESS, -32 },
112 { "-33", 0, VINF_SUCCESS, -33 },
113 { "-64", 0, VINF_SUCCESS, -64 },
114 { "-127", 0, VINF_SUCCESS, -127 },
115 { "-128", 0, VINF_SUCCESS, -128 },
116 { "-129", 0, VINF_SUCCESS, -129 },
117 { "-254", 0, VINF_SUCCESS, -254 },
118 { "-255", 0, VINF_SUCCESS, -255 },
119 { "-256", 0, VINF_SUCCESS, -256 },
120 { "-257", 0, VINF_SUCCESS, -257 },
121 { "-511", 0, VINF_SUCCESS, -511 },
122 { "-512", 0, VINF_SUCCESS, -512 },
123 { "-513", 0, VINF_SUCCESS, -513 },
124 { "-1023", 0, VINF_SUCCESS, -1023 },
125 { "-1023", 0, VINF_SUCCESS, -1023 },
126 { "-1023", 0, VINF_SUCCESS, -1023},
127 { "-1023", 10, VINF_SUCCESS, -1023 },
128 { "-4564678", 0, VINF_SUCCESS, -4564678 },
129 { "-4564678", 10, VINF_SUCCESS, -4564678 },
130 { "-1234567890123456789", 0, VINF_SUCCESS, -1234567890123456789LL },
131 { "-1234567890123456789", 10, VINF_SUCCESS, -1234567890123456789LL },
132 { "0x", 0, VINF_SUCCESS, 0 },
133 { "0x1", 0, VINF_SUCCESS, 1 },
134 { "0x1", 10, VINF_SUCCESS, 0 },
135 { "0x1", 16, VINF_SUCCESS, 1 },
136 { "0x0fffffffffffffff", 0, VINF_SUCCESS, 0x0fffffffffffffffULL },
137 //{ "0x01111111111111111111111",0, VWRN_NUMBER_TOO_BIG, 0x1111111111111111ULL },
138 { "0x0ffffffffffffffffffffff",0, VWRN_NUMBER_TOO_BIG, 0xffffffffffffffffULL },
139 { "asdfasdfasdf", 0, VERR_NO_DIGITS, 0 },
140 { "0x111111111", 0, VINF_SUCCESS, 0x111111111ULL },
141 };
142 RUN_TESTS(aTstI64, int64_t, "%#lld", RTStrToInt64Ex);
143
144
145
146 static const struct TstI32 aTstI32[] =
147 {
148 { "0", 0, VINF_SUCCESS, 0 },
149 { "1", 0, VINF_SUCCESS, 1 },
150 { "-1", 0, VINF_SUCCESS, -1 },
151 { "-1", 10, VINF_SUCCESS, -1 },
152 { "-31", 0, VINF_SUCCESS, -31 },
153 { "-31", 10, VINF_SUCCESS, -31 },
154 { "-32", 0, VINF_SUCCESS, -32 },
155 { "-33", 0, VINF_SUCCESS, -33 },
156 { "-64", 0, VINF_SUCCESS, -64 },
157 { "-127", 0, VINF_SUCCESS, -127 },
158 { "-128", 0, VINF_SUCCESS, -128 },
159 { "-129", 0, VINF_SUCCESS, -129 },
160 { "-254", 0, VINF_SUCCESS, -254 },
161 { "-255", 0, VINF_SUCCESS, -255 },
162 { "-256", 0, VINF_SUCCESS, -256 },
163 { "-257", 0, VINF_SUCCESS, -257 },
164 { "-511", 0, VINF_SUCCESS, -511 },
165 { "-512", 0, VINF_SUCCESS, -512 },
166 { "-513", 0, VINF_SUCCESS, -513 },
167 { "-1023", 0, VINF_SUCCESS, -1023 },
168 { "-1023", 0, VINF_SUCCESS, -1023 },
169 { "-1023", 0, VINF_SUCCESS, -1023},
170 { "-1023", 10, VINF_SUCCESS, -1023 },
171 { "-4564678", 0, VINF_SUCCESS, -4564678 },
172 { "-4564678", 10, VINF_SUCCESS, -4564678 },
173 { "4564678", 0, VINF_SUCCESS, 4564678 },
174 { "4564678", 10, VINF_SUCCESS, 4564678 },
175 { "-1234567890123456789", 0, VWRN_NUMBER_TOO_BIG, (int32_t)-1234567890123456789LL },
176 { "-1234567890123456789", 10, VWRN_NUMBER_TOO_BIG, (int32_t)-1234567890123456789LL },
177 { "1234567890123456789", 0, VWRN_NUMBER_TOO_BIG, (int32_t)1234567890123456789LL },
178 { "1234567890123456789", 10, VWRN_NUMBER_TOO_BIG, (int32_t)1234567890123456789LL },
179 { "0x", 0, VINF_SUCCESS, 0 },
180 { "0x1", 0, VINF_SUCCESS, 1 },
181 { "0x1", 10, VINF_SUCCESS, 0 },
182 { "0x1", 16, VINF_SUCCESS, 1 },
183 { "0x0fffffffffffffff", 0, VWRN_NUMBER_TOO_BIG, 0xffffffff },
184 { "0x01111111111111111111111",0, VWRN_NUMBER_TOO_BIG, 0x11111111 },
185 { "0x0ffffffffffffffffffffff",0, VWRN_NUMBER_TOO_BIG, 0xffffffff },
186 { "asdfasdfasdf", 0, VERR_NO_DIGITS, 0 },
187 { "0x1111111", 0, VINF_SUCCESS, 0x01111111 },
188 };
189 RUN_TESTS(aTstI32, int32_t, "%#d", RTStrToInt32Ex);
190
191 static const struct TstU32 aTstU32[] =
192 {
193 { "0", 0, VINF_SUCCESS, 0 },
194 { "1", 0, VINF_SUCCESS, 1 },
195 { "-1", 0, VWRN_NEGATIVE_UNSIGNED, ~0 },
196 { "0x", 0, VINF_SUCCESS, 0 },
197 { "0x1", 0, VINF_SUCCESS, 1 },
198 { "0x0fffffffffffffff", 0, VWRN_NUMBER_TOO_BIG, 0xffffffffU },
199 { "0x0ffffffffffffffffffffff",0, VWRN_NUMBER_TOO_BIG, 0xffffffffU },
200 { "asdfasdfasdf", 0, VERR_NO_DIGITS, 0 },
201 { "0x1111111", 0, VINF_SUCCESS, 0x1111111 },
202 };
203 RUN_TESTS(aTstU32, uint32_t, "%#x", RTStrToUInt32Ex);
204
205 /*
206 * Summary.
207 */
208 if (!cErrors)
209 RTPrintf("tstStrToNum: SUCCESS\n");
210 else
211 RTPrintf("tstStrToNum: FAILURE - %d errors\n", cErrors);
212 return !!cErrors;
213}
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