tests/org.eclipse.gmf.tests/src/org/eclipse/gmf/tests/Configurator.java

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

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;

import org.junit.Assert;
import junit.framework.TestCase;
import junit.framework.TestSuite;

/**
 * The idea is to minimize number of static fields throughout tests; 
 * to keep tests configuration externally to tests themselves;
 * to allow reuse of single setup instance in partial rerun of few tests
 * @author artem
 */
public class Configurator {
	
	private final Map<Class<? extends TestCase>, Class<? extends TestConfiguration>> config;
	private final Map<Class<? extends TestConfiguration>, TestConfiguration> state;
	// tests from single TestCase usually run sequentially, and never mix with other 
	// TestCases, hence enough to cache only one class/set of methods  
	private Class<?> lastSetupLookupTarget;
	private Method[] lastSetupLookupResult;
	
	
	public Configurator() {
		config = new HashMap<Class<? extends TestCase>, Class<? extends TestConfiguration>>();
		state = new HashMap<Class<? extends TestConfiguration>, TestConfiguration>();
	}
	
	public void dispose() {
		config.clear();
		state.clear();
	}

	// configuration instance would get created on demand
	public void register(Class<? extends TestCase> target, Class<? extends TestConfiguration> configClass) {
		config.put(target, configClass);
	}

	// supplied configuration instance would be used. useful when instance initialization takes extra steps
	// and/or should be done in advance (i.e. before running any test)
	public void register(Class<? extends TestCase> target, TestConfiguration configInstance) {
		Class<? extends TestConfiguration> configClass = configInstance.getClass();
		register(target, configClass);
		registerInstance(configClass, configInstance);
	}

	// 
	public void registerInstance(Class<? extends TestConfiguration> configClass, TestConfiguration configInstance) {
		state.put(configClass, configInstance);
	}

	// potentially may provide different configuration per separate test, although we don't use this now
	private TestConfiguration getConfig(Class<? extends TestCase> target, String testName, boolean instantiate) {
		Class<? extends TestConfiguration> configClass = config.get(target);
		if (configClass == null) {
			return null;
		}
		TestConfiguration configInstance = state.get(configClass);
		if (configInstance == null && instantiate) {
			configInstance = newInstance(configClass);
			state.put(configClass, configInstance); // may be null
		}
		return configInstance;
	}
	
	private TestConfiguration newInstance(Class<? extends TestConfiguration> configClass) {
		// in fact, getMethods may lead to troubles if we have subclasses of TestConfiguration with
		// few newInstance methods, and we pick the one from superclass first. To fix, need to iterate over
		// subclasses manually, but too lazy now.
		for (Method m : configClass.getMethods()) {
			if (Modifier.isStatic(m.getModifiers()) && m.getAnnotation(TestConfiguration.FactoryMethod.class) != null) {
				if (configClass.isAssignableFrom(m.getReturnType())) {
					try {
						// null is ok, client's troubles then
						return (TestConfiguration) m.invoke(null);
					} catch (Exception ex) {
						ex.printStackTrace();
						// FALL-THROUGH - fail
					}
				}
				Assert.fail("Bad factory method: " + m);
				assert false; // should not ever get here
			}
		}
		Assert.fail("Can't find factory method in " + configClass);
		return null;
	}

	// instance method just to allow caching
	private Method[] getSetupMethods(Class<?> target) {
		if (lastSetupLookupTarget == target) {
			return lastSetupLookupResult;
		}
		
		lastSetupLookupTarget = target;
		lastSetupLookupResult = findSetupMethods(target);
		return lastSetupLookupResult;
	}

	private static Method[] findSetupMethods(Class<?> target) {
		ArrayList<Method> setupMethods = new ArrayList<Method>(3);
		for (Method m : target.getMethods()) {
			// may use annotation arguments to denote different configure methods (e.g. taking more than one argument)
			if (m.getAnnotation(NeedsSetup.class) != null) {
				Class<?>[] parameterTypes = m.getParameterTypes();
				if (parameterTypes.length == 1 && TestConfiguration.class.isAssignableFrom(parameterTypes[0])) {
					setupMethods.add(m);
				} else {
					Assert.fail("Invalid test configuration method:" + m);
				}
			}
		}
		return setupMethods.toArray(new Method[setupMethods.size()]);
	}

	// calls back to initialize test with appropriate configuration object
	public void prepare(TestCase test) {
		Class<? extends TestCase> testClass = test.getClass();
		Method[] setupMethods = getSetupMethods(testClass);
		if (setupMethods.length == 0) {
			// fail? OTOH, test would fail itself if no expected setup would be supplied.
			// XXX seems reasonable to fail only in case of programming errors (e.g. incorrectly marked method)
			// and do not fail if none matching setups/methods found.
			return;
		}
		TestConfiguration config = getConfig(testClass, test.getName(), true);
		if (config == null) {
			return;
		}
		for (Method m : setupMethods) {
			// invoke all compatible setup methods, ignore those that not good.
			if (m.getParameterTypes()[0].isInstance(config)) {
				try {
					m.invoke(test, config);
				} catch (Exception ex) {
					// wrong configuration method IS programming error
					Assert.fail(ex.toString());
				}
			}
		}
	}

	public static TestSuite feed(Class<? extends TestCase> theClass, TestConfiguration config, String suiteName) {
		TestSuite suite = new TestSuite(theClass, suiteName);
		try {
			for (Method m : findSetupMethods(theClass)) {
				if (m.getParameterTypes()[0].isInstance(config)) {
					for (Enumeration<?> en = suite.tests(); en.hasMoreElements(); ) {
						Object nextTest = en.nextElement();
						m.invoke(nextTest, config);
					}
				}
			}
		} catch (Exception ex) {
			suite.addTest(new ConfigurationFailedCase(theClass.getName() + ": " + ex.getMessage(), ex));
		}
		return suite;
	}
}