tstAPI.cpp@ 56372

Last change on this file since 56372 was 55969, checked in by vboxsync, 10 years ago
Removed unnecessary LOG_INSTANCE definitions.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 63.3 KB

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

Download in other formats: