This folder should contain all tests

git-svn-id: https://se1.informatik.uni-wuerzburg.de/usvn/svn/code/code/DMM/trunk@9407 9e42b895-fcda-4063-8a3b-11be15eb1bbd

edu.kit.ipd.descartes.adaptation.test/.classpath

+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/log4j"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

edu.kit.ipd.descartes.adaptation.test/.project

+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>edu.kit.ipd.descartes.adaptation.test</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

edu.kit.ipd.descartes.adaptation.test/.settings/org.eclipse.jdt.core.prefs

+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.6

edu.kit.ipd.descartes.adaptation.test/META-INF/MANIFEST.MF

+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: AdaptationTest
+Bundle-SymbolicName: edu.kit.ipd.descartes.adaptation.test
+Bundle-Version: 1.0.0.qualifier
+Bundle-Vendor: Descartes Research Group
+Fragment-Host: edu.kit.ipd.descartes.adaptation;bundle-version="1.0.0"
+Bundle-RequiredExecutionEnvironment: JavaSE-1.6

edu.kit.ipd.descartes.adaptation.test/build.properties

+source.. = src/
+output.. = bin/
+bin.includes = META-INF/,\
+               .

edu.kit.ipd.descartes.adaptation.test/src/edu/kit/ipd/descartes/adaptation/AbstractTest.java

+package edu.kit.ipd.descartes.adaptation;
+
+import org.apache.log4j.BasicConfigurator;
+import org.apache.log4j.Logger;
+import org.junit.Before;
+
+public abstract class AbstractTest {
+
+	private Logger logger = Logger.getLogger(AbstractTest.class);
+
+	@Before
+	public void setUp() throws Exception {
+		BasicConfigurator.configure();
+		logger.info("Logger configured.");
+	}
+
+}

edu.kit.ipd.descartes.adaptation.test/src/edu/kit/ipd/descartes/adaptation/TacticsHistoryTest.java

+package edu.kit.ipd.descartes.adaptation;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import edu.kit.ipd.descartes.mm.adaptation.AdaptationFactory;
+import edu.kit.ipd.descartes.mm.adaptation.WeightedTactic;
+
+public class TacticsHistoryTest {
+
+	TacticsHistory hist = null;
+	WeightedTactic w = null;
+	static String TEST_ID = "TestId";
+	
+	@Before
+	public void setUp() throws Exception {
+		hist = TacticsHistory.getInstance();
+		w = AdaptationFactory.eINSTANCE.createWeightedTactic();
+	}
+
+	@Test
+	public void testAdd() {
+		hist.add(w, TEST_ID, false);
+		assertTrue(hist.size() == 1);
+		assertEquals(w, hist.getLatestAppliedTactic());
+		assertEquals(TEST_ID, hist.getLatestResultId());
+		assertEquals(false, hist.wasLatestTacticSuccessful());
+	}
+}

edu.kit.ipd.descartes.adaptation.test/src/edu/kit/ipd/descartes/adaptation/util/PerfDataRepoHelperTest.java

+package edu.kit.ipd.descartes.adaptation.util;
+
+import static org.junit.Assert.*;
+
+import org.eclipse.emf.common.util.URI;
+import org.junit.Before;
+import org.junit.Test;
+
+import edu.kit.ipd.descartes.adaptation.model.PerformanceDataRepositoryHandler;
+import edu.kit.ipd.descartes.perfdatarepo.Impact;
+import edu.kit.ipd.descartes.perfdatarepo.PerformanceDataRepository;
+
+public class PerfDataRepoHelperTest {
+	
+	private static final String PERF_DATA_REPO_XMI_FILE = "/Users/nhuber/Documents/workspace/descartes/metamodel/ExampleModels/Adaptation/PerformanceDataRepositoryDummy.xmi";
+	PerformanceDataRepository perfDataRepo;
+	
+	@Before
+	public void setUp() throws Exception {
+		
+		PerformanceDataRepositoryHandler repoHander = PerformanceDataRepositoryHandler.getInstance();
+		perfDataRepo = (PerformanceDataRepository) repoHander.load(URI
+				.createFileURI(PERF_DATA_REPO_XMI_FILE));
+	}
+
+	@Test
+	public void testGetLatestImpact() {
+		int historySize = perfDataRepo.getImpactHistory().size();
+		Impact mostRecent = perfDataRepo.getImpactHistory().get(historySize - 1);
+		assertEquals(mostRecent, PerfDataRepoHelper.getLatestImpact(perfDataRepo));
+	}
+
+}

edu.kit.ipd.descartes.adaptation.test/src/edu/kit/ipd/descartes/adaptation/weightingfunction/RandomWeightCalculatorTest.java

+package edu.kit.ipd.descartes.adaptation.weightingfunction;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotSame;
+
+import java.util.Random;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import edu.kit.ipd.descartes.mm.adaptation.AdaptationFactory;
+import edu.kit.ipd.descartes.mm.adaptation.WeightedTactic;
+
+public class RandomWeightCalculatorTest {
+	
+	IWeightingFunctionCalculator randomCalculator = new RandomWeightCalculator();
+	WeightedTactic wt = null;
+
+	@Before
+	public void setUp() throws Exception {
+		wt = AdaptationFactory.eINSTANCE.createWeightedTactic();
+		wt.setName("TestTactic");
+		wt.setId("testTacticTestId");
+		wt.setCurrentWeight(1.0);
+		wt.setDefaultWeight(0.0);
+	}
+
+	@Test
+	public void testCalculateWeight() {
+		Random r = new Random(System.currentTimeMillis());
+		assertEquals(r.nextDouble(), randomCalculator.calculateWeight(wt),1.0);
+		assertEquals(0.0, wt.getDefaultWeight(), 0.0);
+	}
+
+	@Test
+	public void testCalculateAndSetWeight() {
+		randomCalculator.updateWeight(wt);
+		
+		assertNotSame(1.0, wt.getCurrentWeight());
+		assertEquals(0.0, wt.getDefaultWeight(), 0.0);
+	}
+
+}

edu.kit.ipd.descartes.adaptation.test/src/edu/kit/ipd/descartes/adaptation/weightingfunction/WeightedSumCalculatorTest.java

+package edu.kit.ipd.descartes.adaptation.weightingfunction;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import edu.kit.ipd.descartes.adaptation.AbstractTest;
+import edu.kit.ipd.descartes.mm.adaptation.AdaptationFactory;
+import edu.kit.ipd.descartes.mm.adaptation.WeightedMetric;
+import edu.kit.ipd.descartes.mm.adaptation.WeightedTactic;
+import edu.kit.ipd.descartes.mm.adaptation.WeightingFunction;
+import edu.kit.ipd.descartes.perfdatarepo.Impact;
+import edu.kit.ipd.descartes.perfdatarepo.MetricType;
+import edu.kit.ipd.descartes.perfdatarepo.MetricValue;
+import edu.kit.ipd.descartes.perfdatarepo.PerfdatarepoFactory;
+import edu.kit.ipd.descartes.perfdatarepo.Result;
+
+public class WeightedSumCalculatorTest extends AbstractTest {
+	
+	private static final double NEW_WEIGHT = 99.8;
+	
+	IWeightingFunctionCalculator weightedSum;
+	WeightedTactic wt = null;
+	WeightingFunction fun = null;
+	
+
+	@Before
+	@Override
+	public void setUp() throws Exception {
+		super.setUp();
+		MetricType respTime = PerfdatarepoFactory.eINSTANCE.createMetricType();
+		respTime.setName("Response Time");
+		MetricType util = PerfdatarepoFactory.eINSTANCE.createMetricType();
+		util.setName("Utilization");
+		
+		WeightedMetric wmRespTime = AdaptationFactory.eINSTANCE.createWeightedMetric();
+		wmRespTime.setMetricType(respTime);
+		wmRespTime.setWeight(-2.0);
+		WeightedMetric wmUtil = AdaptationFactory.eINSTANCE.createWeightedMetric();
+		wmUtil.setMetricType(util);
+		wmUtil.setWeight(-1.0);
+
+		fun = AdaptationFactory.eINSTANCE.createWeightingFunction();
+		fun.getWeightedMetrics().add(wmRespTime);
+		fun.getWeightedMetrics().add(wmUtil);
+		
+		weightedSum = new WeightedSumCalculator(fun);
+		
+		wt = AdaptationFactory.eINSTANCE.createWeightedTactic();
+		
+		
+		MetricValue metric1ValueBefore = PerfdatarepoFactory.eINSTANCE.createMetricValue();
+		metric1ValueBefore.setMetric(respTime);
+		metric1ValueBefore.setValue(100);
+		MetricValue metric1ValueAfter = PerfdatarepoFactory.eINSTANCE.createMetricValue();
+		metric1ValueAfter.setMetric(respTime);
+		metric1ValueAfter.setValue(50);
+
+		MetricValue metric2ValueBefore = PerfdatarepoFactory.eINSTANCE.createMetricValue();
+		metric2ValueBefore.setMetric(util);
+		metric2ValueBefore.setValue(0.6);
+		MetricValue metric2ValueAfter = PerfdatarepoFactory.eINSTANCE.createMetricValue();
+		metric2ValueAfter.setMetric(util);
+		metric2ValueAfter.setValue(0.8);
+		
+		Result before = PerfdatarepoFactory.eINSTANCE.createResult();
+		before.getMetricValues().add(metric1ValueBefore);
+		before.getMetricValues().add(metric2ValueBefore);
+		Result after = PerfdatarepoFactory.eINSTANCE.createResult();
+		after.getMetricValues().add(metric1ValueAfter);
+		after.getMetricValues().add(metric2ValueAfter);
+		
+		Impact i = PerfdatarepoFactory.eINSTANCE.createImpact();
+		i.setBefore(before);
+		i.setAfter(after);
+		
+		wt.setName("TestTactic");
+		wt.setId("testTacticTestId");
+		wt = AdaptationFactory.eINSTANCE.createWeightedTactic();
+		wt.setCurrentWeight(1.0);
+		wt.setDefaultWeight(0.0);
+		wt.setLastImpact(i);
+	}
+
+	@Test
+	public void testCalculateWeight() {
+		
+		// Weighting function shall calculate: 2 * (100 - 50) + -1 * (0.6 - 0.8)
+		// i.e., everything improved.
+		assertEquals(NEW_WEIGHT, weightedSum.calculateWeight(wt), 0.0);
+		assertEquals(wt.getDefaultWeight(), 0.0, 0);
+	}
+
+	@Test
+	public void testCalculateAndSetWeight() {
+		weightedSum.updateWeight(wt);
+		assertEquals(NEW_WEIGHT, wt.getCurrentWeight(), 0.0);
+		assertEquals(wt.getDefaultWeight(), 0.0, 0);
+	}
+
+}