/**
 *******************************************************************************
 * Copyright (C) 2001-2002, International Business Machines Corporation and    *
 * others. All Rights Reserved.                                                *
 *******************************************************************************
 *
 * $Source: /xsrl/Nsvn/icu/icu4j/src/com/ibm/icu/dev/test/ModuleTest.java,v $
 * $Date: 2002/08/31 04:55:10 $
 * $Revision: 1.3 $
 *
 *******************************************************************************
 */
package com.ibm.icu.dev.test;

import java.lang.reflect.Method;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import com.ibm.icu.dev.test.TestDataModule.TestData;
import com.ibm.icu.dev.test.TestDataModule.DataMap;

/**
 * A convenience extension of TestFmwk for use by data module-driven
 * tests.  Tests can implement this if they make extensive use of
 * information in a TestDataModule.  The module should be openable
 * using TestDataModule.open() passing in the class name of this test
 * + "Data".  For example, a test named MyTest would have a module
 * named MyTestData.  Each test method should also have a
 * corresponding test data in the module whose name matches the test
 * method name.
 *
 * Subclasses can allow for test methods that don't use data from the
 * modeul by overriding validateMethod to return true for these
 * methods.  Tests are also free to instantiate their own modules and
 * run from them, though care should be taken not to interfere with
 * the methods in this class.
 *
 * See ModuleTestSample for an example.  */
public class ModuleTest extends TestFmwk {
    private TestDataModule m;
    private TestData t;
    private String methodName;

    protected ModuleTest() {
        this(null);
    }

    /**
     * Pass the name of a public no-arg method in this class if 
     * you want use that method to run all the tests off the
     * data, otherwise pass null for the typical test behavior.
     */
    protected ModuleTest(String methodName) {
        this.methodName = methodName;
    }

    /**
     * Subclasses access this after calling nextSettings and getting
     * a true result.
     */
    protected DataMap settings;

    /**
     * Subclasses access this after calling nextCase and getting a
     * true result.
     */
    protected DataMap testcase;

    /*
     * If we were initialized with the name of a method to run the
     * data driven tests, drive tests off the data using that method.
     */
    protected Map getAvailableTests() {
        if (methodName != null) {
            List list = getModuleNames();

            if (list != null) {
                Map map = new HashMap(list.size());
                addNamedMethodToMap(list, methodName, map);
                return map;
            }
            return Collections.EMPTY_MAP;
        } else {
            return super.getAvailableTests();
        }
    }

    /**
     * TestFmwk calls this before trying to run a suite of tests.
     * The test suite if valid if a module whose name is the name of
     * this class + "Data" can be opened.  Subclasses can override
     * this if there are different or additional data required.  
     */
    protected boolean validate() {
        return openModule(getClass().getName()+"Data");
    }

    /**
     * TestFmwk calls this before trying to invoke a test method.
     * The method is valid if there is test data with the name of this
     * method in the module.  Subclasses can override this to allow
     * for tests that do not require test data from the module, or
     * if there are different or additional data required.
     */
    protected boolean validateMethod(String methodName) {
	return openTestData(methodName);
    }

    /**
     * Override of TestFmwk method to get the test suite description
     * from the DESCRIPTION field of the module info.  
     */
    protected String getDescription() {
	DataMap info = moduleInfo();
	if (info != null) {
	    return info.getString(TestDataModule.DESCRIPTION);
	}
	return null;
    }

    /**
     * Override of TestFmwk method to get the test method description
     * from the DESCRIPTION field of the test info.  
     */
    protected String getMethodDescription(String methodName) {
	if (openTestData(methodName)) {
	    DataMap info = testInfo();
	    if (info != null) {
		return info.getString(TestDataModule.DESCRIPTION);
	    }
	}
	return null;
    }

    /**
     * Opens the module with the given name, and return true if success.
     * All contents are reset.
     */
    protected boolean openModule(String name) {
	t = null;
	m = TestDataModule.open(name, this);
	return m != null;
    }

    /**
     * Open the test data in the module with the given name, and return
     * true if success.  The current test is reset.
     */
    protected boolean openTestData(String name) {
	t = m == null ? null : m.createTestData(name);
	return t != null;
    }

    /**
     * Return an unmodifiable List of the names of all the tests in the module.
     */
    protected List getModuleNames() {
        if (validate()) {
            return m.getTestDataNames();
        }
        return null;
    }

    /**
     * Utility that associates a public named function in this class
     * with all the names in the provided Set.  The function should be
     * public and take no parameters (like a TestXXX method). You can
     * use this to override getAvailableTests from TestFmwk, which by
     * default associates the names  TestXXX or testXXX with
     * the corresponding methods in the class.  ModuleTests may wish
     * to use a single method to drive all the tests in the module.
     *
     * @param names the names to associated with the named method.
     * @param methodName the name of the method in this class to associate with names
     * @param dest the map to hold the name->method mapping 
     */
    protected void addNamedMethodToMap(List names, String methodName, Map dest) {
        try {
            Method method = getClass().getMethod(methodName, null);
            Iterator i = names.iterator();
            while (i.hasNext()) {
                dest.put(i.next(), method);
            }
        }
        catch (Exception e) {
            throw new InternalError(e.getMessage());
        }
    }
    
    /**
     * Get information on this module.  Returns null if no module
     * open or no info for the module.
     */
    protected DataMap moduleInfo() {
	return m == null ? null : m.getInfo();
    }

    /**
     * Get information on this test.  Returns null if no module
     * open or no test open or not info for this test.
     */
    protected DataMap testInfo() {
	return t == null ? null : t.getInfo();
    }

    /**
     * Advance test to the next settings, and return true if 
     * there are more settings.  The protected member variable
     * 'settings' holds the new settings data.
     */
    protected boolean nextSettings() {
	settings = t == null ? null : t.nextSettings();
	return settings != null;
    }

    /**
     * Advance test to the next case, and return true if there
     * is another case.  The protected member variable
     * 'testcase' holds the new case data.
     */
    protected boolean nextCase() {
	testcase = t == null ? null : t.nextCase();
	return testcase != null;
    }

    /**
     * Report an error, and stop iteration of the current test.
     */
    public void err(String message) {
	if (t != null) {
	    t.stopIteration();
	}
	super.err(message);
    }

    /**
     * Report an error, and stop iteration of the current test.
     */
    public void errln(String message) {
	if (t != null) {
	    t.stopIteration();
	}
	super.errln(message);
    }
}