tests/org.eclipse.sphinx.tests.platform/src/org/eclipse/sphinx/tests/platform/util/ReflectUtilTest.java - sphinx/org.eclipse.sphinx - Git at Google

 /**
  * <copyright>
  *
  * Copyright (c) 2008-2013 See4sys, itemis and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
  *
  * Contributors:
  *     See4sys - Initial API and implementation
  *     itemis - [409510] Enable resource scope-sensitive proxy resolutions without forcing metamodel implementations to subclass EObjectImpl
  *     Siemens - [574930] Model load manager extension
  *
  * </copyright>
  */
 package org.eclipse.sphinx.tests.platform.util;

 import java.io.FileNotFoundException;
 import java.lang.reflect.InvocationTargetException;

 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.Status;
 import org.eclipse.emf.common.util.URI;
 import org.eclipse.emf.common.util.WrappedException;
 import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.emf.ecore.resource.Resource.Diagnostic;
 import org.eclipse.emf.ecore.resource.ResourceSet;
 import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
 import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.eclipse.emf.validation.internal.util.DisabledConstraintStatus;
 import org.eclipse.emf.validation.model.ConstraintStatus;
 import org.eclipse.sphinx.emf.metamodel.IMetaModelDescriptor;
 import org.eclipse.sphinx.emf.resource.ScopingResourceSetImpl;
 import org.eclipse.sphinx.emf.workspace.loading.IModelLoadManager;
 import org.eclipse.sphinx.examples.hummingbird20.typemodel.ComponentType;
 import org.eclipse.sphinx.examples.hummingbird20.typemodel.Platform;
 import org.eclipse.sphinx.examples.hummingbird20.typemodel.Port;
 import org.eclipse.sphinx.examples.hummingbird20.typemodel.TypeModel20Factory;
 import org.eclipse.sphinx.examples.hummingbird20.typemodel.impl.PlatformImpl;
 import org.eclipse.sphinx.platform.stats.PerformanceStatsLog;
 import org.eclipse.sphinx.platform.util.ReflectUtil;

 import junit.framework.TestCase;

 @SuppressWarnings({ "nls", "restriction" })
 public class ReflectUtilTest extends TestCase {

 	private Platform createPlatform() {
 		Platform platform = TypeModel20Factory.eINSTANCE.createPlatform();
 		platform.setName("Platform");

 		org.eclipse.sphinx.examples.hummingbird20.typemodel.Interface interface1 = TypeModel20Factory.eINSTANCE.createInterface();
 		interface1.setName("interface");
 		platform.getInterfaces().add(interface1);

 		ComponentType componentType = TypeModel20Factory.eINSTANCE.createComponentType();
 		componentType.setName("ComponentType");
 		platform.getComponentTypes().add(componentType);

 		org.eclipse.sphinx.examples.hummingbird20.typemodel.Parameter param = TypeModel20Factory.eINSTANCE.createParameter();
 		param.setName("param");
 		param.setDataType("String");
 		param.setOptional(true);
 		componentType.getParameters().add(param);

 		Port port = TypeModel20Factory.eINSTANCE.createPort();
 		port.setName("port");
 		port.setOwner(componentType);
 		port.setMaxProviderCount(100);
 		port.setMinProviderCount(10);
 		port.setRequiredInterface(interface1);

 		componentType.getPorts().add(port);
 		return platform;

 	}

 	/**
 	 * Test method for (@link {@link ReflectUtil#getSimplePackageName(String)}
 	 */
 	public void testGetSimplePackageName() {

 		String testQualifiedPackageName = "org.eclipse.sphinx.tests.platform.util";
 		String simplePackageName = "util";

 		assertEquals(simplePackageName, ReflectUtil.getSimplePackageName(testQualifiedPackageName));

 	}

 	/**
 	 * Test method for {@link ReflectUtil#getSuperPackageName(String)}
 	 */
 	public void testGetSuperPackageName() {
 		String testQualifiedPackageName = "org.eclipse.sphinx.tests.platform.util";
 		String superPackageName = "org.eclipse.sphinx.tests.platform";

 		assertEquals(superPackageName, ReflectUtil.getSuperPackageName(testQualifiedPackageName));
 	}

 	/**
 	 * Test method for{@link ReflectUtil#isAssignableFrom(Class, String)}
 	 */
 	public void testIsAssignableFrom() {
 		assertTrue(ReflectUtil.isAssignableFrom(int.class, "int"));
 		assertFalse(ReflectUtil.isAssignableFrom(int.class, "Integer"));
 		assertFalse(ReflectUtil.isAssignableFrom(Integer.class, "int"));
 		assertTrue(ReflectUtil.isAssignableFrom(Status.class, "IStatus"));
 		assertFalse(ReflectUtil.isAssignableFrom(IStatus.class, "IConstraintStatus"));
 		assertTrue(ReflectUtil.isAssignableFrom(ConstraintStatus.class, "IStatus"));
 		assertTrue(ReflectUtil.isAssignableFrom(ConstraintStatus.class, "IConstraintStatus"));
 		assertTrue(ReflectUtil.isAssignableFrom(DisabledConstraintStatus.class, "ConstraintStatus"));
 		assertTrue(ReflectUtil.isAssignableFrom(DisabledConstraintStatus.class, "IConstraintStatus"));
 		assertFalse(ReflectUtil.isAssignableFrom(DisabledConstraintStatus.class, "IResourceStatus"));
 	}

 	/**
 	 * Test method for {@link ReflectUtil#clearAllFields(Object)}
 	 */
 	public void testClearAllFields_1() throws IllegalAccessException {
 		Platform platform = createPlatform();
 		assertFalse(platform.getComponentTypes().isEmpty());

 		ComponentType componentType = platform.getComponentTypes().get(0);
 		assertFalse(componentType.getPorts().isEmpty());

 		Port port = componentType.getPorts().get(0);
 		ReflectUtil.clearAllFields(port);

 		assertNotNull(port);
 		// Fields of super class
 		assertNull(port.getName());

 		// Fields of object class
 		// Static/final field is not cleared
 		assertNotNull(port.getMaxProviderCount());
 		// Primitive field is not cleared
 		assertNotNull(port.getMinProviderCount());

 		assertNull(port.getRequiredInterface());

 	}

 	/**
 	 * Test method for {@link ReflectUtil#clearAllFields(Object, String[])}
 	 *
 	 * @throws IllegalAccessException
 	 */
 	public void testClearAllFields_2() throws IllegalAccessException {
 		Platform platform = createPlatform();
 		assertFalse(platform.getComponentTypes().isEmpty());

 		ComponentType componentType = platform.getComponentTypes().get(0);
 		assertFalse(componentType.getPorts().isEmpty());

 		Port port = componentType.getPorts().get(0);
 		ReflectUtil.clearAllFields(port, new String[] { "name" });

 		assertNotNull(port);
 		// Fields of super class in excluded list
 		assertNotNull(port.getName());

 		// Fields of object class
 		// Static/final field is not cleared
 		assertNotNull(port.getMaxProviderCount());
 		// Primitive field is not cleared
 		assertNotNull(port.getMinProviderCount());

 		assertNull(port.getRequiredInterface());

 	}

 	/**
 	 * Test method for {@link ReflectUtil#getFieldValue(Object, String)}
 	 */
 	public void testGetFieldValue() {
 		String publicValue = "publicValue";
 		String protectedValue = "protectedValue";
 		String privateValue = "privateValue";

 		Data testData = new Data(publicValue, privateValue, protectedValue);

 		// Non- static
 		// Public field
 		try {
 			assertEquals("Got value is not the same with expected", publicValue, ReflectUtil.getFieldValue(testData, "publicField"));
 		} catch (Exception e) {
 			if (e instanceof IllegalAccessException) {
 				fail("Cannot access to public field");
 			} else if (e instanceof NoSuchFieldException) {
 				fail("Cannot find to public field");

 			} else {
 				fail(e.getLocalizedMessage());
 			}
 		}
 		try {
 			assertNull(ReflectUtil.getFieldValue(Data.class, "publicField"));
 		} catch (Exception e) {
 			if (e instanceof IllegalAccessException) {
 				fail("Cannot access to public field");
 			} else if (e instanceof NoSuchFieldException) {
 				fail("Cannot find to public field");
 			} else if (!(e instanceof IllegalArgumentException)) {
 				fail(e.getClass() + "  " + e.getLocalizedMessage());
 			}
 		}
 		// Protected Field
 		try {
 			assertEquals("Got value is not the same with expected", protectedValue, ReflectUtil.getFieldValue(testData, "protectedField"));
 		} catch (Exception e) {
 			if (!(e instanceof IllegalAccessException)) {
 				fail("Did not throw IllegalAccessException when the given field is private or protected:\n " + "Threw: " + e.getClass() + " "
 						+ e.getMessage());
 			}
 		}
 		try {
 			assertNull(ReflectUtil.getFieldValue(Data.class, "protectedField"));
 		} catch (Exception e) {

 			if (!(e instanceof IllegalAccessException || e instanceof IllegalArgumentException)) {
 				fail("Did not throw IllegalAccessException/IllegalArgumentException when get the given field is private or protected from class instead of object:\n "
 						+ "Threw: " + e.getClass() + " " + e.getMessage());
 			}
 		}
 		// Private field
 		try {
 			assertEquals(privateValue, ReflectUtil.getFieldValue(testData, "privateField"));
 		} catch (Exception e) {
 			if (!(e instanceof IllegalAccessException)) {
 				fail("Did not throw IllegalAccessException when the given field is private or protected:\n " + "Threw: " + e.getClass() + " "
 						+ e.getMessage());
 			}
 		}
 		try {
 			assertNull(ReflectUtil.getFieldValue(Data.class, "privateField"));
 		} catch (Exception e) {
 			if (!(e instanceof IllegalAccessException || e instanceof IllegalArgumentException)) {
 				fail("Did not throw IllegalAccessException/IllegalArgumentException when get the given field is private or protected from class instead of object:\n "
 						+ "Threw: " + e.getClass() + " " + e.getMessage());
 			}
 		}
 		// Static Field
 		// -- visible field
 		try {
 			assertEquals(Data.pubSField, ReflectUtil.getFieldValue(Data.class, "pubSField"));
 		} catch (Exception e) {
 			fail("Cannot get public static field: " + e.getLocalizedMessage());
 		}
 		// --invisible field
 		try {
 			assertEquals(Data.proSField, ReflectUtil.getFieldValue(Data.class, "proSField"));
 		} catch (Exception e) {
 			if (!(e instanceof IllegalAccessException)) {

 				fail("Throw " + e.getClass().toString() + "-Did not throw IllegalAccessException when the given field is private or protectedt");
 			}
 		}

 		try {
 			assertEquals(Data.getPrisfield(), ReflectUtil.getFieldValue(Data.class, "priSField"));
 		} catch (Exception e) {
 			if (!(e instanceof IllegalAccessException)) {
 				fail("Throw " + e.getClass().toString() + "-Did not throw IllegalAccessException when the given field is private or protectedt");
 			}
 		}

 		// Un_existing Field
 		try {
 			ReflectUtil.getFieldValue(testData, "unexistingField");
 		} catch (Exception e) {
 			if (!(e instanceof NoSuchFieldException)) {
 				fail("Throw " + e.getClass().toString() + "-Did not throw NoSuchFieldException when the given field is not exit");
 			}
 		}

 	}

 	/**
 	 * Test method for {@link ReflectUtil#getInvisibleFieldValue(Object, String)}
 	 *
 	 * @throws IllegalAccessException
 	 * @throws NoSuchFieldException
 	 * @throws IllegalArgumentException
 	 */
 	public void testGetInvisibleFieldValue() throws Exception {
 		String publicValue = "publicValue";
 		String protectedValue = "protectedValue";
 		String privateValue = "privateValue";

 		Data testData = new Data(publicValue, privateValue, protectedValue);

 		// Non static field
 		// --Non-static private field
 		try {
 			assertEquals("Return values are not equal", testData.getPrivateField(), ReflectUtil.getInvisibleFieldValue(testData, "privateField"));
 		} catch (Exception e) {
 			if (e instanceof IllegalAccessException) {
 				fail("Cannot access non -static protected field");
 			}
 		}
 		// -- Non-static protected field
 		// -in different package
 		try {
 			assertEquals(true, ReflectUtil.getInvisibleFieldValue(PerformanceStatsLog.class, "consoleLog"));
 		} catch (Exception e) {
 			if (e instanceof IllegalAccessException) {
 				fail("Cannot access non -static protected field");
 			}
 		}
 		// in the same package
 		try {
 			assertEquals(testData.protectedField, ReflectUtil.getInvisibleFieldValue(testData, "protected field"));
 		} catch (Exception e) {
 			if (e instanceof IllegalAccessException) {
 				fail("Cannot access non -static protected field");
 			}
 		}
 		// Static field
 		// --Static protected field
 		// in the same package
 		try {
 			assertEquals(Data.proSField, ReflectUtil.getInvisibleFieldValue(Data.class, "proSField"));
 		} catch (Exception e) {
 			if (e instanceof IllegalAccessException) {
 				fail("Cannot access static protected field");
 			}
 		}
 		// in different package
 		try {
 			assertEquals("!STACK", ReflectUtil.getInvisibleFieldValue(PerformanceStatsLog.class, "STACK"));
 		} catch (Exception e) {
 			if (e instanceof IllegalAccessException) {
 				fail("Cannot access static protected field");
 			}
 		}
 		// --Static private field
 		try {
 			assertEquals(Data.getPrisfield(), ReflectUtil.getInvisibleFieldValue(Data.class, "priSField"));
 		} catch (Exception e) {
 			if (e instanceof IllegalAccessException) {
 				fail("Cannot access static private field");
 			}
 		}

 		// Given field is not exist
 		try {
 			ReflectUtil.getInvisibleFieldValue(Data.class, "priField");
 		} catch (Exception e) {
 			if (!(e instanceof NoSuchFieldException)) {
 				fail("Don't throw NoSuchFiledException when getting unexsitingField\nThrew " + e.getClass() + " " + e.getLocalizedMessage());
 			}
 		}
 	}

 	/**
 	 * Test method for {@link ReflectUtil#invokeMethod(Object, String, Object...)}
 	 */
 	public void testInvokeMethod() {
 		Platform platform = createPlatform();
 		String expectedPlatformName = platform.getName();

 		ResourceSet testResourceSet = new ScopingResourceSetImpl();
 		Resource testResource = testResourceSet.createResource(URI.createURI("newResource.xml"));
 		testResource.getContents().add(platform);

 		// Non static public method
 		boolean flag = false;
 		String message = "";
 		try {
 			assertSame(expectedPlatformName, ReflectUtil.invokeMethod(platform, "getName"));

 		} catch (Exception e) {
 			fail(e.getLocalizedMessage());
 		}
 		// public static method
 		try {
 			Object copiedObject = ReflectUtil.invokeMethod(EcoreUtil.class, "copy", platform);
 			assertNotNull(copiedObject);
 		} catch (Exception e) {
 			fail("Cannot invoke public static method");

 		}

 		// Protected method
 		try {
 			assertEquals(testResource, ReflectUtil.invokeMethod(testResourceSet, "getContextResourceScopes", platform));
 		} catch (Exception e) {
 			if (e instanceof IllegalAccessException) {
 				flag = true;
 			} else {
 				message = "Thrown exception is: " + e.getClass() + ":" + e.getMessage() + " instead of IllegalAccessException";
 			}
 		}
 		assertTrue(message, flag);

 		// Un_existing method
 		flag = false;
 		try {
 			ReflectUtil.invokeMethod(testResourceSet, "getContextResourceSet", platform);
 		} catch (Exception e) {
 			if (e instanceof NoSuchMethodException) {
 				flag = true;
 			} else {
 				message = "Thrown exception is: " + e.getClass() + ":" + e.getMessage() + " instead of NoSuchMethodException";
 			}
 		}
 		assertTrue(message, flag);
 		flag = false;
 		try {
 			ReflectUtil.invokeMethod(testResourceSet, "getEObject", platform, true);
 		} catch (Exception e) {
 			if (e instanceof NoSuchMethodException) {
 				flag = true;
 			} else {
 				message = "Thrown exception is: " + e.getClass() + ":" + e.getMessage() + " instead of NoSuchMethodException";
 			}
 		}

 		assertTrue(message, flag);
 		flag = false;
 		try {
 			ReflectUtil.invokeMethod(testResourceSet, "getEObject", platform);
 		} catch (Exception e) {
 			if (e instanceof NoSuchMethodException) {
 				flag = true;
 			} else {
 				message = "Thrown exception is: " + e.getClass() + ":" + e.getMessage() + " instead of NoSuchMethodException";
 			}
 		}
 		assertTrue(message, flag);
 	}

 	/**
 	 * Test method for {@link ReflectUtil#invokeInvisibleMethod(Object, String, Object...)}
 	 */
 	public void testInvokeInvisibleMethod() throws Exception {
 		Platform platform = createPlatform();

 		ResourceSet testResourceSet = new ResourceSetImpl();
 		Resource testResource = testResourceSet.createResource(URI.createURI("newResource.xml"));
 		testResource.getContents().add(platform);

 		// Non static method
 		// --protected method
 		FileNotFoundException testIOException = new FileNotFoundException("testIOException");
 		try {
 			ReflectUtil.invokeInvisibleMethod(testResourceSet, "handleDemandLoadException", testResource, testIOException);
 		} catch (InvocationTargetException ite) {
 			assertSame(ite.getTargetException().getCause(), testIOException);
 		} catch (Exception e) {
 			fail("Cannot invoke non-static private method " + e.getLocalizedMessage());
 		}
 		assertEquals(1, testResource.getErrors().size());
 		Diagnostic diagnostic = testResource.getErrors().get(0);
 		assertTrue(diagnostic instanceof WrappedException);
 		assertSame(testIOException, ((WrappedException) diagnostic).getCause());

 		// -- private method
 		try {
 			assertTrue(ReflectUtil.invokeInvisibleMethod(this, "createPlatform") instanceof Platform);
 		} catch (Exception e) {

 			fail("Cannot invoke non-static private method " + e.getLocalizedMessage());
 		}

 		// Static method
 		// -- protected static
 		try {

 			assertEquals(Data.proSField, ReflectUtil.invokeInvisibleMethod(Data.class, "proctectedStaticMethod"));
 		} catch (Exception e) {

 			fail("Cannot invoke proctected static method " + e.getLocalizedMessage());
 		}
 		// --private static
 		try {

 			assertEquals(Data.getPrisfield(), ReflectUtil.invokeInvisibleMethod(Data.class, "privateStaticMethod"));
 		} catch (Exception e) {

 			fail("Cannot invoke private static  method " + e.getLocalizedMessage());
 		}
 		// Un_existing method
 		boolean flag = false;
 		try {
 			ReflectUtil.invokeInvisibleMethod(Resource.class, "getContextResourceSet", platform);
 		} catch (NoSuchMethodException e) {
 			flag = true;
 		}
 		String message = "Did not throw NoSuchMethodException when the given method is not exist";
 		assertTrue(message, flag);

 		// Visible method
 		flag = false;
 		message = "";
 		try {
 			assertSame(platform, ReflectUtil.invokeInvisibleMethod(testResourceSet, "getEObject", EcoreUtil.getURI(platform), true));

 		} catch (Exception e) {
 			fail(e.getLocalizedMessage());
 		}
 	}

 	/**
 	 * Test method for {@link ReflectUtil#findDeclaredField(Class, String)}
 	 */
 	public void testFindDeclaredField() {
 		assertNull(ReflectUtil.findDeclaredField(Platform.class, "name"));
 		assertNull(ReflectUtil.findDeclaredField(PlatformImpl.class, "name"));

 		assertNull(ReflectUtil.findDeclaredField(Platform.class, "interfaces"));
 		assertNotNull(ReflectUtil.findDeclaredField(PlatformImpl.class, "interfaces"));
 		assertNotNull(ReflectUtil.findDeclaredField(PlatformImpl.class, "componentTypes"));
 		assertNull(ReflectUtil.findDeclaredField(PlatformImpl.class, "componentType"));
 	}

 	/**
 	 * Test method for {@link ReflectUtil#findField(Class, String)}
 	 */
 	public void testFindField() {
 		assertNull(ReflectUtil.findField(Platform.class, "name"));
 		assertNotNull(ReflectUtil.findField(PlatformImpl.class, "name"));

 		assertNotNull(ReflectUtil.findField(PlatformImpl.class, "interfaces"));
 		assertNotNull(ReflectUtil.findField(PlatformImpl.class, "componentTypes"));
 		assertNull(ReflectUtil.findField(PlatformImpl.class, "ShortName"));

 	}

 	/**
 	 * Test method for {@link ReflectUtil#findDeclaredMethod(Class, String, Class...)}
 	 *
 	 * @throws Exception
 	 */
 	public void testFindDeclaredMethod() throws Exception {
 		assertNull(ReflectUtil.findDeclaredMethod(Platform.class, "getName"));
 		assertNull(ReflectUtil.findDeclaredMethod(PlatformImpl.class, "getName"));

 		assertNotNull(ReflectUtil.findDeclaredMethod(Platform.class, "getComponentTypes"));
 		assertNotNull(ReflectUtil.findDeclaredMethod(PlatformImpl.class, "getComponentTypes"));
 		assertNotNull(ReflectUtil.findDeclaredMethod(Platform.class, "getInterfaces"));
 		assertNull(ReflectUtil.findDeclaredMethod(Platform.class, "getInter"));
 	}

 	/**
 	 * Test method for {@link ReflectUtil#findMethod(Class, String, Class...)}
 	 *
 	 * @throws Exception
 	 */
 	public void testFindMethod() throws Exception {
 		// Overloading
 		// loadProject(IProject project, boolean includeReferencedProjects, boolean async, IProgressMonitor monitor)

 		assertNull(
 				ReflectUtil.findMethod(IModelLoadManager.class, "LoadProject", IProject.class, boolean.class, boolean.class, IProgressMonitor.class));
 		assertNull(ReflectUtil.findMethod(IModelLoadManager.class, "loadProject", IProject.class));
 		assertNull(ReflectUtil.findMethod(IModelLoadManager.class, "loadProject", IProject.class, boolean.class, boolean.class, String.class));
 		assertNotNull(
 				ReflectUtil.findMethod(IModelLoadManager.class, "loadProject", IProject.class, boolean.class, boolean.class, IProgressMonitor.class));
 		assertEquals(4,
 				ReflectUtil.findMethod(IModelLoadManager.class, "loadProject", IProject.class, boolean.class, boolean.class, IProgressMonitor.class)
 						.getParameterTypes().length);

 		assertNotNull(ReflectUtil.findMethod(IModelLoadManager.class, "loadProject", IProject.class, boolean.class, IMetaModelDescriptor.class,
 				boolean.class, IProgressMonitor.class));
 		assertEquals(5, ReflectUtil.findMethod(IModelLoadManager.class, "loadProject", IProject.class, boolean.class, IMetaModelDescriptor.class,
 				boolean.class, IProgressMonitor.class).getParameterTypes().length);

 		// Interface
 		assertNotNull(ReflectUtil.findMethod(Platform.class, "getName"));
 		assertNotNull(ReflectUtil.findMethod(Platform.class, "getComponentTypes"));

 		assertNull(ReflectUtil.findMethod(Platform.class, "getShortName"));
 		// SuperClass
 		assertNotNull(ReflectUtil.findMethod(PlatformImpl.class, "getName"));

 		assertNull(ReflectUtil.findMethod(PlatformImpl.class, "eUnset"));
 		assertNotNull(ReflectUtil.findMethod(PlatformImpl.class, "eUnset", int.class));
 		assertNull(ReflectUtil.findMethod(PlatformImpl.class, "eUnset", int.class, String.class));
 	}

 }
	/**
	* <copyright>
	*
	* Copyright (c) 2008-2013 See4sys, itemis and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v2.0
	* which accompanies this distribution, and is available at
	* https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
	*
	* Contributors:
	* See4sys - Initial API and implementation
	* itemis - [409510] Enable resource scope-sensitive proxy resolutions without forcing metamodel implementations to subclass EObjectImpl
	* Siemens - [574930] Model load manager extension
	*
	* </copyright>
	*/
	package org.eclipse.sphinx.tests.platform.util;

	import java.io.FileNotFoundException;
	import java.lang.reflect.InvocationTargetException;

	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.Status;
	import org.eclipse.emf.common.util.URI;
	import org.eclipse.emf.common.util.WrappedException;
	import org.eclipse.emf.ecore.resource.Resource;
	import org.eclipse.emf.ecore.resource.Resource.Diagnostic;
	import org.eclipse.emf.ecore.resource.ResourceSet;
	import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
	import org.eclipse.emf.ecore.util.EcoreUtil;
	import org.eclipse.emf.validation.internal.util.DisabledConstraintStatus;
	import org.eclipse.emf.validation.model.ConstraintStatus;
	import org.eclipse.sphinx.emf.metamodel.IMetaModelDescriptor;
	import org.eclipse.sphinx.emf.resource.ScopingResourceSetImpl;
	import org.eclipse.sphinx.emf.workspace.loading.IModelLoadManager;
	import org.eclipse.sphinx.examples.hummingbird20.typemodel.ComponentType;
	import org.eclipse.sphinx.examples.hummingbird20.typemodel.Platform;
	import org.eclipse.sphinx.examples.hummingbird20.typemodel.Port;
	import org.eclipse.sphinx.examples.hummingbird20.typemodel.TypeModel20Factory;
	import org.eclipse.sphinx.examples.hummingbird20.typemodel.impl.PlatformImpl;
	import org.eclipse.sphinx.platform.stats.PerformanceStatsLog;
	import org.eclipse.sphinx.platform.util.ReflectUtil;

	import junit.framework.TestCase;

	@SuppressWarnings({ "nls", "restriction" })
	public class ReflectUtilTest extends TestCase {

	private Platform createPlatform() {
	Platform platform = TypeModel20Factory.eINSTANCE.createPlatform();
	platform.setName("Platform");

	org.eclipse.sphinx.examples.hummingbird20.typemodel.Interface interface1 = TypeModel20Factory.eINSTANCE.createInterface();
	interface1.setName("interface");
	platform.getInterfaces().add(interface1);

	ComponentType componentType = TypeModel20Factory.eINSTANCE.createComponentType();
	componentType.setName("ComponentType");
	platform.getComponentTypes().add(componentType);

	org.eclipse.sphinx.examples.hummingbird20.typemodel.Parameter param = TypeModel20Factory.eINSTANCE.createParameter();
	param.setName("param");
	param.setDataType("String");
	param.setOptional(true);
	componentType.getParameters().add(param);

	Port port = TypeModel20Factory.eINSTANCE.createPort();
	port.setName("port");
	port.setOwner(componentType);
	port.setMaxProviderCount(100);
	port.setMinProviderCount(10);
	port.setRequiredInterface(interface1);

	componentType.getPorts().add(port);
	return platform;

	}

	/**
	* Test method for (@link {@link ReflectUtil#getSimplePackageName(String)}
	*/
	public void testGetSimplePackageName() {

	String testQualifiedPackageName = "org.eclipse.sphinx.tests.platform.util";
	String simplePackageName = "util";

	assertEquals(simplePackageName, ReflectUtil.getSimplePackageName(testQualifiedPackageName));

	}

	/**
	* Test method for {@link ReflectUtil#getSuperPackageName(String)}
	*/
	public void testGetSuperPackageName() {
	String testQualifiedPackageName = "org.eclipse.sphinx.tests.platform.util";
	String superPackageName = "org.eclipse.sphinx.tests.platform";

	assertEquals(superPackageName, ReflectUtil.getSuperPackageName(testQualifiedPackageName));
	}

	/**
	* Test method for{@link ReflectUtil#isAssignableFrom(Class, String)}
	*/
	public void testIsAssignableFrom() {
	assertTrue(ReflectUtil.isAssignableFrom(int.class, "int"));
	assertFalse(ReflectUtil.isAssignableFrom(int.class, "Integer"));
	assertFalse(ReflectUtil.isAssignableFrom(Integer.class, "int"));
	assertTrue(ReflectUtil.isAssignableFrom(Status.class, "IStatus"));
	assertFalse(ReflectUtil.isAssignableFrom(IStatus.class, "IConstraintStatus"));
	assertTrue(ReflectUtil.isAssignableFrom(ConstraintStatus.class, "IStatus"));
	assertTrue(ReflectUtil.isAssignableFrom(ConstraintStatus.class, "IConstraintStatus"));
	assertTrue(ReflectUtil.isAssignableFrom(DisabledConstraintStatus.class, "ConstraintStatus"));
	assertTrue(ReflectUtil.isAssignableFrom(DisabledConstraintStatus.class, "IConstraintStatus"));
	assertFalse(ReflectUtil.isAssignableFrom(DisabledConstraintStatus.class, "IResourceStatus"));
	}

	/**
	* Test method for {@link ReflectUtil#clearAllFields(Object)}
	*/
	public void testClearAllFields_1() throws IllegalAccessException {
	Platform platform = createPlatform();
	assertFalse(platform.getComponentTypes().isEmpty());

	ComponentType componentType = platform.getComponentTypes().get(0);
	assertFalse(componentType.getPorts().isEmpty());

	Port port = componentType.getPorts().get(0);
	ReflectUtil.clearAllFields(port);

	assertNotNull(port);
	// Fields of super class
	assertNull(port.getName());

	// Fields of object class
	// Static/final field is not cleared
	assertNotNull(port.getMaxProviderCount());
	// Primitive field is not cleared
	assertNotNull(port.getMinProviderCount());

	assertNull(port.getRequiredInterface());

	}

	/**
	* Test method for {@link ReflectUtil#clearAllFields(Object, String[])}
	*
	* @throws IllegalAccessException
	*/
	public void testClearAllFields_2() throws IllegalAccessException {
	Platform platform = createPlatform();
	assertFalse(platform.getComponentTypes().isEmpty());

	ComponentType componentType = platform.getComponentTypes().get(0);
	assertFalse(componentType.getPorts().isEmpty());

	Port port = componentType.getPorts().get(0);
	ReflectUtil.clearAllFields(port, new String[] { "name" });

	assertNotNull(port);
	// Fields of super class in excluded list
	assertNotNull(port.getName());

	// Fields of object class
	// Static/final field is not cleared
	assertNotNull(port.getMaxProviderCount());
	// Primitive field is not cleared
	assertNotNull(port.getMinProviderCount());

	assertNull(port.getRequiredInterface());

	}

	/**
	* Test method for {@link ReflectUtil#getFieldValue(Object, String)}
	*/
	public void testGetFieldValue() {
	String publicValue = "publicValue";
	String protectedValue = "protectedValue";
	String privateValue = "privateValue";

	Data testData = new Data(publicValue, privateValue, protectedValue);

	// Non- static
	// Public field
	try {
	assertEquals("Got value is not the same with expected", publicValue, ReflectUtil.getFieldValue(testData, "publicField"));
	} catch (Exception e) {
	if (e instanceof IllegalAccessException) {
	fail("Cannot access to public field");
	} else if (e instanceof NoSuchFieldException) {
	fail("Cannot find to public field");

	} else {
	fail(e.getLocalizedMessage());
	}
	}
	try {
	assertNull(ReflectUtil.getFieldValue(Data.class, "publicField"));
	} catch (Exception e) {
	if (e instanceof IllegalAccessException) {
	fail("Cannot access to public field");
	} else if (e instanceof NoSuchFieldException) {
	fail("Cannot find to public field");
	} else if (!(e instanceof IllegalArgumentException)) {
	fail(e.getClass() + " " + e.getLocalizedMessage());
	}
	}
	// Protected Field
	try {
	assertEquals("Got value is not the same with expected", protectedValue, ReflectUtil.getFieldValue(testData, "protectedField"));
	} catch (Exception e) {
	if (!(e instanceof IllegalAccessException)) {
	fail("Did not throw IllegalAccessException when the given field is private or protected:\n " + "Threw: " + e.getClass() + " "
	+ e.getMessage());
	}
	}
	try {
	assertNull(ReflectUtil.getFieldValue(Data.class, "protectedField"));
	} catch (Exception e) {

	if (!(e instanceof IllegalAccessException \|\| e instanceof IllegalArgumentException)) {
	fail("Did not throw IllegalAccessException/IllegalArgumentException when get the given field is private or protected from class instead of object:\n "
	+ "Threw: " + e.getClass() + " " + e.getMessage());
	}
	}
	// Private field
	try {
	assertEquals(privateValue, ReflectUtil.getFieldValue(testData, "privateField"));
	} catch (Exception e) {
	if (!(e instanceof IllegalAccessException)) {
	fail("Did not throw IllegalAccessException when the given field is private or protected:\n " + "Threw: " + e.getClass() + " "
	+ e.getMessage());
	}
	}
	try {
	assertNull(ReflectUtil.getFieldValue(Data.class, "privateField"));
	} catch (Exception e) {
	if (!(e instanceof IllegalAccessException \|\| e instanceof IllegalArgumentException)) {
	fail("Did not throw IllegalAccessException/IllegalArgumentException when get the given field is private or protected from class instead of object:\n "
	+ "Threw: " + e.getClass() + " " + e.getMessage());
	}
	}
	// Static Field
	// -- visible field
	try {
	assertEquals(Data.pubSField, ReflectUtil.getFieldValue(Data.class, "pubSField"));
	} catch (Exception e) {
	fail("Cannot get public static field: " + e.getLocalizedMessage());
	}
	// --invisible field
	try {
	assertEquals(Data.proSField, ReflectUtil.getFieldValue(Data.class, "proSField"));
	} catch (Exception e) {
	if (!(e instanceof IllegalAccessException)) {

	fail("Throw " + e.getClass().toString() + "-Did not throw IllegalAccessException when the given field is private or protectedt");
	}
	}

	try {
	assertEquals(Data.getPrisfield(), ReflectUtil.getFieldValue(Data.class, "priSField"));
	} catch (Exception e) {
	if (!(e instanceof IllegalAccessException)) {
	fail("Throw " + e.getClass().toString() + "-Did not throw IllegalAccessException when the given field is private or protectedt");
	}
	}

	// Un_existing Field
	try {
	ReflectUtil.getFieldValue(testData, "unexistingField");
	} catch (Exception e) {
	if (!(e instanceof NoSuchFieldException)) {
	fail("Throw " + e.getClass().toString() + "-Did not throw NoSuchFieldException when the given field is not exit");
	}
	}

	}

	/**
	* Test method for {@link ReflectUtil#getInvisibleFieldValue(Object, String)}
	*
	* @throws IllegalAccessException
	* @throws NoSuchFieldException
	* @throws IllegalArgumentException
	*/
	public void testGetInvisibleFieldValue() throws Exception {
	String publicValue = "publicValue";
	String protectedValue = "protectedValue";
	String privateValue = "privateValue";

	Data testData = new Data(publicValue, privateValue, protectedValue);

	// Non static field
	// --Non-static private field
	try {
	assertEquals("Return values are not equal", testData.getPrivateField(), ReflectUtil.getInvisibleFieldValue(testData, "privateField"));
	} catch (Exception e) {
	if (e instanceof IllegalAccessException) {
	fail("Cannot access non -static protected field");
	}
	}
	// -- Non-static protected field
	// -in different package
	try {
	assertEquals(true, ReflectUtil.getInvisibleFieldValue(PerformanceStatsLog.class, "consoleLog"));
	} catch (Exception e) {
	if (e instanceof IllegalAccessException) {
	fail("Cannot access non -static protected field");
	}
	}
	// in the same package
	try {
	assertEquals(testData.protectedField, ReflectUtil.getInvisibleFieldValue(testData, "protected field"));
	} catch (Exception e) {
	if (e instanceof IllegalAccessException) {
	fail("Cannot access non -static protected field");
	}
	}
	// Static field
	// --Static protected field
	// in the same package
	try {
	assertEquals(Data.proSField, ReflectUtil.getInvisibleFieldValue(Data.class, "proSField"));
	} catch (Exception e) {
	if (e instanceof IllegalAccessException) {
	fail("Cannot access static protected field");
	}
	}
	// in different package
	try {
	assertEquals("!STACK", ReflectUtil.getInvisibleFieldValue(PerformanceStatsLog.class, "STACK"));
	} catch (Exception e) {
	if (e instanceof IllegalAccessException) {
	fail("Cannot access static protected field");
	}
	}
	// --Static private field
	try {
	assertEquals(Data.getPrisfield(), ReflectUtil.getInvisibleFieldValue(Data.class, "priSField"));
	} catch (Exception e) {
	if (e instanceof IllegalAccessException) {
	fail("Cannot access static private field");
	}
	}

	// Given field is not exist
	try {
	ReflectUtil.getInvisibleFieldValue(Data.class, "priField");
	} catch (Exception e) {
	if (!(e instanceof NoSuchFieldException)) {
	fail("Don't throw NoSuchFiledException when getting unexsitingField\nThrew " + e.getClass() + " " + e.getLocalizedMessage());
	}
	}
	}

	/**
	* Test method for {@link ReflectUtil#invokeMethod(Object, String, Object...)}
	*/
	public void testInvokeMethod() {
	Platform platform = createPlatform();
	String expectedPlatformName = platform.getName();

	ResourceSet testResourceSet = new ScopingResourceSetImpl();
	Resource testResource = testResourceSet.createResource(URI.createURI("newResource.xml"));
	testResource.getContents().add(platform);

	// Non static public method
	boolean flag = false;
	String message = "";
	try {
	assertSame(expectedPlatformName, ReflectUtil.invokeMethod(platform, "getName"));

	} catch (Exception e) {
	fail(e.getLocalizedMessage());
	}
	// public static method
	try {
	Object copiedObject = ReflectUtil.invokeMethod(EcoreUtil.class, "copy", platform);
	assertNotNull(copiedObject);
	} catch (Exception e) {
	fail("Cannot invoke public static method");

	}

	// Protected method
	try {
	assertEquals(testResource, ReflectUtil.invokeMethod(testResourceSet, "getContextResourceScopes", platform));
	} catch (Exception e) {
	if (e instanceof IllegalAccessException) {
	flag = true;
	} else {
	message = "Thrown exception is: " + e.getClass() + ":" + e.getMessage() + " instead of IllegalAccessException";
	}
	}
	assertTrue(message, flag);

	// Un_existing method
	flag = false;
	try {
	ReflectUtil.invokeMethod(testResourceSet, "getContextResourceSet", platform);
	} catch (Exception e) {
	if (e instanceof NoSuchMethodException) {
	flag = true;
	} else {
	message = "Thrown exception is: " + e.getClass() + ":" + e.getMessage() + " instead of NoSuchMethodException";
	}
	}
	assertTrue(message, flag);
	flag = false;
	try {
	ReflectUtil.invokeMethod(testResourceSet, "getEObject", platform, true);
	} catch (Exception e) {
	if (e instanceof NoSuchMethodException) {
	flag = true;
	} else {
	message = "Thrown exception is: " + e.getClass() + ":" + e.getMessage() + " instead of NoSuchMethodException";
	}
	}

	assertTrue(message, flag);
	flag = false;
	try {
	ReflectUtil.invokeMethod(testResourceSet, "getEObject", platform);
	} catch (Exception e) {
	if (e instanceof NoSuchMethodException) {
	flag = true;
	} else {
	message = "Thrown exception is: " + e.getClass() + ":" + e.getMessage() + " instead of NoSuchMethodException";
	}
	}
	assertTrue(message, flag);
	}

	/**
	* Test method for {@link ReflectUtil#invokeInvisibleMethod(Object, String, Object...)}
	*/
	public void testInvokeInvisibleMethod() throws Exception {
	Platform platform = createPlatform();

	ResourceSet testResourceSet = new ResourceSetImpl();
	Resource testResource = testResourceSet.createResource(URI.createURI("newResource.xml"));
	testResource.getContents().add(platform);

	// Non static method
	// --protected method
	FileNotFoundException testIOException = new FileNotFoundException("testIOException");
	try {
	ReflectUtil.invokeInvisibleMethod(testResourceSet, "handleDemandLoadException", testResource, testIOException);
	} catch (InvocationTargetException ite) {
	assertSame(ite.getTargetException().getCause(), testIOException);
	} catch (Exception e) {
	fail("Cannot invoke non-static private method " + e.getLocalizedMessage());
	}
	assertEquals(1, testResource.getErrors().size());
	Diagnostic diagnostic = testResource.getErrors().get(0);
	assertTrue(diagnostic instanceof WrappedException);
	assertSame(testIOException, ((WrappedException) diagnostic).getCause());

	// -- private method
	try {
	assertTrue(ReflectUtil.invokeInvisibleMethod(this, "createPlatform") instanceof Platform);
	} catch (Exception e) {

	fail("Cannot invoke non-static private method " + e.getLocalizedMessage());
	}

	// Static method
	// -- protected static
	try {

	assertEquals(Data.proSField, ReflectUtil.invokeInvisibleMethod(Data.class, "proctectedStaticMethod"));
	} catch (Exception e) {

	fail("Cannot invoke proctected static method " + e.getLocalizedMessage());
	}
	// --private static
	try {

	assertEquals(Data.getPrisfield(), ReflectUtil.invokeInvisibleMethod(Data.class, "privateStaticMethod"));
	} catch (Exception e) {

	fail("Cannot invoke private static method " + e.getLocalizedMessage());
	}
	// Un_existing method
	boolean flag = false;
	try {
	ReflectUtil.invokeInvisibleMethod(Resource.class, "getContextResourceSet", platform);
	} catch (NoSuchMethodException e) {
	flag = true;
	}
	String message = "Did not throw NoSuchMethodException when the given method is not exist";
	assertTrue(message, flag);

	// Visible method
	flag = false;
	message = "";
	try {
	assertSame(platform, ReflectUtil.invokeInvisibleMethod(testResourceSet, "getEObject", EcoreUtil.getURI(platform), true));

	} catch (Exception e) {
	fail(e.getLocalizedMessage());
	}
	}

	/**
	* Test method for {@link ReflectUtil#findDeclaredField(Class, String)}
	*/
	public void testFindDeclaredField() {
	assertNull(ReflectUtil.findDeclaredField(Platform.class, "name"));
	assertNull(ReflectUtil.findDeclaredField(PlatformImpl.class, "name"));

	assertNull(ReflectUtil.findDeclaredField(Platform.class, "interfaces"));
	assertNotNull(ReflectUtil.findDeclaredField(PlatformImpl.class, "interfaces"));
	assertNotNull(ReflectUtil.findDeclaredField(PlatformImpl.class, "componentTypes"));
	assertNull(ReflectUtil.findDeclaredField(PlatformImpl.class, "componentType"));
	}

	/**
	* Test method for {@link ReflectUtil#findField(Class, String)}
	*/
	public void testFindField() {
	assertNull(ReflectUtil.findField(Platform.class, "name"));
	assertNotNull(ReflectUtil.findField(PlatformImpl.class, "name"));

	assertNotNull(ReflectUtil.findField(PlatformImpl.class, "interfaces"));
	assertNotNull(ReflectUtil.findField(PlatformImpl.class, "componentTypes"));
	assertNull(ReflectUtil.findField(PlatformImpl.class, "ShortName"));

	}

	/**
	* Test method for {@link ReflectUtil#findDeclaredMethod(Class, String, Class...)}
	*
	* @throws Exception
	*/
	public void testFindDeclaredMethod() throws Exception {
	assertNull(ReflectUtil.findDeclaredMethod(Platform.class, "getName"));
	assertNull(ReflectUtil.findDeclaredMethod(PlatformImpl.class, "getName"));

	assertNotNull(ReflectUtil.findDeclaredMethod(Platform.class, "getComponentTypes"));
	assertNotNull(ReflectUtil.findDeclaredMethod(PlatformImpl.class, "getComponentTypes"));
	assertNotNull(ReflectUtil.findDeclaredMethod(Platform.class, "getInterfaces"));
	assertNull(ReflectUtil.findDeclaredMethod(Platform.class, "getInter"));
	}

	/**
	* Test method for {@link ReflectUtil#findMethod(Class, String, Class...)}
	*
	* @throws Exception
	*/
	public void testFindMethod() throws Exception {
	// Overloading
	// loadProject(IProject project, boolean includeReferencedProjects, boolean async, IProgressMonitor monitor)

	assertNull(
	ReflectUtil.findMethod(IModelLoadManager.class, "LoadProject", IProject.class, boolean.class, boolean.class, IProgressMonitor.class));
	assertNull(ReflectUtil.findMethod(IModelLoadManager.class, "loadProject", IProject.class));
	assertNull(ReflectUtil.findMethod(IModelLoadManager.class, "loadProject", IProject.class, boolean.class, boolean.class, String.class));
	assertNotNull(
	ReflectUtil.findMethod(IModelLoadManager.class, "loadProject", IProject.class, boolean.class, boolean.class, IProgressMonitor.class));
	assertEquals(4,
	ReflectUtil.findMethod(IModelLoadManager.class, "loadProject", IProject.class, boolean.class, boolean.class, IProgressMonitor.class)
	.getParameterTypes().length);

	assertNotNull(ReflectUtil.findMethod(IModelLoadManager.class, "loadProject", IProject.class, boolean.class, IMetaModelDescriptor.class,
	boolean.class, IProgressMonitor.class));
	assertEquals(5, ReflectUtil.findMethod(IModelLoadManager.class, "loadProject", IProject.class, boolean.class, IMetaModelDescriptor.class,
	boolean.class, IProgressMonitor.class).getParameterTypes().length);

	// Interface
	assertNotNull(ReflectUtil.findMethod(Platform.class, "getName"));
	assertNotNull(ReflectUtil.findMethod(Platform.class, "getComponentTypes"));

	assertNull(ReflectUtil.findMethod(Platform.class, "getShortName"));
	// SuperClass
	assertNotNull(ReflectUtil.findMethod(PlatformImpl.class, "getName"));

	assertNull(ReflectUtil.findMethod(PlatformImpl.class, "eUnset"));
	assertNotNull(ReflectUtil.findMethod(PlatformImpl.class, "eUnset", int.class));
	assertNull(ReflectUtil.findMethod(PlatformImpl.class, "eUnset", int.class, String.class));
	}

	}