VirtualBox

source: vbox/trunk/src/VBox/Runtime/testcase/tstRTStrAlloc.cpp@ 79325

Last change on this file since 79325 was 76553, checked in by vboxsync, 6 years ago

scm --update-copyright-year
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 8.1 KB
Line 
1/* $Id: tstRTStrAlloc.cpp 76553 2019-01-01 01:45:53Z vboxsync $ */
2/** @file
3 * IPRT Testcase - String allocation APIs and related manipulators.
4 */
5
6/*
7 * Copyright (C) 2010-2019 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/string.h>
32
33#include <iprt/asm.h>
34#include <iprt/errcore.h>
35#include <iprt/test.h>
36
37
38/**
39 * Basic API checks.
40 * We'll return if any of these fails.
41 */
42static void tst1(void)
43{
44 RTTestISub("Basics");
45 char *psz;
46 int rc = VINF_SUCCESS;
47
48 /* RTStrAlloc */
49 RTTESTI_CHECK(psz = RTStrAlloc(0));
50 RTTESTI_CHECK(psz && !*psz);
51 RTStrFree(psz);
52
53 RTTESTI_CHECK(psz = RTStrAlloc(1));
54 RTTESTI_CHECK(psz && !*psz);
55 RTStrFree(psz);
56
57 RTTESTI_CHECK(psz = RTStrAlloc(128));
58 RTTESTI_CHECK(psz && !*psz);
59 RTStrFree(psz);
60
61 /* RTStrAllocEx */
62 psz = (char*)"asdfasdf";
63 RTTESTI_CHECK_RC(RTStrAllocEx(&psz, 0), VINF_SUCCESS);
64 RTTESTI_CHECK(psz && !*psz);
65 RTStrFree(psz);
66
67 RTTESTI_CHECK_RC(RTStrAllocEx(&psz, 1), VINF_SUCCESS);
68 RTTESTI_CHECK(psz && !*psz);
69 RTStrFree(psz);
70
71 RTTESTI_CHECK_RC(RTStrAllocEx(&psz, 128), VINF_SUCCESS);
72 RTTESTI_CHECK(psz && !*psz);
73 RTStrFree(psz);
74
75 /* RTStrRealloc */
76 psz = NULL;
77 RTTESTI_CHECK_RC(RTStrRealloc(&psz, 10), VINF_SUCCESS);
78 RTTESTI_CHECK(psz && !psz[0]);
79 RTTESTI_CHECK(psz && !psz[9]);
80 RTStrFree(psz);
81
82 psz = NULL;
83 RTTESTI_CHECK_RC(RTStrRealloc(&psz, 0), VINF_SUCCESS);
84 RTTESTI_CHECK(!psz);
85
86 psz = NULL;
87 RTTESTI_CHECK_RC(RTStrRealloc(&psz, 128), VINF_SUCCESS);
88 RTTESTI_CHECK(psz && !psz[0]);
89 RTTESTI_CHECK(psz && !psz[127]);
90 if (psz)
91 {
92 memset(psz, 'a', 127);
93 RTTESTI_CHECK_RC(rc = RTStrRealloc(&psz, 160), VINF_SUCCESS);
94 if (RT_SUCCESS(rc) && psz)
95 {
96 RTTESTI_CHECK(!psz[127]);
97 RTTESTI_CHECK(!psz[159]);
98 RTTESTI_CHECK(ASMMemIsAllU8(psz, 127, 'a'));
99 memset(psz, 'b', 159);
100
101 RTTESTI_CHECK_RC(rc = RTStrRealloc(&psz, 79), VINF_SUCCESS);
102 if (RT_SUCCESS(rc))
103 {
104 RTTESTI_CHECK(!psz[78]);
105 RTTESTI_CHECK(ASMMemIsAllU8(psz, 78, 'b'));
106
107 RTTESTI_CHECK_RC(rc = RTStrRealloc(&psz, 0), VINF_SUCCESS);
108 RTTESTI_CHECK(!psz);
109 }
110 }
111 }
112 RTStrFree(psz);
113
114 /* RTStrDup */
115 RTTESTI_CHECK(psz = RTStrDup(""));
116 RTTESTI_CHECK(psz && *psz == '\0');
117 RTStrFree(psz);
118
119 RTTESTI_CHECK(psz = RTStrDup("abcdefghijklmnop"));
120 RTTESTI_CHECK(!RTStrCmp(psz, "abcdefghijklmnop"));
121 RTStrFree(psz);
122
123 /* RTStrDupEx */
124 psz = NULL;
125 RTTESTI_CHECK_RC(RTStrDupEx(&psz, ""), VINF_SUCCESS);
126 RTTESTI_CHECK(RT_FAILURE(rc) || *psz == '\0');
127 if (RT_SUCCESS(rc))
128 RTStrFree(psz);
129
130 psz = (char*)"asdfasdfasdfasdf";
131 RTTESTI_CHECK_RC(rc = RTStrDupEx(&psz, "abcdefghijklmnop"), VINF_SUCCESS);
132 RTTESTI_CHECK(RT_FAILURE(rc) || !RTStrCmp(psz, "abcdefghijklmnop"));
133 if (RT_SUCCESS(rc))
134 RTStrFree(psz);
135
136 /* RTStrDupN */
137 RTTESTI_CHECK(psz = RTStrDupN("abcdefg", 3));
138 RTTESTI_CHECK(!RTStrCmp(psz, "abc"));
139 RTStrFree(psz);
140
141 RTTESTI_CHECK(psz = RTStrDupN("abc", 100000));
142 RTTESTI_CHECK(!RTStrCmp(psz, "abc"));
143 RTStrFree(psz);
144
145 RTTESTI_CHECK(psz = RTStrDupN("abc", 0));
146 RTTESTI_CHECK(psz && *psz == '\0');
147 RTStrFree(psz);
148
149 /* RTStrAAppend */
150 RTTESTI_CHECK(psz = RTStrDup("abc"));
151 RTTESTI_CHECK_RC(RTStrAAppend(&psz, "def"), VINF_SUCCESS);
152 RTTESTI_CHECK(!RTStrCmp(psz, "abcdef"));
153 RTStrFree(psz);
154
155 RTTESTI_CHECK(psz = RTStrDup("abc"));
156 RTTESTI_CHECK_RC(RTStrAAppend(&psz, ""), VINF_SUCCESS);
157 RTTESTI_CHECK(!RTStrCmp(psz, "abc"));
158 RTTESTI_CHECK_RC(RTStrAAppend(&psz, NULL), VINF_SUCCESS);
159 RTTESTI_CHECK(!RTStrCmp(psz, "abc"));
160 RTStrFree(psz);
161
162 psz = NULL;
163 RTTESTI_CHECK_RC(RTStrAAppend(&psz, "xyz"), VINF_SUCCESS);
164 RTTESTI_CHECK(!RTStrCmp(psz, "xyz"));
165 RTStrFree(psz);
166
167 /* RTStrAAppendN */
168 RTTESTI_CHECK(psz = RTStrDup("abc"));
169 RTTESTI_CHECK_RC(RTStrAAppendN(&psz, "def", 1), VINF_SUCCESS);
170 RTTESTI_CHECK(!RTStrCmp(psz, "abcd"));
171 RTStrFree(psz);
172
173 RTTESTI_CHECK(psz = RTStrDup("abc"));
174 RTTESTI_CHECK_RC(RTStrAAppendN(&psz, "", 0), VINF_SUCCESS);
175 RTTESTI_CHECK(!RTStrCmp(psz, "abc"));
176 RTTESTI_CHECK_RC(RTStrAAppendN(&psz, "", RTSTR_MAX), VINF_SUCCESS);
177 RTTESTI_CHECK(!RTStrCmp(psz, "abc"));
178 RTTESTI_CHECK_RC(RTStrAAppendN(&psz, NULL, 0), VINF_SUCCESS);
179 RTTESTI_CHECK(!RTStrCmp(psz, "abc"));
180 RTStrFree(psz);
181
182 psz = NULL;
183 RTTESTI_CHECK_RC(RTStrAAppendN(&psz, "abc", 2), VINF_SUCCESS);
184 RTTESTI_CHECK(!RTStrCmp(psz, "ab"));
185 RTTESTI_CHECK_RC(RTStrAAppendN(&psz, "cdefghijklm", 1), VINF_SUCCESS);
186 RTTESTI_CHECK(!RTStrCmp(psz, "abc"));
187 RTTESTI_CHECK_RC(RTStrAAppendN(&psz, "defghijklm", RTSTR_MAX), VINF_SUCCESS);
188 RTTESTI_CHECK(!RTStrCmp(psz, "abcdefghijklm"));
189 RTStrFree(psz);
190
191 /* RTStrAAppendExN / RTStrAAppendExNV */
192 psz = NULL;
193 RTTESTI_CHECK_RC(RTStrAAppendExN(&psz, 5, "a", (size_t)1, "bc", (size_t)1, "cdefg", RTSTR_MAX, "hijkl", (size_t)2, "jklmnopqrstuvwxyz", RTSTR_MAX), VINF_SUCCESS);
194 RTTESTI_CHECK(!RTStrCmp(psz, "abcdefghijklmnopqrstuvwxyz"));
195 RTTESTI_CHECK_RC(RTStrAAppendExN(&psz, 0), VINF_SUCCESS);
196 RTTESTI_CHECK(!RTStrCmp(psz, "abcdefghijklmnopqrstuvwxyz"));
197 RTTESTI_CHECK_RC(RTStrAAppendExN(&psz, 2, NULL, (size_t)0, "", (size_t)0), VINF_SUCCESS);
198 RTTESTI_CHECK(!RTStrCmp(psz, "abcdefghijklmnopqrstuvwxyz"));
199 RTTESTI_CHECK_RC(RTStrAAppendExN(&psz, 1, "-", (size_t)1), VINF_SUCCESS);
200 RTTESTI_CHECK(!RTStrCmp(psz, "abcdefghijklmnopqrstuvwxyz-"));
201 RTStrFree(psz);
202
203 /* RTStrATruncate */
204 psz = NULL;
205 RTTESTI_CHECK_RC(RTStrATruncate(&psz, 0), VINF_SUCCESS);
206 RTTESTI_CHECK(!psz);
207
208 RTTESTI_CHECK(psz = RTStrDup(""));
209 RTTESTI_CHECK_RC(RTStrATruncate(&psz, 0), VINF_SUCCESS);
210 RTStrFree(psz);
211
212 RTTESTI_CHECK(psz = RTStrDup("1234567890"));
213 RTTESTI_CHECK_RC(RTStrATruncate(&psz, 5), VINF_SUCCESS);
214 RTTESTI_CHECK(!RTStrCmp(psz, "12345"));
215 RTStrFree(psz);
216
217 psz = NULL;
218 for (uint32_t i = 0; i < 128; i++)
219 RTTESTI_CHECK_RC_RETV(RTStrAAppend(&psz, "abcdefghijklmnopqrstuvwxyz"), VINF_SUCCESS);
220 RTTESTI_CHECK_RC(RTStrATruncate(&psz, sizeof("abcdefghijklmnopqrstuvwxyz") - 1), VINF_SUCCESS);
221 RTTESTI_CHECK(!RTStrCmp(psz, "abcdefghijklmnopqrstuvwxyz"));
222 RTTESTI_CHECK_RC(RTStrATruncate(&psz, 6), VINF_SUCCESS);
223 RTTESTI_CHECK(!RTStrCmp(psz, "abcdef"));
224 RTTESTI_CHECK_RC(RTStrATruncate(&psz, 1), VINF_SUCCESS);
225 RTTESTI_CHECK(!RTStrCmp(psz, "a"));
226 RTTESTI_CHECK_RC(RTStrATruncate(&psz, 0), VINF_SUCCESS);
227 RTTESTI_CHECK(!RTStrCmp(psz, ""));
228 RTStrFree(psz);
229
230}
231
232
233int main()
234{
235 RTTEST hTest;
236 int rc = RTTestInitAndCreate("tstRTStrAlloc", &hTest);
237 if (rc)
238 return rc;
239 RTTestBanner(hTest);
240
241 tst1();
242
243 return RTTestSummaryAndDestroy(hTest);
244}
245
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