VirtualBox

source: vbox/trunk/src/VBox/Runtime/testcase/tstVector.cpp@ 58063

Last change on this file since 58063 was 57358, checked in by vboxsync, 9 years ago

*: scm cleanup run.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 8.2 KB
Line 
1/* $Id: tstVector.cpp 57358 2015-08-14 15:16:38Z vboxsync $ */
2/** @file
3 * IPRT Testcase - Vector container structure.
4 */
5
6/*
7 * Copyright (C) 2011-2015 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/test.h>
32#include <iprt/vector.h>
33
34#include <stdlib.h> /* For realloc */
35
36/** Counter of the number of delete calls made so far */
37static unsigned s_cDeleteCalls = 0;
38
39/** Record the argument of the delete function here. */
40static void *s_apvDeleteArg[10];
41
42/** Dummy delete function for vector-of-void pointer elements */
43static void deletePVoid(void **ppv)
44{
45 if (s_cDeleteCalls < RT_ELEMENTS(s_apvDeleteArg))
46 s_apvDeleteArg[s_cDeleteCalls] = *ppv;
47 ++s_cDeleteCalls;
48}
49
50/** Dummy delete by value function for vector-of-void pointer elements */
51static void deletePVoidValue(void *pv)
52{
53 if (s_cDeleteCalls < RT_ELEMENTS(s_apvDeleteArg))
54 s_apvDeleteArg[s_cDeleteCalls] = pv;
55 ++s_cDeleteCalls;
56}
57
58/* Start by instantiating each function once for syntax checking */
59RTVEC_DECL_STRUCT(tstInstance, void *)
60RTVEC_DECL_STRUCT(tstInstance2, void *)
61
62RTVEC_DECLFN_DELETE_ADAPTER_ID(tstInstance, void *)
63RTVEC_DECLFN_DELETE_ADAPTER_TO_VALUE(tstInstance, void *)
64
65RTVEC_DECLFN_SIZE(tstInstance, void *)
66RTVEC_DECLFN_RESERVE(tstInstance, void *, rtvecReallocDefTag)
67RTVEC_DECLFN_BEGIN(tstInstance, void *)
68RTVEC_DECLFN_END(tstInstance, void *)
69RTVEC_DECLFN_PUSHBACK(tstInstance, void *)
70RTVEC_DECLFN_POPBACK(tstInstance)
71RTVEC_DECLFN_POPBACK_DELETE(tstInstance2, void *, deletePVoid,
72 tstInstanceDeleteAdapterId)
73RTVEC_DECLFN_CLEAR(tstInstance)
74RTVEC_DECLFN_CLEAR_DELETE(tstInstance2, deletePVoid,
75 tstInstanceDeleteAdapterId)
76RTVEC_DECLFN_DETACH(tstInstance, void *)
77
78RTVEC_DECL(tstSimple, void *)
79
80static void testVectorSimple(RTTEST hTest)
81{
82 RTTestISub("Vector structure, no cleanup callback");
83
84 struct tstSimple myVec = RTVEC_INITIALIZER;
85 void **ppvVal;
86
87 RTTESTI_CHECK(tstSimpleSize(&myVec) == 0);
88
89 ppvVal = tstSimplePushBack(&myVec);
90 /* AssertPtrReturnVoid(ppvVal); */
91 RTTESTI_CHECK(ppvVal == tstSimpleBegin(&myVec));
92 RTTESTI_CHECK(ppvVal + 1 == tstSimpleEnd(&myVec));
93 RTTESTI_CHECK(tstSimpleSize(&myVec) == 1);
94 *ppvVal = (void *)1;
95
96 ppvVal = tstSimplePushBack(&myVec);
97 /* AssertPtrReturnVoid(ppvVal); */
98 RTTESTI_CHECK(ppvVal - 1 == tstSimpleBegin(&myVec));
99 RTTESTI_CHECK(ppvVal + 1 == tstSimpleEnd(&myVec));
100 RTTESTI_CHECK(tstSimpleSize(&myVec) == 2);
101 RTTESTI_CHECK(ppvVal[-1] == (void *)1);
102
103 *ppvVal = (void *)3;
104 ppvVal = tstSimplePushBack(&myVec);
105 /* AssertPtrReturnVoid(ppvVal); */
106 RTTESTI_CHECK(ppvVal - 2 == tstSimpleBegin(&myVec));
107 RTTESTI_CHECK(ppvVal + 1 == tstSimpleEnd(&myVec));
108 RTTESTI_CHECK(tstSimpleSize(&myVec) == 3);
109 RTTESTI_CHECK(ppvVal[-2] == (void *)1);
110 RTTESTI_CHECK(ppvVal[-1] == (void *)3);
111
112 tstSimplePopBack(&myVec);
113 RTTESTI_CHECK(tstSimpleBegin(&myVec) + 2 == tstSimpleEnd(&myVec));
114 RTTESTI_CHECK(*tstSimpleBegin(&myVec) == (void *)1);
115 RTTESTI_CHECK(*(tstSimpleEnd(&myVec) - 1) == (void *)3);
116
117 tstSimpleClear(&myVec);
118 RTTESTI_CHECK(tstSimpleBegin(&myVec) == tstSimpleEnd(&myVec));
119 ppvVal = tstSimplePushBack(&myVec);
120 /* AssertPtrReturnVoid(ppvVal); */
121 RTTESTI_CHECK(ppvVal == tstSimpleBegin(&myVec));
122 RTTESTI_CHECK(ppvVal + 1 == tstSimpleEnd(&myVec));
123
124 tstSimpleClear(&myVec);
125 ppvVal = tstSimplePushBack(&myVec);
126 /* AssertPtrReturnVoid(ppvVal); */
127 *ppvVal = (void *)1;
128 ppvVal = tstSimplePushBack(&myVec);
129 /* AssertPtrReturnVoid(ppvVal); */
130 *ppvVal = (void *)3;
131 ppvVal = tstSimplePushBack(&myVec);
132 /* AssertPtrReturnVoid(ppvVal); */
133 *ppvVal = (void *)2;
134 ppvVal = tstSimpleDetach(&myVec);
135 RTTESTI_CHECK(tstSimpleBegin(&myVec) == NULL);
136 RTTESTI_CHECK(tstSimpleSize(&myVec) == 0);
137 RTTESTI_CHECK(ppvVal[0] == (void *)1);
138 RTTESTI_CHECK(ppvVal[1] == (void *)3);
139 RTTESTI_CHECK(ppvVal[2] == (void *)2);
140}
141
142RTVEC_DECL_DELETE(tstDelete, void *, deletePVoid)
143
144static void testVectorDelete(RTTEST hTest)
145{
146 RTTestISub("Vector structure with cleanup by pointer callback");
147
148 struct tstDelete myVec = RTVEC_INITIALIZER;
149 void **ppvVal;
150
151 ppvVal = tstDeletePushBack(&myVec);
152 /* AssertPtrReturnVoid(ppvVal); */
153 *ppvVal = (void *)1;
154 ppvVal = tstDeletePushBack(&myVec);
155 /* AssertPtrReturnVoid(ppvVal); */
156 *ppvVal = (void *)3;
157 ppvVal = tstDeletePushBack(&myVec);
158 /* AssertPtrReturnVoid(ppvVal); */
159 *ppvVal = (void *)2;
160
161 s_cDeleteCalls = 0;
162 tstDeletePopBack(&myVec);
163 RTTESTI_CHECK(s_cDeleteCalls == 1);
164 RTTESTI_CHECK(s_apvDeleteArg[0] == (void *)2);
165 RTTESTI_CHECK(tstDeleteBegin(&myVec) + 2 == tstDeleteEnd(&myVec));
166 RTTESTI_CHECK(*tstDeleteBegin(&myVec) == (void *)1);
167 RTTESTI_CHECK(*(tstDeleteEnd(&myVec) - 1) == (void *)3);
168
169 s_cDeleteCalls = 0;
170 tstDeleteClear(&myVec);
171 RTTESTI_CHECK(s_cDeleteCalls == 2);
172 RTTESTI_CHECK(s_apvDeleteArg[0] == (void *)1);
173 RTTESTI_CHECK(s_apvDeleteArg[1] == (void *)3);
174 RTTESTI_CHECK(tstDeleteBegin(&myVec) == tstDeleteEnd(&myVec));
175 ppvVal = tstDeletePushBack(&myVec);
176 /* AssertPtrReturnVoid(ppvVal); */
177 RTTESTI_CHECK(ppvVal == tstDeleteBegin(&myVec));
178 RTTESTI_CHECK(ppvVal + 1 == tstDeleteEnd(&myVec));
179}
180
181RTVEC_DECL_DELETE_BY_VALUE(tstDeleteValue, void *, deletePVoidValue)
182
183static void testVectorDeleteValue(RTTEST hTest)
184{
185 RTTestISub("Vector structure with cleanup by value callback");
186
187 struct tstDeleteValue myVec = RTVEC_INITIALIZER;
188 void **ppvVal;
189
190 ppvVal = tstDeleteValuePushBack(&myVec);
191 /* AssertPtrReturnVoid(ppvVal); */
192 *ppvVal = (void *)1;
193 ppvVal = tstDeleteValuePushBack(&myVec);
194 /* AssertPtrReturnVoid(ppvVal); */
195 *ppvVal = (void *)3;
196 ppvVal = tstDeleteValuePushBack(&myVec);
197 /* AssertPtrReturnVoid(ppvVal); */
198 *ppvVal = (void *)2;
199
200 s_cDeleteCalls = 0;
201 tstDeleteValuePopBack(&myVec);
202 RTTESTI_CHECK(s_cDeleteCalls == 1);
203 RTTESTI_CHECK(s_apvDeleteArg[0] == (void *)2);
204 RTTESTI_CHECK( tstDeleteValueBegin(&myVec) + 2
205 == tstDeleteValueEnd(&myVec));
206 RTTESTI_CHECK(*tstDeleteValueBegin(&myVec) == (void *)1);
207 RTTESTI_CHECK(*(tstDeleteValueEnd(&myVec) - 1) == (void *)3);
208
209 s_cDeleteCalls = 0;
210 tstDeleteValueClear(&myVec);
211 RTTESTI_CHECK(s_cDeleteCalls == 2);
212 RTTESTI_CHECK(s_apvDeleteArg[0] == (void *)1);
213 RTTESTI_CHECK(s_apvDeleteArg[1] == (void *)3);
214 RTTESTI_CHECK(tstDeleteValueBegin(&myVec) == tstDeleteValueEnd(&myVec));
215 ppvVal = tstDeleteValuePushBack(&myVec);
216 /* AssertPtrReturnVoid(ppvVal); */
217 RTTESTI_CHECK(ppvVal == tstDeleteValueBegin(&myVec));
218 RTTESTI_CHECK(ppvVal + 1 == tstDeleteValueEnd(&myVec));
219}
220
221
222
223int main()
224{
225 RTTEST hTest;
226 RTEXITCODE rcExit = RTTestInitAndCreate("tstVector", &hTest);
227 if (rcExit != RTEXITCODE_SUCCESS)
228 return rcExit;
229
230 testVectorSimple(hTest);
231 testVectorDelete(hTest);
232 testVectorDeleteValue(hTest);
233
234 return RTTestSummaryAndDestroy(hTest);
235}
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