VirtualBox

source: vbox/trunk/src/VBox/Main/testcase/tstGuestCtrlParseBuffer.cpp@ 101381

Last change on this file since 101381 was 99640, checked in by vboxsync, 13 months ago

testcase/tstGuestCtrlParseBuffer: Simplified determining reading chunk sizes a bit.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 18.4 KB
Line 
1/* $Id: tstGuestCtrlParseBuffer.cpp 99640 2023-05-05 13:44:46Z vboxsync $ */
2/** @file
3 * Tests for VBoxService toolbox output streams.
4 */
5
6/*
7 * Copyright (C) 2011-2023 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.org.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation, in version 3 of the
15 * License.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <https://www.gnu.org/licenses>.
24 *
25 * SPDX-License-Identifier: GPL-3.0-only
26 */
27
28
29/*********************************************************************************************************************************
30* Header Files *
31*********************************************************************************************************************************/
32#define LOG_GROUP LOG_GROUP_MAIN
33#include <VBox/err.h>
34#include <VBox/log.h>
35
36#include "../include/GuestCtrlImplPrivate.h"
37
38using namespace com;
39
40#include <iprt/env.h>
41#include <iprt/file.h>
42#include <iprt/test.h>
43#include <iprt/rand.h>
44#include <iprt/stream.h>
45
46#ifndef BYTE
47# define BYTE uint8_t
48#endif
49
50
51/*********************************************************************************************************************************
52* Defined Constants And Macros *
53*********************************************************************************************************************************/
54/** Defines a test entry string size (in bytes). */
55#define TST_STR_BYTES(a_sz) (sizeof(a_sz) - 1)
56/** Defines a test entry string, followed by its size (in bytes). */
57#define TST_STR_AND_BYTES(a_sz) a_sz, (sizeof(a_sz) - 1)
58/** Defines the termination sequence for a single key/value pair. */
59#define TST_STR_VAL_TRM GUESTTOOLBOX_STRM_TERM_PAIR_STR
60/** Defines the termination sequence for a single stream block. */
61#define TST_STR_BLK_TRM GUESTTOOLBOX_STRM_TERM_BLOCK_STR
62/** Defines the termination sequence for the stream. */
63#define TST_STR_STM_TRM GUESTTOOLBOX_STRM_TERM_STREAM_STR
64
65
66/*********************************************************************************************************************************
67* Structures and Typedefs *
68*********************************************************************************************************************************/
69typedef struct VBOXGUESTCTRL_BUFFER_VALUE
70{
71 char *pszValue;
72} VBOXGUESTCTRL_BUFFER_VALUE, *PVBOXGUESTCTRL_BUFFER_VALUE;
73typedef std::map< RTCString, VBOXGUESTCTRL_BUFFER_VALUE > GuestBufferMap;
74typedef std::map< RTCString, VBOXGUESTCTRL_BUFFER_VALUE >::iterator GuestBufferMapIter;
75typedef std::map< RTCString, VBOXGUESTCTRL_BUFFER_VALUE >::const_iterator GuestBufferMapIterConst;
76
77
78/*********************************************************************************************************************************
79* Global Variables *
80*********************************************************************************************************************************/
81char szUnterm1[] = { 'a', 's', 'd', 'f' };
82char szUnterm2[] = { 'f', 'o', 'o', '3', '=', 'b', 'a', 'r', '3' };
83
84PRTLOGGER g_pLog = NULL;
85
86/**
87 * Tests single block parsing.
88 */
89static struct
90{
91 const char *pbData;
92 size_t cbData;
93 uint32_t offStart;
94 uint32_t offAfter;
95 uint32_t cMapElements;
96 int iResult;
97} g_aTestBlocks[] =
98{
99 /* Invalid stuff. */
100 { NULL, 0, 0, 0, 0, VERR_INVALID_POINTER },
101 { NULL, 512, 0, 0, 0, VERR_INVALID_POINTER },
102 { "", 0, 0, 0, 0, VERR_INVALID_PARAMETER },
103 { "", 0, 0, 0, 0, VERR_INVALID_PARAMETER },
104 { "foo=bar1", 0, 0, 0, 0, VERR_INVALID_PARAMETER },
105 { "foo=bar2", 0, 50, 50, 0, VERR_INVALID_PARAMETER },
106 /* Has a empty key (not allowed). */
107 { TST_STR_AND_BYTES("=test2" TST_STR_VAL_TRM), 0, TST_STR_BYTES(""), 0, VERR_INVALID_PARAMETER },
108 /* Empty buffers, i.e. nothing to process. */
109 /* Index 6*/
110 { "", 1, 0, 0, 0, VINF_SUCCESS },
111 { TST_STR_VAL_TRM, 1, 0, 0, 0, VINF_SUCCESS },
112 /* Stream termination sequence. */
113 { TST_STR_AND_BYTES(TST_STR_STM_TRM), 0,
114 TST_STR_BYTES (TST_STR_STM_TRM), 0, VINF_EOF },
115 /* Trash after stream termination sequence (skipped / ignored). */
116 { TST_STR_AND_BYTES(TST_STR_STM_TRM "trash"), 0,
117 TST_STR_BYTES (TST_STR_STM_TRM "trash"), 0, VINF_EOF },
118 { TST_STR_AND_BYTES("a=b" TST_STR_STM_TRM), 0,
119 TST_STR_BYTES ("a=b" TST_STR_STM_TRM), 1, VINF_EOF },
120 { TST_STR_AND_BYTES("a=b" TST_STR_VAL_TRM "c=d" TST_STR_STM_TRM), 0,
121 TST_STR_BYTES ("a=b" TST_STR_VAL_TRM "c=d" TST_STR_STM_TRM), 2, VINF_EOF },
122 /* Unterminated values (missing separator, i.e. no valid pair). */
123 { TST_STR_AND_BYTES("test1"), 0, 0, 0, VINF_SUCCESS },
124 /* Has a NULL value (allowed). */
125 { TST_STR_AND_BYTES("test2=" TST_STR_VAL_TRM), 0,
126 TST_STR_BYTES ("test2="), 1, VINF_SUCCESS },
127 /* One completed pair only. */
128 { TST_STR_AND_BYTES("test3=test3" TST_STR_VAL_TRM), 0,
129 TST_STR_BYTES ("test3=test3"), 1, VINF_SUCCESS },
130 /* One completed pair, plus an unfinished pair (separator + terminator missing). */
131 { TST_STR_AND_BYTES("test4=test4" TST_STR_VAL_TRM "t41"), 0,
132 TST_STR_BYTES ("test4=test4" TST_STR_VAL_TRM), 1, VINF_SUCCESS },
133 /* Two completed pairs. */
134 { TST_STR_AND_BYTES("test5=test5" TST_STR_VAL_TRM "t51=t51" TST_STR_VAL_TRM), 0,
135 TST_STR_BYTES ("test5=test5" TST_STR_VAL_TRM "t51=t51"), 2, VINF_SUCCESS },
136 /* One complete block, next block unterminated. */
137 { TST_STR_AND_BYTES("a51=b51" TST_STR_VAL_TRM "c52=d52" TST_STR_BLK_TRM "e53=f53"), 0,
138 TST_STR_BYTES ("a51=b51" TST_STR_VAL_TRM "c52=d52" TST_STR_BLK_TRM), 2, VINF_SUCCESS },
139 /* Ditto. */
140 { TST_STR_AND_BYTES("test6=test6" TST_STR_BLK_TRM "t61=t61"), 0,
141 TST_STR_BYTES ("test6=test6" TST_STR_BLK_TRM), 1, VINF_SUCCESS },
142 /* Two complete pairs with a complete stream. */
143 { TST_STR_AND_BYTES("test61=" TST_STR_VAL_TRM "test611=test612" TST_STR_STM_TRM), 0,
144 TST_STR_BYTES ("test61=" TST_STR_VAL_TRM "test611=test612" TST_STR_STM_TRM), 2, VINF_EOF },
145 /* One complete block. */
146 { TST_STR_AND_BYTES("test7=test7" TST_STR_BLK_TRM), 0,
147 TST_STR_BYTES ("test7=test7"), 1, VINF_SUCCESS },
148 /* Ditto. */
149 { TST_STR_AND_BYTES("test81=test82" TST_STR_VAL_TRM "t81=t82" TST_STR_BLK_TRM), 0,
150 TST_STR_BYTES ("test81=test82" TST_STR_VAL_TRM "t81=t82"), 2, VINF_SUCCESS },
151 /* Good stuff, but with a second block -- should be *not* taken into account since
152 * we're only interested in parsing/handling the first object. */
153 { TST_STR_AND_BYTES("t91=t92" TST_STR_VAL_TRM "t93=t94" TST_STR_BLK_TRM "t95=t96" TST_STR_BLK_TRM), 0,
154 TST_STR_BYTES ("t91=t92" TST_STR_VAL_TRM "t93=t94" TST_STR_BLK_TRM), 2, VINF_SUCCESS },
155 /* Nasty stuff. */
156 /* iso 8859-1 encoding (?) of 'aou' all with diaeresis '=f' and 'ao' with diaeresis. */
157 { TST_STR_AND_BYTES("1\xe4\xf6\xfc=\x66\xe4\xf6" TST_STR_BLK_TRM), 0,
158 TST_STR_BYTES ("1\xe4\xf6\xfc=\x66\xe4\xf6"), 1, VINF_SUCCESS },
159 /* Like above, but after the first '\0' it adds 'ooo=aaa' all letters with diaeresis. */
160 { TST_STR_AND_BYTES("2\xe4\xf6\xfc=\x66\xe4\xf6" TST_STR_VAL_TRM "\xf6\xf6\xf6=\xe4\xe4\xe4"), 0,
161 TST_STR_BYTES ("2\xe4\xf6\xfc=\x66\xe4\xf6" TST_STR_VAL_TRM), 1, VINF_SUCCESS },
162 /* Some "real world" examples from VBoxService toolbox. */
163 { TST_STR_AND_BYTES("hdr_id=vbt_stat" TST_STR_VAL_TRM "hdr_ver=1" TST_STR_VAL_TRM "name=foo.txt" TST_STR_BLK_TRM), 0,
164 TST_STR_BYTES ("hdr_id=vbt_stat" TST_STR_VAL_TRM "hdr_ver=1" TST_STR_VAL_TRM "name=foo.txt"), 3, VINF_SUCCESS }
165};
166
167/**
168 * Tests parsing multiple stream blocks.
169 *
170 * Same parsing behavior as for the tests above apply.
171 */
172static struct
173{
174 /** Stream data. */
175 const char *pbData;
176 /** Size of stream data (in bytes). */
177 size_t cbData;
178 /** Number of data blocks retrieved. These are separated by "\0\0". */
179 uint32_t cBlocks;
180 /** Overall result when done parsing. */
181 int iResult;
182} const g_aTestStream[] =
183{
184 /* No blocks. */
185 { "", sizeof(""), 0, VINF_SUCCESS },
186 /* Empty block (no key/value pairs), will not be accounted. */
187 { TST_STR_STM_TRM,
188 TST_STR_BYTES(TST_STR_STM_TRM), 0, VINF_EOF },
189 /* Good stuff. */
190 { TST_STR_AND_BYTES(TST_STR_VAL_TRM "b1=b2" TST_STR_STM_TRM), 1, VINF_EOF },
191 { TST_STR_AND_BYTES("b3=b31" TST_STR_STM_TRM), 1, VINF_EOF },
192 { TST_STR_AND_BYTES("b4=b41" TST_STR_BLK_TRM "b51=b61" TST_STR_STM_TRM), 2, VINF_EOF },
193 { TST_STR_AND_BYTES("b5=b51" TST_STR_VAL_TRM "b61=b71" TST_STR_STM_TRM), 1, VINF_EOF }
194};
195
196/**
197 * Reads and parses the stream from a given file.
198 *
199 * @returns RTEXITCODE
200 * @param pszFile Absolute path to file to parse.
201 */
202static int tstReadFromFile(const char *pszFile)
203{
204 RTFILE fh;
205 int rc = RTFileOpen(&fh, pszFile, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
206 AssertRCReturn(rc, RTEXITCODE_FAILURE);
207
208 uint64_t cbFileSize;
209 rc = RTFileQuerySize(fh, &cbFileSize);
210 AssertRCReturn(rc, RTEXITCODE_FAILURE);
211
212 GuestToolboxStream stream;
213 GuestToolboxStreamBlock block;
214
215 size_t cPairs = 0;
216 size_t cBlocks = 0;
217
218 unsigned aToRead[] = { 256, 23, 13 }; /* Array of certain read amounts to check for in a sequence. */
219 unsigned idxToRead = 0; /* Index within aToRead. */
220
221 uint64_t cbToRead = cbFileSize;
222
223 for (unsigned a = 0; a < 32; a++)
224 {
225 uint8_t buf[_64K];
226 do
227 {
228 size_t cbChunk = cbToRead;
229 size_t const cbToReadFromArray = idxToRead < RT_ELEMENTS(aToRead) ? aToRead[idxToRead++] : 0;
230 if (cbToReadFromArray)
231 cbChunk = RT_MIN(cbChunk, cbToReadFromArray);
232 cbChunk = RT_MIN(cbChunk, RTRandU64Ex(8, RT_MIN(sizeof(buf), 64)));
233 if (cbChunk)
234 {
235 RTTestIPrintf(RTTESTLVL_DEBUG, "Reading %zu bytes (of %zu left) ...\n", cbChunk, cbToRead);
236
237 size_t cbRead;
238 rc = RTFileRead(fh, &buf, cbChunk, &cbRead);
239 AssertRCBreak(rc);
240
241 if (!cbRead)
242 continue;
243
244 cbToRead -= cbRead;
245
246 rc = stream.AddData((BYTE *)buf, cbRead);
247 AssertRCBreak(rc);
248 }
249
250 rc = stream.ParseBlock(block);
251 Assert(rc != VERR_INVALID_PARAMETER);
252 RTTestIPrintf(RTTESTLVL_DEBUG, "Parsing ended with %Rrc\n", rc);
253 if (block.IsComplete())
254 {
255 /* Sanity checks; disable this if you parse anything else but fsinfo output from VBoxService toolbox. */
256 //Assert(block.GetString("name") != NULL);
257
258 cPairs += block.GetCount();
259 cBlocks = stream.GetBlocks();
260 block.Clear();
261 }
262 } while (VINF_SUCCESS == rc /* Might also be VINF_EOF when finished */);
263
264 RTTestIPrintf(RTTESTLVL_ALWAYS, "Total %zu blocks + %zu pairs\n", cBlocks, cPairs);
265
266 /* Reset. */
267 RTFileSeek(fh, 0, RTFILE_SEEK_BEGIN, NULL);
268 cbToRead = cbFileSize;
269 cPairs = 0;
270 cBlocks = 0;
271 block.Clear();
272 stream.Destroy();
273 }
274
275 int rc2 = RTFileClose(fh);
276 if (RT_SUCCESS(rc))
277 rc = rc2;
278
279 return RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
280}
281
282int main(int argc, char **argv)
283{
284 RTTEST hTest;
285 RTEXITCODE rcExit = RTTestInitAndCreate("tstParseBuffer", &hTest);
286 if (rcExit != RTEXITCODE_SUCCESS)
287 return rcExit;
288 RTTestBanner(hTest);
289
290#ifdef DEBUG
291 RTUINT fFlags = RTLOGFLAGS_PREFIX_THREAD | RTLOGFLAGS_PREFIX_TIME_PROG;
292#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
293 fFlags |= RTLOGFLAGS_USECRLF;
294#endif
295 static const char * const s_apszLogGroups[] = VBOX_LOGGROUP_NAMES;
296 int rc = RTLogCreate(&g_pLog, fFlags, "guest_control.e.l.l2.l3.f", NULL,
297 RT_ELEMENTS(s_apszLogGroups), s_apszLogGroups, RTLOGDEST_STDOUT, NULL /*"vkat-release.log"*/);
298 AssertRCReturn(rc, rc);
299 RTLogSetDefaultInstance(g_pLog);
300#endif
301
302 if (argc > 1)
303 return tstReadFromFile(argv[1]);
304
305 RTTestIPrintf(RTTESTLVL_DEBUG, "Initializing COM...\n");
306 HRESULT hrc = com::Initialize();
307 if (FAILED(hrc))
308 {
309 RTTestFailed(hTest, "Failed to initialize COM (%Rhrc)!\n", hrc);
310 return RTEXITCODE_FAILURE;
311 }
312
313 AssertCompile(TST_STR_BYTES("1") == 1);
314 AssertCompile(TST_STR_BYTES("sizecheck") == 9);
315 AssertCompile(TST_STR_BYTES("off=rab") == 7);
316 AssertCompile(TST_STR_BYTES("off=rab\0\0") == 9);
317
318 RTTestSub(hTest, "Blocks");
319
320 RTTestDisableAssertions(hTest);
321
322 for (unsigned iTest = 0; iTest < RT_ELEMENTS(g_aTestBlocks); iTest++)
323 {
324 RTTestIPrintf(RTTESTLVL_DEBUG, "=> Block test #%u:\n'%.*Rhxd\n", iTest, g_aTestBlocks[iTest].cbData, g_aTestBlocks[iTest].pbData);
325
326 GuestToolboxStream stream;
327 int iResult = stream.AddData((BYTE *)g_aTestBlocks[iTest].pbData, g_aTestBlocks[iTest].cbData);
328 if (RT_SUCCESS(iResult))
329 {
330 GuestToolboxStreamBlock curBlock;
331 iResult = stream.ParseBlock(curBlock);
332 if (iResult != g_aTestBlocks[iTest].iResult)
333 RTTestFailed(hTest, "Block #%u: Returned %Rrc, expected %Rrc\n", iTest, iResult, g_aTestBlocks[iTest].iResult);
334 else if (stream.GetOffset() != g_aTestBlocks[iTest].offAfter)
335 RTTestFailed(hTest, "Block #%u: Offset %zu wrong ('%#x'), expected %u ('%#x')\n",
336 iTest, stream.GetOffset(), g_aTestBlocks[iTest].pbData[stream.GetOffset()],
337 g_aTestBlocks[iTest].offAfter, g_aTestBlocks[iTest].pbData[g_aTestBlocks[iTest].offAfter]);
338 else if (iResult == VERR_MORE_DATA)
339 RTTestIPrintf(RTTESTLVL_DEBUG, "\tMore data (Offset: %zu)\n", stream.GetOffset());
340
341 if (RT_SUCCESS(iResult) || iResult == VERR_MORE_DATA)
342 if (curBlock.GetCount() != g_aTestBlocks[iTest].cMapElements)
343 RTTestFailed(hTest, "Block #%u: Map has %u elements, expected %u\n",
344 iTest, curBlock.GetCount(), g_aTestBlocks[iTest].cMapElements);
345
346 /* There is remaining data left in the buffer (which needs to be merged
347 * with a following buffer) -- print it. */
348 size_t off = stream.GetOffset();
349 size_t cbToWrite = g_aTestBlocks[iTest].cbData - off;
350 if (cbToWrite)
351 {
352 RTTestIPrintf(RTTESTLVL_DEBUG, "\tRemaining (%u):\n", cbToWrite);
353
354 /* How to properly get the current RTTESTLVL (aka IPRT_TEST_MAX_LEVEL) here?
355 * Hack alert: Using RTEnvGet for now. */
356 if (!RTStrICmp(RTEnvGet("IPRT_TEST_MAX_LEVEL"), "debug"))
357 RTStrmWriteEx(g_pStdOut, &g_aTestBlocks[iTest].pbData[off], cbToWrite - 1, NULL);
358 }
359
360 if (RTTestIErrorCount())
361 break;
362 }
363 }
364
365 RTTestSub(hTest, "Streams");
366
367 for (unsigned iTest = 0; iTest < RT_ELEMENTS(g_aTestStream); iTest++)
368 {
369 RTTestIPrintf(RTTESTLVL_DEBUG, "=> Stream test #%u\n%.*Rhxd\n",
370 iTest, g_aTestStream[iTest].cbData, g_aTestStream[iTest].pbData);
371
372 GuestToolboxStream stream;
373 int iResult = stream.AddData((BYTE*)g_aTestStream[iTest].pbData, g_aTestStream[iTest].cbData);
374 if (RT_SUCCESS(iResult))
375 {
376 uint32_t cBlocksComplete = 0;
377 uint8_t cSafety = 0;
378 do
379 {
380 GuestToolboxStreamBlock curBlock;
381 iResult = stream.ParseBlock(curBlock);
382 RTTestIPrintf(RTTESTLVL_DEBUG, "Stream #%u: Returned with %Rrc\n", iTest, iResult);
383 if (cSafety++ > 8)
384 break;
385 if (curBlock.IsComplete())
386 cBlocksComplete++;
387 } while (iResult != VINF_EOF);
388
389 if (iResult != g_aTestStream[iTest].iResult)
390 RTTestFailed(hTest, "Stream #%u: Returned %Rrc, expected %Rrc\n", iTest, iResult, g_aTestStream[iTest].iResult);
391 else if (cBlocksComplete != g_aTestStream[iTest].cBlocks)
392 RTTestFailed(hTest, "Stream #%u: Returned %u blocks, expected %u\n", iTest, cBlocksComplete, g_aTestStream[iTest].cBlocks);
393 }
394 else
395 RTTestFailed(hTest, "Stream #%u: Adding data failed with %Rrc\n", iTest, iResult);
396
397 if (RTTestIErrorCount())
398 break;
399 }
400
401 RTTestRestoreAssertions(hTest);
402
403 RTTestIPrintf(RTTESTLVL_DEBUG, "Shutting down COM...\n");
404 com::Shutdown();
405
406 /*
407 * Summary.
408 */
409 return RTTestSummaryAndDestroy(hTest);
410}
411
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use