org.eclipse.skalli.api.test/src/main/java/org/eclipse/skalli/services/extension/MigrationUtilsTest.java - skalli/org.eclipse.skalli - Git at Google

 /*******************************************************************************
  * Copyright (c) 2010-2014 SAP AG and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     SAP AG - initial API and implementation
  *******************************************************************************/
 package org.eclipse.skalli.services.extension;

 import static org.junit.Assert.*;

 import org.eclipse.skalli.commons.XMLUtils;
 import org.eclipse.skalli.testutil.TestEntityBase1;
 import org.eclipse.skalli.testutil.TestExtension;
 import org.eclipse.skalli.testutil.TestExtension1;
 import org.eclipse.skalli.testutil.TestUUIDs;
 import org.junit.Test;
 import org.w3c.dom.Document;
 import org.w3c.dom.Element;
 import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;

 @SuppressWarnings("nls")
 public class MigrationUtilsTest {

     private static final String ROOT_TAG = TestEntityBase1.class.getName();
     private static final String PROPERTY_STR = "str";
     private static final String PROPERTY_STR_VALUE = "value";
     private static final String PROPERTY_STRSET = "strset";
     private static final String TESTEXTENSION_TAG = TestExtension.class.getName();
     private static final String TESTEXTENSION1_TAG = TestExtension1.class.getName();

     private static boolean EXISTS = true;
     private static boolean NOT_EXISTS = false;
     private static boolean COPY = true;
     private static boolean MOVE = false;
     private static boolean TO_EXISTING_EXTENSION = true;
     private static boolean TO_NON_EXISTING_EXTENSION = false;
     private static boolean WITH_RENAME = true;
     private static boolean WITHOUT_RENAME = false;
     private static boolean ATTRIBUTE_OF_EXTENSION = true;
     private static boolean ATTRIBUTE_OF_ENTITY = false;
     private static boolean WITHOUT_COMPARATOR = true;
     private static boolean WITH_COMPARATOR = false;


     @Test
     public void testGetChild() throws Exception
     {
         Document doc = XMLUtils.documentFromString("<bla><hello>world</hello><blubb>noop</blubb></bla>");
         Element parentElement= doc.getDocumentElement();
         Element child = MigrationUtils.getChild(parentElement, "hello");
         assertEquals(child.getNodeName(), "hello");
         assertEquals(child.getTextContent(), "world");
     }

     @Test
     public void testGetChild_NotChilds() throws Exception
     {
         try {
             MigrationUtils.getChild(null, "hello");
             fail("IllegalArgumentException  expected, but not thrown");
         } catch (IllegalArgumentException e) {
             assertTrue(e.getMessage().contains("parentElement"));
         }
     }

     @Test
     public void testMoveToExistingExtension() throws Exception {
         assertCopyOrMove(MOVE, TO_EXISTING_EXTENSION, WITHOUT_RENAME);
     }

     @Test
     public void testMoveToNonExistingExtension() throws Exception {
         assertCopyOrMove(MOVE, TO_NON_EXISTING_EXTENSION, WITHOUT_RENAME);
     }

     @Test
     public void testMoveToExistingExtensionAndRename() throws Exception {
         assertCopyOrMove(MOVE, TO_EXISTING_EXTENSION, WITH_RENAME);
     }

     @Test
     public void testMoveToNonExistingExtensionAndRename() throws Exception {
         assertCopyOrMove(MOVE, TO_NON_EXISTING_EXTENSION, WITH_RENAME);
     }

     @Test
     public void testCopyToExistingExtension() throws Exception {
         assertCopyOrMove(COPY, TO_EXISTING_EXTENSION, WITHOUT_RENAME);
     }

     @Test
     public void testCopyToNonExistingExtension() throws Exception {
         assertCopyOrMove(COPY, TO_NON_EXISTING_EXTENSION, WITHOUT_RENAME);
     }

     @Test
     public void testCopyToExistingExtensionAndRename() throws Exception {
         assertCopyOrMove(COPY, TO_EXISTING_EXTENSION, WITH_RENAME);
     }

     @Test
     public void testCopyToNonExistingExtensionAndRename() throws Exception {
         assertCopyOrMove(COPY, TO_NON_EXISTING_EXTENSION, WITH_RENAME);
     }

     @Test
     public void testMoveFromExtensionToExistingExtension() throws Exception {
         assertMoveExtensionToExtension(TO_EXISTING_EXTENSION, WITHOUT_RENAME);
     }

     @Test
     public void testMoveFromExtensionToNonExistingExtension() throws Exception {
         assertMoveExtensionToExtension(TO_NON_EXISTING_EXTENSION, WITHOUT_RENAME);
     }

     @Test
     public void testMoveFromExtensionToExistingExtensionWithRename() throws Exception {
         assertMoveExtensionToExtension(TO_EXISTING_EXTENSION, WITH_RENAME);
     }

     @Test
     public void testMoveFromExtensionToNonExistingExtensionWithRename() throws Exception {
         assertMoveExtensionToExtension(TO_NON_EXISTING_EXTENSION, WITH_RENAME);
     }

     @Test
     public void testRenameTag() throws Exception {
         assertRenamed(ATTRIBUTE_OF_ENTITY);
     }

     @Test
     public void testRenameExtensionTag() throws Exception {
         assertRenamed(ATTRIBUTE_OF_EXTENSION);
     }

     @Test
     public void testMigrateStringToStringSet() throws Exception {
         assertStringSet(ATTRIBUTE_OF_ENTITY, WITH_COMPARATOR);
     }

     @Test
     public void testMigrateStringToStringSetNoComparator() throws Exception {
         assertStringSet(ATTRIBUTE_OF_ENTITY, WITHOUT_COMPARATOR);
     }

     @Test
     public void testMigrateExtensionStringToStringSet() throws Exception {
         assertStringSet(ATTRIBUTE_OF_EXTENSION, WITH_COMPARATOR);
     }

     @Test
     public void testMigrateExtensionStringToStringSetNoComparator() throws Exception {
         assertStringSet(ATTRIBUTE_OF_EXTENSION, WITHOUT_COMPARATOR);
     }


     private void assertCopyOrMove(boolean copy, boolean extensionExists, boolean rename) throws Exception {
         StringBuilder xml = new StringBuilder();
         beginXml(xml);
         beginNode(xml, ROOT_TAG);
         appendNode(xml, PROPERTY_STR, PROPERTY_STR_VALUE);
         if (extensionExists) {
             beginNode(xml, MigrationUtils.EXTENSIONS_TAGNAME);
             appendTestExtension(xml);
             endNode(xml, MigrationUtils.EXTENSIONS_TAGNAME);
         }
         endNode(xml, ROOT_TAG);

         Document doc = XMLUtils.documentFromString(xml.toString());
         if (rename) {
             if (copy) {
                 MigrationUtils.copyTagToExtension(doc, TESTEXTENSION_TAG, PROPERTY_STR, PROPERTY_STRSET);
             } else {
                 MigrationUtils.moveTagToExtension(doc, TESTEXTENSION_TAG, PROPERTY_STR, PROPERTY_STRSET);
             }
         } else {
             if (copy) {
                 MigrationUtils.copyTagToExtension(doc, TESTEXTENSION_TAG, PROPERTY_STR);
             } else {
                 MigrationUtils.moveTagToExtension(doc, TESTEXTENSION_TAG, PROPERTY_STR);
             }
         }
         assertExtensionAttribute(doc, ROOT_TAG, PROPERTY_STR, PROPERTY_STR_VALUE, copy ? EXISTS : NOT_EXISTS);
         assertExtensionAttribute(doc, TESTEXTENSION_TAG, rename ? PROPERTY_STRSET : PROPERTY_STR, PROPERTY_STR_VALUE,
                 EXISTS);
     }

     private void assertMoveExtensionToExtension(boolean extensionExists, boolean rename) throws Exception {
         StringBuilder xml = new StringBuilder();
         beginXml(xml);
         beginNode(xml, ROOT_TAG);
         beginNode(xml, MigrationUtils.EXTENSIONS_TAGNAME);
         appendTestExtension(xml);
         if (extensionExists) {
             beginNode(xml, TESTEXTENSION1_TAG);
             endNode(xml, TESTEXTENSION1_TAG);
         }
         endNode(xml, MigrationUtils.EXTENSIONS_TAGNAME);
         endNode(xml, ROOT_TAG);

         Document doc = XMLUtils.documentFromString(xml.toString());
         MigrationUtils.moveTagToExtension(doc, TESTEXTENSION_TAG, TESTEXTENSION1_TAG, PROPERTY_STR, rename ? PROPERTY_STRSET
                 : PROPERTY_STR);
         assertExtensionAttribute(doc, TESTEXTENSION_TAG, PROPERTY_STR, null, NOT_EXISTS);
         assertExtensionAttribute(doc, TESTEXTENSION_TAG, PROPERTY_STRSET, null, NOT_EXISTS);
         assertExtensionAttribute(doc, TESTEXTENSION1_TAG, rename ? PROPERTY_STRSET : PROPERTY_STR, PROPERTY_STR_VALUE,
                 EXISTS);
     }

     private void assertRenamed(boolean inExtension) throws Exception {
         StringBuilder xml = new StringBuilder();
         beginXml(xml);
         beginNode(xml, ROOT_TAG);
         if (inExtension) {
             beginNode(xml, MigrationUtils.EXTENSIONS_TAGNAME);
             appendTestExtension(xml);
             endNode(xml, MigrationUtils.EXTENSIONS_TAGNAME);
         } else {
             appendNode(xml, PROPERTY_STR, PROPERTY_STR_VALUE);
         }
         endNode(xml, ROOT_TAG);

         Document doc = XMLUtils.documentFromString(xml.toString());
         if (inExtension) {
             MigrationUtils.renameTag(doc, TESTEXTENSION_TAG, PROPERTY_STR, PROPERTY_STRSET);
         } else {
             MigrationUtils.renameTag(doc, PROPERTY_STR, PROPERTY_STRSET);
         }
         assertElementsByTagName(doc, PROPERTY_STR, NOT_EXISTS);
         assertElementsByTagName(doc, PROPERTY_STRSET, EXISTS);
     }

     private void assertStringSet(boolean inExtension, boolean noComparator) throws Exception {
         StringBuilder xml = new StringBuilder();
         beginXml(xml);
         beginNode(xml, ROOT_TAG);
         if (inExtension) {
             beginNode(xml, MigrationUtils.EXTENSIONS_TAGNAME);
             appendTestExtension(xml);
             endNode(xml, MigrationUtils.EXTENSIONS_TAGNAME);
         } else {
             appendNode(xml, PROPERTY_STR, PROPERTY_STR_VALUE);
         }
         endNode(xml, ROOT_TAG);

         Document doc = XMLUtils.documentFromString(xml.toString());
         if (inExtension) {
             MigrationUtils.migrateStringToStringSet(doc, TESTEXTENSION_TAG, PROPERTY_STR, PROPERTY_STRSET, noComparator);
         } else {
             MigrationUtils.migrateStringToStringSet(doc, PROPERTY_STR, PROPERTY_STRSET, noComparator);
         }
         assertElementsByTagName(doc, PROPERTY_STR, NOT_EXISTS);
         assertElementsByTagName(doc, PROPERTY_STRSET, EXISTS);
         Element setElement = (Element) doc.getElementsByTagName(PROPERTY_STRSET).item(0);
         assertNotNull(setElement);
         Node parent = setElement.getParentNode();
         assertNotNull(parent);
         assertEquals(inExtension ? TESTEXTENSION_TAG : ROOT_TAG, parent.getNodeName());
         NodeList setItems = setElement.getChildNodes();
         assertEquals(noComparator ? 2 : 1, setItems.getLength());
         if (noComparator) {
             assertEquals(MigrationUtils.NO_COMPARATOR_TAGNAME, setItems.item(0).getNodeName());
         }
         assertEquals("string", setItems.item(noComparator ? 1 : 0).getNodeName());
         assertEquals(PROPERTY_STR_VALUE, setItems.item(noComparator ? 1 : 0).getTextContent());
     }

     private void assertElementsByTagName(Document doc, String tagName, boolean exists) {
         NodeList nodes = doc.getElementsByTagName(tagName);
         assertNotNull(nodes);
         assertEquals(exists ? 1 : 0, nodes.getLength());
     }

     private void assertExtensionAttribute(Document doc, String extensionName, String tagName, String value,
             boolean exists) {
         NodeList nodes = doc.getElementsByTagName(extensionName);
         assertEquals(1, nodes.getLength());
         Element extensionElement = (Element) nodes.item(0);
         assertNotNull(extensionElement);
         boolean hasTag = false;
         boolean hasValue = false;
         NodeList children = extensionElement.getChildNodes();
         for (int i = 0; i < children.getLength(); ++i) {
             Node child = children.item(i);
             if (tagName.equals(child.getNodeName())) {
                 assertFalse(hasTag);
                 if (value != null) {
                     hasValue = value.equals(child.getTextContent());
                 }
                 hasTag = true;
                 break;
             }
         }
         if (exists) {
             assertTrue(hasTag);
             assertTrue(hasValue);
         } else {
             assertFalse(hasTag);
         }
     }

     private void beginXml(StringBuilder xml) {
         xml.append("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
     }

     private void beginNode(StringBuilder xml, String tagName) {
         xml.append("<").append(tagName).append(">");
     }

     private void endNode(StringBuilder xml, String tagName) {
         xml.append("</").append(tagName).append(">");
     }

     private void appendNode(StringBuilder xml, String tagName, Object value) {
         beginNode(xml, tagName);
         xml.append(value.toString());
         endNode(xml, tagName);
     }

     private void appendTestExtension(StringBuilder xml) {
         beginNode(xml, TESTEXTENSION_TAG);
         appendNode(xml, TestExtension.PROPERTY_BOOL, Boolean.TRUE);
         appendNode(xml, TestExtension.PROPERTY_STR, PROPERTY_STR_VALUE);
         appendNode(xml, TestExtension.PROPERTY_DELETED, Boolean.FALSE);
         appendNode(xml, TestExtension.PROPERTY_UUID, TestUUIDs.TEST_UUIDS[0]);
         endNode(xml, TESTEXTENSION_TAG);
     }

 }
	/*******************************************************************************
	* Copyright (c) 2010-2014 SAP AG and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* SAP AG - initial API and implementation
	*******************************************************************************/
	package org.eclipse.skalli.services.extension;

	import static org.junit.Assert.*;

	import org.eclipse.skalli.commons.XMLUtils;
	import org.eclipse.skalli.testutil.TestEntityBase1;
	import org.eclipse.skalli.testutil.TestExtension;
	import org.eclipse.skalli.testutil.TestExtension1;
	import org.eclipse.skalli.testutil.TestUUIDs;
	import org.junit.Test;
	import org.w3c.dom.Document;
	import org.w3c.dom.Element;
	import org.w3c.dom.Node;
	import org.w3c.dom.NodeList;

	@SuppressWarnings("nls")
	public class MigrationUtilsTest {

	private static final String ROOT_TAG = TestEntityBase1.class.getName();
	private static final String PROPERTY_STR = "str";
	private static final String PROPERTY_STR_VALUE = "value";
	private static final String PROPERTY_STRSET = "strset";
	private static final String TESTEXTENSION_TAG = TestExtension.class.getName();
	private static final String TESTEXTENSION1_TAG = TestExtension1.class.getName();

	private static boolean EXISTS = true;
	private static boolean NOT_EXISTS = false;
	private static boolean COPY = true;
	private static boolean MOVE = false;
	private static boolean TO_EXISTING_EXTENSION = true;
	private static boolean TO_NON_EXISTING_EXTENSION = false;
	private static boolean WITH_RENAME = true;
	private static boolean WITHOUT_RENAME = false;
	private static boolean ATTRIBUTE_OF_EXTENSION = true;
	private static boolean ATTRIBUTE_OF_ENTITY = false;
	private static boolean WITHOUT_COMPARATOR = true;
	private static boolean WITH_COMPARATOR = false;


	@Test
	public void testGetChild() throws Exception
	{
	Document doc = XMLUtils.documentFromString("<bla><hello>world</hello><blubb>noop</blubb></bla>");
	Element parentElement= doc.getDocumentElement();
	Element child = MigrationUtils.getChild(parentElement, "hello");
	assertEquals(child.getNodeName(), "hello");
	assertEquals(child.getTextContent(), "world");
	}

	@Test
	public void testGetChild_NotChilds() throws Exception
	{
	try {
	MigrationUtils.getChild(null, "hello");
	fail("IllegalArgumentException expected, but not thrown");
	} catch (IllegalArgumentException e) {
	assertTrue(e.getMessage().contains("parentElement"));
	}
	}

	@Test
	public void testMoveToExistingExtension() throws Exception {
	assertCopyOrMove(MOVE, TO_EXISTING_EXTENSION, WITHOUT_RENAME);
	}

	@Test
	public void testMoveToNonExistingExtension() throws Exception {
	assertCopyOrMove(MOVE, TO_NON_EXISTING_EXTENSION, WITHOUT_RENAME);
	}

	@Test
	public void testMoveToExistingExtensionAndRename() throws Exception {
	assertCopyOrMove(MOVE, TO_EXISTING_EXTENSION, WITH_RENAME);
	}

	@Test
	public void testMoveToNonExistingExtensionAndRename() throws Exception {
	assertCopyOrMove(MOVE, TO_NON_EXISTING_EXTENSION, WITH_RENAME);
	}

	@Test
	public void testCopyToExistingExtension() throws Exception {
	assertCopyOrMove(COPY, TO_EXISTING_EXTENSION, WITHOUT_RENAME);
	}

	@Test
	public void testCopyToNonExistingExtension() throws Exception {
	assertCopyOrMove(COPY, TO_NON_EXISTING_EXTENSION, WITHOUT_RENAME);
	}

	@Test
	public void testCopyToExistingExtensionAndRename() throws Exception {
	assertCopyOrMove(COPY, TO_EXISTING_EXTENSION, WITH_RENAME);
	}

	@Test
	public void testCopyToNonExistingExtensionAndRename() throws Exception {
	assertCopyOrMove(COPY, TO_NON_EXISTING_EXTENSION, WITH_RENAME);
	}

	@Test
	public void testMoveFromExtensionToExistingExtension() throws Exception {
	assertMoveExtensionToExtension(TO_EXISTING_EXTENSION, WITHOUT_RENAME);
	}

	@Test
	public void testMoveFromExtensionToNonExistingExtension() throws Exception {
	assertMoveExtensionToExtension(TO_NON_EXISTING_EXTENSION, WITHOUT_RENAME);
	}

	@Test
	public void testMoveFromExtensionToExistingExtensionWithRename() throws Exception {
	assertMoveExtensionToExtension(TO_EXISTING_EXTENSION, WITH_RENAME);
	}

	@Test
	public void testMoveFromExtensionToNonExistingExtensionWithRename() throws Exception {
	assertMoveExtensionToExtension(TO_NON_EXISTING_EXTENSION, WITH_RENAME);
	}

	@Test
	public void testRenameTag() throws Exception {
	assertRenamed(ATTRIBUTE_OF_ENTITY);
	}

	@Test
	public void testRenameExtensionTag() throws Exception {
	assertRenamed(ATTRIBUTE_OF_EXTENSION);
	}

	@Test
	public void testMigrateStringToStringSet() throws Exception {
	assertStringSet(ATTRIBUTE_OF_ENTITY, WITH_COMPARATOR);
	}

	@Test
	public void testMigrateStringToStringSetNoComparator() throws Exception {
	assertStringSet(ATTRIBUTE_OF_ENTITY, WITHOUT_COMPARATOR);
	}

	@Test
	public void testMigrateExtensionStringToStringSet() throws Exception {
	assertStringSet(ATTRIBUTE_OF_EXTENSION, WITH_COMPARATOR);
	}

	@Test
	public void testMigrateExtensionStringToStringSetNoComparator() throws Exception {
	assertStringSet(ATTRIBUTE_OF_EXTENSION, WITHOUT_COMPARATOR);
	}


	private void assertCopyOrMove(boolean copy, boolean extensionExists, boolean rename) throws Exception {
	StringBuilder xml = new StringBuilder();
	beginXml(xml);
	beginNode(xml, ROOT_TAG);
	appendNode(xml, PROPERTY_STR, PROPERTY_STR_VALUE);
	if (extensionExists) {
	beginNode(xml, MigrationUtils.EXTENSIONS_TAGNAME);
	appendTestExtension(xml);
	endNode(xml, MigrationUtils.EXTENSIONS_TAGNAME);
	}
	endNode(xml, ROOT_TAG);

	Document doc = XMLUtils.documentFromString(xml.toString());
	if (rename) {
	if (copy) {
	MigrationUtils.copyTagToExtension(doc, TESTEXTENSION_TAG, PROPERTY_STR, PROPERTY_STRSET);
	} else {
	MigrationUtils.moveTagToExtension(doc, TESTEXTENSION_TAG, PROPERTY_STR, PROPERTY_STRSET);
	}
	} else {
	if (copy) {
	MigrationUtils.copyTagToExtension(doc, TESTEXTENSION_TAG, PROPERTY_STR);
	} else {
	MigrationUtils.moveTagToExtension(doc, TESTEXTENSION_TAG, PROPERTY_STR);
	}
	}
	assertExtensionAttribute(doc, ROOT_TAG, PROPERTY_STR, PROPERTY_STR_VALUE, copy ? EXISTS : NOT_EXISTS);
	assertExtensionAttribute(doc, TESTEXTENSION_TAG, rename ? PROPERTY_STRSET : PROPERTY_STR, PROPERTY_STR_VALUE,
	EXISTS);
	}

	private void assertMoveExtensionToExtension(boolean extensionExists, boolean rename) throws Exception {
	StringBuilder xml = new StringBuilder();
	beginXml(xml);
	beginNode(xml, ROOT_TAG);
	beginNode(xml, MigrationUtils.EXTENSIONS_TAGNAME);
	appendTestExtension(xml);
	if (extensionExists) {
	beginNode(xml, TESTEXTENSION1_TAG);
	endNode(xml, TESTEXTENSION1_TAG);
	}
	endNode(xml, MigrationUtils.EXTENSIONS_TAGNAME);
	endNode(xml, ROOT_TAG);

	Document doc = XMLUtils.documentFromString(xml.toString());
	MigrationUtils.moveTagToExtension(doc, TESTEXTENSION_TAG, TESTEXTENSION1_TAG, PROPERTY_STR, rename ? PROPERTY_STRSET
	: PROPERTY_STR);
	assertExtensionAttribute(doc, TESTEXTENSION_TAG, PROPERTY_STR, null, NOT_EXISTS);
	assertExtensionAttribute(doc, TESTEXTENSION_TAG, PROPERTY_STRSET, null, NOT_EXISTS);
	assertExtensionAttribute(doc, TESTEXTENSION1_TAG, rename ? PROPERTY_STRSET : PROPERTY_STR, PROPERTY_STR_VALUE,
	EXISTS);
	}

	private void assertRenamed(boolean inExtension) throws Exception {
	StringBuilder xml = new StringBuilder();
	beginXml(xml);
	beginNode(xml, ROOT_TAG);
	if (inExtension) {
	beginNode(xml, MigrationUtils.EXTENSIONS_TAGNAME);
	appendTestExtension(xml);
	endNode(xml, MigrationUtils.EXTENSIONS_TAGNAME);
	} else {
	appendNode(xml, PROPERTY_STR, PROPERTY_STR_VALUE);
	}
	endNode(xml, ROOT_TAG);

	Document doc = XMLUtils.documentFromString(xml.toString());
	if (inExtension) {
	MigrationUtils.renameTag(doc, TESTEXTENSION_TAG, PROPERTY_STR, PROPERTY_STRSET);
	} else {
	MigrationUtils.renameTag(doc, PROPERTY_STR, PROPERTY_STRSET);
	}
	assertElementsByTagName(doc, PROPERTY_STR, NOT_EXISTS);
	assertElementsByTagName(doc, PROPERTY_STRSET, EXISTS);
	}

	private void assertStringSet(boolean inExtension, boolean noComparator) throws Exception {
	StringBuilder xml = new StringBuilder();
	beginXml(xml);
	beginNode(xml, ROOT_TAG);
	if (inExtension) {
	beginNode(xml, MigrationUtils.EXTENSIONS_TAGNAME);
	appendTestExtension(xml);
	endNode(xml, MigrationUtils.EXTENSIONS_TAGNAME);
	} else {
	appendNode(xml, PROPERTY_STR, PROPERTY_STR_VALUE);
	}
	endNode(xml, ROOT_TAG);

	Document doc = XMLUtils.documentFromString(xml.toString());
	if (inExtension) {
	MigrationUtils.migrateStringToStringSet(doc, TESTEXTENSION_TAG, PROPERTY_STR, PROPERTY_STRSET, noComparator);
	} else {
	MigrationUtils.migrateStringToStringSet(doc, PROPERTY_STR, PROPERTY_STRSET, noComparator);
	}
	assertElementsByTagName(doc, PROPERTY_STR, NOT_EXISTS);
	assertElementsByTagName(doc, PROPERTY_STRSET, EXISTS);
	Element setElement = (Element) doc.getElementsByTagName(PROPERTY_STRSET).item(0);
	assertNotNull(setElement);
	Node parent = setElement.getParentNode();
	assertNotNull(parent);
	assertEquals(inExtension ? TESTEXTENSION_TAG : ROOT_TAG, parent.getNodeName());
	NodeList setItems = setElement.getChildNodes();
	assertEquals(noComparator ? 2 : 1, setItems.getLength());
	if (noComparator) {
	assertEquals(MigrationUtils.NO_COMPARATOR_TAGNAME, setItems.item(0).getNodeName());
	}
	assertEquals("string", setItems.item(noComparator ? 1 : 0).getNodeName());
	assertEquals(PROPERTY_STR_VALUE, setItems.item(noComparator ? 1 : 0).getTextContent());
	}

	private void assertElementsByTagName(Document doc, String tagName, boolean exists) {
	NodeList nodes = doc.getElementsByTagName(tagName);
	assertNotNull(nodes);
	assertEquals(exists ? 1 : 0, nodes.getLength());
	}

	private void assertExtensionAttribute(Document doc, String extensionName, String tagName, String value,
	boolean exists) {
	NodeList nodes = doc.getElementsByTagName(extensionName);
	assertEquals(1, nodes.getLength());
	Element extensionElement = (Element) nodes.item(0);
	assertNotNull(extensionElement);
	boolean hasTag = false;
	boolean hasValue = false;
	NodeList children = extensionElement.getChildNodes();
	for (int i = 0; i < children.getLength(); ++i) {
	Node child = children.item(i);
	if (tagName.equals(child.getNodeName())) {
	assertFalse(hasTag);
	if (value != null) {
	hasValue = value.equals(child.getTextContent());
	}
	hasTag = true;
	break;
	}
	}
	if (exists) {
	assertTrue(hasTag);
	assertTrue(hasValue);
	} else {
	assertFalse(hasTag);
	}
	}

	private void beginXml(StringBuilder xml) {
	xml.append("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
	}

	private void beginNode(StringBuilder xml, String tagName) {
	xml.append("<").append(tagName).append(">");
	}

	private void endNode(StringBuilder xml, String tagName) {
	xml.append("</").append(tagName).append(">");
	}

	private void appendNode(StringBuilder xml, String tagName, Object value) {
	beginNode(xml, tagName);
	xml.append(value.toString());
	endNode(xml, tagName);
	}

	private void appendTestExtension(StringBuilder xml) {
	beginNode(xml, TESTEXTENSION_TAG);
	appendNode(xml, TestExtension.PROPERTY_BOOL, Boolean.TRUE);
	appendNode(xml, TestExtension.PROPERTY_STR, PROPERTY_STR_VALUE);
	appendNode(xml, TestExtension.PROPERTY_DELETED, Boolean.FALSE);
	appendNode(xml, TestExtension.PROPERTY_UUID, TestUUIDs.TEST_UUIDS[0]);
	endNode(xml, TESTEXTENSION_TAG);
	}

	}