tstAPI.cpp@ 98123

Last change on this file since 98123 was 98103, checked in by vboxsync, 23 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 63.9 KB

Line
1	/* $Id: tstAPI.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* tstAPI - test program for our COM/XPCOM interface
4	*/
5
6	/*
7	* Copyright (C) 2006-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	#include <stdio.h>
29	#include <stdlib.h>
30
31	#include <VBox/com/com.h>
32	#include <VBox/com/string.h>
33	#include <VBox/com/Guid.h>
34	#include <VBox/com/ErrorInfo.h>
35	#include <VBox/com/errorprint.h>
36
37	#include <VBox/com/VirtualBox.h>
38
39	using namespace com;
40
41	#define LOG_ENABLED
42	#define LOG_GROUP LOG_GROUP_MAIN
43	#include <VBox/log.h>
44
45	#include <iprt/initterm.h>
46	#include <iprt/path.h>
47	#include <iprt/param.h>
48	#include <iprt/stream.h>
49	#include <iprt/thread.h>
50
51
52	// forward declarations
53	///////////////////////////////////////////////////////////////////////////////
54
55	#ifdef VBOX_WITH_RESOURCE_USAGE_API
56	static Bstr getObjectName(ComPtr<IVirtualBox> aVirtualBox, ComPtr<IUnknown> aObject);
57	static void queryMetrics(ComPtr<IVirtualBox> aVirtualBox,
58	ComPtr<IPerformanceCollector> collector,
59	ComSafeArrayIn(IUnknown *, objects));
60	static void listAffectedMetrics(ComPtr<IVirtualBox> aVirtualBox,
61	ComSafeArrayIn(IPerformanceMetric*, aMetrics));
62	#endif
63
64	// funcs
65	///////////////////////////////////////////////////////////////////////////////
66
67	HRESULT readAndChangeMachineSettings(IMachine machine, IMachine readonlyMachine = 0)
68	{
69	HRESULT hrc = S_OK;
70
71	Bstr name;
72	RTPrintf("Getting machine name...\n");
73	CHECK_ERROR_RET(machine, COMGETTER(Name)(name.asOutParam()), hrc);
74	RTPrintf("Name: {%ls}\n", name.raw());
75
76	RTPrintf("Getting machine GUID...\n");
77	Bstr guid;
78	CHECK_ERROR(machine, COMGETTER(Id)(guid.asOutParam()));
79	if (SUCCEEDED(hrc) && !guid.isEmpty()) {
80	RTPrintf("Guid::toString(): {%s}\n", Utf8Str(guid).c_str());
81	} else {
82	RTPrintf("WARNING: there's no GUID!");
83	}
84
85	ULONG memorySize;
86	RTPrintf("Getting memory size...\n");
87	CHECK_ERROR_RET(machine, COMGETTER(MemorySize)(&memorySize), hrc);
88	RTPrintf("Memory size: %d\n", memorySize);
89
90	MachineState_T machineState;
91	RTPrintf("Getting machine state...\n");
92	CHECK_ERROR_RET(machine, COMGETTER(State)(&machineState), hrc);
93	RTPrintf("Machine state: %d\n", machineState);
94
95	BOOL modified;
96	RTPrintf("Are any settings modified?...\n");
97	CHECK_ERROR(machine, COMGETTER(SettingsModified)(&modified));
98	if (SUCCEEDED(hrc))
99	RTPrintf("%s\n", modified ? "yes" : "no");
100
101	ULONG memorySizeBig = memorySize * 10;
102	RTPrintf("Changing memory size to %d...\n", memorySizeBig);
103	CHECK_ERROR(machine, COMSETTER(MemorySize)(memorySizeBig));
104
105	if (SUCCEEDED(hrc))
106	{
107	RTPrintf("Are any settings modified now?...\n");
108	CHECK_ERROR_RET(machine, COMGETTER(SettingsModified)(&modified), hrc);
109	RTPrintf("%s\n", modified ? "yes" : "no");
110	ASSERT_RET(modified, 0);
111
112	ULONG memorySizeGot;
113	RTPrintf("Getting memory size again...\n");
114	CHECK_ERROR_RET(machine, COMGETTER(MemorySize)(&memorySizeGot), hrc);
115	RTPrintf("Memory size: %d\n", memorySizeGot);
116	ASSERT_RET(memorySizeGot == memorySizeBig, 0);
117
118	if (readonlyMachine)
119	{
120	RTPrintf("Getting memory size of the counterpart readonly machine...\n");
121	ULONG memorySizeRO;
122	readonlyMachine->COMGETTER(MemorySize)(&memorySizeRO);
123	RTPrintf("Memory size: %d\n", memorySizeRO);
124	ASSERT_RET(memorySizeRO != memorySizeGot, 0);
125	}
126
127	RTPrintf("Discarding recent changes...\n");
128	CHECK_ERROR_RET(machine, DiscardSettings(), hrc);
129	RTPrintf("Are any settings modified after discarding?...\n");
130	CHECK_ERROR_RET(machine, COMGETTER(SettingsModified)(&modified), hrc);
131	RTPrintf("%s\n", modified ? "yes" : "no");
132	ASSERT_RET(!modified, 0);
133
134	RTPrintf("Getting memory size once more...\n");
135	CHECK_ERROR_RET(machine, COMGETTER(MemorySize)(&memorySizeGot), hrc);
136	RTPrintf("Memory size: %d\n", memorySizeGot);
137	ASSERT_RET(memorySizeGot == memorySize, 0);
138
139	memorySize = memorySize > 128 ? memorySize / 2 : memorySize * 2;
140	RTPrintf("Changing memory size to %d...\n", memorySize);
141	CHECK_ERROR_RET(machine, COMSETTER(MemorySize)(memorySize), hrc);
142	}
143
144	Bstr desc;
145	RTPrintf("Getting description...\n");
146	CHECK_ERROR_RET(machine, COMGETTER(Description)(desc.asOutParam()), hrc);
147	RTPrintf("Description is: \"%ls\"\n", desc.raw());
148
149	desc = L"This is an exemplary description (changed).";
150	RTPrintf("Setting description to \"%ls\"...\n", desc.raw());
151	CHECK_ERROR_RET(machine, COMSETTER(Description)(desc.raw()), hrc);
152
153	RTPrintf("Saving machine settings...\n");
154	CHECK_ERROR(machine, SaveSettings());
155	if (SUCCEEDED(hrc))
156	{
157	RTPrintf("Are any settings modified after saving?...\n");
158	CHECK_ERROR_RET(machine, COMGETTER(SettingsModified)(&modified), hrc);
159	RTPrintf("%s\n", modified ? "yes" : "no");
160	ASSERT_RET(!modified, 0);
161
162	if (readonlyMachine) {
163	RTPrintf("Getting memory size of the counterpart readonly machine...\n");
164	ULONG memorySizeRO;
165	readonlyMachine->COMGETTER(MemorySize)(&memorySizeRO);
166	RTPrintf("Memory size: %d\n", memorySizeRO);
167	ASSERT_RET(memorySizeRO == memorySize, 0);
168	}
169	}
170
171	Bstr extraDataKey = L"Blafasel";
172	Bstr extraData;
173	RTPrintf("Getting extra data key {%ls}...\n", extraDataKey.raw());
174	CHECK_ERROR_RET(machine, GetExtraData(extraDataKey.raw(), extraData.asOutParam()), hrc);
175	if (!extraData.isEmpty()) {
176	RTPrintf("Extra data value: {%ls}\n", extraData.raw());
177	} else {
178	RTPrintf("No extra data exists\n");
179	}
180
181	if (extraData.isEmpty())
182	extraData = L"Das ist die Berliner Luft, Luft, Luft...";
183	else
184	extraData.setNull();
185	RTPrintf("Setting extra data key {%ls} to {%ls}...\n",
186	extraDataKey.raw(), extraData.raw());
187	CHECK_ERROR(machine, SetExtraData(extraDataKey.raw(), extraData.raw()));
188
189	if (SUCCEEDED(hrc)) {
190	RTPrintf("Getting extra data key {%ls} again...\n", extraDataKey.raw());
191	CHECK_ERROR_RET(machine, GetExtraData(extraDataKey.raw(), extraData.asOutParam()), hrc);
192	if (!extraData.isEmpty()) {
193	RTPrintf("Extra data value: {%ls}\n", extraData.raw());
194	} else {
195	RTPrintf("No extra data exists\n");
196	}
197	}
198
199	return hrc;
200	}
201
202	// main
203	///////////////////////////////////////////////////////////////////////////////
204
205	int main(int argc, char *argv[])
206	{
207	/*
208	* Initialize the VBox runtime without loading
209	* the support driver.
210	*/
211	RTR3InitExe(argc, &argv, 0);
212
213	HRESULT hrc;
214
215	{
216	char homeDir[RTPATH_MAX];
217	GetVBoxUserHomeDirectory(homeDir, sizeof(homeDir));
218	RTPrintf("VirtualBox Home Directory = '%s'\n", homeDir);
219	}
220
221	RTPrintf("Initializing COM...\n");
222
223	hrc = com::Initialize();
224	if (FAILED(hrc))
225	{
226	RTPrintf("ERROR: failed to initialize COM!\n");
227	return hrc;
228	}
229
230	do
231	{
232	// scopes all the stuff till shutdown
233	////////////////////////////////////////////////////////////////////////////
234
235	ComPtr<IVirtualBoxClient> virtualBoxClient;
236	ComPtr<IVirtualBox> virtualBox;
237	ComPtr<ISession> session;
238
239	#if 0
240	// Utf8Str test
241	////////////////////////////////////////////////////////////////////////////
242
243	Utf8Str nullUtf8Str;
244	RTPrintf("nullUtf8Str='%s'\n", nullUtf8Str.raw());
245
246	Utf8Str simpleUtf8Str = "simpleUtf8Str";
247	RTPrintf("simpleUtf8Str='%s'\n", simpleUtf8Str.raw());
248
249	Utf8Str utf8StrFmt = Utf8StrFmt("[0=%d]%s[1=%d]", 0, "utf8StrFmt", 1);
250	RTPrintf("utf8StrFmt='%s'\n", utf8StrFmt.raw());
251
252	#endif
253
254	RTPrintf("Creating VirtualBox object...\n");
255	hrc = virtualBoxClient.createInprocObject(CLSID_VirtualBoxClient);
256	if (SUCCEEDED(hrc))
257	hrc = virtualBoxClient->COMGETTER(VirtualBox)(virtualBox.asOutParam());
258	if (FAILED(hrc))
259	RTPrintf("ERROR: failed to create the VirtualBox object!\n");
260	else
261	{
262	hrc = session.createInprocObject(CLSID_Session);
263	if (FAILED(hrc))
264	RTPrintf("ERROR: failed to create a session object!\n");
265	}
266
267	if (FAILED(hrc))
268	{
269	com::ErrorInfo info;
270	if (!info.isFullAvailable() && !info.isBasicAvailable())
271	{
272	com::GluePrintRCMessage(hrc);
273	RTPrintf("Most likely, the VirtualBox COM server is not running or failed to start.\n");
274	}
275	else
276	com::GluePrintErrorInfo(info);
277	break;
278	}
279
280	#if 0
281	// Testing VirtualBox::COMGETTER(ProgressOperations).
282	// This is designed to be tested while running
283	// "./VBoxManage clonehd src.vdi clone.vdi" in parallel.
284	// It will then display the progress every 2 seconds.
285	////////////////////////////////////////////////////////////////////////////
286	{
287	RTPrintf("Testing VirtualBox::COMGETTER(ProgressOperations)...\n");
288
289	for (;;) {
290	com::SafeIfaceArray<IProgress> operations;
291
292	CHECK_ERROR_BREAK(virtualBox,
293	COMGETTER(ProgressOperations)(ComSafeArrayAsOutParam(operations)));
294
295	RTPrintf("operations: %d\n", operations.size());
296	if (operations.size() == 0)
297	break; // No more operations left.
298
299	for (size_t i = 0; i < operations.size(); ++i) {
300	PRInt32 percent;
301
302	operations[i]->COMGETTER(Percent)(&percent);
303	RTPrintf("operations[%u]: %ld\n", (unsigned)i, (long)percent);
304	}
305	RTThreadSleep(2000); // msec
306	}
307	}
308	#endif
309
310	#if 0
311	// IUnknown identity test
312	////////////////////////////////////////////////////////////////////////////
313	{
314	{
315	ComPtr<IVirtualBox> virtualBox2;
316
317	RTPrintf("Creating one more VirtualBox object...\n");
318	CHECK_RC(virtualBoxClient->COMGETTER(virtualBox2.asOutParam()));
319	if (FAILED(rc))
320	{
321	CHECK_ERROR_NOCALL();
322	break;
323	}
324
325	RTPrintf("IVirtualBox(virtualBox)=%p IVirtualBox(virtualBox2)=%p\n",
326	(IVirtualBox )virtualBox, (IVirtualBox )virtualBox2);
327	Assert((IVirtualBox )virtualBox == (IVirtualBox )virtualBox2);
328
329	ComPtr<IUnknown> unk(virtualBox);
330	ComPtr<IUnknown> unk2;
331	unk2 = virtualBox2;
332
333	RTPrintf("IUnknown(virtualBox)=%p IUnknown(virtualBox2)=%p\n",
334	(IUnknown )unk, (IUnknown )unk2);
335	Assert((IUnknown )unk == (IUnknown )unk2);
336
337	ComPtr<IVirtualBox> vb = unk;
338	ComPtr<IVirtualBox> vb2 = unk;
339
340	RTPrintf("IVirtualBox(IUnknown(virtualBox))=%p IVirtualBox(IUnknown(virtualBox2))=%p\n",
341	(IVirtualBox )vb, (IVirtualBox )vb2);
342	Assert((IVirtualBox )vb == (IVirtualBox )vb2);
343	}
344
345	{
346	ComPtr<IHost> host;
347	CHECK_ERROR_BREAK(virtualBox, COMGETTER(Host)(host.asOutParam()));
348	RTPrintf(" IHost(host)=%p\n", (IHost *)host);
349	ComPtr<IUnknown> unk = host;
350	RTPrintf(" IUnknown(host)=%p\n", (IUnknown *)unk);
351	ComPtr<IHost> host_copy = unk;
352	RTPrintf(" IHost(host_copy)=%p\n", (IHost *)host_copy);
353	ComPtr<IUnknown> unk_copy = host_copy;
354	RTPrintf(" IUnknown(host_copy)=%p\n", (IUnknown *)unk_copy);
355	Assert((IUnknown )unk == (IUnknown )unk_copy);
356
357	/* query IUnknown on IUnknown */
358	ComPtr<IUnknown> unk_copy_copy;
359	unk_copy.queryInterfaceTo(unk_copy_copy.asOutParam());
360	RTPrintf(" IUnknown(unk_copy)=%p\n", (IUnknown *)unk_copy_copy);
361	Assert((IUnknown )unk_copy == (IUnknown )unk_copy_copy);
362	/* query IUnknown on IUnknown in the opposite direction */
363	unk_copy_copy.queryInterfaceTo(unk_copy.asOutParam());
364	RTPrintf(" IUnknown(unk_copy_copy)=%p\n", (IUnknown *)unk_copy);
365	Assert((IUnknown )unk_copy == (IUnknown )unk_copy_copy);
366
367	/* query IUnknown again after releasing all previous IUnknown instances
368	* but keeping IHost -- it should remain the same (Identity Rule) */
369	IUnknown *oldUnk = unk;
370	unk.setNull();
371	unk_copy.setNull();
372	unk_copy_copy.setNull();
373	unk = host;
374	RTPrintf(" IUnknown(host)=%p\n", (IUnknown *)unk);
375	Assert(oldUnk == (IUnknown *)unk);
376	}
377
378	// RTPrintf("Will be now released (press Enter)...");
379	// getchar();
380	}
381	#endif
382
383	#if 0
384	// the simplest COM API test
385	////////////////////////////////////////////////////////////////////////////
386	{
387	Bstr version;
388	CHECK_ERROR_BREAK(virtualBox, COMGETTER(Version)(version.asOutParam()));
389	RTPrintf("VirtualBox version = %ls\n", version.raw());
390	}
391	#endif
392
393	#if 0
394	// Array test
395	////////////////////////////////////////////////////////////////////////////
396	{
397	RTPrintf("Calling IVirtualBox::Machines...\n");
398
399	com::SafeIfaceArray<IMachine> machines;
400	CHECK_ERROR_BREAK(virtualBox,
401	COMGETTER(Machines)(ComSafeArrayAsOutParam(machines)));
402
403	RTPrintf("%u machines registered (machines.isNull()=%d).\n",
404	machines.size(), machines.isNull());
405
406	for (size_t i = 0; i < machines.size(); ++ i)
407	{
408	Bstr name;
409	CHECK_ERROR_BREAK(machines[i], COMGETTER(Name)(name.asOutParam()));
410	RTPrintf("machines[%u]='%s'\n", i, Utf8Str(name).raw());
411	}
412
413	#if 0
414	{
415	RTPrintf("Testing [out] arrays...\n");
416	com::SafeGUIDArray uuids;
417	CHECK_ERROR_BREAK(virtualBox,
418	COMGETTER(Uuids)(ComSafeArrayAsOutParam(uuids)));
419
420	for (size_t i = 0; i < uuids.size(); ++ i)
421	RTPrintf("uuids[%u]=%RTuuid\n", i, &uuids[i]);
422	}
423
424	{
425	RTPrintf("Testing [in] arrays...\n");
426	com::SafeGUIDArray uuids(5);
427	for (size_t i = 0; i < uuids.size(); ++ i)
428	{
429	Guid id;
430	id.create();
431	uuids[i] = id;
432	RTPrintf("uuids[%u]=%RTuuid\n", i, &uuids[i]);
433	}
434
435	CHECK_ERROR_BREAK(virtualBox,
436	SetUuids(ComSafeArrayAsInParam(uuids)));
437	}
438	#endif
439
440	}
441	#endif
442
443	#if 0
444	// some outdated stuff
445	////////////////////////////////////////////////////////////////////////////
446
447	RTPrintf("Getting IHost interface...\n");
448	IHost *host;
449	rc = virtualBox->GetHost(&host);
450	if (SUCCEEDED(rc))
451	{
452	IHostDVDDriveCollection *dvdColl;
453	rc = host->GetHostDVDDrives(&dvdColl);
454	if (SUCCEEDED(rc))
455	{
456	IHostDVDDrive *dvdDrive = NULL;
457	dvdColl->GetNextHostDVDDrive(dvdDrive, &dvdDrive);
458	while (dvdDrive)
459	{
460	BSTR driveName;
461	char *driveNameUtf8;
462	dvdDrive->GetDriveName(&driveName);
463	RTUtf16ToUtf8((PCRTUTF16)driveName, &driveNameUtf8);
464	RTPrintf("Host DVD drive name: %s\n", driveNameUtf8);
465	RTStrFree(driveNameUtf8);
466	SysFreeString(driveName);
467	IHostDVDDrive *dvdDriveTemp = dvdDrive;
468	dvdColl->GetNextHostDVDDrive(dvdDriveTemp, &dvdDrive);
469	dvdDriveTemp->Release();
470	}
471	dvdColl->Release();
472	} else
473	{
474	RTPrintf("Could not get host DVD drive collection\n");
475	}
476
477	IHostFloppyDriveCollection *floppyColl;
478	rc = host->GetHostFloppyDrives(&floppyColl);
479	if (SUCCEEDED(rc))
480	{
481	IHostFloppyDrive *floppyDrive = NULL;
482	floppyColl->GetNextHostFloppyDrive(floppyDrive, &floppyDrive);
483	while (floppyDrive)
484	{
485	BSTR driveName;
486	char *driveNameUtf8;
487	floppyDrive->GetDriveName(&driveName);
488	RTUtf16ToUtf8((PCRTUTF16)driveName, &driveNameUtf8);
489	RTPrintf("Host floppy drive name: %s\n", driveNameUtf8);
490	RTStrFree(driveNameUtf8);
491	SysFreeString(driveName);
492	IHostFloppyDrive *floppyDriveTemp = floppyDrive;
493	floppyColl->GetNextHostFloppyDrive(floppyDriveTemp, &floppyDrive);
494	floppyDriveTemp->Release();
495	}
496	floppyColl->Release();
497	} else
498	{
499	RTPrintf("Could not get host floppy drive collection\n");
500	}
501	host->Release();
502	} else
503	{
504	RTPrintf("Call failed\n");
505	}
506	RTPrintf("\n");
507	#endif
508
509	#if 0
510	// IVirtualBoxErrorInfo test
511	////////////////////////////////////////////////////////////////////////////
512	{
513	// RPC calls
514
515	// call a method that will definitely fail
516	Guid uuid;
517	ComPtr<IHardDisk> hardDisk;
518	rc = virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
519	RTPrintf("virtualBox->GetHardDisk(null-uuid)=%08X\n", rc);
520
521	// {
522	// com::ErrorInfo info(virtualBox);
523	// PRINT_ERROR_INFO(info);
524	// }
525
526	// call a method that will definitely succeed
527	Bstr version;
528	rc = virtualBox->COMGETTER(Version)(version.asOutParam());
529	RTPrintf("virtualBox->COMGETTER(Version)=%08X\n", rc);
530
531	{
532	com::ErrorInfo info(virtualBox);
533	PRINT_ERROR_INFO(info);
534	}
535
536	// Local calls
537
538	// call a method that will definitely fail
539	ComPtr<IMachine> machine;
540	rc = session->COMGETTER(Machine)(machine.asOutParam());
541	RTPrintf("session->COMGETTER(Machine)=%08X\n", rc);
542
543	// {
544	// com::ErrorInfo info(virtualBox);
545	// PRINT_ERROR_INFO(info);
546	// }
547
548	// call a method that will definitely succeed
549	SessionState_T state;
550	rc = session->COMGETTER(State)(&state);
551	RTPrintf("session->COMGETTER(State)=%08X\n", rc);
552
553	{
554	com::ErrorInfo info(virtualBox);
555	PRINT_ERROR_INFO(info);
556	}
557	}
558	#endif
559
560	#if 0
561	// register the existing hard disk image
562	///////////////////////////////////////////////////////////////////////////
563	do
564	{
565	ComPtr<IHardDisk> hd;
566	Bstr src = L"E:\\develop\\innotek\\images\\NewHardDisk.vdi";
567	RTPrintf("Opening the existing hard disk '%ls'...\n", src.raw());
568	CHECK_ERROR_BREAK(virtualBox, OpenHardDisk(src, AccessMode_ReadWrite, hd.asOutParam()));
569	RTPrintf("Enter to continue...\n");
570	getchar();
571	RTPrintf("Registering the existing hard disk '%ls'...\n", src.raw());
572	CHECK_ERROR_BREAK(virtualBox, RegisterHardDisk(hd));
573	RTPrintf("Enter to continue...\n");
574	getchar();
575	}
576	while (FALSE);
577	RTPrintf("\n");
578	#endif
579
580	#if 0
581	// find and unregister the existing hard disk image
582	///////////////////////////////////////////////////////////////////////////
583	do
584	{
585	ComPtr<IVirtualDiskImage> vdi;
586	Bstr src = L"CreatorTest.vdi";
587	RTPrintf("Unregistering the hard disk '%ls'...\n", src.raw());
588	CHECK_ERROR_BREAK(virtualBox, FindVirtualDiskImage(src, vdi.asOutParam()));
589	ComPtr<IHardDisk> hd = vdi;
590	Guid id;
591	CHECK_ERROR_BREAK(hd, COMGETTER(Id)(id.asOutParam()));
592	CHECK_ERROR_BREAK(virtualBox, UnregisterHardDisk(id, hd.asOutParam()));
593	}
594	while (FALSE);
595	RTPrintf("\n");
596	#endif
597
598	#if 0
599	// clone the registered hard disk
600	///////////////////////////////////////////////////////////////////////////
601	do
602	{
603	#if defined RT_OS_LINUX
604	Bstr src = L"/mnt/hugaida/common/develop/innotek/images/freedos-linux.vdi";
605	#else
606	Bstr src = L"E:/develop/innotek/images/freedos.vdi";
607	#endif
608	Bstr dst = L"./clone.vdi";
609	RTPrintf("Cloning '%ls' to '%ls'...\n", src.raw(), dst.raw());
610	ComPtr<IVirtualDiskImage> vdi;
611	CHECK_ERROR_BREAK(virtualBox, FindVirtualDiskImage(src, vdi.asOutParam()));
612	ComPtr<IHardDisk> hd = vdi;
613	ComPtr<IProgress> progress;
614	CHECK_ERROR_BREAK(hd, CloneToImage(dst, vdi.asOutParam(), progress.asOutParam()));
615	RTPrintf("Waiting for completion...\n");
616	CHECK_ERROR_BREAK(progress, WaitForCompletion(-1));
617	ProgressErrorInfo ei(progress);
618	if (FAILED(ei.getResultCode()))
619	{
620	PRINT_ERROR_INFO(ei);
621	}
622	else
623	{
624	vdi->COMGETTER(FilePath)(dst.asOutParam());
625	RTPrintf("Actual clone path is '%ls'\n", dst.raw());
626	}
627	}
628	while (FALSE);
629	RTPrintf("\n");
630	#endif
631
632	#if 0
633	// find a registered hard disk by location and get properties
634	///////////////////////////////////////////////////////////////////////////
635	do
636	{
637	ComPtr<IHardDisk> hd;
638	static const wchar_t *Names[] =
639	{
640	#ifndef RT_OS_LINUX
641	L"freedos.vdi",
642	L"MS-DOS.vmdk",
643	L"iscsi",
644	L"some/path/and/disk.vdi",
645	#else
646	L"xp.vdi",
647	L"Xp.vDI",
648	#endif
649	};
650
651	RTPrintf("\n");
652
653	for (size_t i = 0; i < RT_ELEMENTS(Names); ++ i)
654	{
655	Bstr src = Names[i];
656	RTPrintf("Searching for hard disk '%ls'...\n", src.raw());
657	rc = virtualBox->FindHardDisk(src, hd.asOutParam());
658	if (SUCCEEDED(rc))
659	{
660	Guid id;
661	Bstr location;
662	CHECK_ERROR_BREAK(hd, COMGETTER(Id)(id.asOutParam()));
663	CHECK_ERROR_BREAK(hd, COMGETTER(Location)(location.asOutParam()));
664	RTPrintf("Found, UUID={%RTuuid}, location='%ls'.\n",
665	id.raw(), location.raw());
666
667	com::SafeArray<BSTR> names;
668	com::SafeArray<BSTR> values;
669
670	CHECK_ERROR_BREAK(hd, GetProperties(NULL,
671	ComSafeArrayAsOutParam(names),
672	ComSafeArrayAsOutParam(values)));
673
674	RTPrintf("Properties:\n");
675	for (size_t i = 0; i < names.size(); ++ i)
676	RTPrintf(" %ls = %ls\n", names[i], values[i]);
677
678	if (names.size() == 0)
679	RTPrintf(" <none>\n");
680
681	#if 0
682	Bstr name("TargetAddress");
683	Bstr value = Utf8StrFmt("lalala (%llu)", RTTimeMilliTS());
684
685	RTPrintf("Settings property %ls to %ls...\n", name.raw(), value.raw());
686	CHECK_ERROR(hd, SetProperty(name, value));
687	#endif
688	}
689	else
690	{
691	com::ErrorInfo info(virtualBox);
692	PRINT_ERROR_INFO(info);
693	}
694	RTPrintf("\n");
695	}
696	}
697	while (FALSE);
698	RTPrintf("\n");
699	#endif
700
701	#if 0
702	// access the machine in read-only mode
703	///////////////////////////////////////////////////////////////////////////
704	do
705	{
706	ComPtr<IMachine> machine;
707	Bstr name = argc > 1 ? argv[1] : "dos";
708	RTPrintf("Getting a machine object named '%ls'...\n", name.raw());
709	CHECK_ERROR_BREAK(virtualBox, FindMachine(name, machine.asOutParam()));
710	RTPrintf("Accessing the machine in read-only mode:\n");
711	readAndChangeMachineSettings(machine);
712	#if 0
713	if (argc != 2)
714	{
715	RTPrintf("Error: a string has to be supplied!\n");
716	}
717	else
718	{
719	Bstr secureLabel = argv[1];
720	machine->COMSETTER(ExtraData)(L"VBoxSDL/SecureLabel", secureLabel);
721	}
722	#endif
723	}
724	while (0);
725	RTPrintf("\n");
726	#endif
727
728	#if 0
729	// create a new machine (w/o registering it)
730	///////////////////////////////////////////////////////////////////////////
731	do
732	{
733	ComPtr<IMachine> machine;
734	#if defined(RT_OS_LINUX)
735	Bstr baseDir = L"/tmp/vbox";
736	#else
737	Bstr baseDir = L"C:\\vbox";
738	#endif
739	Bstr name = L"machina";
740
741	RTPrintf("Creating a new machine object(base dir '%ls', name '%ls')...\n",
742	baseDir.raw(), name.raw());
743	CHECK_ERROR_BREAK(virtualBox, CreateMachine(name, L"", baseDir, L"",
744	false,
745	machine.asOutParam()));
746
747	RTPrintf("Getting name...\n");
748	CHECK_ERROR_BREAK(machine, COMGETTER(Name)(name.asOutParam()));
749	RTPrintf("Name: {%ls}\n", name.raw());
750
751	BOOL modified = FALSE;
752	RTPrintf("Are any settings modified?...\n");
753	CHECK_ERROR_BREAK(machine, COMGETTER(SettingsModified)(&modified));
754	RTPrintf("%s\n", modified ? "yes" : "no");
755
756	ASSERT_BREAK(modified == TRUE);
757
758	name = L"Kakaya prekrasnaya virtual'naya mashina!";
759	RTPrintf("Setting new name ({%ls})...\n", name.raw());
760	CHECK_ERROR_BREAK(machine, COMSETTER(Name)(name));
761
762	RTPrintf("Setting memory size to 111...\n");
763	CHECK_ERROR_BREAK(machine, COMSETTER(MemorySize)(111));
764
765	Bstr desc = L"This is an exemplary description.";
766	RTPrintf("Setting description to \"%ls\"...\n", desc.raw());
767	CHECK_ERROR_BREAK(machine, COMSETTER(Description)(desc));
768
769	ComPtr<IGuestOSType> guestOSType;
770	Bstr type = L"os2warp45";
771	CHECK_ERROR_BREAK(virtualBox, GetGuestOSType(type, guestOSType.asOutParam()));
772
773	RTPrintf("Saving new machine settings...\n");
774	CHECK_ERROR_BREAK(machine, SaveSettings());
775
776	RTPrintf("Accessing the newly created machine:\n");
777	readAndChangeMachineSettings(machine);
778	}
779	while (FALSE);
780	RTPrintf("\n");
781	#endif
782
783	#if 0
784	// enumerate host DVD drives
785	///////////////////////////////////////////////////////////////////////////
786	do
787	{
788	ComPtr<IHost> host;
789	CHECK_RC_BREAK(virtualBox->COMGETTER(Host)(host.asOutParam()));
790
791	{
792	ComPtr<IHostDVDDriveCollection> coll;
793	CHECK_RC_BREAK(host->COMGETTER(DVDDrives)(coll.asOutParam()));
794	ComPtr<IHostDVDDriveEnumerator> enumerator;
795	CHECK_RC_BREAK(coll->Enumerate(enumerator.asOutParam()));
796	BOOL hasmore;
797	while (SUCCEEDED(enumerator->HasMore(&hasmore)) && hasmore)
798	{
799	ComPtr<IHostDVDDrive> drive;
800	CHECK_RC_BREAK(enumerator->GetNext(drive.asOutParam()));
801	Bstr name;
802	CHECK_RC_BREAK(drive->COMGETTER(Name)(name.asOutParam()));
803	RTPrintf("Host DVD drive: name={%ls}\n", name.raw());
804	}
805	CHECK_RC_BREAK(rc);
806
807	ComPtr<IHostDVDDrive> drive;
808	CHECK_ERROR(enumerator, GetNext(drive.asOutParam()));
809	CHECK_ERROR(coll, GetItemAt(1000, drive.asOutParam()));
810	CHECK_ERROR(coll, FindByName(Bstr("R:"), drive.asOutParam()));
811	if (SUCCEEDED(rc))
812	{
813	Bstr name;
814	CHECK_RC_BREAK(drive->COMGETTER(Name)(name.asOutParam()));
815	RTPrintf("Found by name: name={%ls}\n", name.raw());
816	}
817	}
818	}
819	while (FALSE);
820	RTPrintf("\n");
821	#endif
822
823	#if 0
824	// check for available hd backends
825	///////////////////////////////////////////////////////////////////////////
826	{
827	RTPrintf("Supported hard disk backends: --------------------------\n");
828	ComPtr<ISystemProperties> systemProperties;
829	CHECK_ERROR_BREAK(virtualBox,
830	COMGETTER(SystemProperties)(systemProperties.asOutParam()));
831	com::SafeIfaceArray<IHardDiskFormat> hardDiskFormats;
832	CHECK_ERROR_BREAK(systemProperties,
833	COMGETTER(HardDiskFormats)(ComSafeArrayAsOutParam(hardDiskFormats)));
834
835	for (size_t i = 0; i < hardDiskFormats.size(); ++ i)
836	{
837	/* General information */
838	Bstr id;
839	CHECK_ERROR_BREAK(hardDiskFormats[i],
840	COMGETTER(Id)(id.asOutParam()));
841
842	Bstr description;
843	CHECK_ERROR_BREAK(hardDiskFormats[i],
844	COMGETTER(Id)(description.asOutParam()));
845
846	ULONG caps;
847	CHECK_ERROR_BREAK(hardDiskFormats[i],
848	COMGETTER(Capabilities)(&caps));
849
850	RTPrintf("Backend %u: id='%ls' description='%ls' capabilities=%#06x extensions='",
851	i, id.raw(), description.raw(), caps);
852
853	/* File extensions */
854	com::SafeArray<BSTR> fileExtensions;
855	CHECK_ERROR_BREAK(hardDiskFormats[i],
856	COMGETTER(FileExtensions)(ComSafeArrayAsOutParam(fileExtensions)));
857	for (size_t a = 0; a < fileExtensions.size(); ++ a)
858	{
859	RTPrintf("%ls", Bstr(fileExtensions[a]).raw());
860	if (a != fileExtensions.size()-1)
861	RTPrintf(",");
862	}
863	RTPrintf("'");
864
865	/* Configuration keys */
866	com::SafeArray<BSTR> propertyNames;
867	com::SafeArray<BSTR> propertyDescriptions;
868	com::SafeArray<ULONG> propertyTypes;
869	com::SafeArray<ULONG> propertyFlags;
870	com::SafeArray<BSTR> propertyDefaults;
871	CHECK_ERROR_BREAK(hardDiskFormats[i],
872	DescribeProperties(ComSafeArrayAsOutParam(propertyNames),
873	ComSafeArrayAsOutParam(propertyDescriptions),
874	ComSafeArrayAsOutParam(propertyTypes),
875	ComSafeArrayAsOutParam(propertyFlags),
876	ComSafeArrayAsOutParam(propertyDefaults)));
877
878	RTPrintf(" config=(");
879	if (propertyNames.size() > 0)
880	{
881	for (size_t a = 0; a < propertyNames.size(); ++ a)
882	{
883	RTPrintf("key='%ls' desc='%ls' type=", Bstr(propertyNames[a]).raw(), Bstr(propertyDescriptions[a]).raw());
884	switch (propertyTypes[a])
885	{
886	case DataType_Int32Type: RTPrintf("int"); break;
887	case DataType_Int8Type: RTPrintf("byte"); break;
888	case DataType_StringType: RTPrintf("string"); break;
889	}
890	RTPrintf(" flags=%#04x", propertyFlags[a]);
891	RTPrintf(" default='%ls'", Bstr(propertyDefaults[a]).raw());
892	if (a != propertyNames.size()-1)
893	RTPrintf(",");
894	}
895	}
896	RTPrintf(")\n");
897	}
898	RTPrintf("-------------------------------------------------------\n");
899	}
900	#endif
901
902	#if 0
903	// enumerate hard disks & dvd images
904	///////////////////////////////////////////////////////////////////////////
905	do
906	{
907	{
908	com::SafeIfaceArray<IHardDisk> disks;
909	CHECK_ERROR_BREAK(virtualBox,
910	COMGETTER(HardDisks)(ComSafeArrayAsOutParam(disks)));
911
912	RTPrintf("%u base hard disks registered (disks.isNull()=%d).\n",
913	disks.size(), disks.isNull());
914
915	for (size_t i = 0; i < disks.size(); ++ i)
916	{
917	Bstr loc;
918	CHECK_ERROR_BREAK(disks[i], COMGETTER(Location)(loc.asOutParam()));
919	Guid id;
920	CHECK_ERROR_BREAK(disks[i], COMGETTER(Id)(id.asOutParam()));
921	MediaState_T state;
922	CHECK_ERROR_BREAK(disks[i], COMGETTER(State)(&state));
923	Bstr format;
924	CHECK_ERROR_BREAK(disks[i], COMGETTER(Format)(format.asOutParam()));
925
926	RTPrintf(" disks[%u]: '%ls'\n"
927	" UUID: {%RTuuid}\n"
928	" State: %s\n"
929	" Format: %ls\n",
930	i, loc.raw(), id.raw(),
931	state == MediaState_NotCreated ? "Not Created" :
932	state == MediaState_Created ? "Created" :
933	state == MediaState_Inaccessible ? "Inaccessible" :
934	state == MediaState_LockedRead ? "Locked Read" :
935	state == MediaState_LockedWrite ? "Locked Write" :
936	"???",
937	format.raw());
938
939	if (state == MediaState_Inaccessible)
940	{
941	Bstr error;
942	CHECK_ERROR_BREAK(disks[i],
943	COMGETTER(LastAccessError)(error.asOutParam()));
944	RTPrintf(" Access Error: %ls\n", error.raw());
945	}
946
947	/* get usage */
948
949	RTPrintf(" Used by VMs:\n");
950
951	com::SafeGUIDArray ids;
952	CHECK_ERROR_BREAK(disks[i],
953	COMGETTER(MachineIds)(ComSafeArrayAsOutParam(ids)));
954	if (ids.size() == 0)
955	{
956	RTPrintf(" <not used>\n");
957	}
958	else
959	{
960	for (size_t j = 0; j < ids.size(); ++ j)
961	{
962	RTPrintf(" {%RTuuid}\n", &ids[j]);
963	}
964	}
965	}
966	}
967	{
968	com::SafeIfaceArray<IDVDImage> images;
969	CHECK_ERROR_BREAK(virtualBox,
970	COMGETTER(DVDImages)(ComSafeArrayAsOutParam(images)));
971
972	RTPrintf("%u DVD images registered (images.isNull()=%d).\n",
973	images.size(), images.isNull());
974
975	for (size_t i = 0; i < images.size(); ++ i)
976	{
977	Bstr loc;
978	CHECK_ERROR_BREAK(images[i], COMGETTER(Location)(loc.asOutParam()));
979	Guid id;
980	CHECK_ERROR_BREAK(images[i], COMGETTER(Id)(id.asOutParam()));
981	MediaState_T state;
982	CHECK_ERROR_BREAK(images[i], COMGETTER(State)(&state));
983
984	RTPrintf(" images[%u]: '%ls'\n"
985	" UUID: {%RTuuid}\n"
986	" State: %s\n",
987	i, loc.raw(), id.raw(),
988	state == MediaState_NotCreated ? "Not Created" :
989	state == MediaState_Created ? "Created" :
990	state == MediaState_Inaccessible ? "Inaccessible" :
991	state == MediaState_LockedRead ? "Locked Read" :
992	state == MediaState_LockedWrite ? "Locked Write" :
993	"???");
994
995	if (state == MediaState_Inaccessible)
996	{
997	Bstr error;
998	CHECK_ERROR_BREAK(images[i],
999	COMGETTER(LastAccessError)(error.asOutParam()));
1000	RTPrintf(" Access Error: %ls\n", error.raw());
1001	}
1002
1003	/* get usage */
1004
1005	RTPrintf(" Used by VMs:\n");
1006
1007	com::SafeGUIDArray ids;
1008	CHECK_ERROR_BREAK(images[i],
1009	COMGETTER(MachineIds)(ComSafeArrayAsOutParam(ids)));
1010	if (ids.size() == 0)
1011	{
1012	RTPrintf(" <not used>\n");
1013	}
1014	else
1015	{
1016	for (size_t j = 0; j < ids.size(); ++ j)
1017	{
1018	RTPrintf(" {%RTuuid}\n", &ids[j]);
1019	}
1020	}
1021	}
1022	}
1023	}
1024	while (FALSE);
1025	RTPrintf("\n");
1026	#endif
1027
1028	#if 0
1029	// open a (direct) session
1030	///////////////////////////////////////////////////////////////////////////
1031	do
1032	{
1033	ComPtr<IMachine> machine;
1034	Bstr name = argc > 1 ? argv[1] : "dos";
1035	RTPrintf("Getting a machine object named '%ls'...\n", name.raw());
1036	CHECK_ERROR_BREAK(virtualBox, FindMachine(name, machine.asOutParam()));
1037	Guid guid;
1038	CHECK_RC_BREAK(machine->COMGETTER(Id)(guid.asOutParam()));
1039	RTPrintf("Opening a session for this machine...\n");
1040	CHECK_RC_BREAK(virtualBox->OpenSession(session, guid));
1041	#if 1
1042	ComPtr<IMachine> sessionMachine;
1043	RTPrintf("Getting machine session object...\n");
1044	CHECK_RC_BREAK(session->COMGETTER(Machine)(sessionMachine.asOutParam()));
1045	RTPrintf("Accessing the machine within the session:\n");
1046	readAndChangeMachineSettings(sessionMachine, machine);
1047	#if 0
1048	RTPrintf("\n");
1049	RTPrintf("Enabling the VRDE server (must succeed even if the VM is saved):\n");
1050	ComPtr<IVRDEServer> vrdeServer;
1051	CHECK_ERROR_BREAK(sessionMachine, COMGETTER(VRDEServer)(vrdeServer.asOutParam()));
1052	if (FAILED(vrdeServer->COMSETTER(Enabled)(TRUE)))
1053	{
1054	PRINT_ERROR_INFO(com::ErrorInfo(vrdeServer));
1055	}
1056	else
1057	{
1058	BOOL enabled = FALSE;
1059	CHECK_ERROR_BREAK(vrdeServer, COMGETTER(Enabled)(&enabled));
1060	RTPrintf("VRDE server is %s\n", enabled ? "enabled" : "disabled");
1061	}
1062	#endif
1063	#endif
1064	#if 0
1065	ComPtr<IConsole> console;
1066	RTPrintf("Getting the console object...\n");
1067	CHECK_RC_BREAK(session->COMGETTER(Console)(console.asOutParam()));
1068	RTPrintf("Discarding the current machine state...\n");
1069	ComPtr<IProgress> progress;
1070	CHECK_ERROR_BREAK(console, DiscardCurrentState(progress.asOutParam()));
1071	RTPrintf("Waiting for completion...\n");
1072	CHECK_ERROR_BREAK(progress, WaitForCompletion(-1));
1073	ProgressErrorInfo ei(progress);
1074	if (FAILED(ei.getResultCode()))
1075	{
1076	PRINT_ERROR_INFO(ei);
1077
1078	ComPtr<IUnknown> initiator;
1079	CHECK_ERROR_BREAK(progress, COMGETTER(Initiator)(initiator.asOutParam()));
1080
1081	RTPrintf("initiator(unk) = %p\n", (IUnknown *)initiator);
1082	RTPrintf("console(unk) = %p\n", (IUnknown )ComPtr<IUnknown>((IConsole )console));
1083	RTPrintf("console = %p\n", (IConsole *)console);
1084	}
1085	#endif
1086	RTPrintf("Press enter to close session...");
1087	getchar();
1088	session->Close();
1089	}
1090	while (FALSE);
1091	RTPrintf("\n");
1092	#endif
1093
1094	#if 0
1095	// open a remote session
1096	///////////////////////////////////////////////////////////////////////////
1097	do
1098	{
1099	ComPtr<IMachine> machine;
1100	Bstr name = L"dos";
1101	RTPrintf("Getting a machine object named '%ls'...\n", name.raw());
1102	CHECK_RC_BREAK(virtualBox->FindMachine(name, machine.asOutParam()));
1103	Guid guid;
1104	CHECK_RC_BREAK(machine->COMGETTER(Id)(guid.asOutParam()));
1105	RTPrintf("Opening a remote session for this machine...\n");
1106	ComPtr<IProgress> progress;
1107	CHECK_RC_BREAK(virtualBox->OpenRemoteSession(session, guid, Bstr("gui"),
1108	NULL, progress.asOutParam()));
1109	RTPrintf("Waiting for the session to open...\n");
1110	CHECK_RC_BREAK(progress->WaitForCompletion(-1));
1111	ComPtr<IMachine> sessionMachine;
1112	RTPrintf("Getting machine session object...\n");
1113	CHECK_RC_BREAK(session->COMGETTER(Machine)(sessionMachine.asOutParam()));
1114	ComPtr<IConsole> console;
1115	RTPrintf("Getting console object...\n");
1116	CHECK_RC_BREAK(session->COMGETTER(Console)(console.asOutParam()));
1117	RTPrintf("Press enter to pause the VM execution in the remote session...");
1118	getchar();
1119	CHECK_RC(console->Pause());
1120	RTPrintf("Press enter to close this session...");
1121	getchar();
1122	session->Close();
1123	}
1124	while (FALSE);
1125	RTPrintf("\n");
1126	#endif
1127
1128	#if 0
1129	// open an existing remote session
1130	///////////////////////////////////////////////////////////////////////////
1131	do
1132	{
1133	ComPtr<IMachine> machine;
1134	Bstr name = "dos";
1135	RTPrintf("Getting a machine object named '%ls'...\n", name.raw());
1136	CHECK_RC_BREAK(virtualBox->FindMachine(name, machine.asOutParam()));
1137	Guid guid;
1138	CHECK_RC_BREAK(machine->COMGETTER(Id)(guid.asOutParam()));
1139	RTPrintf("Opening an existing remote session for this machine...\n");
1140	CHECK_RC_BREAK(virtualBox->OpenExistingSession(session, guid));
1141	ComPtr<IMachine> sessionMachine;
1142	RTPrintf("Getting machine session object...\n");
1143	CHECK_RC_BREAK(session->COMGETTER(Machine)(sessionMachine.asOutParam()));
1144
1145	#if 0
1146	Bstr extraDataKey = "VBoxSDL/SecureLabel";
1147	Bstr extraData = "Das kommt jetzt noch viel krasser vom total konkreten API!";
1148	CHECK_RC(sessionMachine->SetExtraData(extraDataKey, extraData));
1149	#endif
1150	#if 0
1151	ComPtr<IConsole> console;
1152	RTPrintf("Getting console object...\n");
1153	CHECK_RC_BREAK(session->COMGETTER(Console)(console.asOutParam()));
1154	RTPrintf("Press enter to pause the VM execution in the remote session...");
1155	getchar();
1156	CHECK_RC(console->Pause());
1157	RTPrintf("Press enter to close this session...");
1158	getchar();
1159	#endif
1160	session->Close();
1161	}
1162	while (FALSE);
1163	RTPrintf("\n");
1164	#endif
1165
1166	#if 1
1167	do {
1168	// Get host
1169	ComPtr<IHost> host;
1170	CHECK_ERROR_BREAK(virtualBox, COMGETTER(Host)(host.asOutParam()));
1171
1172	ULONG uMemSize, uMemAvail;
1173	CHECK_ERROR_BREAK(host, COMGETTER(MemorySize)(&uMemSize));
1174	RTPrintf("Total memory (MB): %u\n", uMemSize);
1175	CHECK_ERROR_BREAK(host, COMGETTER(MemoryAvailable)(&uMemAvail));
1176	RTPrintf("Free memory (MB): %u\n", uMemAvail);
1177	} while (0);
1178	#endif
1179
1180	#if 0
1181	do {
1182	// Get host
1183	ComPtr<IHost> host;
1184	CHECK_ERROR_BREAK(virtualBox, COMGETTER(Host)(host.asOutParam()));
1185
1186	com::SafeIfaceArray<IHostNetworkInterface> hostNetworkInterfaces;
1187	CHECK_ERROR_BREAK(host,
1188	COMGETTER(NetworkInterfaces)(ComSafeArrayAsOutParam(hostNetworkInterfaces)));
1189	if (hostNetworkInterfaces.size() > 0)
1190	{
1191	ComPtr<IHostNetworkInterface> networkInterface = hostNetworkInterfaces[0];
1192	Bstr interfaceName;
1193	networkInterface->COMGETTER(Name)(interfaceName.asOutParam());
1194	RTPrintf("Found %d network interfaces, testing with %ls...\n", hostNetworkInterfaces.size(), interfaceName.raw());
1195	Bstr interfaceGuid;
1196	networkInterface->COMGETTER(Id)(interfaceGuid.asOutParam());
1197	// Find the interface by its name
1198	networkInterface.setNull();
1199	CHECK_ERROR_BREAK(host,
1200	FindHostNetworkInterfaceByName(interfaceName.raw(), networkInterface.asOutParam()));
1201	Bstr interfaceGuid2;
1202	networkInterface->COMGETTER(Id)(interfaceGuid2.asOutParam());
1203	if (interfaceGuid2 != interfaceGuid)
1204	RTPrintf("Failed to retrieve an interface by name %ls.\n", interfaceName.raw());
1205	// Find the interface by its guid
1206	networkInterface.setNull();
1207	CHECK_ERROR_BREAK(host,
1208	FindHostNetworkInterfaceById(interfaceGuid.raw(), networkInterface.asOutParam()));
1209	Bstr interfaceName2;
1210	networkInterface->COMGETTER(Name)(interfaceName2.asOutParam());
1211	if (interfaceName != interfaceName2)
1212	RTPrintf("Failed to retrieve an interface by GUID %ls.\n", interfaceGuid.raw());
1213	}
1214	else
1215	{
1216	RTPrintf("No network interfaces found!\n");
1217	}
1218	} while (0);
1219	#endif
1220
1221	#if 0
1222	// DNS & Co.
1223	///////////////////////////////////////////////////////////////////////////
1224	/* XXX: Note it's endless loop */
1225	do
1226	{
1227	ComPtr<IHost> host;
1228	CHECK_ERROR_BREAK(virtualBox, COMGETTER(Host)(host.asOutParam()));
1229
1230	{
1231	Bstr domainName;
1232	CHECK_ERROR_BREAK(host,COMGETTER(DomainName)(domainName.asOutParam()));
1233	RTPrintf("Domain name: %ls\n", domainName.raw());
1234	}
1235
1236	com::SafeArray<BSTR> strs;
1237	CHECK_ERROR_BREAK(host, COMGETTER(NameServers)(ComSafeArrayAsOutParam(strs)));
1238
1239	unsigned int i;
1240	for (i = 0; i < strs.size(); ++i)
1241	RTPrintf("Name server[%d]:%s\n", i, com::Utf8Str(strs[i]).c_str());
1242
1243	RTThreadSleep(1000);
1244	}
1245	while (1);
1246	RTPrintf("\n");
1247	#endif
1248
1249
1250	#if 0 && defined(VBOX_WITH_RESOURCE_USAGE_API)
1251	do {
1252	// Get collector
1253	ComPtr<IPerformanceCollector> collector;
1254	CHECK_ERROR_BREAK(virtualBox,
1255	COMGETTER(PerformanceCollector)(collector.asOutParam()));
1256
1257
1258	// Fill base metrics array
1259	Bstr baseMetricNames[] = { L"Net/eth0/Load" };
1260	com::SafeArray<BSTR> baseMetrics(1);
1261	baseMetricNames[0].cloneTo(&baseMetrics[0]);
1262
1263	// Get host
1264	ComPtr<IHost> host;
1265	CHECK_ERROR_BREAK(virtualBox, COMGETTER(Host)(host.asOutParam()));
1266
1267	// Get host network interfaces
1268	// com::SafeIfaceArray<IHostNetworkInterface> hostNetworkInterfaces;
1269	// CHECK_ERROR_BREAK(host,
1270	// COMGETTER(NetworkInterfaces)(ComSafeArrayAsOutParam(hostNetworkInterfaces)));
1271
1272	// Setup base metrics
1273	// Note that one needs to set up metrics after a session is open for a machine.
1274	com::SafeIfaceArray<IPerformanceMetric> affectedMetrics;
1275	com::SafeIfaceArray<IUnknown> objects(1);
1276	host.queryInterfaceTo(&objects[0]);
1277	CHECK_ERROR_BREAK(collector, SetupMetrics(ComSafeArrayAsInParam(baseMetrics),
1278	ComSafeArrayAsInParam(objects), 1u, 10u,
1279	ComSafeArrayAsOutParam(affectedMetrics)));
1280	listAffectedMetrics(virtualBox,
1281	ComSafeArrayAsInParam(affectedMetrics));
1282	affectedMetrics.setNull();
1283
1284	RTPrintf("Sleeping for 5 seconds...\n");
1285	RTThreadSleep(5000); // Sleep for 5 seconds
1286
1287	RTPrintf("\nMetrics collected: --------------------\n");
1288	queryMetrics(virtualBox, collector, ComSafeArrayAsInParam(objects));
1289	} while (false);
1290	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
1291	#if 0 && defined(VBOX_WITH_RESOURCE_USAGE_API)
1292	do {
1293	// Get collector
1294	ComPtr<IPerformanceCollector> collector;
1295	CHECK_ERROR_BREAK(virtualBox,
1296	COMGETTER(PerformanceCollector)(collector.asOutParam()));
1297
1298
1299	// Fill base metrics array
1300	//Bstr baseMetricNames[] = { L"CPU/Load,RAM/Usage" };
1301	Bstr baseMetricNames[] = { L"RAM/VMM" };
1302	com::SafeArray<BSTR> baseMetrics(1);
1303	baseMetricNames[0].cloneTo(&baseMetrics[0]);
1304
1305	// Get host
1306	ComPtr<IHost> host;
1307	CHECK_ERROR_BREAK(virtualBox, COMGETTER(Host)(host.asOutParam()));
1308
1309	// Get machine
1310	ComPtr<IMachine> machine;
1311	Bstr name = argc > 1 ? argv[1] : "dsl";
1312	Bstr sessionType = argc > 2 ? argv[2] : "headless";
1313	RTPrintf("Getting a machine object named '%ls'...\n", name.raw());
1314	CHECK_ERROR_BREAK(virtualBox, FindMachine(name.raw(), machine.asOutParam()));
1315
1316	// Open session
1317	ComPtr<IProgress> progress;
1318	RTPrintf("Launching VM process...\n");
1319	CHECK_ERROR_BREAK(machine, LaunchVMProcess(session, sessionType.raw(),
1320	ComSafeArrayNullInParam(), progress.asOutParam()));
1321	RTPrintf("Waiting for the VM to power on...\n");
1322	CHECK_ERROR_BREAK(progress, WaitForCompletion(-1));
1323
1324	// ComPtr<IMachine> sessionMachine;
1325	// RTPrintf("Getting machine session object...\n");
1326	// CHECK_ERROR_BREAK(session, COMGETTER(Machine)(sessionMachine.asOutParam()));
1327
1328	// Setup base metrics
1329	// Note that one needs to set up metrics after a session is open for a machine.
1330	com::SafeIfaceArray<IPerformanceMetric> affectedMetrics;
1331	com::SafeIfaceArray<IUnknown> objects(1);
1332	host.queryInterfaceTo(&objects[0]);
1333	//machine.queryInterfaceTo(&objects[1]);
1334	CHECK_ERROR_BREAK(collector, SetupMetrics(ComSafeArrayAsInParam(baseMetrics),
1335	ComSafeArrayAsInParam(objects), 1u, 10u,
1336	ComSafeArrayAsOutParam(affectedMetrics)));
1337	listAffectedMetrics(virtualBox,
1338	ComSafeArrayAsInParam(affectedMetrics));
1339	affectedMetrics.setNull();
1340
1341	// Get console
1342	ComPtr<IConsole> console;
1343	RTPrintf("Getting console object...\n");
1344	CHECK_ERROR_BREAK(session, COMGETTER(Console)(console.asOutParam()));
1345
1346	RTThreadSleep(5000); // Sleep for 5 seconds
1347
1348	RTPrintf("\nMetrics collected with VM running: --------------------\n");
1349	queryMetrics(virtualBox, collector, ComSafeArrayAsInParam(objects));
1350
1351	// Pause
1352	//RTPrintf("Press enter to pause the VM execution in the remote session...");
1353	//getchar();
1354	CHECK_ERROR_BREAK(console, Pause());
1355
1356	RTThreadSleep(5000); // Sleep for 5 seconds
1357
1358	RTPrintf("\nMetrics collected with VM paused: ---------------------\n");
1359	queryMetrics(virtualBox, collector, ComSafeArrayAsInParam(objects));
1360
1361	RTPrintf("\nDrop collected metrics: ----------------------------------------\n");
1362	CHECK_ERROR_BREAK(collector,
1363	SetupMetrics(ComSafeArrayAsInParam(baseMetrics),
1364	ComSafeArrayAsInParam(objects),
1365	1u, 5u, ComSafeArrayAsOutParam(affectedMetrics)));
1366	listAffectedMetrics(virtualBox,
1367	ComSafeArrayAsInParam(affectedMetrics));
1368	affectedMetrics.setNull();
1369	queryMetrics(virtualBox, collector, ComSafeArrayAsInParam(objects));
1370
1371	com::SafeIfaceArray<IUnknown> vmObject(1);
1372	machine.queryInterfaceTo(&vmObject[0]);
1373
1374	RTPrintf("\nDisable collection of VM metrics: ------------------------------\n");
1375	CHECK_ERROR_BREAK(collector,
1376	DisableMetrics(ComSafeArrayAsInParam(baseMetrics),
1377	ComSafeArrayAsInParam(vmObject),
1378	ComSafeArrayAsOutParam(affectedMetrics)));
1379	listAffectedMetrics(virtualBox,
1380	ComSafeArrayAsInParam(affectedMetrics));
1381	affectedMetrics.setNull();
1382	RTThreadSleep(5000); // Sleep for 5 seconds
1383	queryMetrics(virtualBox, collector, ComSafeArrayAsInParam(objects));
1384
1385	RTPrintf("\nRe-enable collection of all metrics: ---------------------------\n");
1386	CHECK_ERROR_BREAK(collector,
1387	EnableMetrics(ComSafeArrayAsInParam(baseMetrics),
1388	ComSafeArrayAsInParam(objects),
1389	ComSafeArrayAsOutParam(affectedMetrics)));
1390	listAffectedMetrics(virtualBox,
1391	ComSafeArrayAsInParam(affectedMetrics));
1392	affectedMetrics.setNull();
1393	RTThreadSleep(5000); // Sleep for 5 seconds
1394	queryMetrics(virtualBox, collector, ComSafeArrayAsInParam(objects));
1395
1396	// Power off
1397	RTPrintf("Press enter to power off VM...");
1398	getchar();
1399	CHECK_ERROR_BREAK(console, PowerDown(progress.asOutParam()));
1400	RTPrintf("Waiting for the VM to power down...\n");
1401	CHECK_ERROR_BREAK(progress, WaitForCompletion(-1));
1402	RTPrintf("Press enter to close this session...");
1403	getchar();
1404	session->UnlockMachine();
1405	} while (false);
1406	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
1407	#if 0
1408	// check of OVF appliance handling
1409	///////////////////////////////////////////////////////////////////////////
1410	do
1411	{
1412	Bstr ovf = argc > 1 ? argv[1] : "someOVF.ovf";
1413	RTPrintf("Try to open %ls ...\n", ovf.raw());
1414
1415	ComPtr<IAppliance> appliance;
1416	CHECK_ERROR_BREAK(virtualBox,
1417	CreateAppliance(appliance.asOutParam()));
1418	CHECK_ERROR_BREAK(appliance, Read(ovf));
1419	Bstr path;
1420	CHECK_ERROR_BREAK(appliance, COMGETTER(Path)(path.asOutParam()));
1421	RTPrintf("Successfully opened %ls.\n", path.raw());
1422	CHECK_ERROR_BREAK(appliance, Interpret());
1423	RTPrintf("Successfully interpreted %ls.\n", path.raw());
1424	RTPrintf("Appliance:\n");
1425	// Fetch all disks
1426	com::SafeArray<BSTR> retDisks;
1427	CHECK_ERROR_BREAK(appliance,
1428	COMGETTER(Disks)(ComSafeArrayAsOutParam(retDisks)));
1429	if (retDisks.size() > 0)
1430	{
1431	RTPrintf("Disks:");
1432	for (unsigned i = 0; i < retDisks.size(); i++)
1433	RTPrintf(" %ls", Bstr(retDisks[i]).raw());
1434	RTPrintf("\n");
1435	}
1436	/* Fetch all virtual system descriptions */
1437	com::SafeIfaceArray<IVirtualSystemDescription> retVSD;
1438	CHECK_ERROR_BREAK(appliance,
1439	COMGETTER(VirtualSystemDescriptions)(ComSafeArrayAsOutParam(retVSD)));
1440	if (retVSD.size() > 0)
1441	{
1442	for (unsigned i = 0; i < retVSD.size(); ++i)
1443	{
1444	com::SafeArray<VirtualSystemDescriptionType_T> retTypes;
1445	com::SafeArray<BSTR> retRefValues;
1446	com::SafeArray<BSTR> retOrigValues;
1447	com::SafeArray<BSTR> retAutoValues;
1448	com::SafeArray<BSTR> retConfiguration;
1449	CHECK_ERROR_BREAK(retVSD[i],
1450	GetDescription(ComSafeArrayAsOutParam(retTypes),
1451	ComSafeArrayAsOutParam(retRefValues),
1452	ComSafeArrayAsOutParam(retOrigValues),
1453	ComSafeArrayAsOutParam(retAutoValues),
1454	ComSafeArrayAsOutParam(retConfiguration)));
1455
1456	RTPrintf("VirtualSystemDescription:\n");
1457	for (unsigned a = 0; a < retTypes.size(); ++a)
1458	{
1459	RTPrintf(" %d %ls %ls %ls\n",
1460	retTypes[a],
1461	Bstr(retOrigValues[a]).raw(),
1462	Bstr(retAutoValues[a]).raw(),
1463	Bstr(retConfiguration[a]).raw());
1464	}
1465	/* Show warnings from interpret */
1466	com::SafeArray<BSTR> retWarnings;
1467	CHECK_ERROR_BREAK(retVSD[i],
1468	GetWarnings(ComSafeArrayAsOutParam(retWarnings)));
1469	if (retWarnings.size() > 0)
1470	{
1471	RTPrintf("The following warnings occurs on interpret:\n");
1472	for (unsigned r = 0; r < retWarnings.size(); ++r)
1473	RTPrintf("%ls\n", Bstr(retWarnings[r]).raw());
1474	RTPrintf("\n");
1475	}
1476	}
1477	RTPrintf("\n");
1478	}
1479	RTPrintf("Try to import the appliance ...\n");
1480	ComPtr<IProgress> progress;
1481	CHECK_ERROR_BREAK(appliance,
1482	ImportMachines(progress.asOutParam()));
1483	CHECK_ERROR(progress, WaitForCompletion(-1));
1484	if (SUCCEEDED(rc))
1485	{
1486	/* Check if the import was successfully */
1487	progress->COMGETTER(ResultCode)(&rc);
1488	if (FAILED(rc))
1489	{
1490	com::ProgressErrorInfo info(progress);
1491	if (info.isBasicAvailable())
1492	RTPrintf("Error: failed to import appliance. Error message: %ls\n", info.getText().raw());
1493	else
1494	RTPrintf("Error: failed to import appliance. No error message available!\n");
1495	}
1496	else
1497	RTPrintf("Successfully imported the appliance.\n");
1498	}
1499
1500	}
1501	while (FALSE);
1502	RTPrintf("\n");
1503	#endif
1504	#if 0
1505	// check of network bandwidth control
1506	///////////////////////////////////////////////////////////////////////////
1507	do
1508	{
1509	Bstr name = argc > 1 ? argv[1] : "ubuntu";
1510	Bstr sessionType = argc > 2 ? argv[2] : "headless";
1511	Bstr grpName = "tstAPI";
1512	{
1513	// Get machine
1514	ComPtr<IMachine> machine;
1515	ComPtr<IBandwidthControl> bwCtrl;
1516	ComPtr<IBandwidthGroup> bwGroup;
1517	ComPtr<INetworkAdapter> nic;
1518	RTPrintf("Getting a machine object named '%ls'...\n", name.raw());
1519	CHECK_ERROR_BREAK(virtualBox, FindMachine(name.raw(), machine.asOutParam()));
1520	/* open a session for the VM (new or shared) */
1521	CHECK_ERROR_BREAK(machine, LockMachine(session, LockType_Shared));
1522	SessionType_T st;
1523	CHECK_ERROR_BREAK(session, COMGETTER(Type)(&st));
1524	bool fRunTime = (st == SessionType_Shared);
1525	if (fRunTime)
1526	{
1527	RTPrintf("Machine %ls must not be running!\n");
1528	break;
1529	}
1530	/* get the mutable session machine */
1531	session->COMGETTER(Machine)(machine.asOutParam());
1532	CHECK_ERROR_BREAK(machine, COMGETTER(BandwidthControl)(bwCtrl.asOutParam()));
1533
1534	RTPrintf("Creating bandwidth group named '%ls'...\n", grpName.raw());
1535	CHECK_ERROR_BREAK(bwCtrl, CreateBandwidthGroup(grpName.raw(), BandwidthGroupType_Network, 123));
1536
1537
1538	CHECK_ERROR_BREAK(bwCtrl, GetBandwidthGroup(grpName.raw(), bwGroup.asOutParam()));
1539	CHECK_ERROR_BREAK(machine, GetNetworkAdapter(0, nic.asOutParam()));
1540	RTPrintf("Assigning the group to the first network adapter...\n");
1541	CHECK_ERROR_BREAK(nic, COMSETTER(BandwidthGroup)(bwGroup));
1542	CHECK_ERROR_BREAK(machine, SaveSettings());
1543	RTPrintf("Press enter to close this session...");
1544	getchar();
1545	session->UnlockMachine();
1546	}
1547	{
1548	// Get machine
1549	ComPtr<IMachine> machine;
1550	ComPtr<IBandwidthControl> bwCtrl;
1551	ComPtr<IBandwidthGroup> bwGroup;
1552	Bstr grpNameReadFromNic;
1553	ComPtr<INetworkAdapter> nic;
1554	RTPrintf("Getting a machine object named '%ls'...\n", name.raw());
1555	CHECK_ERROR_BREAK(virtualBox, FindMachine(name.raw(), machine.asOutParam()));
1556	/* open a session for the VM (new or shared) */
1557	CHECK_ERROR_BREAK(machine, LockMachine(session, LockType_Shared));
1558	/* get the mutable session machine */
1559	session->COMGETTER(Machine)(machine.asOutParam());
1560	CHECK_ERROR_BREAK(machine, COMGETTER(BandwidthControl)(bwCtrl.asOutParam()));
1561	CHECK_ERROR_BREAK(machine, GetNetworkAdapter(0, nic.asOutParam()));
1562
1563	RTPrintf("Reading the group back from the first network adapter...\n");
1564	CHECK_ERROR_BREAK(nic, COMGETTER(BandwidthGroup)(bwGroup.asOutParam()));
1565	if (bwGroup.isNull())
1566	RTPrintf("Error: Bandwidth group is null at the first network adapter!\n");
1567	else
1568	{
1569	CHECK_ERROR_BREAK(bwGroup, COMGETTER(Name)(grpNameReadFromNic.asOutParam()));
1570	if (grpName != grpNameReadFromNic)
1571	RTPrintf("Error: Bandwidth group names do not match (%ls != %ls)!\n", grpName.raw(), grpNameReadFromNic.raw());
1572	else
1573	RTPrintf("Successfully retrieved bandwidth group attribute from NIC (name=%ls)\n", grpNameReadFromNic.raw());
1574	ComPtr<IBandwidthGroup> bwGroupEmpty;
1575	RTPrintf("Assigning an empty group to the first network adapter...\n");
1576	CHECK_ERROR_BREAK(nic, COMSETTER(BandwidthGroup)(bwGroupEmpty));
1577	}
1578	RTPrintf("Removing bandwidth group named '%ls'...\n", grpName.raw());
1579	CHECK_ERROR_BREAK(bwCtrl, DeleteBandwidthGroup(grpName.raw()));
1580	CHECK_ERROR_BREAK(machine, SaveSettings());
1581	RTPrintf("Press enter to close this session...");
1582	getchar();
1583	session->UnlockMachine();
1584	}
1585	} while (FALSE);
1586	RTPrintf("\n");
1587	#endif
1588
1589	RTPrintf("Press enter to release Session and VirtualBox instances...");
1590	getchar();
1591
1592	// end "all-stuff" scope
1593	////////////////////////////////////////////////////////////////////////////
1594	}
1595	while (0);
1596
1597	RTPrintf("Press enter to shutdown COM...");
1598	getchar();
1599
1600	com::Shutdown();
1601
1602	RTPrintf("tstAPI FINISHED.\n");
1603
1604	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1605	}
1606
1607	#ifdef VBOX_WITH_RESOURCE_USAGE_API
1608
1609	static void queryMetrics(ComPtr<IVirtualBox> aVirtualBox,
1610	ComPtr<IPerformanceCollector> collector,
1611	ComSafeArrayIn(IUnknown *, objects))
1612	{
1613	HRESULT rc;
1614
1615	//Bstr metricNames[] = { L"CPU/Load/User:avg,CPU/Load/System:avg,CPU/Load/Idle:avg,RAM/Usage/Total,RAM/Usage/Used:avg" };
1616	Bstr metricNames[] = { L"*" };
1617	com::SafeArray<BSTR> metrics(1);
1618	metricNames[0].cloneTo(&metrics[0]);
1619	com::SafeArray<BSTR> retNames;
1620	com::SafeIfaceArray<IUnknown> retObjects;
1621	com::SafeArray<BSTR> retUnits;
1622	com::SafeArray<ULONG> retScales;
1623	com::SafeArray<ULONG> retSequenceNumbers;
1624	com::SafeArray<ULONG> retIndices;
1625	com::SafeArray<ULONG> retLengths;
1626	com::SafeArray<LONG> retData;
1627	CHECK_ERROR(collector, QueryMetricsData(ComSafeArrayAsInParam(metrics),
1628	ComSafeArrayInArg(objects),
1629	ComSafeArrayAsOutParam(retNames),
1630	ComSafeArrayAsOutParam(retObjects),
1631	ComSafeArrayAsOutParam(retUnits),
1632	ComSafeArrayAsOutParam(retScales),
1633	ComSafeArrayAsOutParam(retSequenceNumbers),
1634	ComSafeArrayAsOutParam(retIndices),
1635	ComSafeArrayAsOutParam(retLengths),
1636	ComSafeArrayAsOutParam(retData)));
1637	RTPrintf("Object Metric Values\n"
1638	"---------- -------------------- --------------------------------------------\n");
1639	for (unsigned i = 0; i < retNames.size(); i++)
1640	{
1641	Bstr metricUnit(retUnits[i]);
1642	Bstr metricName(retNames[i]);
1643	RTPrintf("%-10ls %-20ls ", getObjectName(aVirtualBox, retObjects[i]).raw(), metricName.raw());
1644	const char *separator = "";
1645	for (unsigned j = 0; j < retLengths[i]; j++)
1646	{
1647	if (retScales[i] == 1)
1648	RTPrintf("%s%d %ls", separator, retData[retIndices[i] + j], metricUnit.raw());
1649	else
1650	RTPrintf("%s%d.%02d%ls", separator, retData[retIndices[i] + j] / retScales[i],
1651	(retData[retIndices[i] + j] * 100 / retScales[i]) % 100, metricUnit.raw());
1652	separator = ", ";
1653	}
1654	RTPrintf("\n");
1655	}
1656	}
1657
1658	static Bstr getObjectName(ComPtr<IVirtualBox> aVirtualBox,
1659	ComPtr<IUnknown> aObject)
1660	{
1661	HRESULT rc;
1662
1663	ComPtr<IHost> host = aObject;
1664	if (!host.isNull())
1665	return Bstr("host");
1666
1667	ComPtr<IMachine> machine = aObject;
1668	if (!machine.isNull())
1669	{
1670	Bstr name;
1671	CHECK_ERROR(machine, COMGETTER(Name)(name.asOutParam()));
1672	if (SUCCEEDED(rc))
1673	return name;
1674	}
1675	return Bstr("unknown");
1676	}
1677
1678	static void listAffectedMetrics(ComPtr<IVirtualBox> aVirtualBox,
1679	ComSafeArrayIn(IPerformanceMetric*, aMetrics))
1680	{
1681	HRESULT rc;
1682	com::SafeIfaceArray<IPerformanceMetric> metrics(ComSafeArrayInArg(aMetrics));
1683	if (metrics.size())
1684	{
1685	ComPtr<IUnknown> object;
1686	Bstr metricName;
1687	RTPrintf("The following metrics were modified:\n\n"
1688	"Object Metric\n"
1689	"---------- --------------------\n");
1690	for (size_t i = 0; i < metrics.size(); i++)
1691	{
1692	CHECK_ERROR(metrics[i], COMGETTER(Object)(object.asOutParam()));
1693	CHECK_ERROR(metrics[i], COMGETTER(MetricName)(metricName.asOutParam()));
1694	RTPrintf("%-10ls %-20ls\n",
1695	getObjectName(aVirtualBox, object).raw(), metricName.raw());
1696	}
1697	RTPrintf("\n");
1698	}
1699	else
1700	{
1701	RTPrintf("No metrics match the specified filter!\n");
1702	}
1703	}
1704
1705	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
1706	/* vim: set shiftwidth=4 tabstop=4 expandtab: */

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Main/testcase/tstAPI.cpp@ 98123

Download in other formats: