SOAGlobalRegistryQETest.java

package org.ebayopensource.turmeric.tools.library;

import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.xml.bind.JAXB;
import javax.xml.namespace.QName;

import org.ebayopensource.turmeric.common.config.LibraryType;
import org.ebayopensource.turmeric.common.config.TypeDependencyType;
import org.ebayopensource.turmeric.common.config.TypeInformationType;
import org.ebayopensource.turmeric.common.config.TypeLibraryDependencyType;
import org.ebayopensource.turmeric.common.config.TypeLibraryType;
import org.ebayopensource.turmeric.tools.TestResourceUtil;
import org.ebayopensource.turmeric.tools.codegen.AbstractServiceGeneratorTestCase;
import org.ebayopensource.turmeric.tools.codegen.ServiceGenerator;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

/**
 * This class will validate all the testcases related to SOATypeRegistry.java interface.
 * @author vganjare
 *
 */
public class SOAGlobalRegistryQETest extends AbstractServiceGeneratorTestCase {
	
	File prCategoryRoot = null;
	File prProductRoot = null;

	private static SOATypeRegistry m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
	private String PRODUCT_TYPE_LIBRARY = "ProductTypeLibrary";
	private String CATEGORY_TYPE_LIBRARY = "CategoryTypeLibrary";
	private String TYPE_LIBRARY_TYPE = "TypeLibraryType";
	private String PROJECT_ROOT_CATEGORY = "";
	private String PROJECT_ROOT_PRODUCT = "";
	private String PROJECT_ROOT_TEST = "";
	private TypeLibraryUtility utility = new TypeLibraryUtility();
	private String PROJECT_ROOT = null;
	private String NAMESPACE ="http://www.ebayopensource.org/soaframework/examples/config";

	public  static void removeParentTypes(LibraryType lib) throws Exception{
		
		List<LibraryType> parenttypes = m_soaTypeRegistry.getDependentChildTypeFiles(lib);
		if(parenttypes.size() > 0){
			
			for(LibraryType library : parenttypes){
				removeParentTypes(library);
				m_soaTypeRegistry.removeTypeFromRegistry(library);
				
			}
		} else{
			m_soaTypeRegistry.removeTypeFromRegistry(lib);
		}
		
		
		
	}
	@BeforeClass
	public static void initClassLevel() throws Exception{
		
		List<LibraryType> type = m_soaTypeRegistry.getAllTypes();
		
		for(LibraryType lib : type){
			
			removeParentTypes(lib);
			
		}
		
		
		List<TypeLibraryType> typelib = m_soaTypeRegistry.getAllTypeLibraries();
		for(TypeLibraryType tlib : typelib){
			
			m_soaTypeRegistry.removeLibraryFromRegistry(tlib.getLibraryName());
			
		}
	}
	
	@Before
	public void init() throws Exception{
		
		
		List<LibraryType> type = m_soaTypeRegistry.getAllTypes();
		
		for(LibraryType lib : type){
			
			removeParentTypes(lib);
			
		}
		
		
		List<TypeLibraryType> typelib = m_soaTypeRegistry.getAllTypeLibraries();
		for(TypeLibraryType tlib : typelib){
			
			m_soaTypeRegistry.removeLibraryFromRegistry(tlib.getLibraryName());
			
		}
		
		
		PROJECT_ROOT = testingdir.getDir().getAbsolutePath();
		PROJECT_ROOT_TEST = testingdir.getFile("Test").getAbsolutePath();
		PROJECT_ROOT_CATEGORY = getTestDestDir().getAbsolutePath();
		testingdir.ensureEmpty();
		
		mavenTestingRules.setFailOnViolation(false);
		
		prCategoryRoot = testingdir.getFile("CategoryTypeLibrary");
		prProductRoot = testingdir.getFile("ProductTypeLibrary");
		PROJECT_ROOT_CATEGORY =  prCategoryRoot.getAbsolutePath();
		PROJECT_ROOT_PRODUCT = prProductRoot.getAbsolutePath();
	}
	
	//*********--- boolean populateRegistryWithTypeLibraries(List<String> typeLibraryNames) ---************//

	/**
	 * Validate the working of populateRegistryWithTypeLibraries() for valid 
	 * TypeLibraries.
	 */
	@Test
	public void testPopulateRegistryWithTypeLibraries() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";

		
		try {
		List libraryListBef = m_soaTypeRegistry.getAllTypeLibraries();
		//Set the environment.
		setEnvironment(folderConstant);
		List<String> list = new ArrayList<String>();
		list.add(PRODUCT_TYPE_LIBRARY);
		list.add(CATEGORY_TYPE_LIBRARY);
		
			boolean flag = m_soaTypeRegistry.populateRegistryWithTypeLibraries(list);
			assertTrue("SOAGlobalRegistry is not updated properly.", flag);
			m_soaTypeRegistry.updateGlobalRegistry();
			List libraryListAfter = m_soaTypeRegistry.getAllTypeLibraries();
			boolean libFlag = (( libraryListAfter.size() -libraryListBef.size()) == list.size());
			assertTrue("SOAGlobalRegistry is not updated properly.", libFlag);
		} catch (Exception ex) {
			ex.printStackTrace();
			assertTrue("No Exception should be thrown. Following Exception is thrown: " + ex.getMessage(), false);
		}
	}

	/**
	 * This testcase will validate the working for Invalid TypeLibraryName.
	 *
	 */
	@Test
	public void testPopulateRegistryWithTypeLibrariesInvalidInputs() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		//Set the environment.
		setEnvironment(folderConstant);
		

		List<String> list = new ArrayList<String>();
		CATEGORY_TYPE_LIBRARY = "InvalidTypeLibrary";
		list.add(CATEGORY_TYPE_LIBRARY);
		list.add(PRODUCT_TYPE_LIBRARY);
		
		
		try {
			boolean flag = m_soaTypeRegistry.populateRegistryWithTypeLibraries(list);
			assertFalse("Valid Exception should be thrown.", flag);
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionClassName = "org.ebayopensource.turmeric.tools.library.exception.PopulateRegistryException";
			String exceptionMessage = "Could not find the TypeInformation.xml file for library InvalidTypeLibrary  at location : META-INF/InvalidTypeLibrary/TypeInformation.xml";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().contains(exceptionMessage));
		}
	}

	/**
	 * Duplicate names should not increase the count of libraries in 
	 * GlobalRegistry.
	 *
	 */
	@Test
	public void testPopulateRegistryWithTypeLibrariesDuplicateNames() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";

		
		try {
		List libraryListBef = m_soaTypeRegistry.getAllTypeLibraries();
		List<String> list = new ArrayList<String>();
		list.add(PRODUCT_TYPE_LIBRARY);
		list.add(PRODUCT_TYPE_LIBRARY);
		list.add(CATEGORY_TYPE_LIBRARY);
		list.add(CATEGORY_TYPE_LIBRARY);
		
		//Set the environment.
		setEnvironment(folderConstant);
		
			boolean flag = m_soaTypeRegistry.populateRegistryWithTypeLibraries(list);
			assertTrue("SOAGlobalRegistry is not updated properly.", flag);
			List libraryListAfter = m_soaTypeRegistry.getAllTypeLibraries();
			boolean sizeFlag = ((libraryListAfter.size() -libraryListBef.size()) == (list.size() -2));
			assertTrue("The Global Registry should not be updated for duplicate libraries.", sizeFlag);
		} catch (Exception ex) {
			ex.printStackTrace();
			assertTrue("No Exception should be thrown. Following Exception is thrown: " + ex.getMessage(), false);
		}

	}

	/**
	 * This method will validate the working for the response if 
	 * input is 'null'.
	 * @throws Exception 
	 */
	@Test
	public void testPopulateRegistryWithTypeLibrariesNullValue() throws Exception {
		String folderConstant = "populateRegistryWithTypeLibraries/1";

		

		List<String> list = new ArrayList<String>();
		list.add(PRODUCT_TYPE_LIBRARY);
		list.add(null);
		list.add(PRODUCT_TYPE_LIBRARY);
		list.add(CATEGORY_TYPE_LIBRARY);
		List librariesBef = null;
		librariesBef = m_soaTypeRegistry.getAllTypeLibraries();
		//Set the environment.
		setEnvironment(folderConstant);
		try {
			 
			boolean flag = m_soaTypeRegistry.populateRegistryWithTypeLibraries(list);
			assertFalse("Exception should be thrown.", flag);
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "Could not find the TypeInformation.xml file for library null  at location : META-INF/null/TypeInformation.xml";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.library.exception.PopulateRegistryException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().contains(exceptionMessage));
			try {
				List librariesAfter = m_soaTypeRegistry.getAllTypeLibraries();
				boolean libraryCheck = ((librariesAfter.size() -librariesBef.size()) == 2);
				assertTrue("Global Registry is updated incorrectly.", libraryCheck);
			} catch (Exception e) {
				assertFalse("Exception should be thrown.", true);
			}
		}
	}

	//*********--- boolean addTypeLibraryToRegistry(TypeLibraryType library) ---************//
	/**
	 * Validates the working of boolean addTypeLibraryToRegistry(TypeLibraryType library)
	 * for valid inputs.
	 */
	@Test
	public void testAddTypeLibraryToRegistryTLT() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		//Set the environment.
		setEnvironment(folderConstant);
		try {
			//before call to addTypeLibraryToRegistry();
			int initialCount = getAllLibrariesFromWorkspace();

			TypeLibraryType productTypeLibrary = (TypeLibraryType) updateGlobalTableWithNewLibrary(TYPE_LIBRARY_TYPE,
					PRODUCT_TYPE_LIBRARY);
			TypeLibraryType typeLib = new TypeLibraryType();
			typeLib.setLibraryName("LibraryTest");
			typeLib.setLibraryNamespace("http://www.ebayopensource.org");
			typeLib.setVersion("1.2.3");
			boolean flag = m_soaTypeRegistry.addTypeLibraryToRegistry(typeLib);

			//After call to addTypeLibraryToRegistry(productTypeLibrary)
			int finalCount = getAllLibrariesFromWorkspace();
			boolean checkFlag = (flag == (initialCount + 1 == finalCount));
			assertTrue("Invalid working of addTypeLibraryToRegistry(TypeLibraryType type).", checkFlag);
		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("No exception should be thrown. Exception:" + e.getMessage(), false);
		}
	}
	
	
//	*********--- boolean addTypeLibraryToRegistry(TypeLibraryType library) ---************//
	/**
	 * Validates the working of boolean addTypeLibraryToRegistry(TypeLibraryType library)
	 * for invalid version.
	 */
	@Test
	public void testAddTypeLibraryToRegistryTLTInvalidVersion() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		//Set the environment.
		setEnvironment(folderConstant);
		try {
			//before call to addTypeLibraryToRegistry();
			int initialCount = getAllLibrariesFromWorkspace();

			TypeLibraryType productTypeLibrary = (TypeLibraryType) updateGlobalTableWithNewLibrary(TYPE_LIBRARY_TYPE,
					PRODUCT_TYPE_LIBRARY);
			productTypeLibrary.setVersion("1.2.3.4");
			boolean flag = m_soaTypeRegistry.addTypeLibraryToRegistry(productTypeLibrary);
			assertTrue("Invalid working of addTypeLibraryToRegistry(TypeLibraryType type).",flag);
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "Input param TypeLibraryType's version is not in the format X.Y.Z where X,Y,Z are integers.";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.codegen.exception.BadInputValueException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().equals(exceptionMessage));
		}
	}
	

	/**
	 * Validates the working of boolean addTypeLibraryToRegistry(TypeLibraryType library)
	 * for duplicate inputs.
	 */
	@Test
	//@Ignore("failing")
	public void testAddTypeLibraryToRegistryTLTDuplicateInputs() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		//Set the environment.
		setEnvironment(folderConstant);
		try {
			TypeLibraryType productTypeLibrary = (TypeLibraryType) updateGlobalTableWithNewLibrary(TYPE_LIBRARY_TYPE,
					PRODUCT_TYPE_LIBRARY);
			int initialCount = getAllLibrariesFromWorkspace();
			boolean flag = m_soaTypeRegistry.addTypeLibraryToRegistry(productTypeLibrary);
			boolean flag1 = m_soaTypeRegistry.addTypeLibraryToRegistry(productTypeLibrary);
			int finalCount = getAllLibrariesFromWorkspace();
			assertTrue("Invalid working of addTypeLibraryToRegistry(TypeLibraryType type).",
					(flag || flag1) || (initialCount == finalCount));
		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("No exception should be thrown. Exception:" + e.getMessage(), false);
		}
	}

	/**
	 * Validates the working of boolean addTypeLibraryToRegistry(TypeLibraryType library)
	 * for new TypeLibraryType() inputs.
	 */
	@Test
	public void testAddTypeLibraryToRegistryTLTNewObject() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		//Set the environment.
		setEnvironment(folderConstant);
		try {
			TypeLibraryType productTypeLibrary = new TypeLibraryType();
			boolean flag = m_soaTypeRegistry.addTypeLibraryToRegistry(productTypeLibrary);
			assertFalse("Invalid working of addTypeLibraryToRegistry(TypeLibraryType type).", true);
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "Input param TypeLibraryType's library name is either null or void.";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.codegen.exception.BadInputValueException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().equals(exceptionMessage));
		}
	}

	/**
	 * Validates the working of boolean addTypeLibraryToRegistry(TypeLibraryType library)
	 * for Null inputs.
	 */
	@Test
	public void testAddTypeLibraryToRegistryTLNull() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		//Set the environment.
		setEnvironment(folderConstant);
		try {
			TypeLibraryType productTypeLibrary = null;
			boolean flag = m_soaTypeRegistry.addTypeLibraryToRegistry(productTypeLibrary);
			assertFalse("Invalid working of addTypeLibraryToRegistry(TypeLibraryType type).", true);
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "Input param \"TypeLibraryType\" cannot be null.";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.codegen.exception.BadInputValueException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().equals(exceptionMessage));
		}
	}

	//*********--- boolean addTypeLibraryToRegistry(TypeLibraryType library) ---************//
	/**
	 * Validate the working of boolean addTypeLibraryToRegistry(String library)
	 * for valid LibraryName.
	 */
	@Test
	//@Ignore("failing")
	public void testAddTypeLibraryToRegistryST() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		//Set the environment.
		setEnvironment(folderConstant);
		try {
			//boolean tFlag = utility.deleteTypeLibrary(PROJECT_ROOT_PRODUCT);
			//before call to addTypeLibraryToRegistry();
			int initialCount = getAllLibrariesFromWorkspace();
			boolean flag = m_soaTypeRegistry.addTypeLibraryToRegistry(PRODUCT_TYPE_LIBRARY);
			//After call to addTypeLibraryToRegistry(productTypeLibrary)

			
			createTempLibrary(PROJECT_ROOT_TEST,"Test");
			setEnvironment(folderConstant);
			m_soaTypeRegistry.addTypeLibraryToRegistry("Test");
			int finalCount = getAllLibrariesFromWorkspace();
			boolean checkFlag = (flag == (initialCount != finalCount));
			assertTrue("Invalid working of addTypeLibraryToRegistry(TypeLibraryType type).", checkFlag);
		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("No exception should be thrown. Exception:" + e.getMessage(), false);
		}
	}

	/**
	 * Validates the working of boolean addTypeLibraryToRegistry(String library)
	 * for duplicate inputs.
	 */
	@Test
	public void testAddTypeLibraryToRegistrySLTDuplicateInputs() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		//Set the environment.
		setEnvironment(folderConstant);
		try {
			int initialCount = getAllLibrariesFromWorkspace();
			boolean flag = m_soaTypeRegistry.addTypeLibraryToRegistry(PRODUCT_TYPE_LIBRARY);
			boolean flag1 = m_soaTypeRegistry.addTypeLibraryToRegistry(PRODUCT_TYPE_LIBRARY);
			int finalCount = getAllLibrariesFromWorkspace();
			assertTrue("Invalid working of addTypeLibraryToRegistry(TypeLibraryType type).",
					(flag || flag1) || (initialCount == finalCount));
		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("No exception should be thrown. Exception:" + e.getMessage(), false);
		}
	}

	/**
	 * Validates the working of boolean addTypeLibraryToRegistry(String library)
	 * for new String() inputs.
	 */
	@Test
	public void testAddTypeLibraryToRegistrySLTNewObject() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		//Set the environment.
		setEnvironment(folderConstant);
		try {
			String productTypeLibrary = new String();
			boolean flag = m_soaTypeRegistry.addTypeLibraryToRegistry(productTypeLibrary);
			assertFalse("Invalid working of addTypeLibraryToRegistry(TypeLibraryType type).", true);
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "Could not find the TypeInformation.xml file for library   at location : META-INF//TypeInformation.xml";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.library.exception.PopulateRegistryException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().contains(exceptionMessage));
		}
	}

	/**
	 * Validates the working of boolean addTypeLibraryToRegistry(String library)
	 * for "" inputs.
	 */
	@Test
	public void testAddTypeLibraryToRegistrySLTNEmptyStr() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		//Set the environment.
		setEnvironment(folderConstant);
		try {
			String productTypeLibrary = "";
			boolean flag = m_soaTypeRegistry.addTypeLibraryToRegistry(productTypeLibrary);
			assertFalse("Invalid working of addTypeLibraryToRegistry(TypeLibraryType type).", true);
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "Could not find the TypeInformation.xml file for library   at location : META-INF//TypeInformation.xml";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.library.exception.PopulateRegistryException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().contains(exceptionMessage));
		}
	}

	/**
	 * Validates the working of boolean addTypeLibraryToRegistry(TypeLibraryType library)
	 * for Null inputs.
	 */
	@Test
	public void testAddTypeLibraryToRegistrySLNull() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		//Set the environment.
		setEnvironment(folderConstant);
		try {
			String productTypeLibrary = null;
			boolean flag = m_soaTypeRegistry.addTypeLibraryToRegistry(productTypeLibrary);
			assertFalse("Invalid working of addTypeLibraryToRegistry(TypeLibraryType type).", true);
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "Input param \"library\" cannot be null.";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.codegen.exception.BadInputValueException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().equals(exceptionMessage));
		}
	}

	//*********--- boolean addTypeToRegistry(LibraryType libraryType) ---************//
	/**
	 * Validate the working of addTypeToRegistry(LibraryType libraryType) for 
	 * valid inputs.
	 */
	@Test
	public void testAddTypeToRegistryLT() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		//Set the environment.
		setEnvironment(folderConstant);
		try {
			
			LibraryType type = new LibraryType();
			type.setName("AddType1");
			type.setLibraryInfo((TypeLibraryType) updateGlobalTableWithNewLibrary(TYPE_LIBRARY_TYPE, CATEGORY_TYPE_LIBRARY));
			type.setNamespace(NAMESPACE);
			type.setVersion("1.2.3");
			int initialCount = m_soaTypeRegistry.getAllTypes().size();
			m_soaTypeRegistry.addTypeToRegistry(type);
			int finalCount = m_soaTypeRegistry.getAllTypes().size();
			assertTrue("Invalid working of addTypeToRegistry(LibraryType libraryType)", (initialCount != finalCount));
		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("No exception should be thrown. Exception:" + e.getMessage(), false);
		}
	}

	/**
	 * Validate the working of addTypeToRegistry(LibraryType libraryType) for 
	 * type name as empty string.
	 */
	@Test
	public void testAddTypeToRegistryLTTypeNameEmptyStr() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		//Set the environment.
		setEnvironment(folderConstant);
		try {
			m_soaTypeRegistry.addTypeLibraryToRegistry(CATEGORY_TYPE_LIBRARY);
			LibraryType type = new LibraryType();
			type.setName("");
			type.setLibraryInfo((TypeLibraryType) updateGlobalTableWithNewLibrary(TYPE_LIBRARY_TYPE, CATEGORY_TYPE_LIBRARY));
			type.setNamespace(NAMESPACE);
			type.setVersion("1.2.3");
			m_soaTypeRegistry.addTypeToRegistry(type);
			assertTrue("Invalid working of addTypeToRegistry(LibraryType libraryType)", false);
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "Input params \"libraryType\" cannot have a null value for name.";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.codegen.exception.BadInputValueException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().equals(exceptionMessage));
		}
	}

	/**
	 * Validate the working of addTypeToRegistry(LibraryType libraryType) for 
	 * type name as null.
	 */
	@Test
	public void testAddTypeToRegistryLTTypeNameNull() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		//Set the environment.
		setEnvironment(folderConstant);
		try {
			m_soaTypeRegistry.addTypeLibraryToRegistry(CATEGORY_TYPE_LIBRARY);
			LibraryType type = new LibraryType();
			type.setName(null);
			type.setLibraryInfo((TypeLibraryType) updateGlobalTableWithNewLibrary(TYPE_LIBRARY_TYPE, CATEGORY_TYPE_LIBRARY));
			type.setNamespace(NAMESPACE);
			type.setVersion("1.2.3");
			m_soaTypeRegistry.addTypeToRegistry(type);
			assertTrue("Invalid working of addTypeToRegistry(LibraryType libraryType)", false);
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "Input params \"libraryType\" cannot have a null value for name.";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.codegen.exception.BadInputValueException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().equals(exceptionMessage));
		}
	}

	/**
	 * Validate the working of addTypeToRegistry(LibraryType libraryType) for 
	 * LibraryInfo as new TypeLibraryType().
	 */
	@Test
	public void testAddTypeToRegistryLTNewLibraryObj() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		//Set the environment.
		setEnvironment(folderConstant);
		try {
			m_soaTypeRegistry.addTypeLibraryToRegistry(CATEGORY_TYPE_LIBRARY);
			LibraryType type = new LibraryType();
			type.setName("TestType1");
			type.setLibraryInfo(new TypeLibraryType());
			type.setNamespace(NAMESPACE);
			type.setVersion("1.2.3");
			m_soaTypeRegistry.addTypeToRegistry(type);
			assertTrue("Invalid working of addTypeToRegistry(LibraryType libraryType)", false);
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "Input params \"libraryType\" cannot have a null value for the Library Name.";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.codegen.exception.BadInputValueException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().equals(exceptionMessage));
		}
	}

	/**
	 * Validate the working of addTypeToRegistry(LibraryType libraryType) for 
	 * LibraryInfo as null.
	 */
	@Test
	public void testAddTypeToRegistryLTWithLibraryAsNull() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		//Set the environment.
		setEnvironment(folderConstant);
		try {
			m_soaTypeRegistry.addTypeLibraryToRegistry(CATEGORY_TYPE_LIBRARY);
			LibraryType type = new LibraryType();
			type.setName("TestType1");
			type.setLibraryInfo(null);
			type.setNamespace(NAMESPACE);
			type.setVersion("1.2.3");
			m_soaTypeRegistry.addTypeToRegistry(type);
			assertTrue("Invalid working of addTypeToRegistry(LibraryType libraryType)", false);
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "Input params \"libraryType\" cannot have a null value for the LibraryInfo.";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.codegen.exception.BadInputValueException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().equals(exceptionMessage));
		}
	}

	/**
	 * Validate the working of addTypeToRegistry(LibraryType libraryType) for 
	 * Namespace different than the namespace of Library.
	 */
	@Test
	public void testAddTypeToRegistryLTWithDiffNamespace() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		//Set the environment.
		setEnvironment(folderConstant);
		try {
			
			LibraryType type = new LibraryType();
			type.setName("TestType1");
			type.setLibraryInfo((TypeLibraryType) updateGlobalTableWithNewLibrary(TYPE_LIBRARY_TYPE, CATEGORY_TYPE_LIBRARY));
			type.setNamespace("http://wrong/namespace");
			type.setVersion("1.2.3");
			m_soaTypeRegistry.addTypeToRegistry(type);
			assertTrue("Invalid working of addTypeToRegistry(LibraryType libraryType)", false);
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "The namespace of the type and the library to which it belongs to do not match.";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.codegen.exception.BadInputValueException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().contains(exceptionMessage));
		}
	}

	/**
	 * Validate the working of addTypeToRegistry(LibraryType libraryType) for 
	 * Namespace as Null.
	 */
	@Test
	public void testAddTypeToRegistryLTWithNullNamespace() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		//Set the environment.
		setEnvironment(folderConstant);
		try {
			m_soaTypeRegistry.addTypeLibraryToRegistry(CATEGORY_TYPE_LIBRARY);
			LibraryType type = new LibraryType();
			type.setName("TestType1");
			type.setLibraryInfo((TypeLibraryType) updateGlobalTableWithNewLibrary(TYPE_LIBRARY_TYPE, CATEGORY_TYPE_LIBRARY));
			type.setNamespace(null);
			type.setVersion("1.2.3");
			m_soaTypeRegistry.addTypeToRegistry(type);
			//assertTrue("Invalid working of addTypeToRegistry(LibraryType libraryType)", false);
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "The namespace of the type and the library to which it belongs to do not match.";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.codegen.exception.BadInputValueException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().contains(exceptionMessage));
		}
	}

	/**
	 * Validate the working of addTypeToRegistry(LibraryType libraryType) for 
	 * version of format a.b.c.d
	 */
	@Test
	public void testAddTypeToRegistryLTWrongVersion() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		//Set the environment.
		setEnvironment(folderConstant);
		try {
			m_soaTypeRegistry.addTypeLibraryToRegistry(CATEGORY_TYPE_LIBRARY);
			LibraryType type = new LibraryType();
			type.setName("TestType1");
			type.setLibraryInfo((TypeLibraryType) updateGlobalTableWithNewLibrary(TYPE_LIBRARY_TYPE, CATEGORY_TYPE_LIBRARY));
			type.setNamespace(NAMESPACE);
			type.setVersion("1.2.3.4");
			boolean value = m_soaTypeRegistry.addTypeToRegistry(type);
			System.out.println(value);
			assertTrue("Invalid working of addTypeToRegistry(LibraryType libraryType)", value);
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "The namespace of the type and the library to which it belongs to do not match.";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.codegen.exception.BadInputValueException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().contains(exceptionMessage));
		}
	}

	/**
	 * Validate the working of addTypeToRegistry(LibraryType libraryType) for 
	 * version ""
	 */
	@Test
	public void testAddTypeToRegistryLTEmptyVersion() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		//Set the environment.
		setEnvironment(folderConstant);
		try {
			m_soaTypeRegistry.addTypeLibraryToRegistry(CATEGORY_TYPE_LIBRARY);
			LibraryType type = new LibraryType();
			type.setName("TestType1");
			type.setLibraryInfo((TypeLibraryType) updateGlobalTableWithNewLibrary(TYPE_LIBRARY_TYPE, CATEGORY_TYPE_LIBRARY));
			type.setNamespace(NAMESPACE);
			type.setVersion("");
			m_soaTypeRegistry.addTypeToRegistry(type);
			//assertTrue("Invalid working of addTypeToRegistry(LibraryType libraryType)", false);
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "The namespace of the type and the library to which it belongs to do not match.";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.codegen.exception.BadInputValueException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().contains(exceptionMessage));
		}
	}

	/**
	 * Validate the working of addTypeToRegistry(LibraryType libraryType) for 
	 * version ""
	 */
	@Test
	public void testAddTypeToRegistryLTNullVersion() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		//Set the environment.
		setEnvironment(folderConstant);
		try {
			m_soaTypeRegistry.addTypeLibraryToRegistry(CATEGORY_TYPE_LIBRARY);
			LibraryType type = new LibraryType();
			type.setName("TestType1");
			type.setLibraryInfo((TypeLibraryType) updateGlobalTableWithNewLibrary(TYPE_LIBRARY_TYPE, CATEGORY_TYPE_LIBRARY));
			type.setNamespace(NAMESPACE);
			type.setVersion(null);
			m_soaTypeRegistry.addTypeToRegistry(type);
			//assertTrue("Invalid working of addTypeToRegistry(LibraryType libraryType)", false);
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "The namespace of the type and the library to which it belongs to do not match.";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.codegen.exception.BadInputValueException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().contains(exceptionMessage));
		}
	}

	/**
	 * Validate the working of addTypeToRegistry(LibraryType libraryType) for 
	 * type null.
	 */
	@Test
	public void testAddTypeToRegistryLTTypeNull() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		//Set the environment.
		setEnvironment(folderConstant);
		try {
			m_soaTypeRegistry.addTypeLibraryToRegistry(CATEGORY_TYPE_LIBRARY);
			LibraryType type = null;
			m_soaTypeRegistry.addTypeToRegistry(type);
			assertTrue("Invalid working of addTypeToRegistry(LibraryType libraryType)", false);
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "Input param \"libraryType\" cannot be null.";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.codegen.exception.BadInputValueException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().contains(exceptionMessage));
		}
	}

	//*********--- boolean addDependencyToRegistry(TypeDependencyType typeDependencyType , String libraryName) ---************//

	@Test
	public void testAddDependencyToRegistry() {
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		utility.setClassPath(testingdir.getDir().getAbsolutePath() );
		String typeDependenciesFilePath = getTestResrcDir()+"\\TypeLibraryCodegen\\CategoryTypeLibrary\\gen-meta-src\\META-INF\\CategoryTypeLibrary\\populateRegistryWithTypeLibraries\\1\\NewTypeDependencies.xml";
		File f = new File(typeDependenciesFilePath);
		String path = f.getAbsolutePath();
		boolean flag = f.exists();
		try {
			ClassLoader myClassLoader = Thread.currentThread().getContextClassLoader();
			InputStream inStream = myClassLoader.getResourceAsStream(path);
			inStream = new FileInputStream(f);
			TypeLibraryDependencyType typeLibraryDependencyType = null;
			String typeName = "CategoryProduct";

			LibraryType libraryType = new LibraryType();
			libraryType.setName(typeName);

			int initialSize = m_soaTypeRegistry.getDependentParentTypeFiles(libraryType).size();
			System.out.println("Start:" + initialSize);
			typeLibraryDependencyType = JAXB.unmarshal(inStream, TypeLibraryDependencyType.class);

			for (TypeDependencyType type : typeLibraryDependencyType.getType()) {
				System.out.println("Type : " + type.getName());
				if (type.getName().equals(typeName)) {
					m_soaTypeRegistry.addDependencyToRegistry(type, CATEGORY_TYPE_LIBRARY);
				}
			}

			List<LibraryType> tlt = m_soaTypeRegistry.getDependentParentTypeFiles(libraryType);
			List<LibraryType> tlt1 = m_soaTypeRegistry.getDependentChildTypeFiles(libraryType);
			//System.out.println("End:"+finalSize );
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	private void showTypeInformation() throws Exception {
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		List<LibraryType> typeList = m_soaTypeRegistry.getAllTypes();
		for (int i = 0; i < typeList.size(); i++) {
			LibraryType type1 = typeList.get(i);
			System.out.println(type1.getName());
		}
		TypeLibraryType typeLibraryInfo = m_soaTypeRegistry.getTypeLibrary(PRODUCT_TYPE_LIBRARY);
		List<TypeInformationType> libType = typeLibraryInfo.getType();
		System.out.println("Library Name : " + typeLibraryInfo.getLibraryName()
				+ "  |  "
				+ "Library Version: "
				+ typeLibraryInfo.getLibraryNamespace());
		for (int j = 0; j < libType.size(); j++) {
			TypeInformationType typeInfo = libType.get(j);
			System.out.println("JavaTypeName: " + typeInfo.getJavaTypeName()
					+ "  |  "
					+ "Type Version: "
					+ typeInfo.getVersion()
					+ "  |  "
					+ "xml Type name: "
					+ typeInfo.getXmlTypeName());
		}
	}

	//*********--- boolean updateGlobalRegistry() ---************//
	/**
	 * Validate the working of the updateGlobalRegistry() method.
	 */
	@Test
	//@Ignore("failing")
	public void testUpdateGlobalRegistryValidInputs() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		try {
			setEnvironment(folderConstant);
			createTempLibrary(testingdir.getDir().getAbsolutePath() +"/LibraryTest", "LibraryTest");
			
			m_soaTypeRegistry.addTypeLibraryToRegistry(PRODUCT_TYPE_LIBRARY);

			//Create ProductTypeLibrary object.
			TypeLibraryType library = (TypeLibraryType) updateGlobalTableWithNewLibrary(TYPE_LIBRARY_TYPE,
					PRODUCT_TYPE_LIBRARY);
			createTypeLibrary(PROJECT_ROOT_TEST, "Test", "1.2.3");
			setEnvironment(folderConstant);
			//Create type object.
			LibraryType type = new LibraryType();
			type.setName("testUpdateGlobalRegistry");
			type.setLibraryInfo(library);
			type.setVersion("1.2.3");
			m_soaTypeRegistry.addTypeToRegistry(type);
			TypeLibraryType tlt = m_soaTypeRegistry.getTypeLibrary(PRODUCT_TYPE_LIBRARY);
			int initialCount = tlt.getType().size();
			
			//Type name should get updated to testUpdateGlobalRegistryChanged
			boolean flag1 = m_soaTypeRegistry.updateGlobalRegistry();
			tlt = m_soaTypeRegistry.getTypeLibrary(PRODUCT_TYPE_LIBRARY);
			int finalCount = tlt.getType().size();
			assertTrue("Updating to global registry failed.", (flag1 || (initialCount != finalCount)));
		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("Following exception occured: " + e.getMessage(), false);
		}

	}

	//*********---LibraryType getType(String typeName) ---************//
	/**
	 * Validate the working of getType(String typeName) for valid type name.
	 */
	@Test
	//@Ignore("failing")
	public void testGetTypeValidTypeName() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		String PRODUCT_TYPE = "CategoryName";
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		setEnvironment(folderConstant);
		try {
			
			
			LibraryType type = m_soaTypeRegistry.getType(PRODUCT_TYPE, CATEGORY_TYPE_LIBRARY);
			boolean flag = false;
			if (type != null && PRODUCT_TYPE.equals(type.getName()))
				flag = true;
			assertTrue("Invalid working of getType(String typeName)", flag);
		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("Following exception occured: " + e.getMessage(), false);
		}
	}

	/**
	 * Validate the working of getType(String typeName) for non-existing type name.
	 */
	@Test
	public void testGetTypeNonExistingTypeName() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		String PRODUCT_TYPE = "CategoryName123";
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		setEnvironment(folderConstant);
		try {
			m_soaTypeRegistry.addTypeLibraryToRegistry(CATEGORY_TYPE_LIBRARY);
			LibraryType type = m_soaTypeRegistry.getType(PRODUCT_TYPE);
			boolean flag = false;
			if (type != null && PRODUCT_TYPE.equals(type.getName()))
				flag = true;
			assertFalse("Invalid working of getType(String typeName)", flag);
		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("Following exception occured: " + e.getMessage(), false);
		}
	}

	/**
	 * Validate the working of getType(String typeName) for null type name.
	 */
	@Test
	public void testGetTypeNullTypeName() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		String PRODUCT_TYPE = null;
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		setEnvironment(folderConstant);
		try {
			m_soaTypeRegistry.addTypeLibraryToRegistry(CATEGORY_TYPE_LIBRARY);
			LibraryType type = m_soaTypeRegistry.getType(PRODUCT_TYPE);
			boolean flag = false;
			if (type != null && PRODUCT_TYPE.equals(type.getName()))
				flag = true;
			assertFalse("Invalid working of getType(String typeName)", flag);
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "Input param \"typeName\" cannot be null.";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.codegen.exception.BadInputValueException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().contains(exceptionMessage));
		}
	}

	//*********--- List<LibraryType> getAllTypes() ---************//
	/**
	 * Validate the working of the List<LibraryType> getAllTypes() for valid library.
	 */
	@Test
	public void testGetAllTypesValidLib() {
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		try {
			List<LibraryType> typeList = m_soaTypeRegistry.getAllTypes();
			assertTrue("Invalid working of getAllTypes().", (typeList != null));
			int initialCount = typeList.size();
			TypeLibraryType productLibrary = m_soaTypeRegistry.getTypeLibrary(PRODUCT_TYPE_LIBRARY);
			LibraryType type1 = new LibraryType();
			type1.setLibraryInfo(productLibrary);
			type1.setName("Type1");
			m_soaTypeRegistry.addTypeToRegistry(type1);
			
			typeList = m_soaTypeRegistry.getAllTypes();
			assertTrue("Invalid working of getAllTypes().", (typeList != null));
			int interMidCount = typeList.size();
			//m_soaTypeRegistry.addTypeLibraryToRegistry(CATEGORY_TYPE_LIBRARY);
			
			LibraryType type2 = new LibraryType();
			type2.setLibraryInfo(productLibrary);
			type2.setName("Type2");
			m_soaTypeRegistry.addTypeToRegistry(type2);
			
			typeList = m_soaTypeRegistry.getAllTypes();
			assertTrue("Invalid working of getAllTypes().", (typeList != null));
			int finalCount = typeList.size();
			boolean flag = ((initialCount < interMidCount) && (interMidCount < finalCount));
			assertTrue("Invalid working of getAllTypes().", flag);
		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("Following exception occured: " + e, false);
		}
	}

	//*********--- Map<String,String> getTypeLibrariesVersion(List<String> typeLibraryNames) ---************//
	/**
	 * Validate the working of getTypeLibrariesVersion(List<String> typeLibraryNames) for valid LibraryName list.
	 */
	@Test
	public void testGetTypeLibrariesVersion() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		List<String> typeNames = new ArrayList();
		try {
			

			TypeLibraryType productTypeLibrary = m_soaTypeRegistry.getTypeLibrary(PRODUCT_TYPE_LIBRARY);
			TypeLibraryType categoryTypeLibrary = m_soaTypeRegistry.getTypeLibrary(CATEGORY_TYPE_LIBRARY);
			productTypeLibrary.setVersion("1.2.3");
			categoryTypeLibrary.setVersion("3.2.1");
			m_soaTypeRegistry.addTypeLibraryToRegistry(productTypeLibrary);
			m_soaTypeRegistry.addTypeLibraryToRegistry(categoryTypeLibrary);
			typeNames.add(PRODUCT_TYPE_LIBRARY);
			typeNames.add(CATEGORY_TYPE_LIBRARY);

			Map<String, String> typeVersions = m_soaTypeRegistry.getTypeLibrariesVersion(typeNames);
			boolean flag1 = ("1.2.3".equals(typeVersions.get(PRODUCT_TYPE_LIBRARY)));
			boolean flag2 = ("3.2.1".equals(typeVersions.get(CATEGORY_TYPE_LIBRARY)));
			assertTrue("Invalid working of getTypeLibrariesVersion(List<String> typeLibraryNames)", (flag1 || flag2));
		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("Following exception occured:" + e.getMessage(), false);
		}
	}

	/**
	 * Validate the working of getTypeLibrariesVersion(List<String> typeLibraryNames) for valid LibraryName list
	 * along with non existent libraryName.
	 */
	@Test
	public void testGetTypeLibrariesVersionInvalidName() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		List<String> typeNames = new ArrayList();
		try {
			

			TypeLibraryType productTypeLibrary = m_soaTypeRegistry.getTypeLibrary(PRODUCT_TYPE_LIBRARY);
			TypeLibraryType categoryTypeLibrary = m_soaTypeRegistry.getTypeLibrary(CATEGORY_TYPE_LIBRARY);
			productTypeLibrary.setVersion("1.2.3");
			categoryTypeLibrary.setVersion("3.2.1");
			m_soaTypeRegistry.addTypeLibraryToRegistry(productTypeLibrary);
			m_soaTypeRegistry.addTypeLibraryToRegistry(categoryTypeLibrary);
			typeNames.add(PRODUCT_TYPE_LIBRARY);
			typeNames.add(CATEGORY_TYPE_LIBRARY);
			typeNames.add("InvalidLibraryName");

			Map<String, String> typeVersions = m_soaTypeRegistry.getTypeLibrariesVersion(typeNames);
			boolean flag1 = ("1.2.3".equals(typeVersions.get(PRODUCT_TYPE_LIBRARY)));
			boolean flag2 = ("3.2.1".equals(typeVersions.get(CATEGORY_TYPE_LIBRARY)));
			assertTrue("Invalid working of getTypeLibrariesVersion(List<String> typeLibraryNames)", (flag1 || flag2));
		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("Following exception occured:" + e.getMessage(), false);
		}
	}

	/**
	 * Validate the working of getTypeLibrariesVersion(List<String> typeLibraryNames) for valid LibraryName list
	 * along with null libraryName.
	 */
	@Test
	public void testGetTypeLibrariesVersionNull() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		List<String> typeNames = new ArrayList();
		try {
			
			TypeLibraryType productTypeLibrary = m_soaTypeRegistry.getTypeLibrary(PRODUCT_TYPE_LIBRARY);
			TypeLibraryType categoryTypeLibrary = m_soaTypeRegistry.getTypeLibrary(CATEGORY_TYPE_LIBRARY);
			productTypeLibrary.setVersion("1.2.3");
			categoryTypeLibrary.setVersion("3.2.1");
			m_soaTypeRegistry.addTypeLibraryToRegistry(productTypeLibrary);
			m_soaTypeRegistry.addTypeLibraryToRegistry(categoryTypeLibrary);
			typeNames.add(PRODUCT_TYPE_LIBRARY);
			typeNames.add(null);
			typeNames.add(CATEGORY_TYPE_LIBRARY);

			Map<String, String> typeVersions = m_soaTypeRegistry.getTypeLibrariesVersion(typeNames);
			boolean flag1 = ("1.2.3".equals(typeVersions.get(PRODUCT_TYPE_LIBRARY)));
			boolean flag2 = ("3.2.1".equals(typeVersions.get(CATEGORY_TYPE_LIBRARY)));
			assertTrue("Invalid working of getTypeLibrariesVersion(List<String> typeLibraryNames)", (flag1 || flag2));
		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("Following exception occured:" + e.getMessage(), false);
		}
	}

	/**
	 * Validate the working of getTypeLibrariesVersion(List<String> typeLibraryNames) for valid LibraryName list
	 * along with duplicate libraryName.
	 */
	@Test
	public void testGetTypeLibrariesVersionDuplicateNames() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		List<String> typeNames = new ArrayList();
		try {
			m_soaTypeRegistry.addTypeLibraryToRegistry(PRODUCT_TYPE_LIBRARY);
			m_soaTypeRegistry.addTypeLibraryToRegistry(CATEGORY_TYPE_LIBRARY);

			TypeLibraryType productTypeLibrary = m_soaTypeRegistry.getTypeLibrary(PRODUCT_TYPE_LIBRARY);
			TypeLibraryType categoryTypeLibrary = m_soaTypeRegistry.getTypeLibrary(CATEGORY_TYPE_LIBRARY);
			productTypeLibrary.setVersion("1.2.3");
			categoryTypeLibrary.setVersion("3.2.1");
			m_soaTypeRegistry.addTypeLibraryToRegistry(productTypeLibrary);
			m_soaTypeRegistry.addTypeLibraryToRegistry(categoryTypeLibrary);
			typeNames.add(CATEGORY_TYPE_LIBRARY);
			typeNames.add(CATEGORY_TYPE_LIBRARY);
			typeNames.add(CATEGORY_TYPE_LIBRARY);

			Map<String, String> typeVersions = m_soaTypeRegistry.getTypeLibrariesVersion(typeNames);
			boolean flag1 = (typeVersions.size() == 1);
			boolean flag2 = ("3.2.1".equals(typeVersions.get(CATEGORY_TYPE_LIBRARY)));
			assertTrue("Invalid working of getTypeLibrariesVersion(List<String> typeLibraryNames)", (flag1 || flag2));
		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("Following exception occured:" + e.getMessage(), false);
		}
	}

	/**
	 * Validate the working of getTypeLibrariesVersion(List<String> typeLibraryNames) for valid LibraryName list
	 * along with null parameter to method.
	 */
	@Test
	public void testGetTypeLibrariesVersionNullParam() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		try {
		

			Map<String, String> typeVersions = m_soaTypeRegistry.getTypeLibrariesVersion(null);
			boolean flag1 = (typeVersions.size() == 1);
			boolean flag2 = ("3.2.1".equals(typeVersions.get(CATEGORY_TYPE_LIBRARY)));
			assertTrue("Invalid working of getTypeLibrariesVersion(List<String> typeLibraryNames)", (flag1 || flag2));
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "nput param \"typeLibraryNames\" cannot be null.";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.codegen.exception.BadInputValueException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().contains(exceptionMessage));
		}
	}

	//*********--- List<TypeLibraryType> getAllTypeLibraries() ---************//
	/**
	 * Validate the working of List<TypeLibraryType> getAllTypeLibraries().
	 */
	@Test
	public void testGetAllTypeLibraries() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		try {
			

			List<TypeLibraryType> libraryType = m_soaTypeRegistry.getAllTypeLibraries();
			boolean libName = false;
			boolean libNamespace = false;
			boolean libVersion = false;
			for (TypeLibraryType library : libraryType) {
				if (PRODUCT_TYPE_LIBRARY.equals(library.getLibraryName()))
					libName = true;

				if ("http://www.ebayopensource.org/soaframework/examples/config".equals(library.getLibraryNamespace()))
					libNamespace = true;

				if ("1.2.3".equals(library.getVersion()))
					libVersion = true;
			}
			assertTrue("Invalid working of List<TypeLibraryType> getAllTypeLibraries()",
					(libName || libVersion || libNamespace));

			boolean check = true;
			m_soaTypeRegistry.addTypeLibraryToRegistry(CATEGORY_TYPE_LIBRARY);
			libraryType = m_soaTypeRegistry.getAllTypeLibraries();
			for (TypeLibraryType library : libraryType) {
				if (PRODUCT_TYPE_LIBRARY.equals(library.getLibraryName())) {
					check = ("http://www.ebayopensource.org/soaframework/examples/config".equals(library.getLibraryNamespace())) || ("1.2.3".equals(library.getVersion()));
				} else if (CATEGORY_TYPE_LIBRARY.equals(library.getLibraryName())) {
					check = ("http://www.ebayopensource.org/soaframework/examples/config".equals(library.getLibraryNamespace())) || ("1.2.3".equals(library.getVersion()));
				} 
				assertTrue("Invalid working of List<TypeLibraryType> getAllTypeLibraries()", check);
			}
		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("Following exception occured: " + e.getMessage(), false);
		}
	}

	//*********--- TypeLibraryType getTypeLibrary(String typeLibName) ---************//
	/**
	 * Validate the working of TypeLibraryType getTypeLibrary(String typeLibName) for
	 * valid library name.
	 */
	@Test
	public void testGetTypeLibrary() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		try {
		
			TypeLibraryType library = m_soaTypeRegistry.getTypeLibrary(PRODUCT_TYPE_LIBRARY);
			boolean libName = false;
			boolean libNamespace = false;
			boolean libVersion = false;

			if (PRODUCT_TYPE_LIBRARY.equals(library.getLibraryName()))
				libName = true;

			if ("http://www.ebayopensource.org/soaframework/examples/config".equals(library.getLibraryNamespace()))
				libNamespace = true;

			if ("1.2.3".equals(library.getVersion()))
				libVersion = true;

			assertTrue("Invalid working of List<TypeLibraryType> getAllTypeLibraries()",
					(libName || libVersion || libNamespace));
		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("Following exception occured :" + e.getMessage(), false);
		}
	}

	/**
	 * Validate the working of TypeLibraryType getTypeLibrary(String typeLibName) for
	 * invalid typeLibraryName.
	 */
	@Test
	public void testGetTypeLibraryInvalidLibrary() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		try {
			TypeLibraryType library = m_soaTypeRegistry.getTypeLibrary(PRODUCT_TYPE_LIBRARY + "Changed");
			assertTrue("Invalid working of List<TypeLibraryType> getAllTypeLibraries()", (library == null));
		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("Following exception occured :" + e.getMessage(), false);
		}
	}

	/**
	 * Validate the working of TypeLibraryType getTypeLibrary(String typeLibName) for
	 *  null typeLibraryName.
	 */
	@Test
	public void testGetTypeLibraryNullLibraryName() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		String libName = null;
		try {
			TypeLibraryType library = m_soaTypeRegistry.getTypeLibrary(libName);
			assertTrue("Invalid working of List<TypeLibraryType> getAllTypeLibraries()", (library == null));
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "Input param \"typeLibName\" cannot be null.";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.codegen.exception.BadInputValueException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().contains(exceptionMessage));
		}
	}

	/**
	 * Validate the working of TypeLibraryType getTypeLibrary(String typeLibName) for
	 *  empty typeLibraryName.
	 */
	@Test
	public void testGetTypeLibraryEmptyLibraryName() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		try {
			TypeLibraryType library = m_soaTypeRegistry.getTypeLibrary("");
			assertTrue("Invalid working of List<TypeLibraryType> getAllTypeLibraries()", (library == null));
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "Input param \"typeLibName\" cannot be null.";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.codegen.exception.BadInputValueException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().contains(exceptionMessage));
		}
	}

	//*********--- Set<String> getLibrariesReferredByType(String typeName) ---************//
	/**
	 * Validate the working of getLibrariesReferredByType(String typeName) for valid type name.
	 */
	@Test
	//@Ignore("failing")
	public void testGetLibrariesReferredByTypeST() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		try {
			
			QName typeQ = new QName(NAMESPACE,"CategoryName");
			Set<String> librariesRefered = m_soaTypeRegistry.getLibrariesReferredByType(typeQ);
			boolean flag = librariesRefered.contains(CATEGORY_TYPE_LIBRARY);
			assertTrue("Invalid working of getLibrariesReferredByType(String typeName)", flag);
		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("Following exception occured: " + e.getMessage(), false);
		}
	}

	/**
	 * Validate the working of getLibrariesReferredByType(String typeName) for invalid
	 * type name.
	 */
	@Test
	public void testGetLibrariesReferredByTypeSTInvalidTypeName() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		try {
			

			QName typeQ = new QName(NAMESPACE,"CategoryName12345");	
			Set<String> librariesRefered = m_soaTypeRegistry.getLibrariesReferredByType(typeQ);
			boolean flag = librariesRefered.isEmpty();
			assertTrue("Invalid working of getLibrariesReferredByType(String typeName)", flag);
		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("Following exception occured: " + e.getMessage(), false);
		}
	}

	

	//*********--- Set<String> getLibrariesReferredByType(LibraryType typeName) ---************//
	/**
	 * Validate the working of getLibrariesReferredByType(LibraryType typeName) for valid
	 * LibraryType object.
	 */
	@Test
	//@Ignore("failing")
	public void testGetLibrariesReferredByTypeLT() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		try {
			
			LibraryType type = m_soaTypeRegistry.getType("ProductName", PRODUCT_TYPE_LIBRARY);
			Set<String> librariesRefered = m_soaTypeRegistry.getLibrariesReferredByType(type);
			boolean flag = librariesRefered.contains(PRODUCT_TYPE_LIBRARY);
			assertTrue("Invalid working of getLibrariesReferredByType(LibraryType typeName)", flag);
		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("Following exception occured: " + e.getMessage(), false);
		}
	}

	/**
	 * Validate the working of getLibrariesReferredByType(LibraryType typeName) for new
	 * LibraryType object.
	 */
	@Test
	public void testGetLibrariesReferredByTypeLTNewObj() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		try {
			
			LibraryType type = new LibraryType();
			Set<String> librariesRefered = m_soaTypeRegistry.getLibrariesReferredByType(type);
			boolean flag = librariesRefered.isEmpty();
			assertTrue("Invalid working of getLibrariesReferredByType(LibraryType typeName)", flag);
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "Input LibraryType's name is either null or empty.";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.codegen.exception.BadInputValueException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().contains(exceptionMessage));
		}
	}

	/**
	 * Validate the working of getLibrariesReferredByType(LibraryType typeName) for null
	 * LibraryType object.
	 */
	@Test
	public void testGetLibrariesReferredByTypeLTNull() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		try {
			
			LibraryType type = null;
			Set<String> librariesRefered = m_soaTypeRegistry.getLibrariesReferredByType(type);
			boolean flag = librariesRefered.isEmpty();
			assertTrue("Invalid working of getLibrariesReferredByType(LibraryType typeName)", flag);
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "Input param \"LibraryType\" cannot be null.";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.codegen.exception.BadInputValueException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().contains(exceptionMessage));
		}
	}

	//*********--- List<LibraryType> getDependentParentTypeFiles(LibraryType libraryType) ---************//
	/**
	 * Validate the working of getDependentParentTypeFiles(LibraryType libraryType) for valid LibraryType 
	 * object.
	 */
	@Test
	//@Ignore("failing")
	public void testGetDependentParentTypeFiles() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		try {
			
			LibraryType libraryType = m_soaTypeRegistry.getType("CategoryName", CATEGORY_TYPE_LIBRARY);
			List<LibraryType> actualList = m_soaTypeRegistry.getDependentParentTypeFiles(libraryType);
			assertTrue("Invalid working of getDependentParentTypeFiles(LibraryType libraryType).",
					(actualList != null || actualList.size() != 0));
		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("Following exception occured: " + e.getMessage(), false);
		}
	}

	/**
	 * Validate the working of getDependentParentTypeFiles(LibraryType libraryType) for invalid LibraryType 
	 * object.
	 */
	@Test
	public void testGetDependentParentTypeFilesInvalid() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		try {
			
			LibraryType libraryType = new LibraryType();
			libraryType.setName("XYZ");
			List<LibraryType> actualList = m_soaTypeRegistry.getDependentParentTypeFiles(libraryType);
			assertTrue("Invalid working of getDependentParentTypeFiles(LibraryType libraryType).", (actualList.size() == 0));
		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("Following exception occured: " + e.getMessage(), false);
		}
	}

	/**
	 * Validate the working of getDependentParentTypeFiles(LibraryType libraryType) for null LibraryType 
	 * object.
	 */
	@Test
	public void testGetDependentParentTypeFilesNull() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		try {
			
			LibraryType libraryType = null;
			List<LibraryType> actualList = m_soaTypeRegistry.getDependentParentTypeFiles(libraryType);
			assertTrue("Invalid working of getDependentParentTypeFiles(LibraryType libraryType).", false);
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "Input param \"LibraryType\" cannot be null.";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.codegen.exception.BadInputValueException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().contains(exceptionMessage));
		}
	}

	//*********--- List<LibraryType> getDependentChildTypeFiles(LibraryType libraryType) ---************//
	/**
	 * Validate the working of getDependentChildTypeFiles(LibraryType libraryType) for valid 
	 * LibraryType object.
	 */
	@Test
	//@Ignore("failing")
	public void testGetDependentChildTypeFiles() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		try {
			
			LibraryType libraryType = m_soaTypeRegistry.getType("ProductName",PRODUCT_TYPE_LIBRARY);
			List<LibraryType> actualList = m_soaTypeRegistry.getDependentChildTypeFiles(libraryType);
			assertTrue("Invalid working of getDependentParentTypeFiles(LibraryType libraryType).",
					(actualList != null || actualList.size() != 0));
		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("Following exception occured :" + e.getMessage(), false);
		}
	}

	/**
	 * Validate the working of getDependentChildTypeFiles(LibraryType libraryType) for invalid 
	 * LibraryType object.
	 */
	@Test
	public void testGetDependentChildTypeFilesInvalidType() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		try {
			
			LibraryType libraryType = new LibraryType();
			libraryType.setName("XYZ");
			List<LibraryType> actualList = m_soaTypeRegistry.getDependentChildTypeFiles(libraryType);
			assertTrue("Invalid working of getDependentParentTypeFiles(LibraryType libraryType).", (actualList.size() == 0));
		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("Following exception occured :" + e.getMessage(), false);
		}
	}

	/**
	 * Validate the working of getDependentChildTypeFiles(LibraryType libraryType) for null 
	 * LibraryType object.
	 */
	@Test
	public void testGetDependentChildTypeFilesNull() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		try {
			
			LibraryType libraryType = null;
			List<LibraryType> actualList = m_soaTypeRegistry.getDependentChildTypeFiles(libraryType);
			assertTrue("Invalid working of getDependentParentTypeFiles(LibraryType libraryType).", (actualList.size() == 0));
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "Input param \"LibraryType\" cannot be null.";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.codegen.exception.BadInputValueException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().contains(exceptionMessage));
		}
	}

	//*********--- boolean removeTypeFromRegistry(String typeName) ---************//
	/**
	 * Validate the working of removeTypeFromRegistry(String typeName) for valid type name.
	 */
	@Test
	public void testRemoveTypeFromRegistryST() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		try {
			
			List<LibraryType> types = m_soaTypeRegistry.getAllTypes();
			int initialCount = types.size();
			boolean check = true;
			QName typeQ = new QName(NAMESPACE,"CategoryName");
			boolean flag = m_soaTypeRegistry.removeTypeFromRegistry(typeQ);
			types = m_soaTypeRegistry.getAllTypes();
			for (LibraryType type : types) {
				if ("CategoryName".equals(type.getName())) {
					check = false;
				}
			}
			assertTrue("Invalid working of removeTypeFromRegistry(String typeName)", (check || flag));

		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("Following exception occured : " + e.getMessage(), false);
		}
	}

	//*********--- boolean removeTypeFromRegistry(LibraryType typeName) ---************//
	/**
	 * Validate the working of removeTypeFromRegistry(LibraryType typeName) for valid LibraryType 
	 * Object.
	 */
	@Test
	public void testRemoveTypeFromRegistryLT() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		try {
			
			LibraryType productNameType = m_soaTypeRegistry.getType("CategoryName",CATEGORY_TYPE_LIBRARY);
			m_soaTypeRegistry.removeTypeFromRegistry(productNameType);
			List<LibraryType> types = m_soaTypeRegistry.getAllTypes();
			for (LibraryType type : types) {
				if ("CategoryName".equals(type.getName())) {
					//check = false;
				}
			}
			//assertTrue("Invalid working of removeTypeFromRegistry(String typeName)", (check || flag));

		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	//*********--- boolean doesTypeNameExist(String typeName) ---************//
	/**
	 * Validate the working of doesTypeNameExist(String typeName) for valid type name.
	 */
	@Test
	//@Ignore("failing")
	public void testDoesTypeNameExistST() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		try {
			QName typeQ = new QName(NAMESPACE,"CategoryName");
			boolean type = m_soaTypeRegistry.doesTypeNameExist(typeQ);
			assertTrue("Invalid working of doesTypeNameExist(String typeName).", type);
		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("Following exception occured: " + e.getMessage(), false);
		}
	}

	/**
	 * Validate the working of doesTypeNameExist(String typeName) for empty type name.
	 */
	@Test
	public void testDoesTypeNameExistSTEmpty() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		try {
			
			QName typeQ = new QName(NAMESPACE,"");
			boolean type = m_soaTypeRegistry.doesTypeNameExist(typeQ);
			assertFalse("Invalid working of doesTypeNameExist(String typeName).", type);
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "Input LibraryType's name is either null or empty";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.codegen.exception.BadInputValueException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().contains(exceptionMessage));
		}
	}

	/**
	 * Validate the working of doesTypeNameExist(String typeName) for invalid type name.
	 */
	@Test
	public void testDoesTypeNameExistSTInvalidTypeName() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		try {
			m_soaTypeRegistry.addTypeLibraryToRegistry(CATEGORY_TYPE_LIBRARY);
			QName typeQ = new QName(NAMESPACE,"XYZ");
			boolean type = m_soaTypeRegistry.doesTypeNameExist(typeQ);
			assertFalse("Invalid working of doesTypeNameExist(String typeName).", type);
		} catch (Exception ex) {
			ex.printStackTrace();
			assertTrue("Following exception occured: " + ex.getMessage(), false);
		}
	}

	

	//*********--- boolean doesTypeNameExist(LibraryType typeName) ---************//
	/**
	 * Validate the working of doesTypeNameExist(LibraryType typeName) for valid libraryType object.
	 */
	@Test
	//@Ignore("failing")
	public void testDoesTypeNameExistLT() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		try {
			QName typeQ = new QName(NAMESPACE,"CategoryName");
			LibraryType type = m_soaTypeRegistry.getType(typeQ);
			boolean catType = m_soaTypeRegistry.doesTypeNameExist(type);
			assertTrue("Invalid working of doesTypeNameExist(String typeName).", catType);
		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("Following exception occured: " + e.getMessage(), false);
		}
	}

	/**
	 * Validate the working of doesTypeNameExist(LibraryType typeName) for new libraryType object.
	 */
	@Test
	public void testDoesTypeNameExistLTNewObj() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		try {
			LibraryType type = new LibraryType();
			type.setName("XYZ");
			boolean catType = m_soaTypeRegistry.doesTypeNameExist(type);
			assertFalse("Invalid working of doesTypeNameExist(String typeName).", catType);
		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("Following exception occured: " + e.getMessage(), false);
		}
	}

	/**
	 * Validate the working of doesTypeNameExist(LibraryType typeName) for null.
	 */
	@Test
	public void testDoesTypeNameExistLTNull() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		try {
		
			LibraryType type = null;
			boolean catType = m_soaTypeRegistry.doesTypeNameExist(type);
			assertFalse("Invalid working of doesTypeNameExist(String typeName).", catType);
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "Input param \"LibraryType\" cannot be null.";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.codegen.exception.BadInputValueException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().contains(exceptionMessage));
		}
	}

	/**
	 * Validate the working of doesTypeNameExist(LibraryType typeName) for LibraryType object without name.
	 */
	@Test
	public void testDoesTypeNameExistLTWithoutName() {
		String folderConstant = "populateRegistryWithTypeLibraries/1";
		setEnvironment(folderConstant);
		m_soaTypeRegistry = SOAGlobalRegistryFactory.getSOATypeRegistryInstance();
		try {
			
			LibraryType type = new LibraryType();
			boolean catType = m_soaTypeRegistry.doesTypeNameExist(type);
			assertFalse("Invalid working of doesTypeNameExist(String typeName).", catType);
		} catch (Exception ex) {
			ex.printStackTrace();
			String exceptionMessage = "Input LibraryType's name is either null or empty.";
			String exceptionClassName = "org.ebayopensource.turmeric.tools.codegen.exception.BadInputValueException";
			assertTrue("Exception class is invalid. \n Actual:" + ex.getClass().getName()
					+ " \n Expected:"
					+ exceptionClassName, ex.getClass().getName().equals(exceptionClassName));
			assertTrue("Exception message is Invalid. \n Actual:" + ex.getMessage() + "\n Expected:" + exceptionMessage,
					ex.getMessage().contains(exceptionMessage));
		}
	}

	public static void main(String[] args) {
		SOAGlobalRegistryQETest test = new SOAGlobalRegistryQETest();
		test.testDoesTypeNameExistLTWithoutName();
	}

	private Object updateGlobalTableWithNewLibrary(String objectName, String typeLibraryName) throws Exception {
		String projectRoot = PROJECT_ROOT +"/" + typeLibraryName;
		String libraryName = typeLibraryName;
		TypeLibraryType typeLibraryType = null;
		Object globalObject = null;
		String typeInfoXMLFilePath = projectRoot +File.separator +"gen-meta-src/META-INF/" +typeLibraryName+
				 "/TypeInformation.xml";
		File file = new File(typeInfoXMLFilePath);
		try {
			typeLibraryType = JAXB.unmarshal(file, TypeLibraryType.class);
		} catch (Throwable t) {
			throw new Exception(t);
		} finally {
		}

		if (objectName.equals("TypeLibraryType")) {
			globalObject = typeLibraryType;
		}
		return globalObject;
	}

	private Object updateGlobalTableWithDependentLibrary(String objectName, String typeLibraryName) throws Exception {
		String projectRoot = PROJECT_ROOT +"/" + typeLibraryName;
		String libraryName = typeLibraryName;
		TypeLibraryType typeDependencyType = null;
		Object globalObject = null;
		String typeInfoXMLFilePath = projectRoot +File.separator +"gen-meta-src/META-INF" +typeLibraryName+
		 "/TypeInformation.xml";
		File file = new File(typeInfoXMLFilePath);
		try {
			typeDependencyType = JAXB.unmarshal(file, TypeLibraryType.class);
		} catch (Throwable t) {
			throw new Exception(t);
		} finally {
		}

		if (objectName.equals("TypeDependentType")) {
			globalObject = typeDependencyType;
		}
		return globalObject;
	}

	private boolean deleteTypeLibrary(String projectRoot) {
		File projectDir = new File(projectRoot);
		if (projectDir.isDirectory()) {
			String[] childFiles = projectDir.list();
			for (int i = 0; i < childFiles.length; i++) {
				deleteTypeLibrary(projectRoot + "\\" + childFiles[i]);
			}
		}
		boolean flag = projectDir.delete();
		System.out.println(flag);
		return flag;
	}

	private String getTypeInformationXMLPath(String projectRoot, String libraryName, String aditionalPath) {
		String path = null;
		if (aditionalPath != null && aditionalPath.trim().length() != 0) {
			path = projectRoot + "/gen-meta-src/META-INF/" + libraryName + "/" + aditionalPath + "/TypeInformation.xml";
		} else {
			path = projectRoot + "/gen-meta-src/META-INF/" + libraryName + "/TypeInformation.xml";
		}
		return path;
	}

	public boolean createTypeLibrary(String projectRoot, String libraryName, String version) {
		boolean flag = false;
		ServiceGenerator sGenerator = new ServiceGenerator();
		String[] pluginParameter = { "-gentype",
				"genTypeCreateTypeLibrary",
				"-pr",
				projectRoot,
				"-libname",
				libraryName,
				"-libVersion",
				version,
				"-libNamespace",
				"http://www.ebayopensource.org/soaframework/examples/config" };
		try {
			sGenerator.startCodeGen(pluginParameter);
			flag = true;
		} catch (Exception e) {
			e.printStackTrace();
			flag = false;
		}
		return flag;
	}

	private boolean addTypeToLibrary(String projectRoot, String libraryName, String xsdName) {
		boolean flag = false;
		ServiceGenerator sGenerator = new ServiceGenerator();
		String[] pluginParameter = { "-gentype",
				"genTypeAddType",
				"-pr",
				projectRoot,
				"-libname",
				libraryName,
				"-type",
				xsdName };
		try {
			sGenerator.startCodeGen(pluginParameter);
			flag = true;
		} catch (Exception e) {
			e.printStackTrace();
			flag = false;
		}
		return flag;
	}

	/**
	 * This method will set environment. Following tasks are to be done by this method.
	 * 1. Delete ProductTypeLibrary and CategoryTypeLibrary.
	 * 2. Create ProductTypeLibrary and CategoryTypeLibrary.
	 * 3. Update the TypeInformation.xml and TypeDependencies.xml.
	 * 4. Add these projects into the class path.
	 * @param folderConstant
	 */
	private void setEnvironment(String folderConstant) {
		

		//Create CategoryTypeLibrary
		boolean createCategoryLib = createTypeLibrary(PROJECT_ROOT_CATEGORY, CATEGORY_TYPE_LIBRARY, "1.2.3");
		assertTrue(CATEGORY_TYPE_LIBRARY + " creation failed.", createCategoryLib);
		
		try {
			TestResourceUtil.copyResource("types/CategoryTypeLibrary/CategoryName.xsd", testingdir, "CategoryTypeLibrary/meta-src");
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		addTypeToLibrary(PROJECT_ROOT_CATEGORY,CATEGORY_TYPE_LIBRARY,"CategoryName.xsd");
		
		//Create CategoryTypeLibrary
		boolean createProductLib = createTypeLibrary(PROJECT_ROOT_PRODUCT, PRODUCT_TYPE_LIBRARY, "3.2.1");
		assertTrue(PRODUCT_TYPE_LIBRARY + " creation failed.", createProductLib);
		try {
			TestResourceUtil.copyResource("types/ProductTypeLibrary/ProductName.xsd", testingdir, "ProductTypeLibrary/meta-src");
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		addTypeToLibrary(PROJECT_ROOT_PRODUCT,PRODUCT_TYPE_LIBRARY,"ProductName.xsd");
		
		
		//Copy TypeInformation.xml of CategoryTypeLibrary from Vanilla Copies to AntTests.
		String categoryTIXmlCodegenPath = utility.getTypeInformationXMLPath(PROJECT_ROOT_CATEGORY,
				CATEGORY_TYPE_LIBRARY,
				null);
		String categoryTIXmlVanillaPath =  getTestResrcDir().getAbsolutePath() + "/TypeLibraryCodegen/CategoryTypeLibrary/gen-meta-src/META-INF/CategoryTypeLibrary/"+folderConstant+"/TypeInformation.xml";
		boolean updateTIXmlCat = utility.updateSourceFile(categoryTIXmlVanillaPath, categoryTIXmlCodegenPath);
		assertTrue("TypeInformation.xml updation failed for Library" + CATEGORY_TYPE_LIBRARY, updateTIXmlCat);

		//Copy TypeInformation.xml of ProductTypeLibrary from Vanilla Copies to AntTests.
		String productTIXmlCodegenPath = utility.getTypeInformationXMLPath(PROJECT_ROOT_PRODUCT, PRODUCT_TYPE_LIBRARY, null);
		String productTIXmlVanillaPath = getTestResrcDir().getAbsolutePath() + "/TypeLibraryCodegen/ProductTypeLibrary/gen-meta-src/META-INF/ProductTypeLibrary/"+folderConstant+"/TypeInformation.xml";
		boolean updateTIXmlProd = utility.updateSourceFile(productTIXmlVanillaPath, productTIXmlCodegenPath);
		assertTrue("TypeInformation.xml updation failed for Library" + PRODUCT_TYPE_LIBRARY, updateTIXmlProd);

		String categoryTDXmlCodegenPath = testingdir.getDir().getAbsolutePath() + "/CategoryTypeLibrary/meta-src/META-INF/CategoryTypeLibrary/TypeDependencies.xml";
		String categoryTDXmlVanillaPath =getTestResrcDir().getAbsolutePath() + "/TypeLibraryCodegen/CategoryTypeLibrary/meta-src/META-INF/CategoryTypeLibrary/TypeDependencies.xml";
		boolean updateTDXmlCat = utility.updateSourceFile(categoryTDXmlVanillaPath, categoryTDXmlCodegenPath);
		assertTrue("TypeDependencies.xml updation failed for Library", updateTDXmlCat);

		//Set the class path
		boolean classPath = utility.setClassPath(testingdir.getDir().getAbsolutePath() );
		assertTrue("Class path is not set properly.", classPath);
	}

	private int getAllLibrariesFromWorkspace() {
		int count = 0;
		List<TypeLibraryType> allTypeLibrary = null;
		try {
			allTypeLibrary = m_soaTypeRegistry.getAllTypeLibraries();
			count = allTypeLibrary.size();
			for (int i = 0; i < allTypeLibrary.size(); i++) {
				TypeLibraryType library = allTypeLibrary.get(i);
				System.out.println((i + 1) + "." + library.getLibraryName());
			}
		} catch (Exception e) {
			e.printStackTrace();
			assertTrue("No exception should be thrown. Exception:" + e.getMessage(), false);
		}
		return count;
	}
	
	private void createTempLibrary(String projectRoot,String libraryName){
		String[] pluginParameter = {
				"-gentype",
				"genTypeCreateTypeLibrary",
				"-pr",
				projectRoot,
				"-libname", libraryName, "-libVersion", "1.2.3" ,"-libNamespace",NAMESPACE};
		try{
			ServiceGenerator sGenerator = new ServiceGenerator();
			sGenerator.startCodeGen(pluginParameter);
		}catch(Exception e){
			e.printStackTrace();
		}		
	}
}