org.eclipse.stem.tests.diseasemodels/src/org/eclipse/stem/diseasemodels/standard/tests/DiseaseModelScenarioTest.java - stem/org.eclipse.stem - Git at Google

 // DiseaseModelScenarioTest.java
 package org.eclipse.stem.diseasemodels.standard.tests;

 /*******************************************************************************
  * Copyright (c) 2006 IBM Corporation 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:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.StringTokenizer;

 import junit.framework.TestCase;

 import org.eclipse.emf.common.util.URI;
 import org.eclipse.stem.core.graph.Graph;
 import org.eclipse.stem.core.graph.LabelValue;
 import org.eclipse.stem.core.graph.NodeLabel;
 import org.eclipse.stem.core.model.Decorator;
 import org.eclipse.stem.core.model.Model;
 import org.eclipse.stem.core.model.NodeDecorator;
 import org.eclipse.stem.core.scenario.Scenario;
 import org.eclipse.stem.core.scenario.tests.ScenarioTest;
 import org.eclipse.stem.definitions.nodes.Region;
 import org.eclipse.stem.diseasemodels.standard.DiseaseModel;
 import org.eclipse.stem.diseasemodels.standard.DiseaseModelLabel;
 import org.eclipse.stem.diseasemodels.standard.DiseaseModelLabelValue;

 /**
  * This class is the top-level class for all test of disease models in a
  * particular scenario.
  */
 public abstract class DiseaseModelScenarioTest extends TestCase {

 	protected static final String DIRECTORY = "temp";

 	/**
 	 * The key for scenario 1x1
 	 */
 	public static final String TEST_SCENARIO1x1_KEY = "1x1";

 	/**
 	 * The key for scenario 1x2
 	 */
 	public static final String TEST_SCENARIO1x2_KEY = "1x2";

 	/**
 	 * The key for scenario 1x3
 	 */
 	public static final String TEST_SCENARIO1x3_KEY = "1x3";

 	/**
 	 * The key for scenario 2x2
 	 */
 	public static final String TEST_SCENARIO2x2_KEY = "2x2";

 	/**
 	 * The key for scenario 3x3
 	 */
 	public static final String TEST_SCENARIO3x3_KEY = "3x3";

 	// TODO implement the disease model test scenarios

 	// You need to un-comment the testSpecifications and then in each of the
 	// test implementations you're going to need to figure out the valid disease
 	// model label values. see StochasticSEIRScenarioTest.java etc.
 	protected static TestSpec[] testSpecifications = new TestSpec[] { new TestSpec(
 			1, 1, TEST_SCENARIO1x1_KEY)
 	/*
 	 * new TestSpec(1, 1, TEST_SCENARIO1x1_KEY), new TestSpec(1, 2,
 	 * TEST_SCENARIO1x2_KEY), new TestSpec(1, 3, TEST_SCENARIO1x3_KEY), new
 	 * TestSpec(2, 2, TEST_SCENARIO2x2_KEY), new TestSpec(3, 3,
 	 * TEST_SCENARIO3x3_KEY)
 	 */
 	};

 	/**
 	 * @param expectedLabelValues
 	 *            the expected label values for the test
 	 * @return how many labels are expected to be updated by a disease model for
 	 *         each test.
 	 */
 	protected static int computeExpectedNumberOfLabels(
 			final LabelValue[][][] expectedLabelValues) {
 		return expectedLabelValues[0].length * expectedLabelValues[0][0].length;
 	} // computeExpectedNumberOfLabels

 	/**
 	 * @param numRows
 	 *            the number of rows in the lattice
 	 * @param numColumns
 	 *            the number of columns in the lattice
 	 * @return a scenario with nodes in a lattice with a disease model.
 	 */
 	public Scenario createFixture(final int numRows, final int numColumns) {
 		final Collection<NodeDecorator> DISEASE_MODELS = new ArrayList<NodeDecorator>();
 		DISEASE_MODELS.addAll(getDiseaseModelsToTest());

 		final Model model = DiseaseModelTestUtil.createLatticeModel(
 				DISEASE_MODELS, numRows, numColumns,
 				DiseaseModelTestUtil.TEST_POPULATION_COUNT,
 				DiseaseModelTestUtil.TEST_AREA);

 		final Scenario retValue = DiseaseModelTestUtil.createLatticeScenario(
 				getScenarioDecorators(model), model);

 		assert retValue.sane();

 		return retValue;
 	} // createFixture

 	/**
 	 * Execute all of the tests specified in testSpecifications
 	 */
 	public void testDoAllTests() {
 		for (final TestSpec testSpec : testSpecifications) {
 			doTest(testSpec);
 		}
 	} // testDoAllTests

 	/**
 	 * Test serializing and de-serializing scenarios
 	 */
 	public void testSerializeDeserializeScenario() {

 		final int[][] rowColumns = new int[][] { { 1, 1 }, { 1, 2 }, { 3, 3 } };

 		for (final int[] rowColumn : rowColumns) {
 			final Scenario fixture = createFixture(rowColumn[0], rowColumn[1]);

 			final URI uri = createSerializationURI(fixture);
 			ScenarioTest.serializeDeserializeScenario(fixture, uri);
 		}
 	} // testSerializeDeserializeScenario

 	/**
 	 * @param testSpec
 	 *            a test specification
 	 */
 	private void doTest(final TestSpec testSpec) {
 		doTest(createFixture(testSpec.numRows, testSpec.numColumns),
 				testSpec.scenarioDiseaseKey);
 	} // doTest

 	/**
 	 * @param scenario
 	 *            the scenario to test
 	 * @param scenarioDiseaseKey
 	 *            the unique identifier of the scenario test
 	 */
 	private void doTest(final Scenario scenario, final String scenarioDiseaseKey) {

 		final int numSteps = getNumberOfSteps(scenarioDiseaseKey);

 		// Step through the disease computation by using the actual scenario
 		// step method
 		for (int step = 0; step < numSteps; step++) {
 			// Make one step...
 			scenario.step();
 			// ... and make sure everything looks ok
 			assertTrue(scenario.sane());

 			// Now validate the computed values for each disease model in the
 			// scenario...
 			for (final DiseaseModel diseaseModel : getDiseaseModels(scenario)) {
 				// Really only need to check this once...
 				if (step == 0) {
 					assertTrue(
 							"Disease model \""
 									+ diseaseModel.getDublinCore().getTitle()
 									+ "\" \""
 									+ scenario.getDublinCore().getTitle()
 									+ "\" \"" + scenarioDiseaseKey,
 							diseaseModel.getLabelsToUpdate().size() == getExpectedNumberOfLabelsToUpdate(scenarioDiseaseKey));
 				} // if

 				assertTrue(validateDiseaseModelState(scenario,
 						scenarioDiseaseKey, step, diseaseModel,
 						getExpectedDiseaseModelState(scenarioDiseaseKey, step)));

 			} // for each disease model
 		} // for each step

 	} // doTest

 	/**
 	 * @param scenario
 	 *            the scenario whose state is to be verified
 	 * @param scenarioDiseaseKey
 	 *            the unique identifier of the scenario test
 	 * @param step
 	 *            the step number in the test being verified
 	 * @param expectedDiseaseModelState
 	 *            the disease model label values that should be present
 	 */
 	private boolean validateDiseaseModelState(final Scenario scenario,
 			final String scenarioDiseaseKey, final int step,
 			final DiseaseModel diseaseModel,
 			final LabelValue[][] expectedDiseaseModelState) {
 		final boolean retValue = true;

 		final Graph canonicalGraph = scenario.getCanonicalGraph();

 		for (int row = 0; row < expectedDiseaseModelState.length; row++) {
 			for (int column = 0; column < expectedDiseaseModelState[row].length; column++) {
 				final Region region = DiseaseModelTestUtil.getRegion(
 						canonicalGraph, row, column);
 				final LabelValue labelValue = expectedDiseaseModelState[row][column];
 				final LabelValue dmLabelValue = getCurrentDiseaseModelLabelValue(
 						region, diseaseModel);
 				assertTrue("Disease model \""
 						+ diseaseModel.getDublinCore().getTitle() + "\" ("
 						+ scenarioDiseaseKey + ") step: " + step + " [" + row
 						+ ", " + column + "] Got \"" + dmLabelValue.toString()
 						+ "\", expected \"" + labelValue.toString() + "\"",
 						compareLabelValues(labelValue, dmLabelValue));
 			} // for column
 		} // for row

 		return retValue;
 	} // validateDiseaseModelState

 	/**
 	 * @param labelValue
 	 * @param dmLabelValue
 	 * @return <code>true</code> if the labels are "equal". We do a "fuzzy"
 	 *         compare on the double values. We declare them "equal" if they
 	 *         differ by less than a specified tolerance.
 	 */
 	protected boolean compareLabelValues(final LabelValue lableValue1,
 			final LabelValue lableValue2) {
 		boolean retValue = true;
 		final DiseaseModelLabelValue dmLV1 = (DiseaseModelLabelValue) lableValue1;
 		final DiseaseModelLabelValue dmLV2 = (DiseaseModelLabelValue) lableValue2;

 		retValue = retValue
 				&& DiseaseModelTestUtil.closeEnough(dmLV1.getDiseaseDeaths(),
 						dmLV2.getDiseaseDeaths());
 		return retValue;
 	} // compareLabelValues

 	/**
 	 * @param fixture
 	 *            the scenario to test
 	 * @return the URI to use to serialize and then de-serialize the scenario
 	 *         under test
 	 */
 	private URI createSerializationURI(final Scenario fixture) {
 		final URI uri = URI
 				.createURI(DIRECTORY + "/" + getDiseaseURIPrefix()
 						+ encodeTitle(fixture.getDublinCore().getTitle())
 						+ ".scenario");
 		return uri;
 	} // createSerializationURI

 	/**
 	 * @param title
 	 *            the title of a scenario
 	 * @return the title with all whitespace removed
 	 */
 	private String encodeTitle(final String title) {
 		final StringBuilder sb = new StringBuilder();
 		final StringTokenizer st = new StringTokenizer(title, ",.[] ");
 		while (st.hasMoreTokens()) {
 			sb.append(st.nextToken());
 		} // while
 		return sb.toString();
 	} // encodeTitle

 	/**
 	 * @param region
 	 *            the region node to search for a label updated by the disease
 	 *            model
 	 * @param diseaseModel
 	 *            the disease model
 	 * @return the current value of the label on the node updated by the disease
 	 *         model
 	 */
 	private LabelValue getCurrentDiseaseModelLabelValue(final Region region,
 			final DiseaseModel diseaseModel) {
 		LabelValue retValue = null;
 		for (final Object element : region.getLabels()) {
 			final NodeLabel nodeLabel = (NodeLabel) element;
 			if (nodeLabel instanceof DiseaseModelLabel) {
 				final DiseaseModelLabel diseaseModelLabel = (DiseaseModelLabel) nodeLabel;
 				// Is this label updated by the disease model?
 				if (diseaseModel.getLabelsToUpdate()
 						.contains(diseaseModelLabel)) {
 					// Yes
 					retValue = diseaseModelLabel.getCurrentValue();
 					break;
 				}
 			} // if
 		} // for each node label
 		return retValue;
 	} // getCurrentDiseaseModelLabelValue

 	/**
 	 *
 	 * @param scenario
 	 *            a scenario
 	 * @return all of the disease models in the scenario.
 	 */
 	protected List<DiseaseModel> getDiseaseModels(final Scenario scenario) {
 		final List<DiseaseModel> retValue = new ArrayList<DiseaseModel>();

 		for (final Object element : scenario.getCanonicalGraph()
 				.getDecorators()) {
 			final Decorator decorator = (Decorator) element;
 			if (decorator instanceof DiseaseModel) {
 				retValue.add((DiseaseModel) decorator);
 			}
 		} // for each decorator in the canonical graph
 		return retValue;
 	} // getDiseaseModel

 	/**
 	 * @param diseaseScenarioKey
 	 *            the key identifying the test
 	 * @return the number of disease model computations to execute for the test.
 	 */
 	protected abstract int getNumberOfSteps(final String diseaseScenarioKey);

 	/**
 	 * @param diseaseScenarioKey
 	 *            the key identifying the test
 	 * @return the expected number of labels a disease model will update
 	 */
 	protected abstract int getExpectedNumberOfLabelsToUpdate(
 			final String diseaseScenarioKey);

 	/**
 	 * @param diseaseScenarioKey
 	 *            identifier that uniquely identifies the combination of disease
 	 *            and scenario.
 	 * @param step
 	 *            the simulation step that has been completed.
 	 * @return an array of disease model label values that are the expected
 	 *         values after the given step of the simulation.
 	 */
 	protected abstract LabelValue[][] getExpectedDiseaseModelState(
 			final String diseaseScenarioKey, final int step);

 	/**
 	 * @return the disease models to be tested
 	 */
 	public abstract List<NodeDecorator> getDiseaseModelsToTest();

 	/**
 	 * @param model
 	 *            the model to generate scenario decorators for
 	 * @return the scenario decorators to include in a fixture
 	 */
 	public abstract Collection<Decorator> getScenarioDecorators(Model model);

 	/**
 	 * @return a string to be used in a URI to prefix the scenario files being
 	 *         serialized for a particular disease under test.
 	 */
 	protected abstract String getDiseaseURIPrefix();

 	/**
 	 * This class represents the parameters for the specification of a test
 	 */
 	protected static final class TestSpec {
 		/**
 		 * The number of rows in the lattice graph
 		 */
 		public int numRows = 0;

 		/**
 		 * The number of columns in the lattice graph
 		 */
 		public int numColumns = 0;

 		/**
 		 * The scenario/disease key of the test.
 		 */
 		public String scenarioDiseaseKey = "";

 		/**
 		 * @param numRows
 		 * @param numColumns
 		 * @param scenarioDiseaseKey
 		 */
 		protected TestSpec(final int numRows, final int numColumns,
 				final String scenarioDiseaseKey) {
 			super();
 			this.numRows = numRows;
 			this.numColumns = numColumns;
 			this.scenarioDiseaseKey = scenarioDiseaseKey;
 		}
 	} // TestSpec

 } // DiseaseModelScenarioTest
	// DiseaseModelScenarioTest.java
	package org.eclipse.stem.diseasemodels.standard.tests;

	/*******************************************************************************
	* Copyright (c) 2006 IBM Corporation 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:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/

	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.List;
	import java.util.StringTokenizer;

	import junit.framework.TestCase;

	import org.eclipse.emf.common.util.URI;
	import org.eclipse.stem.core.graph.Graph;
	import org.eclipse.stem.core.graph.LabelValue;
	import org.eclipse.stem.core.graph.NodeLabel;
	import org.eclipse.stem.core.model.Decorator;
	import org.eclipse.stem.core.model.Model;
	import org.eclipse.stem.core.model.NodeDecorator;
	import org.eclipse.stem.core.scenario.Scenario;
	import org.eclipse.stem.core.scenario.tests.ScenarioTest;
	import org.eclipse.stem.definitions.nodes.Region;
	import org.eclipse.stem.diseasemodels.standard.DiseaseModel;
	import org.eclipse.stem.diseasemodels.standard.DiseaseModelLabel;
	import org.eclipse.stem.diseasemodels.standard.DiseaseModelLabelValue;

	/**
	* This class is the top-level class for all test of disease models in a
	* particular scenario.
	*/
	public abstract class DiseaseModelScenarioTest extends TestCase {

	protected static final String DIRECTORY = "temp";

	/**
	* The key for scenario 1x1
	*/
	public static final String TEST_SCENARIO1x1_KEY = "1x1";

	/**
	* The key for scenario 1x2
	*/
	public static final String TEST_SCENARIO1x2_KEY = "1x2";

	/**
	* The key for scenario 1x3
	*/
	public static final String TEST_SCENARIO1x3_KEY = "1x3";

	/**
	* The key for scenario 2x2
	*/
	public static final String TEST_SCENARIO2x2_KEY = "2x2";

	/**
	* The key for scenario 3x3
	*/
	public static final String TEST_SCENARIO3x3_KEY = "3x3";

	// TODO implement the disease model test scenarios

	// You need to un-comment the testSpecifications and then in each of the
	// test implementations you're going to need to figure out the valid disease
	// model label values. see StochasticSEIRScenarioTest.java etc.
	protected static TestSpec[] testSpecifications = new TestSpec[] { new TestSpec(
	1, 1, TEST_SCENARIO1x1_KEY)
	/*
	* new TestSpec(1, 1, TEST_SCENARIO1x1_KEY), new TestSpec(1, 2,
	* TEST_SCENARIO1x2_KEY), new TestSpec(1, 3, TEST_SCENARIO1x3_KEY), new
	* TestSpec(2, 2, TEST_SCENARIO2x2_KEY), new TestSpec(3, 3,
	* TEST_SCENARIO3x3_KEY)
	*/
	};

	/**
	* @param expectedLabelValues
	* the expected label values for the test
	* @return how many labels are expected to be updated by a disease model for
	* each test.
	*/
	protected static int computeExpectedNumberOfLabels(
	final LabelValue[][][] expectedLabelValues) {
	return expectedLabelValues[0].length * expectedLabelValues[0][0].length;
	} // computeExpectedNumberOfLabels

	/**
	* @param numRows
	* the number of rows in the lattice
	* @param numColumns
	* the number of columns in the lattice
	* @return a scenario with nodes in a lattice with a disease model.
	*/
	public Scenario createFixture(final int numRows, final int numColumns) {
	final Collection<NodeDecorator> DISEASE_MODELS = new ArrayList<NodeDecorator>();
	DISEASE_MODELS.addAll(getDiseaseModelsToTest());

	final Model model = DiseaseModelTestUtil.createLatticeModel(
	DISEASE_MODELS, numRows, numColumns,
	DiseaseModelTestUtil.TEST_POPULATION_COUNT,
	DiseaseModelTestUtil.TEST_AREA);

	final Scenario retValue = DiseaseModelTestUtil.createLatticeScenario(
	getScenarioDecorators(model), model);

	assert retValue.sane();

	return retValue;
	} // createFixture

	/**
	* Execute all of the tests specified in testSpecifications
	*/
	public void testDoAllTests() {
	for (final TestSpec testSpec : testSpecifications) {
	doTest(testSpec);
	}
	} // testDoAllTests

	/**
	* Test serializing and de-serializing scenarios
	*/
	public void testSerializeDeserializeScenario() {

	final int[][] rowColumns = new int[][] { { 1, 1 }, { 1, 2 }, { 3, 3 } };

	for (final int[] rowColumn : rowColumns) {
	final Scenario fixture = createFixture(rowColumn[0], rowColumn[1]);

	final URI uri = createSerializationURI(fixture);
	ScenarioTest.serializeDeserializeScenario(fixture, uri);
	}
	} // testSerializeDeserializeScenario

	/**
	* @param testSpec
	* a test specification
	*/
	private void doTest(final TestSpec testSpec) {
	doTest(createFixture(testSpec.numRows, testSpec.numColumns),
	testSpec.scenarioDiseaseKey);
	} // doTest

	/**
	* @param scenario
	* the scenario to test
	* @param scenarioDiseaseKey
	* the unique identifier of the scenario test
	*/
	private void doTest(final Scenario scenario, final String scenarioDiseaseKey) {

	final int numSteps = getNumberOfSteps(scenarioDiseaseKey);

	// Step through the disease computation by using the actual scenario
	// step method
	for (int step = 0; step < numSteps; step++) {
	// Make one step...
	scenario.step();
	// ... and make sure everything looks ok
	assertTrue(scenario.sane());

	// Now validate the computed values for each disease model in the
	// scenario...
	for (final DiseaseModel diseaseModel : getDiseaseModels(scenario)) {
	// Really only need to check this once...
	if (step == 0) {
	assertTrue(
	"Disease model \""
	+ diseaseModel.getDublinCore().getTitle()
	+ "\" \""
	+ scenario.getDublinCore().getTitle()
	+ "\" \"" + scenarioDiseaseKey,
	diseaseModel.getLabelsToUpdate().size() == getExpectedNumberOfLabelsToUpdate(scenarioDiseaseKey));
	} // if

	assertTrue(validateDiseaseModelState(scenario,
	scenarioDiseaseKey, step, diseaseModel,
	getExpectedDiseaseModelState(scenarioDiseaseKey, step)));

	} // for each disease model
	} // for each step

	} // doTest

	/**
	* @param scenario
	* the scenario whose state is to be verified
	* @param scenarioDiseaseKey
	* the unique identifier of the scenario test
	* @param step
	* the step number in the test being verified
	* @param expectedDiseaseModelState
	* the disease model label values that should be present
	*/
	private boolean validateDiseaseModelState(final Scenario scenario,
	final String scenarioDiseaseKey, final int step,
	final DiseaseModel diseaseModel,
	final LabelValue[][] expectedDiseaseModelState) {
	final boolean retValue = true;

	final Graph canonicalGraph = scenario.getCanonicalGraph();

	for (int row = 0; row < expectedDiseaseModelState.length; row++) {
	for (int column = 0; column < expectedDiseaseModelState[row].length; column++) {
	final Region region = DiseaseModelTestUtil.getRegion(
	canonicalGraph, row, column);
	final LabelValue labelValue = expectedDiseaseModelState[row][column];
	final LabelValue dmLabelValue = getCurrentDiseaseModelLabelValue(
	region, diseaseModel);
	assertTrue("Disease model \""
	+ diseaseModel.getDublinCore().getTitle() + "\" ("
	+ scenarioDiseaseKey + ") step: " + step + " [" + row
	+ ", " + column + "] Got \"" + dmLabelValue.toString()
	+ "\", expected \"" + labelValue.toString() + "\"",
	compareLabelValues(labelValue, dmLabelValue));
	} // for column
	} // for row

	return retValue;
	} // validateDiseaseModelState

	/**
	* @param labelValue
	* @param dmLabelValue
	* @return <code>true</code> if the labels are "equal". We do a "fuzzy"
	* compare on the double values. We declare them "equal" if they
	* differ by less than a specified tolerance.
	*/
	protected boolean compareLabelValues(final LabelValue lableValue1,
	final LabelValue lableValue2) {
	boolean retValue = true;
	final DiseaseModelLabelValue dmLV1 = (DiseaseModelLabelValue) lableValue1;
	final DiseaseModelLabelValue dmLV2 = (DiseaseModelLabelValue) lableValue2;

	retValue = retValue
	&& DiseaseModelTestUtil.closeEnough(dmLV1.getDiseaseDeaths(),
	dmLV2.getDiseaseDeaths());
	return retValue;
	} // compareLabelValues

	/**
	* @param fixture
	* the scenario to test
	* @return the URI to use to serialize and then de-serialize the scenario
	* under test
	*/
	private URI createSerializationURI(final Scenario fixture) {
	final URI uri = URI
	.createURI(DIRECTORY + "/" + getDiseaseURIPrefix()
	+ encodeTitle(fixture.getDublinCore().getTitle())
	+ ".scenario");
	return uri;
	} // createSerializationURI

	/**
	* @param title
	* the title of a scenario
	* @return the title with all whitespace removed
	*/
	private String encodeTitle(final String title) {
	final StringBuilder sb = new StringBuilder();
	final StringTokenizer st = new StringTokenizer(title, ",.[] ");
	while (st.hasMoreTokens()) {
	sb.append(st.nextToken());
	} // while
	return sb.toString();
	} // encodeTitle

	/**
	* @param region
	* the region node to search for a label updated by the disease
	* model
	* @param diseaseModel
	* the disease model
	* @return the current value of the label on the node updated by the disease
	* model
	*/
	private LabelValue getCurrentDiseaseModelLabelValue(final Region region,
	final DiseaseModel diseaseModel) {
	LabelValue retValue = null;
	for (final Object element : region.getLabels()) {
	final NodeLabel nodeLabel = (NodeLabel) element;
	if (nodeLabel instanceof DiseaseModelLabel) {
	final DiseaseModelLabel diseaseModelLabel = (DiseaseModelLabel) nodeLabel;
	// Is this label updated by the disease model?
	if (diseaseModel.getLabelsToUpdate()
	.contains(diseaseModelLabel)) {
	// Yes
	retValue = diseaseModelLabel.getCurrentValue();
	break;
	}
	} // if
	} // for each node label
	return retValue;
	} // getCurrentDiseaseModelLabelValue

	/**
	*
	* @param scenario
	* a scenario
	* @return all of the disease models in the scenario.
	*/
	protected List<DiseaseModel> getDiseaseModels(final Scenario scenario) {
	final List<DiseaseModel> retValue = new ArrayList<DiseaseModel>();

	for (final Object element : scenario.getCanonicalGraph()
	.getDecorators()) {
	final Decorator decorator = (Decorator) element;
	if (decorator instanceof DiseaseModel) {
	retValue.add((DiseaseModel) decorator);
	}
	} // for each decorator in the canonical graph
	return retValue;
	} // getDiseaseModel

	/**
	* @param diseaseScenarioKey
	* the key identifying the test
	* @return the number of disease model computations to execute for the test.
	*/
	protected abstract int getNumberOfSteps(final String diseaseScenarioKey);

	/**
	* @param diseaseScenarioKey
	* the key identifying the test
	* @return the expected number of labels a disease model will update
	*/
	protected abstract int getExpectedNumberOfLabelsToUpdate(
	final String diseaseScenarioKey);

	/**
	* @param diseaseScenarioKey
	* identifier that uniquely identifies the combination of disease
	* and scenario.
	* @param step
	* the simulation step that has been completed.
	* @return an array of disease model label values that are the expected
	* values after the given step of the simulation.
	*/
	protected abstract LabelValue[][] getExpectedDiseaseModelState(
	final String diseaseScenarioKey, final int step);

	/**
	* @return the disease models to be tested
	*/
	public abstract List<NodeDecorator> getDiseaseModelsToTest();

	/**
	* @param model
	* the model to generate scenario decorators for
	* @return the scenario decorators to include in a fixture
	*/
	public abstract Collection<Decorator> getScenarioDecorators(Model model);

	/**
	* @return a string to be used in a URI to prefix the scenario files being
	* serialized for a particular disease under test.
	*/
	protected abstract String getDiseaseURIPrefix();

	/**
	* This class represents the parameters for the specification of a test
	*/
	protected static final class TestSpec {
	/**
	* The number of rows in the lattice graph
	*/
	public int numRows = 0;

	/**
	* The number of columns in the lattice graph
	*/
	public int numColumns = 0;

	/**
	* The scenario/disease key of the test.
	*/
	public String scenarioDiseaseKey = "";

	/**
	* @param numRows
	* @param numColumns
	* @param scenarioDiseaseKey
	*/
	protected TestSpec(final int numRows, final int numColumns,
	final String scenarioDiseaseKey) {
	super();
	this.numRows = numRows;
	this.numColumns = numColumns;
	this.scenarioDiseaseKey = scenarioDiseaseKey;
	}
	} // TestSpec

	} // DiseaseModelScenarioTest