So first a list of documentation I found:

• offical javadoc of ODFDOM
• ODF Documentation hosted by ODFDOM
• ODFDOM samples (slightly out of date)

Adding a new paragraph with a pre-defined style

To create a new paragraph with a style I used the following static function:

public static OdfTextParagraph newStyledParagraph ( final OdfTextDocument odt, final String style, final String content ) throws Exception
{
  final OdfTextParagraph p;
  if ( content != null ) {
    p = odt.newParagraph ( content );
  } else {
    p = odt.newParagraph ();
  }
  p.setStyleName ( style );
  return p;
}

Adding fields (like title and subtitle)

The following snippet will create a new paragraph

OdfTextParagraph p;
p = OdfHelper.newStyledParagraph ( odt, "Title", null );
p.newTextTitleElement ();

p = OdfHelper.newStyledParagraph ( odt, "Subtitle", null );
p.newTextSubjectElement ();

Creating a new parapgraph style

The next snippet creates a new a new style called “Source Text” dereived from “Text Boby”. The setFontFamily method is a helper to set all font properties at once.

protected void setFontFamily ( final OdfStyleBase style, final String value )
{
    style.setProperty ( OdfTextProperties.FontFamily, value );
    style.setProperty ( OdfTextProperties.FontFamilyAsian, value );
    style.setProperty ( OdfTextProperties.FontFamilyComplex, value );
}

private void createStyles ( final OdfTextDocument odt )
{
    final OdfOfficeStyles styles = odt.getOrCreateDocumentStyles ();

    final OdfStyle style = styles.newStyle ( "Source Text", OdfStyleFamily.Paragraph );
    style.setStyleParentStyleNameAttribute ( "Text Body" );
    style.setProperty ( OdfParagraphProperties.Margin, "1cm" );
    style.setProperty ( OdfParagraphProperties.BackgroundColor, "#DDDDDD" );
    setFontFamily ( style, "Courier New" );
}

Copy content from one to another ODF File

While most of the document I made was created some static part a the beginning was needed. Instead of creating it manually I created a new ODT File in LibreOffice and imported the content to the generated document.

The following snipped does that:

private void createStaticContent ( final OdfTextDocument odt, final File file ) throws Exception
{
    // check if file is readable and is a file
    if ( !file.canRead () || !file.isFile () )
    {
        return;
    }

    // Load the document to import

    final OdfTextDocument staticOdt = OdfTextDocument.loadDocument ( file );

    // Create a new text section which will receive the content. This is optional.
    // You could also load the content directly on the root of the document

    final TextSectionElement section = new TextSectionElement ( odt.getContentDom () );
    odt.getContentRoot ().appendChild ( section );
    section.setTextProtectedAttribute ( true );
    section.setTextNameAttribute ( "Static Content" ); //$NON-NLS-1$

    // iterate over all nodes
    final NodeList childNodes = staticOdt.getContentRoot ().getChildNodes ();
    for ( int i = 0; i < childNodes.getLength (); i++ )
    {
        // clone node from source
        final Node newNode = childNodes.item ( i ).cloneNode ( true );
        // import to target DOM
        final Node adoptedNode = odt.getContentDom ().adoptNode ( newNode );
        // append to section
        section.appendChild ( adoptedNode );
    }
}
Since only content is imported the styles of the target document will be used for the content that was imported.

But now Apple is ready to strike back and has added a bunch of new features to it upcoming iPhone 5 S. Adding a sensor to the touch screen that can performed a chemical analysis of substances that touches it allows the iOS to provide a neat new feature: Lick to unlock!

Right, by licking over the screen your phone it can detect if you are the respectful owner of the device. Insider information told us that Apple wanted to release this feature earlier, but hat to fix some simple issues that did not occur in the lab. No one tested the sensor after having lunch.

But Apple would not be called innovative if this would would be the end of the story. The additional “lunch information” is extracted and rendered out of the unlock pattern. But instead is feed into Siri to provider her with additional information of what the owner ate, when and were. This allows Siri to provide more accurate suggestions of restaurants and even can provide you a list of nearest dentists when if thinks appropriate.

We are really looking forward to “unlicking” our phone.

well, let me just say: PNG, 64bit Linux, Windows 7, …

I was migrating E-Mails from Notes to Courier IMAP using “imapsync” when I stumbled over two strange problems…

Missing “sent” folder

I was not able to synchronize the “Sent” folder. Since the “Sent” folder does not seem to exists in the IMAP namespace and also Notes seems to have two sent folders (one for Notes one for IMAP). In the recent 8.5.2 release a new “IMAP Folder Sync” option was added (see http://www.dominopower.com/issues/issue201103/00002621001.html) that should fix this issue. Since we had 8.5.2 installed I tried and failed. This feature instantly caused a deadlock in the Domino server when the mail file was accessed with a write operation. In addition the “Sent” folder was absent. Event running “convert” in the mail file locked the server up and resolved nothing. The only “solution” was to create a “SentXX” folder (or any other name) and copy the messages in Notes to that folder, synchronizing the folder and move the messages back to the “Sent” folder in Courier IMAP.

IMAP Idle/Lookup/Protocol error

Converting e-mails takes some time and for some users the process just stopped with a timeout message like this:

Could not fetch message #123 from MyFolder timeout waiting 600s for data from server

Re-running the task continued with the messages that were not converted up to now (thanks to imapsync) but immediately stopped at the first message with the same timeout. Looking on the domino server side I noticed that the “imap” process was idling at 0% CPU load, which is strange since it normally takes up to 200% when converting messages.

Running “imapsync” the flags –debug and –debugimap showed a strange response in the protocol stream at the end of attachments:

While the normal response seem to be something like:

10 OK FETCH completed

in these cases the response was:

10 O K FETCH completed (or something similar).

Which was not interpreted by “imapsync” as response and kept it waiting until it timed out.

Scrolling up in the log file a little bit showed the message that caused the problem and fiddling around with the message a little bit provided a workaround that helped.

Locate the message in the mail file. Open it. Edit the message (e.g. by double clicking the content). Make no changes! (You could but you should not since you don’t want to edit received mail). And “Save and close” the message. Et voilá, it worked. Re-running “imapsync” did convert this message and successfully all following until it runs in the next timeout.

I hope this helps anybody running into the same issues.

Bye bye Notes!

PS: I used the following parameters with imapsync:

imapsync --host1 domino.mydomain.com --user1 "Ford Prefect" --passfile1 passfile1 --ssl1 --authmech1 PLAIN --host2 localhost --user2 ford.prefect@mydomain.com --passfile2 passfile2 --ssl2 --authmech2 PLAIN --skipsize --nofoldersizes --regextrans2 "s/\\\\/\\./g" --useheader Subject --useheader Date --allowsizemismatch --skipsize --regextrans2 "s/\\//_/g" --include "^Folder Prefix"

--useheader Date --useheader Subject : was necessary since Notes seemed to change the message IDs, which caused duplicate messages each time imapsync was run. These two arguments limited the equality of messages to Subject and Date, which was OK for me.

--nofoldersizes : stopped imapsync from calculating the size of the folder before it runs. This caused a huge speedup since this seems to be a major task for notes to provide this operation.

--skipsize --allowsizemismatch : also was required to prevent imapsync from canceling messages that had another amount of payload data than the header suggested. Notes sometimes reported wrong message sizes which could be the same issue as the protocol error above.

--regextrans2 "s/\\\\/\\./g" : was necessary since imapsync sometimes did not apply the IMAP namespace and prefix correctly when using regular expressions for the folder names.

--regextrans2 "s/\\//_/g" : was necessary since Lotus Notes allows “/” in the folder name, which Courier IMAP does not. So all “/” where converted to “_” for the moment.

--include "^Folder Prefix" : was quite useful to limit the imapsync run to a specific folder name if you need to close in on some issues or want more control on the current migration. Leaving out this parameter simply converts all folders.

PPS: Running “imapsync” seemed to be extremely slow before enabling specific IMAP features in the Notes mail files. I had to run “convert” for each file file in order to enable IMAP folder references and generate IMAP specific attributes. This could be due to the fact that we never used IMAP in Notes and therefore had IMAP features not enabled. Which prevents Notes from creating these information during normal runtime. This information is the generated “on demand” but not stored.

Enable IMAP for mailfile: load convert -e mail/mailfile.nsf
Enable IMAP folder references: load convert -m mail/mailfile.nsf
Generate IMAP attributes: load convert -h mail/mailfile.nsf

First of all, we have mixed environment of EJB3 and Spring 3 using JPA2. All in JBoss 6 AS, with default Hibernate 3.6 as JPA provider. Now for a long time everything works fine until we re-organize the dependencies of our modules. Starting with that we got some strange JPA behavior like “class is not an entity” and some rather weird getter issues.

Altogether it looked like some classloader issue. But it took some time to find that one.

In the beginning there was a JPA persistence unit called “someModel”. The problem with spring was, that it needs to be imported using the “jee:jndi-lookup” tag, which requires a JNDI name. That one was provided by JBoss itself using the “jboss.entity.manager.factory.jndi.name” property in the “persistence.xml” file. This triggers JBoss/Hibernate to bind the persistence unit with that specified name. Of course the name was “persistence/someModel”.

Now everything grew, EJB was added in order to gain modularity. And now that the dependencies and the start order was changed, the same persistence unit was used multiple times in multiple EJBs beside the spring application. While EJB seems not to have any problems finding its persistence unit, spring needs a bit more information and requires the already discusses “jee:jndi-lookup” tag in order to find its persistence unit.

As it turned out, the multiple persistence units all registered with the same name, leaving spring with the first (or last) registration, but not necessarily the correct registration. So spring accesses “some” persistence unit with that name and possible used the wrong classloader.

The solution was quite and and lot cleaner than using the “jboss.entity.manager.factory.jndi.name” property. But, less intuitive I have to say.

In the “web.xml” of the servlet that starts the application context a reference has to be added to the persistence unit:

	<persistence-unit-ref>
		<persistence-unit-ref-name>persistence/someModel</persistence-unit-ref-name>
		<persistence-unit-name>someModel</persistence-unit-name>
	</persistence-unit-ref>

This will register the local (in the EAR file hosting the WAR) peristence unit “someModel” in the local JNDI space as “persistence/someModel” and you are done. Spring will can still import it as “persistence/someModel”.

Starting the generator after the upgrade simply brought up:

Exception in thread "Main Thread" org.eclipse.acceleo.engine.AcceleoEvaluationException: The type of the first parameter of the main template named 'myTemplate' is a proxy.
    at org.eclipse.acceleo.engine.service.AcceleoService.doGenerate(AcceleoService.java:507)
    at org.eclipse.acceleo.engine.service.AbstractAcceleoGenerator.generate(AbstractAcceleoGenerator.java:175)
    at org.eclipse.acceleo.engine.service.AbstractAcceleoGenerator.doGenerate(AbstractAcceleoGenerator.java:154)
...

The main template did not accept the model anymore. Although everything was registered and working with the previous version.

Googling a bit I found out that Acceleo provides a different serialization model which stores models in binary form instead of XMI. Since all my models I flipped the switch in the project settings:

Acceleo Project Settings

Which worked at first until I stumbled over the next problem a few hours later:

org.eclipse.acceleo.engine.AcceleoEvaluationException: Invalid loop iteration at line 18 in Module myModule for block for (myObject.null). Last recorded value of self was com.thfour.config.model.model.impl.MyObjectImpl@81b69bf (....).
    at subModule.subModule(null)(subModule.mtl:18)
    at subModule.subModule(null)(subModule.mtl:6)
    at subModule.subModule(null)(subModule.mtl:4)
    at module.module(MyObject)(module.mtl:0)
    at module.module(MyObject)(module.mtl:7)

After some debugging it seemed as if the main module could not pass a model object to a template that is located in another bundle. We have structured our model generator to have a common part and a project specific bundle. At first it looked like as it this stopped working by an unknown reason.

After some testing, flipping switches, debugging, restructuring I found out that the solution was rather simple. The same switch (Binary, XMI) has to be set to the common generator module as well. All modules must agree to a model format (either binary or XMI).

While I can understand this for the generator that is launched, I cannot understand this for submodules that provide common generating templates and should not even care about the serialization form. But it is as it is

A default use case is to add a description to e.g. an icon based button:

Now and then you might find yourself in the need to add some more information than just a short text. While I think the upper example is a good example for using a tooltip the following is now really:

The problem is not necessarily the amount of information but the way it is presented. So why is it used? Because it is quite easy to use with SWT. The following line of code sets the tooltip text:

Button button = ...
button.setToolTipText ( "Read descriptor: " + readDescriptor + "\nWrite descriptor: " + writeDescriptor );

This call is using the widget toolkit’s own way to activate and render the tooltip. On the pro side you have the native look and feel and the quick way to add it, on the con side it only looks good when you have short and compact tooltips. Also you might run into problems with different behaviors on different platforms.

But Eclipse would not be Eclipse if there wasn’t a second way to add tooltips to you user interface. In JFace you will find a ToolTip class which is the base for custom made tooltips. Using DefaultToolTip you have a working base that provides a plain implementation quite similar in the rendering as the native tooltip:

Adding this a bit more complex but also provides some more options:

DefaultToolTip toolTip = new DefaultToolTip ( widget );
toolTip.setShift ( new Point ( 5, 5 ) );
toolTip.setText ( "Hello World" );

Browsing through the setters of the class you will find a lot to customize. On the con side, as you can see in the screenshot, it look like the native tooltip, but not exactly.

Now if this is still not enough customizing you can also dereive directly from org.eclipse.jface.window.ToolTip and implement createToolTipContentArea yourself:

protected Composite createToolTipContentArea ( final Event event, final Composite parent )
{
 ...
}

In our case we created a tooltip containing a header, an icon and a styled text:

The pros and cons should be obvious.

But … there is one more thing. Eclipse would not be Eclipse if there would not be another way to do it (I know I repeat myself here). SWT also provides another ToolTip class. This class provides tooltips and <q>balloons/q>:

The problem with these tooltips is, that they seem to be made for the Tray that can pop up balloons (see Snippet). You still can position the tooltip manually and align it to you control, but I would guess that using JFace is a much cleaner approach.

While one can argue about the pros and cons of formal quality management and rules of software development processes it ends up in the psychology of the team if and how good the testing has been performed. Some simply tricks ease the whole process and improve the result without adding lots of rules and frustration:

Reduce deployment times

If it takes 30 minutes from one change in the source code to the living result on the test system it will take ages to find and solve issues. Of course a coordinated build system is an important part of development. But quickly patching an issue is as well. If you need three steps to solve the issue and need half an hour to create a new version you have wasted 1½ hours instead of maybe five minutes if your development environment is quick enough. Not all issues can be resolved on the local development machine, so deployment has to be quick on the path up to the integration and testing system.

Early set up of a test system

Two days to the test. Everybody is confident that testing will go well. Everything was tested… on machines of developers. Installing the system on the testing machines turns out to be a huge problem and the day your customer arrives you have a badly set up system, developers worked over night and weekend to find the remaining hard coded path of /home/user/local/development which are not working in the test system.

Adding different operating systems of developers, additionally installed software packaged and more system resources the development system is always different to the test system. In addition you normally don’t deploy your software in the development system but simply start it from the IDE.

So as soon as you have your first few functions, set up a test system and deploy you software as it would be done during the real testing. You will be surprised how many bug/issues you will find in advance.

Test with the customer

If you have your test system that early you can also invite your customer to test with you. While not all customers are interested in that, some are and you should take the chance to do so. The first thing you will think is something like this costs us more time than it is worth. But in the end you have tested most functionally long before your final test and end up with a test system that is already known by your customer before the tests start. Unexpected but correct reactions of your system are already common knowledge and need no explanation. And of course you will get feedback much earlier and can integrate that into your development process ending up with a product that is much closer to your customer than introducing him to a brand new system on day 1 of the test.

Also let your developers test with the customer. Hiding developers in the basement and letting management perform the testing is not always a good choice of job assignment. There may be good reasons to let management do the final and formal testing. But during the beginning direct contact with the technical counterparts of your customer and your developers will give your own people a much better understanding of what the customer needs and you will loose much less information in the process. Many developers will also see this as benefit of seeing where their solution will later be put to use. Of course some prefer the basement

Add obstacles between test and development systems

While a short path between development and test system is important it might turn out to be good idea to add some temporary obstacles to that path. Otherwise you might end up with two development systems instead of one development system and one test system.

Cutting of the network access or relocating the machines to a different part of the building are some ways to do that. This will pull people together in one room for testing and bind their focus in the subject. And it will also show that when the system is productive in the future the way to reach it might be a lot more problematic than just connecting to a local server. New ideas and ways of how to test and debug will automatically turn up and can later be used in the productive system.

Who is testing

At least one person non developer should be responsible for testing. This does not mean that no developer should test but people tend to test the same way all over again. Just using the system another way might turn up lots of interesting issues. You will encounter situations you only can get out of using a developer, which will not be possible in the productive system. So the earlier you let people test that do not know the source code and can influence system internals the earlier you will get a system that can be managed by administrators of your customer alone (if this is what you wish). In the end the customer will click in a different way and will find issues with his approach on the system.

Also if you focus on special <q>test users</q> reduce the problem of having all developers think <q>the other one</q> tested that cool new feature which went out untested.

Test cases

I am a little biased about automated test cases. In the end you will have a manual test. Most systems I know cannot be completely tested using an automated test system. Developing a specialized solution in one project is totally different to a product that developed once and sold many times. Writing test cases can be quite difficult and time consuming. if you have to re-write them for every new project it might turn out easier to just perform then manually.

On the other hand automated test cases definitely will improve quality. But the are no guarantee for successful test with your customer. You will never reach a point where you have your system covered 100% by your automated tests. See it reaching light speed. You never can and getting closer will cost you more and more energy. Also automated test cases are just source code that might contains bugs ore may simply be wrong.

Finally

There is lots more to say about testing. Important is to test early, often, quick and separated and as realistic as you can.

After some digging I remembered that SWT brings an OLE interface which provides direct COM access. So I started poking around and finally come up with a solution that works quite well.

For the impatient: The full source code is available from github https://github.com/ctron/wmisample and the screenshot is here.

The solution requires: win32 or win64, SWT and some classes from the SWT internal namespace. The latter is a catch that does not hurt too much.

First one needs a SWbemServices object which is obtained by asking the SWbemLocator to create one:

OleAutomation automation = new OleAutomation("WbemScripting.SWbemLocator");
Variant service = automation.invoke(Helper.getId(automation, "ConnectServer"));

The variant will hold a VT_DISPATCH value which references the SWbemServices instance. Instead of calling the ConnectServer method with any parameters one can also call with full remote server support (see MSDN).

The next, and rather easy, step is to execute the query:

OleAutomation serviceAutomation = service.getAutomation();

Variant resultList = serviceAutomation.invoke(
   Helper.getId(serviceAutomation, "ExecQuery"),
   new Variant[] {
      new Variant(query),
      new Variant("WQL"),
      new Variant(32) });

The Helper.getId method fetches the dispatch id (function number) from the name of the function. So instead of calling a function by name you call it by id and look up the id by the name first:

public static int getId(OleAutomation auto, String name) {
   int result[] = auto.getIDsOfNames(new String[] { name });
   if (result == null || result.length < 1) {
      throw new RuntimeException(String.format(
         "Object does not support '%s'", name));
   }
   return result[0];
}

The result of the ExecQuery call is an object of the type SWbemObjectSet. The strange thing with this object is, that by documentation it only has an Item method which requires that you actually don’t want to know and provide. While all examples you find which that the result is directly used in VB for each constructs. But the object also provides an undocumented (still valid) _NewEnum method which is used by e.g. VB by default for for each loops. So one can call this method explicitly and iterate over the result.

The problem here is, that the result to the _NewEnum call is a VT_UNKNOWN variant since the result is a COM object without support for IDispatch. So one has to play plain COM games and QueryInterface for IEnumVARIANT and iterate using Next.

And here comes the part were one needs to use SWT internal methods, since this requires allocating memory and performing pointer stuff. So be warned, from here on your are actually calling operating system memory allocating functions that may: a) crash your application when used improperly (like it does when you use C or C++) and b) produce memory leaks that are not covered by the Java VM but by direct calls to alloc calls in the OS.

In order to separate this stuff from the rest of the classes it all went into the Helper class, providing an forEachVariant method using a visitor interface:

public static interface VariantVisitor {
  public void visit(Variant variant);
}

The method first gets the enum using the property (not method) _NewEnum which returns a variant of type VT_UNKNOWN:

Variant enumObject = enumerableAuto.getProperty(
  Helper.getId(enumerableAuto, "_NewEnum")
);

Now one needs to QueryInterface to get the IEnumVARIANT interface for the unknown:

long /* int */[] ppvObject = new long /* int */[1];
int rc = enumObject.getUnknown().QueryInterface(COM.IIDIEnumVARIANT, ppvObject);
if (rc != OS.S_OK)
  return rc; // in case of error

Looks actually like call in C. The result will be a pointer to a IEnumVARIANT in ppvObject. You should also be aware of the fact that QueryInterface also performes an AddRef, so you have to perform one Release call when you are done in order to decrease the usage count on the instance.

Next one can pass the pointer to the instance to an instance of IEnumVARIANT (which is also from SWT internal) and already provides mapping to the function calls Reset, Next, Release.

IEnumVARIANT enumVariant = new IEnumVARIANT(ppvObject[0]);
enumVariant.Reset();

And now comes the fun part of the whole thing. Allocating memory and iterating over the enumeration:

int[] pceltFetched = new int[1];
long rgelt = OS.GlobalAlloc(OS.GMEM_FIXED | OS.GMEM_ZEROINIT,Variant.sizeof);

try {
  while (enumVariant.Next(1, rgelt, pceltFetched) == OLE.S_OK
    && pceltFetched[0] == 1) {
      Variant v = Variant.win32_new(rgelt);
      variantVisitor.visit(v);
   }
} finally {
    OS.GlobalFree(rgelt);
}

First a new Variant structure is allocated (again, this is OS memory allocation, not JVM!). Next the while loop iterates over the enumeration using Next calls and passes the variants to the visitor interface. The try-finally block ensures that when something goes wrong, at least the memory is freed in order to prevent memory leaks.

Actually is was asking myself why this IEnumVARIANT implementation does not perform the full magic and provides a way to access enums without using internal stuff. But I guess the SWT team has not too much interest in working on OLE/COM stuff and likes to keeps things as minimalistic as possible.

As last step the while executeQuery method iterates over the SWbemObjectSet enumeration which returns Variants (VT_DISPATCH) pointing to instances of SWbemObject. They again have a property Properties_ that, which again is an enumeration of Name and Value pairs. The one needs to iterate again in order to request all properties.

it was quite interesting to see what is possible with Eclipse SWT and quite annoying to dig through incomplete COM documentation. But in the end it worked

Don’t forget to check the full source code at github: https://github.com/ctron/wmisample

Just clone (aka check out) the source:

git clone git://github.com/ctron/wmisample.git wmisample.git

If you don’t like to use git, you can also use the “Downloads” button on github and download a ZIP instead.

The full forEach method is:

	public static int forEachVariant(Variant enumerable,
			VariantVisitor variantVisitor) {
		OleAutomation enumerableAuto = enumerable.getAutomation();

		try {
			Variant enumObject = enumerableAuto.getProperty(Helper.getId(
					enumerableAuto, "_NewEnum"));

			long /* int */[] ppvObject = new long /* int */[1];
			int rc = enumObject.getUnknown().QueryInterface(
					COM.IIDIEnumVARIANT, ppvObject);

			if (rc != OS.S_OK)
				return rc;

			IEnumVARIANT enumVariant = new IEnumVARIANT(ppvObject[0]);

			try {
				enumVariant.Reset();

				int[] pceltFetched = new int[1];

				long rgelt = OS.GlobalAlloc(OS.GMEM_FIXED | OS.GMEM_ZEROINIT,
						Variant.sizeof);

				try {
					while (enumVariant.Next(1, rgelt, pceltFetched) == OLE.S_OK
							&& pceltFetched[0] == 1) {
						Variant v = Variant.win32_new(rgelt);
						variantVisitor.visit(v);
					}
				} finally {
					OS.GlobalFree(rgelt);
				}
			} finally {
				enumVariant.Release();
			}

			return OLE.S_OK;

		} finally {
			enumerableAuto.dispose();
		}
	}

And the full query logic method is:

	public List<WMIObjectInformation> executeQuery(String query) {
		OleAutomation serviceAutomation = service.getAutomation();
		try {
			final List<WMIObjectInformation> result = new LinkedList<WMIObjectInformation>();

			Variant resultList = serviceAutomation.invoke(
					Helper.getId(serviceAutomation, "ExecQuery"),
					new Variant[] { new Variant(query), new Variant("WQL"),
							new Variant(32) });

			if (resultList == null) {
				throw new RuntimeException(serviceAutomation.getLastError());
			}

			Helper.forEachVariant(resultList, new VariantVisitor() {

				@Override
				public void visit(Variant variant) {

					final Map<String, Object> params = new HashMap<String, Object>();

					Variant properties = Helper.getParameter(variant,
							"Properties_");

					Helper.forEachVariant(properties, new VariantVisitor() {

						@Override
						public void visit(Variant variant) {

							Variant name = Helper.getParameter(variant, "Name");
							Variant value = Helper.getParameter(variant,
									"Value");
							Object objectValue = Helper.convertVariant(value);

							params.put(name.getString(), objectValue);
						}
					});

					result.add(new WMIObjectInformation(Helper.getParameter(
							Helper.getParameter(variant, "Path_"), "Path")
							.getString(), params));
				}
			});

			return result;
		} finally {
			serviceAutomation.dispose();
		}
	}