removed duplicate tests

some class refactoring

build.gradle

@@ -161,6 +161,7 @@ dependencies {
 	runtime 'ch.qos.logback:logback-classic:1.0.13'
 
 	testCompile 'org.testng:testng:6+'
+//	testCompile 'org.apache.jmeter:ApacheJMeter:2.+'
 }
 
 tasks.withType(JavaCompile) {

src/test/java/it/unibz/inf/isochrone/network/AlgorithmHelper.java

@@ -12,8 +12,7 @@ final class AlgorithmHelper {
 
 	// Constructor
 
-	private AlgorithmHelper() {
-	}
+	private AlgorithmHelper() { }
 
 	// Public static methods
 

src/test/java/it/unibz/inf/isochrone/network/RuntimeComplex.java → src/test/java/it/unibz/inf/isochrone/network/AlgorithmRuntimeTest.java

@@ -11,15 +11,16 @@ import java.io.BufferedWriter;
 import java.io.File;
 import java.io.IOException;
 import java.io.PrintWriter;
+import java.util.ArrayList;
 import java.util.Calendar;
-import java.util.Collection;
 import java.util.GregorianCalendar;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
-import java.util.TreeMap;
 import java.util.TreeSet;
 
 import org.slf4j.Logger;
@@ -34,17 +35,9 @@ import org.testng.annotations.Test;
  * time of 5 runs for each different algorithm and isochrone is
  * stored, to account for changed test conditions.
  */
-public final class RuntimeComplex {
-	private static final Logger LOGGER = LoggerFactory.getLogger(RuntimeComplex.class);
+public final class AlgorithmRuntimeTest {
+	private static final Logger LOGGER = LoggerFactory.getLogger(AlgorithmRuntimeTest.class);
 	private static final int REPEAT_COUNT = 5;
-	private static final int BZ_NODE_ID = 2000500;
-	private static final Calendar BZ_TIME = new GregorianCalendar(2011, 5, 10, 10, 10, 0);
-	private static final int SF_NODE_ID = 21355;
-	private static final Calendar SF_TIME = new GregorianCalendar(2010, 9, 6, 9, 50, 0);
-	private static final int ST_NODE_ID = 2008706;
-	private static final Calendar ST_TIME = new GregorianCalendar(2010, 6, 14, 10, 30, 0);
-	private static final int IT_NODE_ID = 21;
-	private static final Calendar IT_TIME = new GregorianCalendar(2011, 9, 20, 15, 0, 0);
 	private static final String RESULTFILE_XML_RUNTIME = "build/reports/tests/algorithm-runtimes.xml";
 	private static final Direction DIRECTION = Direction.INCOMING;
 	private static final Mode MODE = Mode.MULTIMODAL;
@@ -56,18 +49,39 @@ public final class RuntimeComplex {
 		3600,	// 1 hour (in sec)
 		86400	// 1 day (in sec)
 	};
-	private static Map<Integer, TestParameters> datasets = new TreeMap<>();
-	private static Map<String, Map<String, Long>> runtimes = new TreeMap<>();
+	private static Map<String, InitParams> initParamsMap;
+	private static List<TestParameters> datsetParams = new ArrayList<>();
+	private static Map<String, Map<String, Long>> runtimes = new LinkedHashMap<>();
+	private static Set<Integer> times;
+	private static Set<String> datasetsAdded = new HashSet<>();
+	// InitParams (class and initialization)
+	private static final class InitParams {
+		private final int nodeId;
+		private final Calendar time;
+
+		private InitParams(final int nodeId, final Calendar time) {
+			this.nodeId = nodeId;
+			this.time = time;
+		}
+	}
+	static {
+		initParamsMap = new HashMap<>();
+		// CHECKSTYLE:OFF MagicNumber
+		initParamsMap.put("bz", new InitParams(2000500, new GregorianCalendar(2011, 5, 10, 10, 10, 0)));
+		initParamsMap.put("it", new InitParams(21, new GregorianCalendar(2011, 9, 20, 15, 0, 0)));
+		initParamsMap.put("sf", new InitParams(21355, new GregorianCalendar(2010, 9, 6, 9, 50, 0)));
+		initParamsMap.put("st", new InitParams(2008706, new GregorianCalendar(2010, 6, 14, 10, 30, 0)));
+		// CHECKSTYLE:ON MagicNumber
+	}
 
 	// Launcher method (main method) for visualVM
 
 	public static void main(final String[] args) {
-		final RuntimeComplex o = new RuntimeComplex();
-//		addAllDatasets();
-
-		final Set<Integer> times = new HashSet<>();
+		final AlgorithmRuntimeTest o = new AlgorithmRuntimeTest();
+//		o.initTimeAndParamSet();
+		times = new HashSet<>();
 		times.add(MAX_RUNTIME);
-		addDatasetBZ(times);
+		addDatasetBZ();
 
 		System.out.println("Starting profiling:");
 		long startTimeOverall = Calendar.getInstance().getTimeInMillis();
@@ -94,12 +108,12 @@ public final class RuntimeComplex {
 	}
 
 	@BeforeClass
-	public static void addAllDatasets() {
-		final Set<Integer> times = getTimeSet();
-		addDatasetBZ(times);
-//		addDatasetIT(times);
-//		addDatasetSF(times);
-//		addDatasetST(times);
+	public static void initTimeAndParamSet() {
+		initTimeSet();
+		addDatasetBZ();
+//		addDatasetIT();
+//		addDatasetSF();
+//		addDatasetST();
 	}
 
 	// Public methods
@@ -121,60 +135,61 @@ public final class RuntimeComplex {
 
 	// Private static methods
 
-	private static void addDatasetBZ(final Set<Integer> times) {
-		int i = 0;
+	private static synchronized void addDataset(final String datasetName) {
+		if (datasetsAdded.contains(datasetName)) {
+			return;
+		}
+
+		datasetsAdded.add(datasetName);
+		final InitParams iParams = initParamsMap.get(datasetName);
 		for (final Integer time : times) {
-			datasets.put(i++, new TestParameters(WALKING_SPEED, time, BZ_TIME, MODE, BZ_NODE_ID, "bz", DIRECTION));
+			datsetParams.add(new TestParameters(WALKING_SPEED, time, iParams.time, MODE, iParams.nodeId, datasetName, DIRECTION));
 		}
 	}
 
+	private static synchronized void addDatasetBZ() {
+		addDataset("bz");
+	}
+
 	@SuppressWarnings("unused")
-	private static void addDatasetIT(final Set<Integer> times) {
-		int i = 0;
-		for (final Integer time : times) {
-			datasets.put(i++, new TestParameters(WALKING_SPEED, time, IT_TIME, MODE, IT_NODE_ID, "it", DIRECTION));
-		}
+	private static synchronized void addDatasetIT() {
+		addDataset("it");
 	}
 
 	@SuppressWarnings("unused")
-	private static void addDatasetSF(final Set<Integer> times) {
-		int i = 0;
-		for (final Integer time : times) {
-			datasets.put(i++, new TestParameters(WALKING_SPEED, time, SF_TIME, MODE, SF_NODE_ID, "sf", DIRECTION));
-		}
+	private static synchronized void addDatasetSF() {
+		addDataset("sf");
 	}
 
 	@SuppressWarnings("unused")
-	private static void addDatasetST(final Set<Integer> times) {
-		int i = 0;
-		for (final Integer time : times) {
-			datasets.put(i++, new TestParameters(WALKING_SPEED, time, ST_TIME, MODE, ST_NODE_ID, "st", DIRECTION));
-		}
+	private static synchronized void addDatasetST() {
+		addDataset("st");
 	}
 
-	private static Set<Integer> getTimeSet() {
-		final Set<Integer> times = new TreeSet<Integer>();
+	private static synchronized void initTimeSet() {
+		if (times != null) {
+			return;
+		}
+
+		times = new TreeSet<Integer>();
 		for (int offset : RUNTIME_OFFSETS) {
 			int stepWidth = (offset / RUNTIME_POINTS_PER_OFFSET);
 			for (int i = 0; i < offset; i += stepWidth) {
 				int runtime = Math.max(offset, offset * i);
 				if (runtime > MAX_RUNTIME) {
-					return times;
+					return;
 				}
 
 				times.add(runtime);
 			}
 		}
-
-		return times;
 	}
 
 	private static void runForAllDatasets(final Class<? extends Isochrone> clazz) {
 		LOGGER.info("Executing " + clazz.getSimpleName());
 		long runTimeOverall = 0;
 
-		final Collection<TestParameters> allParams = datasets.values();
-		for (final TestParameters params : allParams) {
+		for (final TestParameters params : datsetParams) {
 			long startTime = Calendar.getInstance().getTimeInMillis();
 			AlgorithmHelper.run(clazz, params);
 

src/test/java/it/unibz/inf/isochrone/network/AlgorithmTest.java

 package it.unibz.inf.isochrone.network;
 
+import it.unibz.inf.isochrone.algorithm.Isochrone;
 import it.unibz.inf.isochrone.algorithm.MDijkstra;
 import it.unibz.inf.isochrone.algorithm.MineX;
 import it.unibz.inf.isochrone.algorithm.MrneX;
@@ -9,9 +10,13 @@ import it.unibz.inf.isochrone.util.EnumContainer.Mode;
 import java.util.Calendar;
 import java.util.GregorianCalendar;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.testng.annotations.Test;
 
 public class AlgorithmTest {
+	private static final Logger LOGGER = LoggerFactory.getLogger(AlgorithmTest.class);
+	// local test parameters
 	private static final String DATASET = "bz";
 	private static final Double WALKING_SPEED = 1.0;
 	private static final int DURATION = 50;
@@ -20,27 +25,73 @@ public class AlgorithmTest {
 	private static final Mode MODE = Mode.MULTIMODAL;
 	private static final Direction DIRECTION = Direction.INCOMING;
 
-	// Public methodd
+	// Public methods
 
 	@Test
-	public void testMDijkstra() {
-		AlgorithmHelper.run(MDijkstra.class, getParams(), false);
+	public void testMDijkstraDefault() {
+		runDefault(MDijkstra.class, false);
 	}
 
 	@Test
-	public void testMineX() {
-		AlgorithmHelper.run(MineX.class, getParams());
+	public void testMDijkstraLocal() {
+		runLocal(MDijkstra.class, false);
 	}
 
 	@Test
-	public void testMrneX() {
-		AlgorithmHelper.run(MrneX.class, getParams());
+	public void testMineXDefault() {
+		runDefault(MineX.class);
 	}
 
-	// Private methods
+	@Test
+	public void testMineXLocal() {
+		runLocal(MineX.class);
+	}
+
+	@Test
+	public void testMrneXDefault() {
+		runDefault(MrneX.class);
+	}
+
+	@Test
+	public void testMrneXLocal() {
+		runLocal(MrneX.class);
+	}
+
+	// Private static methods
 
-	private static TestParameters getParams() {
+	private static TestParameters getParamsDefault() {
+		return new TestParameters();
+	}
+
+	private static TestParameters getParamsLocal() {
 		return new TestParameters(WALKING_SPEED, DURATION, TIME, MODE, STARTNODE_ID, DATASET, DIRECTION);
 	}
 
+	private static void runDefault(final Class<? extends Isochrone> algorithmClass) {
+		runDefault(algorithmClass, true);
+	}
+
+	private static void runDefault(final Class<? extends Isochrone> algorithmClass, final boolean expireNodes) {
+		LOGGER.info("Executing \"" + algorithmClass.getSimpleName() + "\" (with default test parameters)");
+		final TestParameters params = getParamsDefault();
+		long startTime = Calendar.getInstance().getTimeInMillis();
+		AlgorithmHelper.run(algorithmClass, params, expireNodes);
+		long runTime = Calendar.getInstance().getTimeInMillis() - startTime;
+		LOGGER.info(" - runtime: \"" + params.getRuntime() + "\": " + runTime + "msec");
+		LOGGER.info("-----------------------------");
+	}
+
+	private static void runLocal(final Class<? extends Isochrone> algorithmClass) {
+		runLocal(algorithmClass, true);
+	}
+
+	private static void runLocal(final Class<? extends Isochrone> algorithmClass, final boolean expireNodes) {
+		LOGGER.info("Executing \"" + algorithmClass.getSimpleName() + "\" (with local test parameters)");
+		final TestParameters params = getParamsLocal();
+		long startTime = Calendar.getInstance().getTimeInMillis();
+		AlgorithmHelper.run(algorithmClass, params, expireNodes);
+		long runTime = Calendar.getInstance().getTimeInMillis() - startTime;
+		LOGGER.info(" - runtime: \"" + params.getRuntime() + "\": " + runTime + "msec");
+		LOGGER.info("-----------------------------");
+	}
 }

src/test/java/it/unibz/inf/isochrone/network/RuntimeSimple.java

-package it.unibz.inf.isochrone.network;
-
-import it.unibz.inf.isochrone.algorithm.Isochrone;
-import it.unibz.inf.isochrone.algorithm.MDijkstra;
-import it.unibz.inf.isochrone.algorithm.MineX;
-import it.unibz.inf.isochrone.algorithm.MrneX;
-
-import java.util.Calendar;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.testng.annotations.Test;
-
-/**
- * Performance test class that measures performance of one algorithm
- * at one time.  Change the algorithm in the main method to change the
- * algorithm that should be run on.
- *
- * Change the invocation for the Parameters class to change which
- * isochrone should be computed.
- */
-public final class RuntimeSimple {
-	private static final Logger LOGGER = LoggerFactory.getLogger(RuntimeSimple.class);
-
-	// Public methods
-
-	@Test
-	public void runMDijkstra() {
-		run(MDijkstra.class);
-	}
-
-	@Test
-	public void runMineX() {
-		run(MineX.class);
-	}
-
-	@Test
-	public void runMrneX() {
-		run(MrneX.class);
-	}
-
-	// Private static methods
-
-	private static void run(final Class<? extends Isochrone> algorithmClass) {
-		LOGGER.info("Executing \"" + algorithmClass.getSimpleName() + "\"");
-		final TestParameters params = new TestParameters();
-		long startTime = Calendar.getInstance().getTimeInMillis();
-		AlgorithmHelper.run(algorithmClass, params);
-		long runTime = Calendar.getInstance().getTimeInMillis() - startTime;
-		LOGGER.info(" - runtime: \"" + params.getRuntime() + "\": " + runTime + "msec");
-		LOGGER.info("-----------------------------");
-	}
-
-}