restructure tests and add new test for abstract solving

jastadd-mquat-solver-ilp/src/main/java/de/tudresden/inf/st/mquat/solving/ilp/AbstractILPSolver.java

@@ -21,6 +21,15 @@ public abstract class AbstractILPSolver implements BenchmarkableSolver {
   protected transient long timeoutValue;
   protected transient TimeUnit timeoutUnit;
   protected boolean timedOut;
+
+  public ILPTransformer getTransformer() {
+    return transformer;
+  }
+
+  public void setTransformer(ILPTransformer transformer) {
+    this.transformer = transformer;
+  }
+
   protected ILPTransformer transformer;
 
   /**

jastadd-mquat-solver/src/test/java/de/tudresden/inf/st/mquat/solving/AbstractHandwrittenTestSuite.java → jastadd-mquat-solver-ilp/src/test/java/de/tudresden/inf/st/mquat/solving/AbstractHandwrittenTestSuite.java

@@ -2,26 +2,26 @@ package de.tudresden.inf.st.mquat.solving;
 
 import beaver.Parser;
 import de.tudresden.inf.st.mquat.jastadd.model.*;
+import de.tudresden.inf.st.mquat.solving.ilp.AbstractILPSolver;
+import de.tudresden.inf.st.mquat.solving.ilp.AbstractILPTransformer;
 import de.tudresden.inf.st.mquat.utils.ParserUtils;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.junit.Assert;
 import org.junit.Test;
 
 import java.io.IOException;
 
-public abstract class AbstractHandwrittenTestSuite extends HandwrittenTestSuite {
+public abstract class AbstractHandwrittenTestSuite extends ILPHandwrittenTest {
 
   private static Logger logger = LogManager.getLogger(AbstractHandwrittenTestSuite.class);
 
-  /**
-   * Create and return the solver to use in this test suite
-   * @return a solver instance
-   */
-  protected abstract Solver getSolver();
-
-  protected Tuple<Root, Solution> loadAndSolve(String filename) throws IOException, Parser.Exception, SolvingException {
+  protected Tuple<Root, Solution> loadAndSolve(String filename, int numClusters) throws IOException, Parser.Exception, SolvingException {
     Root model = ParserUtils.load(filename, HandwrittenTestSuite.class);
-    Solution solution = getSolver().solve(model);
+    AbstractILPSolver solver = (AbstractILPSolver) getSolver();
+    solver.setTransformer(new AbstractILPTransformer(numClusters));
+    Solution solution = solver.solve(model);
+
     if (logger.isDebugEnabled()) {
       MquatString out = solution.print(new MquatWriteSettings(" "));
       logger.debug("Solution:\n{}", out);
@@ -29,7 +29,13 @@ public abstract class AbstractHandwrittenTestSuite extends HandwrittenTestSuite
     return new Tuple<>(model, solution);
   }
 
-  protected Tuple<Root, Solution> loadAndSolve(String filename, int numClusters) throws IOException, Parser.Exception, SolvingException {
+  /**
+   * Create and return the solver to use in this test suite
+   * @return a solver instance
+   */
+  protected abstract Solver getSolver();
+
+  protected Tuple<Root, Solution> loadAndSolve(String filename) throws IOException, Parser.Exception, SolvingException {
     Root model = ParserUtils.load(filename, HandwrittenTestSuite.class);
     Solution solution = getSolver().solve(model);
     if (logger.isDebugEnabled()) {
@@ -68,7 +74,7 @@ public abstract class AbstractHandwrittenTestSuite extends HandwrittenTestSuite
 
   @Test
   public void test_02_abstract() throws IOException, Parser.Exception, SolvingException {
-    Tuple<Root, Solution> modelAndSolution = loadAndSolve("test_02_abstract.txt", 3);
+    Tuple<Root, Solution> modelAndSolution = loadAndSolve("test_02_abstract.txt", 2);
     assertValidSolution(modelAndSolution);
     Assignment config_0i0m0 = assertAssignment(modelAndSolution.getSecondElement(), "rq1", "config_0i0m0", "r0");
     Assignment config_1i0m0 = assertAssignment(modelAndSolution.getSecondElement(), "rq1", "config_1i0m0", "r1");
@@ -77,7 +83,7 @@ public abstract class AbstractHandwrittenTestSuite extends HandwrittenTestSuite
 
   @Test
   public void test_02_abstract_2() throws IOException, Parser.Exception, SolvingException {
-    Tuple<Root, Solution> modelAndSolution = loadAndSolve("test_02_abstract_2.txt", 3);
+    Tuple<Root, Solution> modelAndSolution = loadAndSolve("test_02_abstract_2.txt", 2);
     assertValidSolution(modelAndSolution);
     Assignment config_0i0m0 = assertAssignment(modelAndSolution.getSecondElement(), "rq1", "config_0i0m0", "r0");
     Assignment config_1i0m0 = assertAssignment(modelAndSolution.getSecondElement(), "rq1", "config_1i0m0", "r1");
@@ -87,4 +93,11 @@ public abstract class AbstractHandwrittenTestSuite extends HandwrittenTestSuite
     assertComponentRequirement(config_0i0m0,"other", config_1i0m0);
   }
 
+  @Test
+  public void test_03_abstract_1() throws IOException, Parser.Exception, SolvingException {
+    Tuple<Root, Solution> modelAndSolution = loadAndSolve("test_03_abstract_1.txt", 1);
+    Assert.assertFalse("solution is invalid.", modelAndSolution.getSecondElement().isValid());
+    Assert.assertTrue("solution is empty.", modelAndSolution.getSecondElement().getNumAssignment() == 0);
+  }
+
 }

jastadd-mquat-solver-ilp/src/test/java/de/tudresden/inf/st/mquat/solving/AbstractILPTest1.java

+package de.tudresden.inf.st.mquat.solving;
+
+import de.tudresden.inf.st.mquat.generator.ScenarioDescription;
+import de.tudresden.inf.st.mquat.generator.ScenarioGenerator;
+import de.tudresden.inf.st.mquat.jastadd.model.Root;
+import de.tudresden.inf.st.mquat.jastadd.model.Solution;
+import de.tudresden.inf.st.mquat.solving.ilp.GLPKSolver;
+import de.tudresden.inf.st.mquat.solving.ilp.ILPExternalSolver;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class AbstractILPTest1 {
+
+  private static Logger logger;
+
+  @BeforeClass
+  public static void initLogger() {
+    logger = LogManager.getLogger(AbstractILPTest1.class);
+  }
+
+
+
+  @Test
+  public void test_config_01() throws SolvingException {
+    int tlc = 1;
+    int iac = 1;
+    int isd = 0;
+    int cac = 0;
+    int csd = 0;
+    int dep = 2;
+    int imp = 2;
+    int res = 10;
+    int req = 1;
+    int cpu = 1;
+    int seed = 0;
+
+    ScenarioGenerator generator = new ScenarioGenerator(new ScenarioDescription(tlc, iac, isd, cac, csd, dep, imp, res, req, cpu, seed));
+    Root model = generator.generate();
+    ILPExternalSolver solver = new GLPKSolver().setDeleteFilesOnExit(false);
+    Solution solution = solver.solve(model);
+    Assert.assertTrue(solution.isValid());
+    logger.info("Solution (objective={}): {}", solution.computeObjective(), solution);
+  }
+}

jastadd-mquat-solver-ilp/src/test/java/de/tudresden/inf/st/mquat/solving/ILPHandwrittenTest.java

+package de.tudresden.inf.st.mquat.solving;
+
+import beaver.Parser;
+import de.tudresden.inf.st.mquat.jastadd.model.*;
+import de.tudresden.inf.st.mquat.solving.ilp.AbstractILPSolver;
+import de.tudresden.inf.st.mquat.solving.ilp.AbstractILPTransformer;
+import de.tudresden.inf.st.mquat.utils.ParserUtils;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.io.IOException;
+
+public abstract class ILPHandwrittenTest extends HandwrittenTestSuite {
+
+  private static Logger logger = LogManager.getLogger(ILPHandwrittenTest.class);
+
+
+}

jastadd-mquat-solver/src/test/resources/test_03_abstract_1.txt

+container resource type ComputeNode {
+    resource type CPU {
+        property frequency [Hz]
+        property load [%]
+    }
+    property flops [ops/s]
+}
+resource r0a:ComputeNode {
+    resource cpu0_0:CPU {
+        frequency = 100
+        load = 30
+    }
+    flops = 100
+}
+resource r0b:ComputeNode {
+    resource cpu0_0:CPU {
+        frequency = 110
+        load = 30
+    }
+    flops = 100
+}
+resource r0c:ComputeNode {
+    resource cpu0_0:CPU {
+        frequency = 120
+        load = 30
+    }
+    flops = 100
+}
+resource r0d:ComputeNode {
+    resource cpu0_0:CPU {
+        frequency = 80
+        load = 30
+    }
+    flops = 100
+}
+resource r0e:ComputeNode {
+    resource cpu0_0:CPU {
+        frequency = 90
+        load = 30
+    }
+    flops = 100
+}
+
+property energy [J]
+
+component c0 {
+    using property energy
+    contract config_0i0m0 {
+        requires resource compute_resource_0 of type ComputeNode with {
+          cpu_1 of type CPU
+        }
+        requiring compute_resource_0.cpu_1.frequency >= 90
+        providing energy = compute_resource_0.flops
+    }
+}
+
+request rq1 for c0 {
+}
+minimize sum(energy)