VirtualBox

source: vbox/trunk/src/VBox/Storage/testcase/tstVD-2.cpp@ 80074

Last change on this file since 80074 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: 7.5 KB
Line 
1/** @file
2 *
3 * Simple VBox HDD container test utility. Only fast tests.
4 */
5
6/*
7 * Copyright (C) 2006-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
18#include <VBox/err.h>
19#include <VBox/vd.h>
20#include <iprt/string.h>
21#include <iprt/stream.h>
22#include <iprt/file.h>
23#include <iprt/mem.h>
24#include <iprt/initterm.h>
25#include <iprt/rand.h>
26#include "stdio.h"
27#include "stdlib.h"
28
29
30/*********************************************************************************************************************************
31* Global Variables *
32*********************************************************************************************************************************/
33/** The error count. */
34unsigned g_cErrors = 0;
35
36static struct KeyValuePair {
37 const char *key;
38 const char *value;
39} aCfgNode[] = {
40 { "TargetName", "test" },
41 { "LUN", "1" },
42 { "TargetAddress", "address" },
43 { NULL, NULL }
44};
45
46static DECLCALLBACK(bool) tstAreKeysValid(void *pvUser, const char *pszzValid)
47{
48 RT_NOREF2(pvUser, pszzValid);
49 return true;
50}
51
52static const char *tstGetValueByKey(const char *pszKey)
53{
54 for (int i = 0; aCfgNode[i].key; i++)
55 if (!strcmp(aCfgNode[i].key, pszKey))
56 return aCfgNode[i].value;
57 return NULL;
58}
59
60static DECLCALLBACK(int) tstQuerySize(void *pvUser, const char *pszName, size_t *pcbValue)
61{
62 RT_NOREF1(pvUser);
63 const char *pszValue = tstGetValueByKey(pszName);
64 if (!pszValue)
65 return VERR_CFGM_VALUE_NOT_FOUND;
66 *pcbValue = strlen(pszValue) + 1;
67 return VINF_SUCCESS;
68}
69
70static DECLCALLBACK(int) tstQuery(void *pvUser, const char *pszName, char *pszValue, size_t cchValue)
71{
72 RT_NOREF1(pvUser);
73 const char *pszTmp = tstGetValueByKey(pszName);
74 if (!pszValue)
75 return VERR_CFGM_VALUE_NOT_FOUND;
76 size_t cchTmp = strlen(pszTmp) + 1;
77 if (cchValue < cchTmp)
78 return VERR_CFGM_NOT_ENOUGH_SPACE;
79 memcpy(pszValue, pszTmp, cchTmp);
80 return VINF_SUCCESS;
81}
82
83static const char *tstVDDeviceType(VDTYPE enmType)
84{
85 switch (enmType)
86 {
87 case VDTYPE_HDD:
88 return "HardDisk";
89 case VDTYPE_OPTICAL_DISC:
90 return "OpticalDisc";
91 case VDTYPE_FLOPPY:
92 return "Floppy";
93 default:
94 return "Unknown";
95 }
96}
97
98static int tstVDBackendInfo(void)
99{
100 int rc;
101#define MAX_BACKENDS 100
102 VDBACKENDINFO aVDInfo[MAX_BACKENDS];
103 unsigned cEntries;
104
105#define CHECK(str) \
106 do \
107 { \
108 RTPrintf("%s rc=%Rrc\n", str, rc); \
109 if (RT_FAILURE(rc)) \
110 return rc; \
111 } while (0)
112
113 rc = VDBackendInfo(MAX_BACKENDS, aVDInfo, &cEntries);
114 CHECK("VDBackendInfo()");
115
116 for (unsigned i=0; i < cEntries; i++)
117 {
118 RTPrintf("Backend %u: name=%s capabilities=%#06x extensions=",
119 i, aVDInfo[i].pszBackend, aVDInfo[i].uBackendCaps);
120 if (aVDInfo[i].paFileExtensions)
121 {
122 PCVDFILEEXTENSION pa = aVDInfo[i].paFileExtensions;
123 while (pa->pszExtension != NULL)
124 {
125 if (pa != aVDInfo[i].paFileExtensions)
126 RTPrintf(",");
127 RTPrintf("%s (%s)", pa->pszExtension, tstVDDeviceType(pa->enmType));
128 pa++;
129 }
130 if (pa == aVDInfo[i].paFileExtensions)
131 RTPrintf("<EMPTY>");
132 }
133 else
134 RTPrintf("<NONE>");
135 RTPrintf(" config=");
136 if (aVDInfo[i].paConfigInfo)
137 {
138 PCVDCONFIGINFO pa = aVDInfo[i].paConfigInfo;
139 while (pa->pszKey != NULL)
140 {
141 if (pa != aVDInfo[i].paConfigInfo)
142 RTPrintf(",");
143 RTPrintf("(key=%s type=", pa->pszKey);
144 switch (pa->enmValueType)
145 {
146 case VDCFGVALUETYPE_INTEGER:
147 RTPrintf("integer");
148 break;
149 case VDCFGVALUETYPE_STRING:
150 RTPrintf("string");
151 break;
152 case VDCFGVALUETYPE_BYTES:
153 RTPrintf("bytes");
154 break;
155 default:
156 RTPrintf("INVALID!");
157 }
158 RTPrintf(" default=");
159 if (pa->pszDefaultValue)
160 RTPrintf("%s", pa->pszDefaultValue);
161 else
162 RTPrintf("<NONE>");
163 RTPrintf(" flags=");
164 if (!pa->uKeyFlags)
165 RTPrintf("none");
166 unsigned cFlags = 0;
167 if (pa->uKeyFlags & VD_CFGKEY_MANDATORY)
168 {
169 if (cFlags)
170 RTPrintf(",");
171 RTPrintf("mandatory");
172 cFlags++;
173 }
174 if (pa->uKeyFlags & VD_CFGKEY_EXPERT)
175 {
176 if (cFlags)
177 RTPrintf(",");
178 RTPrintf("expert");
179 cFlags++;
180 }
181 RTPrintf(")");
182 pa++;
183 }
184 if (pa == aVDInfo[i].paConfigInfo)
185 RTPrintf("<EMPTY>");
186 }
187 else
188 RTPrintf("<NONE>");
189 RTPrintf("\n");
190
191 PVDINTERFACE pVDIfs = NULL;
192 VDINTERFACECONFIG ic;
193
194 ic.pfnAreKeysValid = tstAreKeysValid;
195 ic.pfnQuerySize = tstQuerySize;
196 ic.pfnQuery = tstQuery;
197
198 rc = VDInterfaceAdd(&ic.Core, "tstVD-2_Config", VDINTERFACETYPE_CONFIG,
199 NULL, sizeof(VDINTERFACECONFIG), &pVDIfs);
200 AssertRC(rc);
201
202 char *pszLocation, *pszName;
203 rc = aVDInfo[i].pfnComposeLocation(pVDIfs, &pszLocation);
204 CHECK("pfnComposeLocation()");
205 if (pszLocation)
206 {
207 RTMemFree(pszLocation);
208 if (aVDInfo[i].uBackendCaps & VD_CAP_FILE)
209 {
210 RTPrintf("Non-NULL location returned for file-based backend!\n");
211 return VERR_INTERNAL_ERROR;
212 }
213 }
214 rc = aVDInfo[i].pfnComposeName(pVDIfs, &pszName);
215 CHECK("pfnComposeName()");
216 if (pszName)
217 {
218 RTMemFree(pszName);
219 if (aVDInfo[i].uBackendCaps & VD_CAP_FILE)
220 {
221 RTPrintf("Non-NULL name returned for file-based backend!\n");
222 return VERR_INTERNAL_ERROR;
223 }
224 }
225 }
226
227#undef CHECK
228 return 0;
229}
230
231
232int main(int argc, char *argv[])
233{
234 int rc;
235
236 RTR3InitExe(argc, &argv, 0);
237 RTPrintf("tstVD-2: TESTING...\n");
238
239 rc = tstVDBackendInfo();
240 if (RT_FAILURE(rc))
241 {
242 RTPrintf("tstVD-2: getting backend info test failed! rc=%Rrc\n", rc);
243 g_cErrors++;
244 }
245
246 rc = VDShutdown();
247 if (RT_FAILURE(rc))
248 {
249 RTPrintf("tstVD-2: unloading backends failed! rc=%Rrc\n", rc);
250 g_cErrors++;
251 }
252 /*
253 * Summary
254 */
255 if (!g_cErrors)
256 RTPrintf("tstVD-2: SUCCESS\n");
257 else
258 RTPrintf("tstVD-2: FAILURE - %d errors\n", g_cErrors);
259
260 return !!g_cErrors;
261}
262
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