tstAPI.cpp@ 83820

Last change on this file since 83820 was 82968, checked in by vboxsync, 5 years 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.5 KB

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

Download in other formats: