src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
BootNode extends Action implements NodeEvent { @Override public boolean equals(Object o) { if (!super.equals(o)) { return false; } BootNode that = (BootNode) o; return this.node.equals(that.node); } BootNode(Node n, int start, int end); @Override boolean equals(Object o); @Override Node getNode(); @Override int hashCode(); @Override String pretty(); @Override boolean applyAction(Model c); @Override Object visit(ActionVisitor v); } | @Test(dependsOnMethods = {"testInstantiate"}) public void testEquals() { BootNode a = new BootNode(ns.get(0), 3, 5); BootNode b = new BootNode(ns.get(0), 3, 5); Assert.assertFalse(a.equals(new Object())); Assert.assertTrue(a.equals(a)); Assert.assertEquals(a, b); Assert.assertEquals(a.hashCode(), b.hashCode()); Assert.assertNotSame(a, new BootNode(ns.get(0), 4, 5)); Assert.assertNotSame(a, new BootNode(ns.get(0), 3, 4)); Assert.assertNotSame(a, new BootNode(ns.get(1), 3, 5)); } |
BootNode extends Action implements NodeEvent { @Override public Object visit(ActionVisitor v) { return v.visit(this); } BootNode(Node n, int start, int end); @Override boolean equals(Object o); @Override Node getNode(); @Override int hashCode(); @Override String pretty(); @Override boolean applyAction(Model c); @Override Object visit(ActionVisitor v); } | @Test public void testVisit() { ActionVisitor visitor = mock(ActionVisitor.class); a.visit(visitor); verify(visitor).visit(a); } |
ShutdownNode extends Action implements NodeEvent { @Override public Node getNode() { return node; } ShutdownNode(Node n, int start, int end); @Override Node getNode(); @Override boolean equals(Object o); @Override int hashCode(); @Override String pretty(); @Override boolean applyAction(Model c); @Override Object visit(ActionVisitor v); } | @Test public void testInstantiate() { ShutdownNode a = new ShutdownNode(ns.get(0), 3, 5); Assert.assertEquals(ns.get(0), a.getNode()); Assert.assertEquals(3, a.getStart()); Assert.assertEquals(5, a.getEnd()); Assert.assertFalse(a.toString().contains("null")); } |
ShutdownNode extends Action implements NodeEvent { @Override public boolean equals(Object o) { if (!super.equals(o)) { return false; } ShutdownNode that = (ShutdownNode) o; return this.node.equals(that.node); } ShutdownNode(Node n, int start, int end); @Override Node getNode(); @Override boolean equals(Object o); @Override int hashCode(); @Override String pretty(); @Override boolean applyAction(Model c); @Override Object visit(ActionVisitor v); } | @Test(dependsOnMethods = {"testInstantiate"}) public void testEquals() { ShutdownNode a = new ShutdownNode(ns.get(0), 3, 5); ShutdownNode b = new ShutdownNode(ns.get(0), 3, 5); Assert.assertFalse(a.equals(new Object())); Assert.assertTrue(a.equals(a)); Assert.assertEquals(a, b); Assert.assertEquals(a.hashCode(), b.hashCode()); Assert.assertNotSame(a, new ShutdownNode(ns.get(0), 4, 5)); Assert.assertNotSame(a, new ShutdownNode(ns.get(0), 3, 4)); Assert.assertNotSame(a, new ShutdownNode(ns.get(1), 4, 5)); } |
ShutdownNode extends Action implements NodeEvent { @Override public Object visit(ActionVisitor v) { return v.visit(this); } ShutdownNode(Node n, int start, int end); @Override Node getNode(); @Override boolean equals(Object o); @Override int hashCode(); @Override String pretty(); @Override boolean applyAction(Model c); @Override Object visit(ActionVisitor v); } | @Test public void testVisit() { ActionVisitor visitor = mock(ActionVisitor.class); a.visit(visitor); verify(visitor).visit(a); } |
BootVM extends Action implements VMStateTransition, RunningVMPlacement { @Override public boolean equals(Object o) { if (!super.equals(o)) { return false; } BootVM that = (BootVM) o; return this.vm.equals(that.vm) && this.node.equals(that.node); } BootVM(VM v, Node to, int start, int end); @Override String pretty(); @Override Node getDestinationNode(); @Override VM getVM(); @Override boolean applyAction(Model c); @Override boolean equals(Object o); @Override int hashCode(); @Override VMState getCurrentState(); @Override VMState getNextState(); @Override Object visit(ActionVisitor v); } | @Test(dependsOnMethods = {"testInstantiate"}) public void testEquals() { BootVM a = new BootVM(vms.get(0), ns.get(0), 3, 5); BootVM b = new BootVM(vms.get(0), ns.get(0), 3, 5); Assert.assertFalse(a.equals(new Object())); Assert.assertTrue(a.equals(a)); Assert.assertEquals(a, b); Assert.assertEquals(a.hashCode(), b.hashCode()); Assert.assertNotSame(a, new BootVM(vms.get(0), ns.get(0), 4, 5)); Assert.assertNotSame(a, new BootVM(vms.get(0), ns.get(0), 3, 4)); Assert.assertNotSame(a, new BootVM(vms.get(0), ns.get(1), 3, 5)); Assert.assertNotSame(a, new BootVM(vms.get(1), ns.get(0), 4, 5)); } |
BootVM extends Action implements VMStateTransition, RunningVMPlacement { @Override public Object visit(ActionVisitor v) { return v.visit(this); } BootVM(VM v, Node to, int start, int end); @Override String pretty(); @Override Node getDestinationNode(); @Override VM getVM(); @Override boolean applyAction(Model c); @Override boolean equals(Object o); @Override int hashCode(); @Override VMState getCurrentState(); @Override VMState getNextState(); @Override Object visit(ActionVisitor v); } | @Test public void testVisit() { ActionVisitor visitor = mock(ActionVisitor.class); a.visit(visitor); verify(visitor).visit(a); } |
ReadyConverter implements ConstraintConverter<Ready> { @Override public String getJSONId() { return "ready"; } @Override Class<Ready> getSupportedConstraint(); @Override String getJSONId(); @Override Ready fromJSON(Model mo, JSONObject o); @Override JSONObject toJSON(Ready o); } | @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Ready.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new ReadyConverter().getJSONId())); } |
ForgeVM extends Action implements VMStateTransition { @Override public boolean equals(Object o) { if (!super.equals(o)) { return false; } ForgeVM that = (ForgeVM) o; return this.id.equals(that.id); } ForgeVM(VM vm, int start, int end); @Override boolean applyAction(Model m); @Override boolean equals(Object o); @Override int hashCode(); @Override VM getVM(); @Override String pretty(); @Override VMState getCurrentState(); @Override VMState getNextState(); @Override Object visit(ActionVisitor v); } | @Test(dependsOnMethods = {"testInstantiate"}) public void testEquals() { ForgeVM a = new ForgeVM(vms.get(0), 3, 5); ForgeVM b = new ForgeVM(vms.get(0), 3, 5); Assert.assertFalse(a.equals(new Object())); Assert.assertTrue(a.equals(a)); Assert.assertEquals(a, b); Assert.assertEquals(a.hashCode(), b.hashCode()); Assert.assertNotSame(a, new ForgeVM(vms.get(0), 4, 5)); Assert.assertNotSame(a, new ForgeVM(vms.get(0), 3, 4)); Assert.assertNotSame(a, new ForgeVM(vms.get(1), 3, 5)); } |
ForgeVM extends Action implements VMStateTransition { @Override public Object visit(ActionVisitor v) { return v.visit(this); } ForgeVM(VM vm, int start, int end); @Override boolean applyAction(Model m); @Override boolean equals(Object o); @Override int hashCode(); @Override VM getVM(); @Override String pretty(); @Override VMState getCurrentState(); @Override VMState getNextState(); @Override Object visit(ActionVisitor v); } | @Test public void testVisit() { ActionVisitor visitor = mock(ActionVisitor.class); a.visit(visitor); verify(visitor).visit(a); } |
SubstitutedVMEvent implements VMEvent { @Override public Object visit(ActionVisitor v) { return v.visit(this); } SubstitutedVMEvent(VM vm, VM newVM); @Override VM getVM(); VM getNewVM(); @Override boolean apply(Model m); @Override Object visit(ActionVisitor v); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); } | @Test public void testVisit() { ActionVisitor visitor = mock(ActionVisitor.class); s.visit(visitor); verify(visitor).visit(s); } |
SubstitutedVMEvent implements VMEvent { @Override public boolean apply(Model m) { for (ModelView v : m.getViews()) { v.substituteVM(oldVm, newVm); } return true; } SubstitutedVMEvent(VM vm, VM newVM); @Override VM getVM(); VM getNewVM(); @Override boolean apply(Model m); @Override Object visit(ActionVisitor v); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); } | @Test public void testApply() { Model mo = new DefaultModel(); Mapping map = mo.getMapping(); map.addOnlineNode(ns.get(0)); map.addOnlineNode(ns.get(1)); map.addReadyVM(vms.get(0)); map.addReadyVM(vms.get(2)); ModelView v = mock(ModelView.class); mo.attach(v); Assert.assertTrue(s.apply(mo)); verify(v).substituteVM(vms.get(0), vms.get(1)); } |
AllocateEvent implements VMEvent { @Override public boolean apply(Model i) { ShareableResource r = ShareableResource.get(i, rc); if (r == null) { return false; } r.setConsumption(vm, qty); return true; } AllocateEvent(VM vmId, String rcId, int amount); @Override VM getVM(); String getResourceId(); int getAmount(); @Override boolean apply(Model i); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); @Override Object visit(ActionVisitor v); } | @Test public void testApply() { AllocateEvent na = new AllocateEvent(vms.get(0), "foo", 3); Model mo = new DefaultModel(); Mapping map = mo.getMapping(); map.addOnlineNode(ns.get(0)); map.addRunningVM(vms.get(0), ns.get(0)); Assert.assertFalse(na.apply(mo)); ShareableResource rc = new ShareableResource("foo"); mo.attach(rc); Assert.assertTrue(na.apply(mo)); Assert.assertEquals(3, rc.getConsumption(vms.get(0))); } |
AllocateEvent implements VMEvent { @Override public Object visit(ActionVisitor v) { return v.visit(this); } AllocateEvent(VM vmId, String rcId, int amount); @Override VM getVM(); String getResourceId(); int getAmount(); @Override boolean apply(Model i); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); @Override Object visit(ActionVisitor v); } | @Test public void testVisit() { ActionVisitor visitor = mock(ActionVisitor.class); a.visit(visitor); verify(visitor).visit(a); } |
ShutdownVM extends Action implements VMStateTransition { @Override public boolean equals(Object o) { if (!super.equals(o)) { return false; } ShutdownVM that = (ShutdownVM) o; return this.vm.equals(that.vm) && this.node.equals(that.node); } ShutdownVM(VM v, Node on, int start, int end); @Override boolean applyAction(Model m); @Override String pretty(); @Override boolean equals(Object o); @Override int hashCode(); @Override VM getVM(); Node getNode(); @Override VMState getCurrentState(); @Override VMState getNextState(); @Override Object visit(ActionVisitor v); } | @Test(dependsOnMethods = {"testInstantiate"}) public void testEquals() { ShutdownVM a = new ShutdownVM(vms.get(0), ns.get(0), 3, 5); ShutdownVM b = new ShutdownVM(vms.get(0), ns.get(0), 3, 5); Assert.assertFalse(a.equals(new Object())); Assert.assertTrue(a.equals(a)); Assert.assertEquals(a, b); Assert.assertEquals(a.hashCode(), b.hashCode()); Assert.assertNotSame(a, new ShutdownVM(vms.get(0), ns.get(0), 4, 5)); Assert.assertNotSame(a, new ShutdownVM(vms.get(0), ns.get(0), 3, 4)); Assert.assertNotSame(a, new ShutdownVM(vms.get(0), ns.get(1), 3, 5)); Assert.assertNotSame(a, new ShutdownVM(vms.get(1), ns.get(0), 4, 5)); } |
ShutdownVM extends Action implements VMStateTransition { @Override public Object visit(ActionVisitor v) { return v.visit(this); } ShutdownVM(VM v, Node on, int start, int end); @Override boolean applyAction(Model m); @Override String pretty(); @Override boolean equals(Object o); @Override int hashCode(); @Override VM getVM(); Node getNode(); @Override VMState getCurrentState(); @Override VMState getNextState(); @Override Object visit(ActionVisitor v); } | @Test public void testVisit() { ActionVisitor visitor = mock(ActionVisitor.class); a.visit(visitor); verify(visitor).visit(a); } |
MigrateVM extends Action implements RunningVMPlacement { @Override public boolean equals(Object o) { if (!super.equals(o)) { return false; } MigrateVM that = (MigrateVM) o; return this.vm.equals(that.vm) && this.src.equals(that.src) && this.dst.equals(that.dst) && this.bw == that.bw; } MigrateVM(VM v, Node from, Node to, int start, int end, int bandwidth); MigrateVM(VM v, Node from, Node to, int start, int end); Node getSourceNode(); int getBandwidth(); @Override Node getDestinationNode(); @Override VM getVM(); @Override boolean applyAction(Model i); @Override boolean equals(Object o); @Override int hashCode(); @Override String pretty(); @Override Object visit(ActionVisitor v); boolean setBandwidth(int bandwidth); } | @Test(dependsOnMethods = {"testInstantiate"}) public void testEquals() { MigrateVM a = new MigrateVM(vms.get(0), ns.get(0), ns.get(1), 3, 5); MigrateVM b = new MigrateVM(vms.get(0), ns.get(0), ns.get(1), 3, 5); Assert.assertFalse(a.equals(new Object())); Assert.assertTrue(a.equals(a)); Assert.assertEquals(a, b); Assert.assertEquals(a.hashCode(), b.hashCode()); b.setBandwidth(200); Assert.assertNotEquals(a, b); Assert.assertNotEquals(a, new MigrateVM(vms.get(0), ns.get(0), ns.get(1), 4, 5)); Assert.assertNotEquals(a, new MigrateVM(vms.get(0), ns.get(0), ns.get(1), 3, 4)); Assert.assertNotEquals(a, new MigrateVM(vms.get(1), ns.get(0), ns.get(1), 3, 5)); Assert.assertNotEquals(a, new MigrateVM(vms.get(0), ns.get(2), ns.get(1), 3, 5)); Assert.assertNotEquals(a, new MigrateVM(vms.get(0), ns.get(0), ns.get(2), 3, 5)); } |
MigrateVM extends Action implements RunningVMPlacement { @Override public Object visit(ActionVisitor v) { return v.visit(this); } MigrateVM(VM v, Node from, Node to, int start, int end, int bandwidth); MigrateVM(VM v, Node from, Node to, int start, int end); Node getSourceNode(); int getBandwidth(); @Override Node getDestinationNode(); @Override VM getVM(); @Override boolean applyAction(Model i); @Override boolean equals(Object o); @Override int hashCode(); @Override String pretty(); @Override Object visit(ActionVisitor v); boolean setBandwidth(int bandwidth); } | @Test public void testVisit() { ActionVisitor visitor = mock(ActionVisitor.class); a.visit(visitor); verify(visitor).visit(a); } |
ResourceCapacityConverter implements ConstraintConverter<ResourceCapacity> { @Override public String getJSONId() { return "resourceCapacity"; } @Override Class<ResourceCapacity> getSupportedConstraint(); @Override String getJSONId(); @Override ResourceCapacity fromJSON(Model mo, JSONObject o); @Override JSONObject toJSON(ResourceCapacity o); } | @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(ResourceCapacity.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new ResourceCapacityConverter().getJSONId())); } |
KillVM extends Action implements VMStateTransition { @Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } KillVM killVM = (KillVM) o; return Objects.equals(id, killVM.id) && Objects.equals(host, killVM.host); } KillVM(VM vm, Node on, int start, int end); Node getNode(); @Override VM getVM(); @Override boolean applyAction(Model i); @Override boolean equals(Object o); @Override int hashCode(); @Override String pretty(); @Override VMState getCurrentState(); @Override VMState getNextState(); @Override Object visit(ActionVisitor v); } | @Test(dependsOnMethods = {"testInstantiate"}) public void testEquals() { KillVM a = new KillVM(vms.get(0), ns.get(0), 3, 5); KillVM b = new KillVM(vms.get(0), ns.get(0), 3, 5); Assert.assertFalse(a.equals(new Object())); Assert.assertTrue(a.equals(a)); Assert.assertTrue(a.equals(b)); Assert.assertEquals(a.hashCode(), b.hashCode()); Assert.assertNotSame(a, new KillVM(vms.get(0), ns.get(0), 4, 5)); Assert.assertNotSame(a, new KillVM(vms.get(0), ns.get(0), 3, 4)); Assert.assertNotSame(a, new KillVM(vms.get(0), ns.get(1), 3, 5)); Assert.assertNotSame(a, new KillVM(vms.get(1), ns.get(0), 4, 5)); } |
KillVM extends Action implements VMStateTransition { @Override public Object visit(ActionVisitor v) { return v.visit(this); } KillVM(VM vm, Node on, int start, int end); Node getNode(); @Override VM getVM(); @Override boolean applyAction(Model i); @Override boolean equals(Object o); @Override int hashCode(); @Override String pretty(); @Override VMState getCurrentState(); @Override VMState getNextState(); @Override Object visit(ActionVisitor v); } | @Test public void testVisit() { ActionVisitor visitor = mock(ActionVisitor.class); a.visit(visitor); verify(visitor).visit(a); } |
InconsistentSolutionException extends SchedulerModelingException { public ReconfigurationPlan getResult() { return plan; } InconsistentSolutionException(ReconfigurationPlan p, String msg); ReconfigurationPlan getResult(); } | @Test public void test() { final Model mo = new DefaultModel(); final ReconfigurationPlan plan = new DefaultReconfigurationPlan(mo); final InconsistentSolutionException ex = new InconsistentSolutionException(plan, "foo"); Assert.assertEquals(ex.getModel(), mo); Assert.assertEquals(ex.getResult(), plan); Assert.assertEquals(ex.getMessage(), "foo"); } |
SchedulerException extends RuntimeException { public Model getModel() { return model; } SchedulerException(Model m, String msg); SchedulerException(Model m, String msg, Throwable t); Model getModel(); } | @Test public void testBasic() { Model mo = new DefaultModel(); SchedulerException ex = new SchedulerException(mo, "foo"); Assert.assertEquals(ex.getModel(), mo); Assert.assertEquals(ex.getMessage(), "foo"); SchedulerException ex2 = new SchedulerException(mo, "foo", ex); Assert.assertEquals(ex2.getModel(), mo); Assert.assertEquals(ex2.getMessage(), "foo"); Assert.assertEquals(ex2.getCause(), ex); } |
UnstatableProblemException extends SchedulerException { public int timeout() { return duration; } UnstatableProblemException(Model m, int to); int timeout(); } | @Test public void test() { final Model mo = new DefaultModel(); final UnstatableProblemException ex = new UnstatableProblemException(mo, 7); Assert.assertEquals(ex.getModel(), mo); Assert.assertEquals(ex.timeout(), 7); Assert.assertTrue(ex.getMessage().contains("Unable to state about the problem feasibility within the allotted 7 seconds")); } |
SchedulerModelingException extends SchedulerException { public static SchedulerModelingException missingView(Model m, String viewId) { return new SchedulerModelingException(m, "View '" + viewId + "' is required but missing"); } SchedulerModelingException(Model m, String msg); SchedulerModelingException(Model m, String msg, Throwable t); static SchedulerModelingException missingView(Model m, String viewId); } | @Test public void simpleTests() { final Model mo = new DefaultModel(); SchedulerModelingException ex = SchedulerModelingException.missingView(mo, "foo"); Assert.assertEquals(ex.getModel(), mo); Assert.assertTrue(ex.getMessage().contains("foo")); final Exception baz = new Exception("baz"); ex = new SchedulerModelingException(mo, "foo", baz); Assert.assertEquals(ex.getModel(), mo); Assert.assertEquals(ex.getMessage(), "foo"); Assert.assertEquals(ex.getCause(), baz); } |
FixedNodeSetsPartitioning extends StaticPartitioning { @Override public List<Instance> split(Parameters ps, Instance i) throws SchedulerException { Model mo = i.getModel(); SynchronizedElementBuilder eb = new SynchronizedElementBuilder(mo); List<Instance> parts = new ArrayList<>(partitions.size()); int nbVMs = i.getModel().getMapping().getNbVMs(); int nbNodes = i.getModel().getMapping().getNbNodes(); TIntIntHashMap vmPosition = new TIntIntHashMap(nbVMs); TIntIntHashMap nodePosition = new TIntIntHashMap(nbNodes); int partNumber = 0; Set<VM> toLaunch = getVMsToLaunch(i); for (Collection<Node> s : partitions) { SubModel partModel = new SubModel(mo, eb, s, new HashSet<>(toLaunch.size() / partitions.size())); parts.add(new Instance(partModel, new THashSet<>(), i.getOptConstraint())); partModel.getMapping().fillVMIndex(vmPosition, partNumber); for (Node n : s) { nodePosition.put(n.id(), partNumber); } partNumber++; } int p = 0; for (VM v : toLaunch) { if (!parts.get(p).getModel().getMapping().addReadyVM(v)) { throw new SplitException(parts.get(p).getModel(), "Unable to dispatch the VM to launch '" + v + "'"); } vmPosition.put(v.id(), p); p = (p + 1) % parts.size(); } for (SatConstraint cstr : i.getSatConstraints()) { if (!cstrMapper.split(cstr, i, parts, vmPosition, nodePosition)) { throw new SplitException(i.getModel(), "Unable to split " + cstr); } } return parts; } FixedNodeSetsPartitioning(Collection<Collection<Node>> parts); ConstraintSplitterMapper getSplitterMapper(); void setSplitterMapper(ConstraintSplitterMapper m); Collection<Collection<Node>> getPartitions(); boolean setPartitions(Collection<Collection<Node>> parts); @Override List<Instance> split(Parameters ps, Instance i); } | @Test public void testSplit() throws SchedulerException { Instance origin = makeInstance(); List<Collection<Node>> parts = splitIn(origin.getModel().getMapping().getAllNodes(), 3); FixedNodeSetsPartitioning f = new FixedNodeSetsPartitioning(parts); f.setWorkersCount(3); List<Instance> subs = f.split(new DefaultParameters(), origin); Set<VM> allReady = new HashSet<>(); for (Instance i : subs) { allReady.addAll(i.getModel().getMapping().getReadyVMs()); } Assert.assertEquals(allReady.size(), 30); DefaultChocoScheduler cra = new DefaultChocoScheduler(); cra.setInstanceSolver(f); ReconfigurationPlan plan = cra.solve(origin); Assert.assertEquals(plan.getSize(), 30); System.out.println(cra.getStatistics()); System.out.flush(); }
@Test(expectedExceptions = {SchedulerException.class}) public void testSplitWithUnsplittableConstraint() throws SchedulerException { Instance orig = makeInstance(); orig.getSatConstraints().add(new MaxOnline(orig.getModel().getMapping().getAllNodes(), 5)); List<Collection<Node>> parts = splitIn(orig.getModel().getMapping().getAllNodes(), 3); FixedNodeSetsPartitioning f = new FixedNodeSetsPartitioning(parts); f.split(new DefaultParameters(), orig); } |
StaticPartitioning implements InstanceSolver { @Override public ReconfigurationPlan solve(Parameters cra, Instance orig) throws SchedulerException { stats = new StaticPartitioningStatistics(cra, orig, System.currentTimeMillis(), workersCount); long d = -System.currentTimeMillis(); List<Instance> partitions = split(cra, orig); d += System.currentTimeMillis(); stats.setSplittingStatistics(partitions.size(), d); ExecutorService exe = Executors.newFixedThreadPool(this.workersCount); CompletionService<SolvingStatistics> completionService = new ExecutorCompletionService<>(exe); List<SolvingStatistics> results = new ArrayList<>(partitions.size()); runners = new ArrayList<>(); long duration = -System.currentTimeMillis(); for (Instance partition : partitions) { InstanceSolverRunner runner = new InstanceSolverRunner(cra, partition); completionService.submit(runner); runners.add(runner); } for (int i = 0; i < partitions.size(); i++) { try { results.add(completionService.take().get()); } catch (ExecutionException ignore) { Throwable cause = ignore.getCause(); if (cause != null) { throw new SplitException(null, cause.getMessage(), ignore); } } catch (InterruptedException e) { Thread.currentThread().interrupt(); throw new SplitException(orig.getModel(), e.getMessage(), e); } } duration += System.currentTimeMillis(); stats.setSolvingDuration(duration); exe.shutdown(); return merge(orig, results); } StaticPartitioning(); int getWorkersCount(); void setWorkersCount(int s); @Override ReconfigurationPlan solve(Parameters cra, Instance orig); @Override StaticPartitioningStatistics getStatistics(); abstract List<Instance> split(Parameters ps, Instance i); @Override void stop(); } | @Test(expectedExceptions = {SchedulerException.class}) public void testSolvingIncorrectPartitioning() throws SchedulerException { SynchronizedElementBuilder eb = new SynchronizedElementBuilder(new DefaultElementBuilder()); Model origin = new DefaultModel(eb); Node n1 = origin.newNode(); Node n2 = origin.newNode(); VM vm1 = origin.newVM(); VM vm2 = origin.newVM(); origin.getMapping().addOnlineNode(n1); origin.getMapping().addOfflineNode(n2); origin.getMapping().addReadyVM(vm1); origin.getMapping().addReadyVM(vm2); Model s1 = new SubModel(origin, eb, Collections.singletonList(n1), Collections.singleton(vm1)); Model s2 = new SubModel(origin, eb, Collections.singletonList(n2), Collections.singleton(vm2)); Instance i0 = new Instance(origin, new MinMTTR()); final Instance i1 = new Instance(s1, Running.newRunning(Collections.singletonList(vm1)), new MinMTTR()); final Instance i2 = new Instance(s2, new MinMTTR()); i2.getSatConstraints().add(new Running(vm1)); StaticPartitioning st = new StaticPartitioning() { @Override public List<Instance> split(Parameters ps, Instance i) throws SchedulerException { return Arrays.asList(i1, i2); } }; Parameters p = new DefaultChocoScheduler(); st.solve(p, i0); } |
GatherSplitter implements ConstraintSplitter<Gather> { @Override public boolean split(Gather cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition) { final boolean c = cstr.isContinuous(); return SplittableElementSet.newVMIndex(cstr.getInvolvedVMs(), vmsPosition). forEachPartition(new IterateProcedure<VM>() { private boolean first = true; @Override public boolean extract(SplittableElementSet<VM> index, int idx, int from, int to) { if (!first) { return false; } if (to - from >= 2) { partitions.get(idx).getSatConstraints().add(new Gather(new ElementSubSet<>(index, idx, from, to), c)); first = false; } return true; } }); } @Override Class<Gather> getKey(); @Override boolean split(Gather cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition); } | @Test public void simpleTest() { GatherSplitter splitter = new GatherSplitter(); List<Instance> instances = new ArrayList<>(); Model m0 = new DefaultModel(); m0.getMapping().addReadyVM(m0.newVM(1)); Node n1 = m0.newNode(); m0.getMapping().addOnlineNode(n1); m0.getMapping().addRunningVM(m0.newVM(2), n1); Model m1 = new DefaultModel(); Node n2 = m1.newNode(); Node n3 = m1.newNode(); m1.getMapping().addOnlineNode(n2); m1.getMapping().addOnlineNode(n3); m1.getMapping().addReadyVM(m1.newVM(3)); m1.getMapping().addSleepingVM(m1.newVM(4), n2); m1.getMapping().addRunningVM(m1.newVM(5), n3); instances.add(new Instance(m0, new ArrayList<>(), new MinMTTR())); instances.add(new Instance(m1, new ArrayList<>(), new MinMTTR())); Set<VM> all = new HashSet<>(m0.getMapping().getAllVMs()); all.addAll(m1.getMapping().getAllVMs()); TIntIntHashMap vmIndex = Instances.makeVMIndex(instances); Gather single = new Gather(m0.getMapping().getAllVMs()); Assert.assertTrue(splitter.split(single, null, instances, vmIndex, new TIntIntHashMap())); Assert.assertTrue(instances.get(0).getSatConstraints().contains(single)); Assert.assertFalse(instances.get(1).getSatConstraints().contains(single)); Gather among = new Gather(all, false); Assert.assertFalse(splitter.split(among, null, instances, vmIndex, new TIntIntHashMap())); } |
AmongConverter implements ConstraintConverter<Among> { @Override public String getJSONId() { return "among"; } @Override Class<Among> getSupportedConstraint(); @Override String getJSONId(); @Override Among fromJSON(Model mo, JSONObject o); @Override JSONObject toJSON(Among o); } | @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Among.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new AmongConverter().getJSONId())); } |
SpreadSplitter implements ConstraintSplitter<Spread> { @Override public boolean split(final Spread cstr, Instance origin, final List<Instance> partitions, final TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition) { final boolean c = cstr.isContinuous(); return SplittableElementSet.newVMIndex(cstr.getInvolvedVMs(), vmsPosition). forEachPartition((index, idx, from, to) -> { if (to - from >= 2) { partitions.get(idx).getSatConstraints().add(new Spread(new ElementSubSet<>(index, idx, from, to), c)); } return true; }); } @Override Class<Spread> getKey(); @Override boolean split(final Spread cstr, Instance origin, final List<Instance> partitions, final TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition); } | @Test public void simpleTest() { SpreadSplitter splitter = new SpreadSplitter(); List<Instance> instances = new ArrayList<>(); Model m0 = new DefaultModel(); m0.getMapping().addReadyVM(m0.newVM(1)); Node n1 = m0.newNode(); m0.getMapping().addOnlineNode(n1); m0.getMapping().addRunningVM(m0.newVM(2), n1); Model m1 = new DefaultModel(); m1.getMapping().addReadyVM(m1.newVM(3)); Node n2 = m1.newNode(); Node n3 = m1.newNode(); m1.getMapping().addOnlineNode(n2); m1.getMapping().addOnlineNode(n3); m1.getMapping().addSleepingVM(m1.newVM(4), n2); m1.getMapping().addRunningVM(m1.newVM(5), n3); instances.add(new Instance(m0, new ArrayList<>(), new MinMTTR())); instances.add(new Instance(m1, new ArrayList<>(), new MinMTTR())); Set<VM> all = new HashSet<>(m0.getMapping().getAllVMs()); all.addAll(m1.getMapping().getAllVMs()); TIntIntHashMap index = Instances.makeVMIndex(instances); Spread spreadSingle = new Spread(m0.getMapping().getAllVMs()); Assert.assertTrue(splitter.split(spreadSingle, null, instances, index, new TIntIntHashMap())); Assert.assertTrue(instances.get(0).getSatConstraints().contains(spreadSingle)); Assert.assertFalse(instances.get(1).getSatConstraints().contains(spreadSingle)); Spread spreadAmong = new Spread(all, false); Assert.assertTrue(splitter.split(spreadAmong, null, instances, index, new TIntIntHashMap())); Assert.assertTrue(instances.get(0).getSatConstraints().contains(new Spread(m0.getMapping().getAllVMs(), false))); Assert.assertTrue(instances.get(1).getSatConstraints().contains(new Spread(m1.getMapping().getAllVMs(), false))); } |
RunningSplitter implements ConstraintSplitter<Running> { @Override public boolean split(Running cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition) { VM v = cstr.getInvolvedVMs().iterator().next(); int i = vmsPosition.get(v.id()); return partitions.get(i).getSatConstraints().add(cstr); } @Override Class<Running> getKey(); @Override boolean split(Running cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition); } | @Test public void simpleTest() { RunningSplitter splitter = new RunningSplitter(); List<Instance> instances = new ArrayList<>(); Model origin = new DefaultModel(); Node n1 = origin.newNode(); Node n2 = origin.newNode(); VM vm1 = origin.newVM(); VM vm2 = origin.newVM(); VM vm3 = origin.newVM(); VM vm4 = origin.newVM(); origin.getMapping().addOnlineNode(n1); origin.getMapping().addReadyVM(vm1); origin.getMapping().addRunningVM(vm2, n1); origin.getMapping().addOnlineNode(n2); origin.getMapping().addSleepingVM(vm3, n2); origin.getMapping().addRunningVM(vm4, n2); Model m0 = new DefaultModel(); m0.newNode(n1.id()); m0.newVM(vm1.id()); m0.newVM(vm2.id()); m0.getMapping().addOnlineNode(n1); m0.getMapping().addReadyVM(vm1); m0.getMapping().addRunningVM(vm2, n1); Model m1 = new DefaultModel(); m1.newNode(n2.id()); m1.newVM(vm3.id()); m1.newVM(vm4.id()); m1.getMapping().addOnlineNode(n2); m1.getMapping().addSleepingVM(vm3, n2); m1.getMapping().addRunningVM(vm4, n2); instances.add(new Instance(m0, new ArrayList<>(), new MinMTTR())); instances.add(new Instance(m1, new ArrayList<>(), new MinMTTR())); Set<VM> all = new HashSet<>(m0.getMapping().getAllVMs()); all.addAll(m1.getMapping().getAllVMs()); TIntIntHashMap index = Instances.makeVMIndex(instances); Running single = new Running(vm1); Assert.assertTrue(splitter.split(single, null, instances, index, new TIntIntHashMap())); Assert.assertTrue(instances.get(0).getSatConstraints().contains(single)); Assert.assertFalse(instances.get(1).getSatConstraints().contains(single)); } |
BanSplitter implements ConstraintSplitter<Ban> { @Override public boolean split(Ban cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition) { final SplittableElementSet<Node> nodeIndex = SplittableElementSet.newNodeIndex(cstr.getInvolvedNodes(), nodePosition); VM v = cstr.getInvolvedVMs().iterator().next(); int p = vmsPosition.get(v.id()); return partitions.get(p).getSatConstraints().add(new Ban(v, nodeIndex.getSubSet(p))); } @Override Class<Ban> getKey(); @Override boolean split(Ban cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition); } | @Test public void simpleTest() { BanSplitter splitter = new BanSplitter(); List<Instance> instances = new ArrayList<>(); Model origin = new DefaultModel(); Node n1 = origin.newNode(); Node n2 = origin.newNode(); VM vm1 = origin.newVM(); VM vm2 = origin.newVM(); VM vm3 = origin.newVM(); VM vm4 = origin.newVM(); origin.getMapping().addOnlineNode(n1); origin.getMapping().addReadyVM(vm1); origin.getMapping().addRunningVM(vm2, n1); origin.getMapping().addOnlineNode(n2); origin.getMapping().addSleepingVM(vm3, n2); origin.getMapping().addRunningVM(vm4, n2); Model m0 = new DefaultModel(); m0.newNode(n1.id()); m0.newVM(vm1.id()); m0.newVM(vm2.id()); m0.getMapping().addOnlineNode(n1); m0.getMapping().addReadyVM(vm1); m0.getMapping().addRunningVM(vm2, n1); Model m1 = new DefaultModel(); m1.newNode(n2.id()); m1.newVM(vm3.id()); m1.newVM(vm4.id()); m1.getMapping().addOnlineNode(n2); m1.getMapping().addSleepingVM(vm3, n2); m1.getMapping().addRunningVM(vm4, n2); instances.add(new Instance(m0, new ArrayList<>(), new MinMTTR())); instances.add(new Instance(m1, new ArrayList<>(), new MinMTTR())); Set<VM> all = new HashSet<>(m0.getMapping().getAllVMs()); all.addAll(m1.getMapping().getAllVMs()); TIntIntHashMap vmIndex = Instances.makeVMIndex(instances); TIntIntHashMap nodeIndex = Instances.makeNodeIndex(instances); Ban single = new Ban(vm1, m0.getMapping().getAllNodes()); Assert.assertTrue(splitter.split(single, null, instances, vmIndex, nodeIndex)); Assert.assertTrue(instances.get(0).getSatConstraints().contains(single)); Assert.assertFalse(instances.get(1).getSatConstraints().contains(single)); Ban among = new Ban(vm3, m1.getMapping().getAllNodes()); Assert.assertTrue(splitter.split(among, null, instances, vmIndex, nodeIndex)); Assert.assertTrue(instances.get(0).getSatConstraints().contains(new Ban(vm1, m0.getMapping().getAllNodes()))); Assert.assertTrue(instances.get(1).getSatConstraints().contains(new Ban(vm3, m1.getMapping().getAllNodes()))); } |
OfflineSplitter implements ConstraintSplitter<Offline> { @Override public boolean split(Offline cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition) { Node n = cstr.getInvolvedNodes().iterator().next(); int i = nodePosition.get(n.id()); return partitions.get(i).getSatConstraints().add(cstr); } @Override Class<Offline> getKey(); @Override boolean split(Offline cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition); } | @Test public void simpleTest() { OfflineSplitter splitter = new OfflineSplitter(); List<Instance> instances = new ArrayList<>(); Model m0 = new DefaultModel(); Node n = m0.newNode(); m0.getMapping().addOfflineNode(n); m0.getMapping().addOfflineNode(m0.newNode(1)); Model m1 = new DefaultModel(); m1.getMapping().addOfflineNode(m1.newNode(2)); m1.getMapping().addOfflineNode(m1.newNode(3)); instances.add(new Instance(m0, new ArrayList<>(), new MinMTTR())); instances.add(new Instance(m1, new ArrayList<>(), new MinMTTR())); Set<Node> all = new HashSet<>(m0.getMapping().getAllNodes()); all.addAll(m1.getMapping().getAllNodes()); TIntIntHashMap nodeIndex = Instances.makeNodeIndex(instances); Offline oSimple = new Offline(n); Assert.assertTrue(splitter.split(oSimple, null, instances, new TIntIntHashMap(), nodeIndex)); Assert.assertTrue(instances.get(0).getSatConstraints().contains(oSimple)); Assert.assertFalse(instances.get(1).getSatConstraints().contains(oSimple)); } |
KilledSplitter implements ConstraintSplitter<Killed> { @Override public boolean split(Killed cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition) { VM v = cstr.getInvolvedVMs().iterator().next(); int i = vmsPosition.get(v.id()); return partitions.get(i).getSatConstraints().add(cstr); } @Override Class<Killed> getKey(); @Override boolean split(Killed cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition); } | @Test public void simpleTest() { KilledSplitter splitter = new KilledSplitter(); List<Instance> instances = new ArrayList<>(); Model m0 = new DefaultModel(); VM v = m0.newVM(1); m0.getMapping().addReadyVM(v); m0.getMapping().addRunningVM(m0.newVM(2), m0.newNode(1)); Model m1 = new DefaultModel(); m1.getMapping().addReadyVM(m1.newVM(3)); m1.getMapping().addSleepingVM(m1.newVM(4), m1.newNode(2)); m1.getMapping().addRunningVM(m1.newVM(5), m1.newNode(3)); instances.add(new Instance(m0, new ArrayList<>(), new MinMTTR())); instances.add(new Instance(m1, new ArrayList<>(), new MinMTTR())); TIntIntHashMap index = Instances.makeVMIndex(instances); Set<VM> all = new HashSet<>(m0.getMapping().getAllVMs()); all.addAll(m1.getMapping().getAllVMs()); Killed single = new Killed(v); Assert.assertTrue(splitter.split(single, null, instances, index, new TIntIntHashMap())); Assert.assertTrue(instances.get(0).getSatConstraints().contains(single)); Assert.assertFalse(instances.get(1).getSatConstraints().contains(single)); } |
SleepingSplitter implements ConstraintSplitter<Sleeping> { @Override public boolean split(Sleeping cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition) { VM v = cstr.getInvolvedVMs().iterator().next(); int i = vmsPosition.get(v.id()); return partitions.get(i).getSatConstraints().add(cstr); } @Override Class<Sleeping> getKey(); @Override boolean split(Sleeping cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition); } | @Test public void simpleTest() { SleepingSplitter splitter = new SleepingSplitter(); List<Instance> instances = new ArrayList<>(); Model origin = new DefaultModel(); Node n1 = origin.newNode(); Node n2 = origin.newNode(); VM vm1 = origin.newVM(); VM vm2 = origin.newVM(); VM vm3 = origin.newVM(); VM vm4 = origin.newVM(); origin.getMapping().addOnlineNode(n1); origin.getMapping().addReadyVM(vm1); origin.getMapping().addRunningVM(vm2, n1); origin.getMapping().addOnlineNode(n2); origin.getMapping().addSleepingVM(vm3, n2); origin.getMapping().addRunningVM(vm4, n2); Model m0 = new DefaultModel(); m0.newNode(n1.id()); m0.newVM(vm1.id()); m0.newVM(vm2.id()); m0.getMapping().addOnlineNode(n1); m0.getMapping().addReadyVM(vm1); m0.getMapping().addRunningVM(vm2, n1); Model m1 = new DefaultModel(); m1.newNode(n2.id()); m1.newVM(vm3.id()); m1.newVM(vm4.id()); m1.getMapping().addOnlineNode(n2); m1.getMapping().addSleepingVM(vm3, n2); m1.getMapping().addRunningVM(vm4, n2); instances.add(new Instance(m0, new ArrayList<>(), new MinMTTR())); instances.add(new Instance(m1, new ArrayList<>(), new MinMTTR())); Set<VM> all = new HashSet<>(m0.getMapping().getAllVMs()); all.addAll(m1.getMapping().getAllVMs()); TIntIntHashMap index = Instances.makeVMIndex(instances); Sleeping single = new Sleeping(vm2); Assert.assertTrue(splitter.split(single, null, instances, index, new TIntIntHashMap())); Assert.assertTrue(instances.get(0).getSatConstraints().contains(single)); Assert.assertFalse(instances.get(1).getSatConstraints().contains(single)); } |
LonelySplitter implements ConstraintSplitter<Lonely> { @Override public boolean split(Lonely cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition) { final boolean c = cstr.isContinuous(); return SplittableElementSet.newVMIndex(cstr.getInvolvedVMs(), vmsPosition). forEachPartition((index, idx, from, to) -> { if (to != from) { partitions.get(idx).getSatConstraints().add(new Lonely(new ElementSubSet<>(index, idx, from, to), c)); } return true; }); } @Override Class<Lonely> getKey(); @Override boolean split(Lonely cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition); } | @Test public void simpleTest() { LonelySplitter splitter = new LonelySplitter(); List<Instance> instances = new ArrayList<>(); Model m0 = new DefaultModel(); m0.getMapping().addReadyVM(m0.newVM(1)); m0.getMapping().addRunningVM(m0.newVM(2), m0.newNode(1)); Model m1 = new DefaultModel(); m1.getMapping().addReadyVM(m1.newVM(3)); m1.getMapping().addSleepingVM(m1.newVM(4), m1.newNode(2)); m1.getMapping().addRunningVM(m1.newVM(5), m1.newNode(3)); instances.add(new Instance(m0, new ArrayList<>(), new MinMTTR())); instances.add(new Instance(m1, new ArrayList<>(), new MinMTTR())); TIntIntHashMap index = Instances.makeVMIndex(instances); Set<VM> all = new HashSet<>(m0.getMapping().getAllVMs()); all.addAll(m1.getMapping().getAllVMs()); Lonely single = new Lonely(m0.getMapping().getAllVMs()); Assert.assertTrue(splitter.split(single, null, instances, index, new TIntIntHashMap())); Assert.assertTrue(instances.get(0).getSatConstraints().contains(single)); Assert.assertFalse(instances.get(1).getSatConstraints().contains(single)); Lonely among = new Lonely(all, false); Assert.assertTrue(splitter.split(among, null, instances, index, new TIntIntHashMap())); Assert.assertTrue(instances.get(0).getSatConstraints().contains(new Lonely(m0.getMapping().getAllVMs(), false))); Assert.assertTrue(instances.get(1).getSatConstraints().contains(new Lonely(m1.getMapping().getAllVMs(), false))); } |
MaxOnlineSplitter implements ConstraintSplitter<MaxOnline> { @Override public boolean split(MaxOnline cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition) { final boolean c = cstr.isContinuous(); final int q = cstr.getAmount(); return SplittableElementSet.newNodeIndex(cstr.getInvolvedNodes(), nodePosition). forEachPartition(new IterateProcedure<Node>() { private boolean first = true; @Override public boolean extract(SplittableElementSet<Node> index, int idx, int from, int to) { if (!first) { return false; } if (to - from >= 1) { partitions.get(idx).getSatConstraints().add(new MaxOnline(new ElementSubSet<>(index, idx, from, to), q, c)); first = false; } return true; } }); } @Override Class<MaxOnline> getKey(); @Override boolean split(MaxOnline cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition); } | @Test public void testSplit() throws SchedulerException { MaxOnlineSplitter splitter = new MaxOnlineSplitter(); Model mo = new DefaultModel(); Node[] ns = new Node[10]; for (int i = 0; i < ns.length; i++) { Node n = mo.newNode(); mo.getMapping().addOnlineNode(n); ns[i] = n; } FixedNodeSetsPartitioning cut = new FixedSizePartitioning(5); Instance origin = new Instance(mo, Collections.emptyList(), new MinMTTR()); List<Instance> instances = cut.split(new DefaultParameters(), origin); TIntIntHashMap vmIndex = Instances.makeVMIndex(instances); TIntIntHashMap nodeIndex = Instances.makeNodeIndex(instances); MaxOnline m1 = new MaxOnline(new HashSet<>(Arrays.asList(ns[0], ns[1], ns[2], ns[3], ns[4])), 3); Assert.assertTrue(splitter.split(m1, origin, instances, vmIndex, nodeIndex)); boolean found = false; for (Instance i : instances) { if (i.getSatConstraints().contains(m1)) { if (found) { Assert.fail(m1 + " is already in a partition"); } found = true; } } MaxOnline m2 = new MaxOnline(new HashSet<>(Arrays.asList(ns[0], ns[1], ns[5])), 3); Assert.assertFalse(splitter.split(m2, origin, instances, vmIndex, nodeIndex)); } |
PreserveSplitter implements ConstraintSplitter<Preserve> { @Override public boolean split(Preserve cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition) { VM v = cstr.getInvolvedVMs().iterator().next(); int p = vmsPosition.get(v.id()); return partitions.get(p).getSatConstraints().add(cstr); } @Override Class<Preserve> getKey(); @Override boolean split(Preserve cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition); } | @Test public void simpleTest() { PreserveSplitter splitter = new PreserveSplitter(); List<Instance> instances = new ArrayList<>(); Model m0 = new DefaultModel(); VM v = m0.newVM(1); m0.getMapping().addReadyVM(v); m0.getMapping().addRunningVM(m0.newVM(2), m0.newNode(1)); Model m1 = new DefaultModel(); m1.getMapping().addReadyVM(m1.newVM(3)); m1.getMapping().addSleepingVM(m1.newVM(4), m1.newNode(2)); m1.getMapping().addRunningVM(m1.newVM(5), m1.newNode(3)); instances.add(new Instance(m0, new ArrayList<>(), new MinMTTR())); instances.add(new Instance(m1, new ArrayList<>(), new MinMTTR())); TIntIntHashMap index = Instances.makeVMIndex(instances); Set<VM> all = new HashSet<>(m0.getMapping().getAllVMs()); all.addAll(m1.getMapping().getAllVMs()); Preserve single = new Preserve(v, "foo", 3); Assert.assertTrue(splitter.split(single, null, instances, index, new TIntIntHashMap())); Assert.assertTrue(instances.get(0).getSatConstraints().contains(single)); Assert.assertFalse(instances.get(1).getSatConstraints().contains(single)); } |
OverbookSplitter implements ConstraintSplitter<Overbook> { @Override public boolean split(Overbook cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition) { Node n = cstr.getInvolvedNodes().iterator().next(); int i = nodePosition.get(n.id()); return partitions.get(i).getSatConstraints().add(cstr); } @Override Class<Overbook> getKey(); @Override boolean split(Overbook cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition); } | @Test public void simpleTest() { OverbookSplitter splitter = new OverbookSplitter(); List<Instance> instances = new ArrayList<>(); Model m0 = new DefaultModel(); Node n = m0.newNode(0); m0.getMapping().addOnlineNode(n); m0.getMapping().addOnlineNode(m0.newNode(1)); Model m1 = new DefaultModel(); m1.getMapping().addOnlineNode(m1.newNode(2)); m1.getMapping().addOnlineNode(m1.newNode(3)); instances.add(new Instance(m0, new ArrayList<>(), new MinMTTR())); instances.add(new Instance(m1, new ArrayList<>(), new MinMTTR())); Set<Node> all = new HashSet<>(m0.getMapping().getAllNodes()); all.addAll(m1.getMapping().getAllNodes()); TIntIntHashMap nodeIndex = Instances.makeNodeIndex(instances); Overbook oSimple = new Overbook(n, "cpu", 2); Assert.assertTrue(splitter.split(oSimple, null, instances, new TIntIntHashMap(), nodeIndex)); Assert.assertTrue(instances.get(0).getSatConstraints().contains(oSimple)); Assert.assertFalse(instances.get(1).getSatConstraints().contains(oSimple)); } |
QuarantineConverter implements ConstraintConverter<Quarantine> { @Override public String getJSONId() { return "quarantine"; } @Override Class<Quarantine> getSupportedConstraint(); @Override String getJSONId(); @Override Quarantine fromJSON(Model mo, JSONObject o); @Override JSONObject toJSON(Quarantine o); } | @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Quarantine.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new QuarantineConverter().getJSONId())); } |
OnlineSplitter implements ConstraintSplitter<Online> { @Override public boolean split(Online cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition) { Node n = cstr.getInvolvedNodes().iterator().next(); int i = nodePosition.get(n.id()); return partitions.get(i).getSatConstraints().add(cstr); } @Override Class<Online> getKey(); @Override boolean split(Online cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition); } | @Test public void simpleTest() { OnlineSplitter splitter = new OnlineSplitter(); List<Instance> instances = new ArrayList<>(); Model m0 = new DefaultModel(); Node n = m0.newNode(); m0.getMapping().addOnlineNode(n); m0.getMapping().addOnlineNode(m0.newNode(1)); Model m1 = new DefaultModel(); m1.getMapping().addOnlineNode(m1.newNode(2)); m1.getMapping().addOnlineNode(m1.newNode(3)); instances.add(new Instance(m0, new ArrayList<>(), new MinMTTR())); instances.add(new Instance(m1, new ArrayList<>(), new MinMTTR())); Set<Node> all = new HashSet<>(m0.getMapping().getAllNodes()); all.addAll(m1.getMapping().getAllNodes()); TIntIntHashMap nodeIndex = Instances.makeNodeIndex(instances); Online oSimple = new Online(n); Assert.assertTrue(splitter.split(oSimple, null, instances, new TIntIntHashMap(), nodeIndex)); Assert.assertTrue(instances.get(0).getSatConstraints().contains(oSimple)); Assert.assertFalse(instances.get(1).getSatConstraints().contains(oSimple)); } |
RootSplitter implements ConstraintSplitter<Root> { @Override public boolean split(Root cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition) { VM v = cstr.getInvolvedVMs().iterator().next(); int i = vmsPosition.get(v.id()); return partitions.get(i).getSatConstraints().add(cstr); } @Override Class<Root> getKey(); @Override boolean split(Root cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition); } | @Test public void simpleTest() { RootSplitter splitter = new RootSplitter(); List<Instance> instances = new ArrayList<>(); Model m0 = new DefaultModel(); VM v = m0.newVM(1); m0.getMapping().addReadyVM(v); m0.getMapping().addRunningVM(m0.newVM(2), m0.newNode(1)); Model m1 = new DefaultModel(); m1.getMapping().addReadyVM(m1.newVM(3)); m1.getMapping().addSleepingVM(m1.newVM(4), m1.newNode(2)); m1.getMapping().addRunningVM(m1.newVM(5), m1.newNode(3)); instances.add(new Instance(m0, new ArrayList<>(), new MinMTTR())); instances.add(new Instance(m1, new ArrayList<>(), new MinMTTR())); Set<VM> all = new HashSet<>(m0.getMapping().getAllVMs()); all.addAll(m1.getMapping().getAllVMs()); TIntIntHashMap index = Instances.makeVMIndex(instances); Root single = new Root(v); Assert.assertTrue(splitter.split(single, null, instances, index, new TIntIntHashMap())); Assert.assertTrue(instances.get(0).getSatConstraints().contains(single)); Assert.assertFalse(instances.get(1).getSatConstraints().contains(single)); } |
ReadySplitter implements ConstraintSplitter<Ready> { @Override public boolean split(Ready cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition) { VM v = cstr.getInvolvedVMs().iterator().next(); int i = vmsPosition.get(v.id()); return partitions.get(i).getSatConstraints().add(cstr); } @Override Class<Ready> getKey(); @Override boolean split(Ready cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, TIntIntHashMap nodePosition); } | @Test public void simpleTest() { ReadySplitter splitter = new ReadySplitter(); List<Instance> instances = new ArrayList<>(); Model m0 = new DefaultModel(); VM v = m0.newVM(1); m0.getMapping().addReadyVM(v); m0.getMapping().addRunningVM(m0.newVM(2), m0.newNode(1)); Model m1 = new DefaultModel(); m1.getMapping().addReadyVM(m1.newVM(3)); m1.getMapping().addSleepingVM(m1.newVM(4), m1.newNode(2)); m1.getMapping().addRunningVM(m1.newVM(5), m1.newNode(3)); instances.add(new Instance(m0, new ArrayList<>(), new MinMTTR())); instances.add(new Instance(m1, new ArrayList<>(), new MinMTTR())); Set<VM> all = new HashSet<>(m0.getMapping().getAllVMs()); all.addAll(m1.getMapping().getAllVMs()); TIntIntHashMap index = Instances.makeVMIndex(instances); Ready single = new Ready(v); Assert.assertTrue(splitter.split(single, null, instances, index, new TIntIntHashMap())); Assert.assertTrue(instances.get(0).getSatConstraints().contains(single)); Assert.assertFalse(instances.get(1).getSatConstraints().contains(single)); } |
AmongSplitter implements ConstraintSplitter<Among> { @Override public boolean split(final Among cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, final TIntIntHashMap nodePosition) { final boolean c = cstr.isContinuous(); return SplittableElementSet.newVMIndex(cstr.getInvolvedVMs(), vmsPosition). forEachPartition((index, idx, from, to) -> { if (to - from >= 2) { ElementSubSet<VM> vms = new ElementSubSet<>(index, idx, from, to); final Collection<Collection<Node>> subParams = new ArrayList<>(); for (Collection<Node> ns : cstr.getGroupsOfNodes()) { SplittableElementSet<Node> nodeIndex = SplittableElementSet.newNodeIndex(ns, nodePosition); Set<Node> s = nodeIndex.getSubSet(idx); if (s != null && !s.isEmpty()) { subParams.add(s); } } partitions.get(idx).getSatConstraints().add(new Among(vms, subParams, c)); } return true; }); } @Override Class<Among> getKey(); @Override boolean split(final Among cstr, Instance origin, final List<Instance> partitions, TIntIntHashMap vmsPosition, final TIntIntHashMap nodePosition); } | @Test public void testSplittable() throws SchedulerException { List<VM> vms = Arrays.asList(vm1, vm2, vm3); Collection<Collection<Node>> parts = new ArrayList<>(); parts.add(Arrays.asList(n1, n2)); parts.add(Collections.singletonList(n3)); parts.add(Collections.singletonList(n4)); Among single = new Among(vms, parts); FixedNodeSetsPartitioning partitionner = new FixedNodeSetsPartitioning(parts); partitionner.setPartitions(parts); List<Instance> instances = partitionner.split(new DefaultParameters(), new Instance(mo, Collections.emptyList(), new MinMTTR())); TIntIntHashMap vmIndex = Instances.makeVMIndex(instances); TIntIntHashMap nodeIndex = Instances.makeNodeIndex(instances); splitter.split(single, new Instance(mo, new MinMTTR()), instances, vmIndex, nodeIndex); Among a = (Among) instances.get(0).getSatConstraints().iterator().next(); Assert.assertEquals(a.getGroupsOfNodes().size(), 1); Assert.assertEquals(a.getInvolvedNodes(), Arrays.asList(n1, n2)); for (Instance i : instances) { System.out.println(i.getSatConstraints()); } } |
Script { public boolean add(Collection<BtrpElement> elems) { boolean ret = false; for (BtrpElement el : elems) { ret |= add(el); } return ret; } Script(); void setFullyQualifiedName(String n); String getNamespace(); String getlocalName(); String id(); Set<VM> getVMs(); Set<Node> getNodes(); boolean addConstraint(SatConstraint c); Set<SatConstraint> getConstraints(); boolean add(Collection<BtrpElement> elems); boolean add(BtrpElement el); List<BtrpOperand> getImportables(String ns); BtrpOperand getImportable(String label, String namespace); BtrpOperand getImportable(String label); boolean canImport(String label, String namespace); void addExportable(String name, BtrpOperand e, Set<String> scopes); String fullyQualifiedSymbolName(String name); Set<String> getExported(); List<Script> getDependencies(); @Override String toString(); String prettyDependencies(); static final String EXTENSION; } | @Test public void testIncludeResolution() throws Exception { String include1 = "namespace foo.inc1;\n$myV = 3;\nexport $myV to *;"; String include2 = "namespace foo.inc2;\n$myV = 3;\nexport $myV to *;"; String script = "namespace foo.script;\nimport foo.inc1;\nimport foo.inc2;\n $myV = $foo.inc1.myV + $foo.inc2.myV; export $myV to *;"; Model mo = new DefaultModel(); ScriptBuilder builder = new ScriptBuilder(10, mo); BasicIncludes bi = new BasicIncludes(); Script scr1 = builder.build(include1); Script scr2 = builder.build(include2); bi.add(scr1); bi.add(scr2); builder.setIncludes(bi); builder.build(script); } |
BtrpNumber extends DefaultBtrpOperand { @Override public BtrpNumber power(BtrpOperand nb) { checkType(nb); BtrpNumber x = (BtrpNumber) nb; if (x.dVal <= 0) { throw new UnsupportedOperationException(nb + " must be strictly positive"); } double res = Math.pow(dVal, x.dVal); return isInteger && x.isInteger ? new BtrpNumber((int) res, base) : new BtrpNumber(res); } BtrpNumber(int v, Base b); BtrpNumber(double d); @Override Type type(); Base getBase(); @Override BtrpNumber power(BtrpOperand nb); @Override BtrpNumber plus(BtrpOperand other); @Override BtrpNumber minus(BtrpOperand other); @Override BtrpNumber negate(); @Override BtrpNumber times(BtrpOperand other); @Override BtrpNumber div(BtrpOperand other); @Override BtrpNumber remainder(BtrpOperand other); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); @Override int degree(); int getIntValue(); double getDoubleValue(); @Override BtrpNumber eq(BtrpOperand other); @Override BtrpNumber geq(BtrpOperand other); @Override BtrpNumber gt(BtrpOperand other); @Override BtrpNumber not(); @Override BtrpNumber copy(); boolean isInteger(); static final BtrpNumber TRUE; static final BtrpNumber FALSE; } | @Test(expectedExceptions = {UnsupportedOperationException.class}) public void testNonViablePower() { BtrpNumber i = new BtrpNumber(5, BtrpNumber.Base.BASE_16); Model mo = new DefaultModel(); BtrpElement j = new BtrpElement(BtrpOperand.Type.VM, "foo", mo.newVM()); i.power(j); }
@Test(expectedExceptions = {UnsupportedOperationException.class}) public void testNonViablePower2() { BtrpNumber i = new BtrpNumber(5, BtrpNumber.Base.BASE_16); BtrpNumber j = new BtrpNumber(-3, BtrpNumber.Base.BASE_16); i.power(j); } |
BtrpNumber extends DefaultBtrpOperand { @Override public BtrpNumber plus(BtrpOperand other) { checkType(other); BtrpNumber x = (BtrpNumber) other; double res = dVal + x.dVal; return isInteger && x.isInteger ? new BtrpNumber((int) res, base) : new BtrpNumber(res); } BtrpNumber(int v, Base b); BtrpNumber(double d); @Override Type type(); Base getBase(); @Override BtrpNumber power(BtrpOperand nb); @Override BtrpNumber plus(BtrpOperand other); @Override BtrpNumber minus(BtrpOperand other); @Override BtrpNumber negate(); @Override BtrpNumber times(BtrpOperand other); @Override BtrpNumber div(BtrpOperand other); @Override BtrpNumber remainder(BtrpOperand other); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); @Override int degree(); int getIntValue(); double getDoubleValue(); @Override BtrpNumber eq(BtrpOperand other); @Override BtrpNumber geq(BtrpOperand other); @Override BtrpNumber gt(BtrpOperand other); @Override BtrpNumber not(); @Override BtrpNumber copy(); boolean isInteger(); static final BtrpNumber TRUE; static final BtrpNumber FALSE; } | @Test(expectedExceptions = {UnsupportedOperationException.class}) public void testNonViableAddition() { BtrpNumber i = new BtrpNumber(5, BtrpNumber.Base.BASE_16); Model mo = new DefaultModel(); BtrpElement j = new BtrpElement(BtrpOperand.Type.VM, "foo", mo.newVM()); i.plus(j); } |
BtrpNumber extends DefaultBtrpOperand { @Override public BtrpNumber minus(BtrpOperand other) { checkType(other); BtrpNumber x = (BtrpNumber) other; double res = dVal - x.dVal; return isInteger && x.isInteger ? new BtrpNumber((int) res, base) : new BtrpNumber(res); } BtrpNumber(int v, Base b); BtrpNumber(double d); @Override Type type(); Base getBase(); @Override BtrpNumber power(BtrpOperand nb); @Override BtrpNumber plus(BtrpOperand other); @Override BtrpNumber minus(BtrpOperand other); @Override BtrpNumber negate(); @Override BtrpNumber times(BtrpOperand other); @Override BtrpNumber div(BtrpOperand other); @Override BtrpNumber remainder(BtrpOperand other); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); @Override int degree(); int getIntValue(); double getDoubleValue(); @Override BtrpNumber eq(BtrpOperand other); @Override BtrpNumber geq(BtrpOperand other); @Override BtrpNumber gt(BtrpOperand other); @Override BtrpNumber not(); @Override BtrpNumber copy(); boolean isInteger(); static final BtrpNumber TRUE; static final BtrpNumber FALSE; } | @Test(expectedExceptions = {UnsupportedOperationException.class}) public void testNonViableDifference() { BtrpNumber i = new BtrpNumber(5, BtrpNumber.Base.BASE_16); Model mo = new DefaultModel(); BtrpElement j = new BtrpElement(BtrpOperand.Type.VM, "foo", mo.newVM()); i.minus(j); } |
BtrpNumber extends DefaultBtrpOperand { @Override public BtrpNumber times(BtrpOperand other) { checkType(other); BtrpNumber x = (BtrpNumber) other; double res = dVal * x.dVal; return isInteger && x.isInteger ? new BtrpNumber((int) res, base) : new BtrpNumber(res); } BtrpNumber(int v, Base b); BtrpNumber(double d); @Override Type type(); Base getBase(); @Override BtrpNumber power(BtrpOperand nb); @Override BtrpNumber plus(BtrpOperand other); @Override BtrpNumber minus(BtrpOperand other); @Override BtrpNumber negate(); @Override BtrpNumber times(BtrpOperand other); @Override BtrpNumber div(BtrpOperand other); @Override BtrpNumber remainder(BtrpOperand other); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); @Override int degree(); int getIntValue(); double getDoubleValue(); @Override BtrpNumber eq(BtrpOperand other); @Override BtrpNumber geq(BtrpOperand other); @Override BtrpNumber gt(BtrpOperand other); @Override BtrpNumber not(); @Override BtrpNumber copy(); boolean isInteger(); static final BtrpNumber TRUE; static final BtrpNumber FALSE; } | @Test(expectedExceptions = {UnsupportedOperationException.class}) public void testNonViableTimes() { BtrpNumber i = new BtrpNumber(5, BtrpNumber.Base.BASE_16); Model mo = new DefaultModel(); BtrpElement j = new BtrpElement(BtrpOperand.Type.VM, "foo", mo.newVM()); i.times(j); } |
KilledConverter implements ConstraintConverter<Killed> { @Override public String getJSONId() { return "killed"; } @Override Class<Killed> getSupportedConstraint(); @Override String getJSONId(); @Override Killed fromJSON(Model mo, JSONObject o); @Override JSONObject toJSON(Killed o); } | @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Killed.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new KilledConverter().getJSONId())); } |
BtrpNumber extends DefaultBtrpOperand { @Override public BtrpNumber div(BtrpOperand other) { checkType(other); BtrpNumber x = (BtrpNumber) other; if (Double.doubleToRawLongBits(x.dVal) == 0) { throw new ArithmeticException("Division by 0"); } double res = dVal / x.dVal; return isInteger && x.isInteger ? new BtrpNumber((int) res, base) : new BtrpNumber(res); } BtrpNumber(int v, Base b); BtrpNumber(double d); @Override Type type(); Base getBase(); @Override BtrpNumber power(BtrpOperand nb); @Override BtrpNumber plus(BtrpOperand other); @Override BtrpNumber minus(BtrpOperand other); @Override BtrpNumber negate(); @Override BtrpNumber times(BtrpOperand other); @Override BtrpNumber div(BtrpOperand other); @Override BtrpNumber remainder(BtrpOperand other); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); @Override int degree(); int getIntValue(); double getDoubleValue(); @Override BtrpNumber eq(BtrpOperand other); @Override BtrpNumber geq(BtrpOperand other); @Override BtrpNumber gt(BtrpOperand other); @Override BtrpNumber not(); @Override BtrpNumber copy(); boolean isInteger(); static final BtrpNumber TRUE; static final BtrpNumber FALSE; } | @Test(expectedExceptions = {UnsupportedOperationException.class}) public void testNonViableDiv() { BtrpNumber i = new BtrpNumber(5, BtrpNumber.Base.BASE_16); Model mo = new DefaultModel(); BtrpElement j = new BtrpElement(BtrpOperand.Type.VM, "foo", mo.newVM()); i.div(j); }
@Test(expectedExceptions = {ArithmeticException.class}) public void testNonViableDivCauseZero() { BtrpNumber i = new BtrpNumber(5, BtrpNumber.Base.BASE_16); i.div(new BtrpNumber(0, BtrpNumber.Base.BASE_16)); }
@Test(expectedExceptions = {ArithmeticException.class}) public void testNonViableDivCauseRealZero() { BtrpNumber i = new BtrpNumber(5.7); i.div(new BtrpNumber(0.0)); } |
BtrpNumber extends DefaultBtrpOperand { @Override public BtrpNumber remainder(BtrpOperand other) { checkType(other); BtrpNumber x = (BtrpNumber) other; double res = dVal % x.dVal; return isInteger && x.isInteger ? new BtrpNumber((int) res, base) : new BtrpNumber(res); } BtrpNumber(int v, Base b); BtrpNumber(double d); @Override Type type(); Base getBase(); @Override BtrpNumber power(BtrpOperand nb); @Override BtrpNumber plus(BtrpOperand other); @Override BtrpNumber minus(BtrpOperand other); @Override BtrpNumber negate(); @Override BtrpNumber times(BtrpOperand other); @Override BtrpNumber div(BtrpOperand other); @Override BtrpNumber remainder(BtrpOperand other); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); @Override int degree(); int getIntValue(); double getDoubleValue(); @Override BtrpNumber eq(BtrpOperand other); @Override BtrpNumber geq(BtrpOperand other); @Override BtrpNumber gt(BtrpOperand other); @Override BtrpNumber not(); @Override BtrpNumber copy(); boolean isInteger(); static final BtrpNumber TRUE; static final BtrpNumber FALSE; } | @Test(expectedExceptions = {UnsupportedOperationException.class}) public void testNonViableRemainder() { BtrpNumber i = new BtrpNumber(5, BtrpNumber.Base.BASE_16); Model mo = new DefaultModel(); BtrpElement j = new BtrpElement(BtrpOperand.Type.VM, "foo", mo.newVM()); i.remainder(j); }
@Test(expectedExceptions = {UnsupportedOperationException.class}) public void testNonViableEq() { BtrpNumber i = new BtrpNumber(5, BtrpNumber.Base.BASE_16); Model mo = new DefaultModel(); BtrpElement j = new BtrpElement(BtrpOperand.Type.VM, "foo", mo.newVM()); i.remainder(j); }
@Test(expectedExceptions = {UnsupportedOperationException.class}) public void testNonViableGeq() { BtrpNumber i = new BtrpNumber(5, BtrpNumber.Base.BASE_16); Model mo = new DefaultModel(); BtrpElement j = new BtrpElement(BtrpOperand.Type.VM, "foo", mo.newVM()); i.remainder(j); } |
BtrpNumber extends DefaultBtrpOperand { @Override public BtrpNumber gt(BtrpOperand other) { checkType(other); BtrpNumber x = (BtrpNumber) other; return dVal > x.dVal ? BtrpNumber.TRUE : BtrpNumber.FALSE; } BtrpNumber(int v, Base b); BtrpNumber(double d); @Override Type type(); Base getBase(); @Override BtrpNumber power(BtrpOperand nb); @Override BtrpNumber plus(BtrpOperand other); @Override BtrpNumber minus(BtrpOperand other); @Override BtrpNumber negate(); @Override BtrpNumber times(BtrpOperand other); @Override BtrpNumber div(BtrpOperand other); @Override BtrpNumber remainder(BtrpOperand other); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); @Override int degree(); int getIntValue(); double getDoubleValue(); @Override BtrpNumber eq(BtrpOperand other); @Override BtrpNumber geq(BtrpOperand other); @Override BtrpNumber gt(BtrpOperand other); @Override BtrpNumber not(); @Override BtrpNumber copy(); boolean isInteger(); static final BtrpNumber TRUE; static final BtrpNumber FALSE; } | @Test(expectedExceptions = {UnsupportedOperationException.class}) public void testNonViableGt() { BtrpNumber i = new BtrpNumber(5, BtrpNumber.Base.BASE_16); Model mo = new DefaultModel(); BtrpElement j = new BtrpElement(BtrpOperand.Type.VM, "foo", mo.newVM()); i.gt(j); } |
BtrpNumber extends DefaultBtrpOperand { @Override public BtrpNumber not() { if (TRUE.equals(this)) { return FALSE; } else if (FALSE.equals(this)) { return TRUE; } throw new UnsupportedOperationException("Cannot negate a non-boolean"); } BtrpNumber(int v, Base b); BtrpNumber(double d); @Override Type type(); Base getBase(); @Override BtrpNumber power(BtrpOperand nb); @Override BtrpNumber plus(BtrpOperand other); @Override BtrpNumber minus(BtrpOperand other); @Override BtrpNumber negate(); @Override BtrpNumber times(BtrpOperand other); @Override BtrpNumber div(BtrpOperand other); @Override BtrpNumber remainder(BtrpOperand other); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); @Override int degree(); int getIntValue(); double getDoubleValue(); @Override BtrpNumber eq(BtrpOperand other); @Override BtrpNumber geq(BtrpOperand other); @Override BtrpNumber gt(BtrpOperand other); @Override BtrpNumber not(); @Override BtrpNumber copy(); boolean isInteger(); static final BtrpNumber TRUE; static final BtrpNumber FALSE; } | @Test(expectedExceptions = {UnsupportedOperationException.class}) public void testIncorrectNot() { BtrpNumber i = new BtrpNumber(2.5); i.not(); } |
BtrpSet extends DefaultBtrpOperand { @Override public BtrpSet div(BtrpOperand nb) { if (nb instanceof BtrpNumber) { BtrpNumber x = (BtrpNumber) nb; if (!x.isInteger()) { throw new UnsupportedOperationException("Integer divider expected"); } int s = x.getIntValue(); if (s == 0) { throw new UnsupportedOperationException("Illegal division by 0"); } if (s > size()) { throw new UnsupportedOperationException("Divider can not be greater than the set cardinality"); } int card = (int) Math.ceil(size() * 1.0 / s); BtrpSet res = new BtrpSet(degree() + 1, t); BtrpSet cur = new BtrpSet(degree(), t); res.add(cur); for (int i = 0; i < size(); i++) { cur.add(values.get(i)); if (cur.size() == card && i != size() - 1) { cur = new BtrpSet(degree(), t); res.add(cur); } } return res; } throw new UnsupportedOperationException("Integer divider expected"); } BtrpSet(int d, Type ty); @Override Type type(); @Override BtrpSet plus(BtrpOperand s); @Override BtrpSet minus(BtrpOperand s); int size(); @Override int degree(); @Override BtrpSet remainder(BtrpOperand other); @Override BtrpSet div(BtrpOperand nb); @Override BtrpSet times(BtrpOperand s); @Override BtrpSet power(BtrpOperand nb); @Override String toString(); @Override BtrpSet copy(); @Override boolean equals(Object o); @Override BtrpNumber eq(BtrpOperand other); @Override int hashCode(); List<BtrpOperand> getValues(); } | @Test(expectedExceptions = {UnsupportedOperationException.class}) public void testNonViableDivCauseType() { BtrpSet s = new BtrpSet(1, BtrpOperand.Type.NUMBER); Model mo = new DefaultModel(); s.div(new BtrpElement(BtrpOperand.Type.VM, "V", mo.newVM())); }
@Test(expectedExceptions = {UnsupportedOperationException.class}) public void testNonViableDivCauseType2() { BtrpSet s = new BtrpSet(1, BtrpOperand.Type.NUMBER); s.div(new BtrpNumber(3.2)); }
@Test(expectedExceptions = {UnsupportedOperationException.class}) public void testNonViableDivCauseZero() { BtrpSet s = new BtrpSet(1, BtrpOperand.Type.NUMBER); s.div(new BtrpNumber(0, BtrpNumber.Base.BASE_10)); } |
RunningConverter implements ConstraintConverter<Running> { @Override public String getJSONId() { return "running"; } @Override Class<Running> getSupportedConstraint(); @Override String getJSONId(); @Override Running fromJSON(Model mo, JSONObject o); @Override JSONObject toJSON(Running o); } | @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Running.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new RunningConverter().getJSONId())); } |
BtrpSet extends DefaultBtrpOperand { @Override public BtrpSet remainder(BtrpOperand other) { if (other instanceof BtrpNumber) { BtrpNumber x = (BtrpNumber) other; if (!x.isInteger()) { throw new UnsupportedOperationException("Integer divider expected"); } int size = x.getIntValue(); if (size == 0) { throw new UnsupportedOperationException("cannot split into empty subsets"); } BtrpSet res = new BtrpSet(degree + 1, t); res.t = t; BtrpSet s = new BtrpSet(degree, t); s.t = t; res.add(s); for (Iterator<BtrpOperand> ite = values.iterator(); ite.hasNext(); ) { BtrpOperand v = ite.next(); s.add(v); if (s.size() == size && ite.hasNext()) { s = new BtrpSet(degree, t); res.add(s); } } return res; } throw new UnsupportedOperationException("Integer divider expected"); } BtrpSet(int d, Type ty); @Override Type type(); @Override BtrpSet plus(BtrpOperand s); @Override BtrpSet minus(BtrpOperand s); int size(); @Override int degree(); @Override BtrpSet remainder(BtrpOperand other); @Override BtrpSet div(BtrpOperand nb); @Override BtrpSet times(BtrpOperand s); @Override BtrpSet power(BtrpOperand nb); @Override String toString(); @Override BtrpSet copy(); @Override boolean equals(Object o); @Override BtrpNumber eq(BtrpOperand other); @Override int hashCode(); List<BtrpOperand> getValues(); } | @Test(expectedExceptions = {UnsupportedOperationException.class}) public void testNonViableRemainderCauseType() { BtrpSet s = new BtrpSet(1, BtrpOperand.Type.NUMBER); Model mo = new DefaultModel(); s.remainder(new BtrpElement(BtrpOperand.Type.VM, "V", mo.newVM())); }
@Test(expectedExceptions = {UnsupportedOperationException.class}) public void testNonViableRemainderCauseType2() { BtrpSet s = new BtrpSet(1, BtrpOperand.Type.NUMBER); s.remainder(new BtrpNumber(4.3)); }
@Test(expectedExceptions = {UnsupportedOperationException.class}) public void testNonViableRemainderCauseZero() { BtrpSet s = new BtrpSet(1, BtrpOperand.Type.NUMBER); s.remainder(new BtrpNumber(0, BtrpNumber.Base.BASE_10)); } |
ScriptBuilder { public Script build(File f) throws ScriptBuilderException { int k = f.getAbsolutePath().hashCode(); if (dates.containsKey(k) && dates.get(k) == f.lastModified() && cache.containsKey(f.getPath())) { LOGGER.debug("get '" + f.getName() + "' from the cache"); return cache.get(f.getPath()); } LOGGER.debug(f.getName() + " is built from the file"); dates.put(k, f.lastModified()); String name = f.getName(); try { Script v = build(new ANTLRFileStream(f.getAbsolutePath())); if (!name.equals(v.getlocalName() + Script.EXTENSION)) { throw new ScriptBuilderException("Script '" + v.getlocalName() + "' must be declared in a file named '" + v.getlocalName() + Script.EXTENSION); } cache.put(f.getPath(), v); return v; } catch (IOException e) { throw new ScriptBuilderException(e.getMessage(), e); } } ScriptBuilder(Model mo); ScriptBuilder(final int cacheSize, Model mo); Includes getIncludes(); void setIncludes(Includes incs); Script build(File f); Script build(String description); void setErrorReporterBuilder(ErrorReporterBuilder b); NamingService<VM> getNamingServiceVMs(); NamingService<Node> getNamingServiceNodes(); TemplateFactory getTemplateFactory(); void setTemplateFactory(TemplateFactory f); ConstraintsCatalog getConstraintsCatalog(); void setConstraintsCatalog(ConstraintsCatalog c); static final int DEFAULT_CACHE_SIZE; static final Logger LOGGER; static final String EXTENSION; } | @Test(expectedExceptions = {ScriptBuilderException.class}) public void testSetManipulationWithErrors() throws ScriptBuilderException { try { ScriptBuilder b = new ScriptBuilder(new DefaultModel()); b.build( "namespace test.template;\n" + "VM[1..20] : tinyVMs<migratable,volatile>;\n" + "$x = VM[1..10] + VM15;\n" + "$y = VM[1..10] + @N[1..20,57];\n" + "$z = VM[1..10] + 7;\n" + "$a = VM[1..10] - {VM[1..10]};\n" + "$b = VM[1..10] / @N1;\n" + "$c = VM[1..10] / @N[1,3];\n" + "$d = VM[1..10] * VM[21,22];\n" + "$e = VM[22,23] / 2;\n" ); } catch (ScriptBuilderException x) { System.out.println(x); Assert.assertEquals(x.getErrorReporter().getErrors().size(), 8); throw x; } }
@Test public void testTemplateWithOptions() throws ScriptBuilderException { Model mo = new DefaultModel(); ScriptBuilder b = new ScriptBuilder(mo); Script v = b.build("namespace test.template;\nVM[1..3] : tinyVMs<migratable,start=\"7.5\",stop=12>;"); Assert.assertEquals(v.getVMs().size(), 3); for (VM el : v.getVMs()) { Assert.assertEquals(mo.getAttributes().getKeys(el).size(), 4); Assert.assertEquals(mo.getAttributes().get(el, "migratable", false), true); Assert.assertEquals(mo.getAttributes().get(el, "start", -1.5), 7.5); Assert.assertEquals(mo.getAttributes().get(el, "stop", -1), 12); } }
@Test(expectedExceptions = {ScriptBuilderException.class}) public void testMeReassignment() throws ScriptBuilderException { ScriptBuilder b = new ScriptBuilder(new DefaultModel()); b.build("namespace foo; VM[1..5] : tiny;\nVM[6..10] : small;\n $me = 7; "); }
@Test(dataProvider = "badRanges", expectedExceptions = {ScriptBuilderException.class}) public void testBadRanges(String str) throws ScriptBuilderException { ScriptBuilder b = new ScriptBuilder(new DefaultModel()); try { b.build("namespace test; VM[1..10] : tiny;\n@N[1..10] : defaultNode;\n" + str); } catch (ScriptBuilderException ex) { System.err.println(str + " " + ex.getMessage()); System.err.flush(); throw ex; } Assert.fail(); }
@Test(expectedExceptions = {ScriptBuilderException.class}) public void testConstraintWithBadParameters() throws ScriptBuilderException { ScriptBuilder b = new ScriptBuilder(new DefaultModel()); b.build("namespace foo; VM[1..10] : tiny;\nlonely(N15);"); }
@Test(expectedExceptions = {ScriptBuilderException.class}) public void testWithLexerErrors() throws ScriptBuilderException { ScriptBuilder b = new ScriptBuilder(new DefaultModel()); b.build("namespace foo; VM[1..10] : tiny;\nroot(VM10;"); }
@Test(expectedExceptions = {ScriptBuilderException.class}) public void testReAssignment() throws ScriptBuilderException { ScriptBuilder b = new ScriptBuilder(100, new DefaultModel()); ErrorReporter r; try { Script scr = b.build("namespace foo; @N[1,1] : tiny;"); System.out.println(scr.getVMs()); } catch (ScriptBuilderException ex) { System.out.println(ex); r = ex.getErrorReporter(); Assert.assertEquals(r.getErrors().size(), 1); throw ex; } }
@Test(expectedExceptions = {ScriptBuilderException.class}) public void testVMReAssignment() throws ScriptBuilderException { ScriptBuilder b = new ScriptBuilder(100, new DefaultModel()); ErrorReporter r; try { Script scr = b.build("namespace foo; VM[1,1] : tiny;"); System.out.println(scr.getVMs()); } catch (ScriptBuilderException ex) { System.out.println(ex); r = ex.getErrorReporter(); Assert.assertEquals(r.getErrors().size(), 1); throw ex; } } |
SpreadConverter implements ConstraintConverter<Spread> { @Override public String getJSONId() { return "spread"; } @Override Class<Spread> getSupportedConstraint(); @Override String getJSONId(); @Override Spread fromJSON(Model mo, JSONObject o); @Override JSONObject toJSON(Spread o); } | @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Spread.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new SpreadConverter().getJSONId())); } |
And extends BinaryProp { @Override public Or not() { return new Or(p1.not(), p2.not()); } And(Proposition p1, Proposition p2); @Override String operator(); @Override Or not(); @Override Boolean eval(Context m); @Override String toString(); } | @Test public void testNot() { And and = new And(Proposition.True, Proposition.False); Or o = and.not(); Assert.assertEquals(o.first(), Proposition.False); Assert.assertEquals(o.second(), Proposition.True); } |
DefaultTemplateFactory implements TemplateFactory { @Override public Set<String> getAvailables() { return vmTpls.keySet(); } DefaultTemplateFactory(NamingService<Node> srvNodes, NamingService<VM> srvVMs, Model m); @Override Set<String> getAvailables(); @Override boolean isAvailable(String id); @Override void check(Script scr, String tplName, Element e, Map<String, String> attrs); @Override Template register(Template tpl); } | @Test public void testInstantiation() { DefaultTemplateFactory tplf = new DefaultTemplateFactory(NamingService.newNodeNS(), NamingService.newVMNS(), new DefaultModel()); Assert.assertTrue(tplf.getAvailables().isEmpty()); } |
DefaultTemplateFactory implements TemplateFactory { @Override public Template register(Template tpl) { tpl.setNamingServiceNodes(namingServerNodes); tpl.setNamingServiceVMs(namingServerVMs); if (tpl.getElementType() == BtrpOperand.Type.VM) { return vmTpls.put(tpl.getIdentifier(), tpl); } else if (tpl.getElementType() == BtrpOperand.Type.NODE) { return nodeTpls.put(tpl.getIdentifier(), tpl); } return null; } DefaultTemplateFactory(NamingService<Node> srvNodes, NamingService<VM> srvVMs, Model m); @Override Set<String> getAvailables(); @Override boolean isAvailable(String id); @Override void check(Script scr, String tplName, Element e, Map<String, String> attrs); @Override Template register(Template tpl); } | @Test(dependsOnMethods = {"testInstantiation"}) public void testRegister() { NamingService<Node> srvNodes = NamingService.newNodeNS(); NamingService<VM> srvVMs = NamingService.newVMNS(); DefaultTemplateFactory tplf = new DefaultTemplateFactory(srvNodes, srvVMs, new DefaultModel()); MockVMTemplate t1 = new MockVMTemplate("mock1"); Assert.assertNull(tplf.register(t1)); Assert.assertEquals(t1.srvNodes, srvNodes); Assert.assertEquals(t1.srvVMs, srvVMs); Assert.assertTrue(tplf.getAvailables().contains("mock1")); MockVMTemplate t2 = new MockVMTemplate("mock2"); Assert.assertNull(tplf.register(t2)); Assert.assertEquals(t2.srvNodes, srvNodes); Assert.assertEquals(t2.srvVMs, srvVMs); Assert.assertTrue(tplf.getAvailables().contains("mock2") && tplf.getAvailables().size() == 2); } |
SeqConverter implements ConstraintConverter<Seq> { @Override public String getJSONId() { return "seq"; } @Override Class<Seq> getSupportedConstraint(); @Override String getJSONId(); @Override Seq fromJSON(Model mo, JSONObject o); @Override JSONObject toJSON(Seq o); } | @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Seq.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new SeqConverter().getJSONId())); } |
PrecedenceConverter implements ConstraintConverter<Precedence> { @Override public String getJSONId() { return "Precedence"; } @Override Class<Precedence> getSupportedConstraint(); @Override String getJSONId(); @Override Precedence fromJSON(Model mo, JSONObject in); @Override JSONObject toJSON(Precedence precedence); } | @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Precedence.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new PrecedenceConverter().getJSONId())); } |
SyncConverter implements ConstraintConverter<Sync> { @Override public String getJSONId() { return "Sync"; } @Override Class<Sync> getSupportedConstraint(); @Override String getJSONId(); @Override Sync fromJSON(Model mo, JSONObject in); @Override JSONObject toJSON(Sync sync); } | @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Sync.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new SyncConverter().getJSONId())); } |
DeadlineConverter implements ConstraintConverter<Deadline> { @Override public String getJSONId() { return "Deadline"; } @Override Class<Deadline> getSupportedConstraint(); @Override String getJSONId(); @Override Deadline fromJSON(Model mo, JSONObject in); @Override JSONObject toJSON(Deadline deadline); } | @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Deadline.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new DeadlineConverter().getJSONId())); } |
SerializeConverter implements ConstraintConverter<Serialize> { @Override public String getJSONId() { return "Serialize"; } @Override Class<Serialize> getSupportedConstraint(); @Override String getJSONId(); @Override Serialize fromJSON(Model mo, JSONObject in); @Override JSONObject toJSON(Serialize serialize); } | @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Serialize.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new SerializeConverter().getJSONId())); } |
PreserveConverter implements ConstraintConverter<Preserve> { @Override public String getJSONId() { return "preserve"; } @Override Class<Preserve> getSupportedConstraint(); @Override String getJSONId(); @Override Preserve fromJSON(Model mo, JSONObject o); @Override JSONObject toJSON(Preserve o); } | @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Preserve.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new PreserveConverter().getJSONId())); } |
OverbookConverter implements ConstraintConverter<Overbook> { @Override public String getJSONId() { return "overbook"; } @Override Class<Overbook> getSupportedConstraint(); @Override String getJSONId(); @Override Overbook fromJSON(Model mo, JSONObject o); @Override JSONObject toJSON(Overbook o); } | @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Overbook.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new OverbookConverter().getJSONId())); } |
FenceConverter implements ConstraintConverter<Fence> { @Override public String getJSONId() { return "fence"; } @Override Class<Fence> getSupportedConstraint(); @Override String getJSONId(); @Override Fence fromJSON(Model mo, JSONObject o); @Override JSONObject toJSON(Fence o); } | @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Fence.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new FenceConverter().getJSONId())); } |
RunningCapacityConverter implements ConstraintConverter<RunningCapacity> { @Override public String getJSONId() { return "runningCapacity"; } @Override Class<RunningCapacity> getSupportedConstraint(); @Override String getJSONId(); @Override RunningCapacity fromJSON(Model mo, JSONObject o); @Override JSONObject toJSON(RunningCapacity o); } | @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(RunningCapacity.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new RunningCapacityConverter().getJSONId())); } |
NoDelayConverter implements ConstraintConverter<NoDelay> { @Override public String getJSONId() { return "noDelay"; } @Override Class<NoDelay> getSupportedConstraint(); @Override String getJSONId(); @Override NoDelay fromJSON(Model mo, JSONObject in); @Override JSONObject toJSON(NoDelay noDelay); } | @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(NoDelay.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new NoDelayConverter().getJSONId())); } |
Iff extends BinaryProp { @Override public Boolean eval(Context m) { return o.eval(m); } Iff(Proposition p1, Proposition p2); @Override String operator(); @Override And not(); @Override Boolean eval(Context m); } | @Test(dataProvider = "input") public void testTruthTable(Proposition a, Proposition b, Boolean r) { Iff p = new Iff(a, b); Assert.assertEquals(p.eval(new Context()), r); } |
LonelyConverter implements ConstraintConverter<Lonely> { @Override public String getJSONId() { return "lonely"; } @Override Class<Lonely> getSupportedConstraint(); @Override String getJSONId(); @Override Lonely fromJSON(Model mo, JSONObject o); @Override JSONObject toJSON(Lonely o); } | @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Lonely.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new LonelyConverter().getJSONId())); } |
OfflineConverter implements ConstraintConverter<Offline> { @Override public String getJSONId() { return "offline"; } @Override Class<Offline> getSupportedConstraint(); @Override String getJSONId(); @Override Offline fromJSON(Model mo, JSONObject o); @Override JSONObject toJSON(Offline o); } | @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Offline.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new OfflineConverter().getJSONId())); } |
OnlineConverter implements ConstraintConverter<Online> { @Override public String getJSONId() { return "online"; } @Override Class<Online> getSupportedConstraint(); @Override String getJSONId(); @Override Online fromJSON(Model mo, JSONObject o); @Override JSONObject toJSON(Online o); } | @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Online.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new OnlineConverter().getJSONId())); } |
ConstraintsConverter { public void register(ConstraintConverter<? extends Constraint> c) { java2json.put(c.getSupportedConstraint(), c); json2java.put(c.getJSONId(), c); } ConstraintsConverter(); static ConstraintsConverter newBundle(); void register(ConstraintConverter<? extends Constraint> c); Set<Class<? extends Constraint>> getSupportedJavaConstraints(); Set<String> getSupportedJSONConstraints(); Constraint fromJSON(Model mo, JSONObject in); JSONObject toJSON(Constraint o); List<SatConstraint> listFromJSON(Model mo, JSONArray in); JSONArray toJSON(Collection<SatConstraint> e); } | @Test public void testRegister() { ConstraintsConverter c = new ConstraintsConverter(); c.register(new MockConstraintConverter()); Assert.assertTrue(c.getSupportedJavaConstraints().contains(MockSatConstraint.class)); Assert.assertTrue(c.getSupportedJSONConstraints().contains("mock")); } |
ConstraintsConverter { public JSONObject toJSON(Constraint o) throws JSONConverterException { ConstraintConverter c = java2json.get(o.getClass()); if (c == null) { throw new JSONConverterException("No converter available for a constraint with the '" + o.getClass() + "' className"); } return c.toJSON(o); } ConstraintsConverter(); static ConstraintsConverter newBundle(); void register(ConstraintConverter<? extends Constraint> c); Set<Class<? extends Constraint>> getSupportedJavaConstraints(); Set<String> getSupportedJSONConstraints(); Constraint fromJSON(Model mo, JSONObject in); JSONObject toJSON(Constraint o); List<SatConstraint> listFromJSON(Model mo, JSONArray in); JSONArray toJSON(Collection<SatConstraint> e); } | @Test(dependsOnMethods = {"testRegister"}, expectedExceptions = {JSONConverterException.class}) public void testToJSonWithNoConverters() throws JSONConverterException { ConstraintsConverter c = new ConstraintsConverter(); MockSatConstraint m = new MockSatConstraint("bar"); c.toJSON(m); } |
ConstraintsConverter { public Constraint fromJSON(Model mo, JSONObject in) throws JSONConverterException { checkKeys(in, "id"); Object id = in.get("id"); ConstraintConverter<? extends Constraint> c = json2java.get(id.toString()); if (c == null) { throw new JSONConverterException("No converter available for a constraint having id '" + id + "'"); } return c.fromJSON(mo, in); } ConstraintsConverter(); static ConstraintsConverter newBundle(); void register(ConstraintConverter<? extends Constraint> c); Set<Class<? extends Constraint>> getSupportedJavaConstraints(); Set<String> getSupportedJSONConstraints(); Constraint fromJSON(Model mo, JSONObject in); JSONObject toJSON(Constraint o); List<SatConstraint> listFromJSON(Model mo, JSONArray in); JSONArray toJSON(Collection<SatConstraint> e); } | @Test(dependsOnMethods = {"testRegister"}, expectedExceptions = {JSONConverterException.class}) public void testFromJSonWithNoConverter() throws JSONConverterException { JSONObject ob = new JSONObject(); ob.put("id", "mock"); ob.put("value", "val"); ConstraintsConverter c = new ConstraintsConverter(); c.fromJSON(null, ob); } |
MinMigrationsConverter implements ConstraintConverter<MinMigrations> { @Override public String getJSONId() { return "minimizeMigrations"; } @Override Class<MinMigrations> getSupportedConstraint(); @Override String getJSONId(); @Override MinMigrations fromJSON(Model mo, JSONObject o); @Override JSONObject toJSON(MinMigrations o); } | @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(MinMigrations.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new MinMigrationsConverter().getJSONId())); } |
SplitAmongConverter implements ConstraintConverter<SplitAmong> { @Override public String getJSONId() { return "splitAmong"; } @Override Class<SplitAmong> getSupportedConstraint(); @Override String getJSONId(); @Override SplitAmong fromJSON(Model mo, JSONObject o); @Override JSONObject toJSON(SplitAmong o); } | @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(SplitAmong.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new SplitAmongConverter().getJSONId())); } |
SleepingConverter implements ConstraintConverter<Sleeping> { @Override public String getJSONId() { return "sleeping"; } @Override Class<Sleeping> getSupportedConstraint(); @Override String getJSONId(); @Override Sleeping fromJSON(Model mo, JSONObject o); @Override JSONObject toJSON(Sleeping o); } | @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Sleeping.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new SleepingConverter().getJSONId())); } |
SplitConverter implements ConstraintConverter<Split> { @Override public String getJSONId() { return "split"; } @Override Class<Split> getSupportedConstraint(); @Override String getJSONId(); @Override Split fromJSON(Model mo, JSONObject o); @Override JSONObject toJSON(Split o); } | @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Split.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new SplitConverter().getJSONId())); } |
Implies extends BinaryProp { @Override public Boolean eval(Context m) { return o.eval(m); } Implies(Proposition p1, Proposition p2); @Override String operator(); @Override And not(); @Override Boolean eval(Context m); } | @Test(dataProvider = "input") public void testTruthTable(Proposition a, Proposition b, Boolean r) { Implies p = new Implies(a, b); Assert.assertEquals(p.eval(new Context()), r); } |
ModelConverter implements JSONObjectConverter<Model> { @Override public Model fromJSON(JSONObject o) throws JSONConverterException { checkKeys(o, MAPPING_LABEL, ATTRS_LABEL, VIEWS_LABEL); Model i = new DefaultModel(); fillMapping(i, (JSONObject) o.get(MAPPING_LABEL)); i.setAttributes(AttributesConverter.fromJSON(i, (JSONObject) o.get(ATTRS_LABEL))); for (Object view : (JSONArray) o.get(VIEWS_LABEL)) { i.attach(viewsConverter.fromJSON(i, (JSONObject) view)); } return i; } ModelConverter(); ModelViewsConverter getViewsConverter(); void setModelViewConverters(ModelViewsConverter c); @Override JSONObject toJSON(Model i); @Override Model fromJSON(JSONObject o); void fillMapping(Model mo, JSONObject o); static final String MAPPING_LABEL; static final String VIEWS_LABEL; static final String ATTRS_LABEL; } | @Test public void testConversion() throws JSONConverterException { ModelConverter conv = new ModelConverter(); Model mo = new DefaultModel(); Mapping m = mo.getMapping(); Node n1 = mo.newNode(); VM vm1 = mo.newVM(); m.addOnlineNode(n1); m.addReadyVM(vm1); Attributes attrs = mo.getAttributes(); attrs.put(vm1, "boot", 5); attrs.put(n1, "type", "xen"); ShareableResource rc = new ShareableResource("cpu"); rc.setConsumption(vm1, 5); rc.setCapacity(n1, 10); mo.attach(rc); String jo = conv.toJSONString(mo); System.out.println(jo); Model res = conv.fromJSON(jo); Assert.assertEquals(res, mo); Assert.assertTrue(res.contains(n1)); Assert.assertTrue(res.contains(vm1)); } |
ModelViewsConverter { public void register(ModelViewConverter<? extends ModelView> c) { java2json.put(c.getSupportedView(), c); json2java.put(c.getJSONId(), c); } ModelViewsConverter(); static ModelViewsConverter newBundle(); void register(ModelViewConverter<? extends ModelView> c); Set<Class<? extends ModelView>> getSupportedJavaViews(); Set<String> getSupportedJSONViews(); ModelView fromJSON(Model mo, JSONObject in); JSONObject toJSON(ModelView o); } | @Test public void testRegister() { ModelViewsConverter c = new ModelViewsConverter(); c.register(new MockModelViewConverter()); Assert.assertTrue(c.getSupportedJavaViews().contains(MockModelView.class)); Assert.assertTrue(c.getSupportedJSONViews().contains("mockView")); } |
ModelViewsConverter { public JSONObject toJSON(ModelView o) throws JSONConverterException { ModelViewConverter c = java2json.get(o.getClass()); if (c == null) { throw new JSONConverterException("No converter available for a view with the '" + o.getClass() + "' className"); } return c.toJSON(o); } ModelViewsConverter(); static ModelViewsConverter newBundle(); void register(ModelViewConverter<? extends ModelView> c); Set<Class<? extends ModelView>> getSupportedJavaViews(); Set<String> getSupportedJSONViews(); ModelView fromJSON(Model mo, JSONObject in); JSONObject toJSON(ModelView o); } | @Test(dependsOnMethods = {"testRegister"}, expectedExceptions = {JSONConverterException.class}) public void testToJSonWithNoConverters() throws JSONConverterException { ModelViewsConverter c = new ModelViewsConverter(); MockModelView m = new MockModelView("bar"); c.toJSON(m); } |
ModelViewsConverter { public ModelView fromJSON(Model mo, JSONObject in) throws JSONConverterException { checkKeys(in, ModelViewConverter.IDENTIFIER); Object id = in.get(ModelViewConverter.IDENTIFIER); ModelViewConverter<? extends ModelView> c = json2java.get(id.toString()); if (c == null) { throw new JSONConverterException("No converter available for a view having id '" + id + "'"); } return c.fromJSON(mo, in); } ModelViewsConverter(); static ModelViewsConverter newBundle(); void register(ModelViewConverter<? extends ModelView> c); Set<Class<? extends ModelView>> getSupportedJavaViews(); Set<String> getSupportedJSONViews(); ModelView fromJSON(Model mo, JSONObject in); JSONObject toJSON(ModelView o); } | @Test(dependsOnMethods = {"testRegister"}, expectedExceptions = {JSONConverterException.class}) public void testFromJSonWithNoConverter() throws JSONConverterException { JSONObject ob = new JSONObject(); ob.put("id", "mockView"); ob.put("value", "val"); ModelViewsConverter c = new ModelViewsConverter(); c.fromJSON(null, ob); } |
InstanceConverter implements JSONObjectConverter<Instance> { @Override public Instance fromJSON(JSONObject in) throws JSONConverterException { checkKeys(in, MODEL_LABEL, CONSTRAINTS_LABEL, OBJ_LABEL); Model mo = moc.fromJSON((JSONObject) in.get(MODEL_LABEL)); return new Instance(mo, cc.listFromJSON(mo, (JSONArray) in.get(CONSTRAINTS_LABEL)), (OptConstraint) cc.fromJSON(mo, (JSONObject) in.get(OBJ_LABEL))); } InstanceConverter(); @Override Instance fromJSON(JSONObject in); ModelConverter getModelConverter(); ConstraintsConverter getConstraintsConverter(); @Override JSONObject toJSON(Instance instance); } | @Test public void testConversion() throws JSONConverterException { Model mo = new DefaultModel(); Mapping ma = mo.getMapping(); Node n1 = mo.newNode(); VM vm1 = mo.newVM(); VM vm2 = mo.newVM(); ma.addOnlineNode(n1); ma.addOfflineNode(n1); ma.addReadyVM(vm1); ma.addReadyVM(vm2); List<SatConstraint> cstrs = new ArrayList<>(); cstrs.addAll(Online.newOnline(ma.getAllNodes())); cstrs.add(new Running(vm2)); Instance i = new Instance(mo, cstrs, new MinMTTR()); InstanceConverter conv = new InstanceConverter(); String o = conv.toJSONString(i); System.out.println(o); Instance res = conv.fromJSON(o); Assert.assertEquals(i, res); } |
ReconfigurationPlanConverter implements
JSONObjectConverter<ReconfigurationPlan> { public ModelConverter getModelConverter() { return mc; } ReconfigurationPlanConverter(ModelConverter c); ReconfigurationPlanConverter(); @Override ReconfigurationPlan fromJSON(JSONObject ob); ModelConverter getModelConverter(); @Override JSONObject toJSON(ReconfigurationPlan plan); void register(final EventConverter<? extends Event> ec); void register(final ActionConverter<? extends Action> ec); static ReconfigurationPlanConverter newBundle(); static final String ORIGIN_LABEL; static final String ACTIONS_LABEL; static final String HOOK_LABEL; } | @Test public void testAccessors() { ModelConverter mc = new ModelConverter(); ReconfigurationPlanConverter rcp = new ReconfigurationPlanConverter(mc); Assert.assertEquals(rcp.getModelConverter(), mc); } |
ReconfigurationPlanConverter implements
JSONObjectConverter<ReconfigurationPlan> { @Override public JSONObject toJSON(ReconfigurationPlan plan) throws JSONConverterException { final JSONObject ob = new JSONObject(); final Model src = plan.getOrigin(); ob.put(ORIGIN_LABEL, mc.toJSON(src)); final JSONArray actions = new JSONArray(); for (final Action a : plan.getActions()) { final ActionConverter ac = java3json.get(a.getClass()); if (ac == null) { throw new JSONConverterException( "No converter registered for '" + a.getClass() + "'"); } final JSONObject json = ac.toJSON(a); eventsToJSON(a, json); actions.add(json); } ob.put(ACTIONS_LABEL, actions); return ob; } ReconfigurationPlanConverter(ModelConverter c); ReconfigurationPlanConverter(); @Override ReconfigurationPlan fromJSON(JSONObject ob); ModelConverter getModelConverter(); @Override JSONObject toJSON(ReconfigurationPlan plan); void register(final EventConverter<? extends Event> ec); void register(final ActionConverter<? extends Action> ec); static ReconfigurationPlanConverter newBundle(); static final String ORIGIN_LABEL; static final String ACTIONS_LABEL; static final String HOOK_LABEL; } | @Test(expectedExceptions = JSONConverterException.class) public void testMissingConverter() throws JSONConverterException { Model mo = new DefaultModel(); final Node n0 = mo.newNode(); mo.getMapping().off(n0); final ReconfigurationPlan plan = new DefaultReconfigurationPlan(mo); plan.add(new BootNode(n0, 0, 1)); ReconfigurationPlanConverter rcp = new ReconfigurationPlanConverter(); rcp.toJSON(plan); } |
JSONs { public static int requiredInt(JSONObject o, String id) throws JSONConverterException { checkKeys(o, id); try { return (Integer) o.get(id); } catch (ClassCastException e) { throw new JSONConverterException("Unable to read a int from string '" + id + "'", e); } } private JSONs(); static void resetCaches(int size); static int requiredInt(JSONObject o, String id); static int optInt(JSONObject o, String id, int def); static void checkKeys(JSONObject o, String... keys); static String requiredString(JSONObject o, String id); static double requiredDouble(JSONObject o, String id); static boolean requiredBoolean(JSONObject o, String id); static List<VM> vmsFromJSON(Model mo, JSONArray a); static List<Node> nodesFromJSON(Model mo, JSONArray a); static JSONArray vmsToJSON(Collection<VM> s); static JSONArray nodesToJSON(Collection<Node> s); static List<VM> requiredVMs(Model mo, JSONObject o, String id); static List<Node> requiredNodes(Model mo, JSONObject o, String id); static Set<Collection<VM>> requiredVMPart(Model mo, JSONObject o, String id); static Set<Collection<Node>> requiredNodePart(Model mo, JSONObject o, String id); static VM requiredVM(Model mo, JSONObject o, String id); static Node requiredNode(Model mo, JSONObject o, String id); static VM getVM(Model mo, int vmID); static Node getNode(Model mo, int nodeID); static Integer elementToJSON(Element e); } | @Test public void testValidRequiredInt() throws JSONConverterException { JSONObject o = new JSONObject(); int u = rnd.nextInt(); o.put("id", u); Assert.assertEquals(JSONs.requiredInt(o, "id"), u); }
@Test(expectedExceptions = {JSONConverterException.class}, dataProvider = "getInvalidInts") public void testInValidRequiredInt(String storeKey, String readKey, Object o) throws JSONConverterException { JSONObject obj = new JSONObject(); obj.put(storeKey, o); JSONs.requiredInt(obj, readKey); } |
JSONs { public static String requiredString(JSONObject o, String id) throws JSONConverterException { checkKeys(o, id); Object x = o.get(id); return x.toString(); } private JSONs(); static void resetCaches(int size); static int requiredInt(JSONObject o, String id); static int optInt(JSONObject o, String id, int def); static void checkKeys(JSONObject o, String... keys); static String requiredString(JSONObject o, String id); static double requiredDouble(JSONObject o, String id); static boolean requiredBoolean(JSONObject o, String id); static List<VM> vmsFromJSON(Model mo, JSONArray a); static List<Node> nodesFromJSON(Model mo, JSONArray a); static JSONArray vmsToJSON(Collection<VM> s); static JSONArray nodesToJSON(Collection<Node> s); static List<VM> requiredVMs(Model mo, JSONObject o, String id); static List<Node> requiredNodes(Model mo, JSONObject o, String id); static Set<Collection<VM>> requiredVMPart(Model mo, JSONObject o, String id); static Set<Collection<Node>> requiredNodePart(Model mo, JSONObject o, String id); static VM requiredVM(Model mo, JSONObject o, String id); static Node requiredNode(Model mo, JSONObject o, String id); static VM getVM(Model mo, int vmID); static Node getNode(Model mo, int nodeID); static Integer elementToJSON(Element e); } | @Test public void testValidRequiredString() throws JSONConverterException { JSONObject o = new JSONObject(); o.put("id", "bar"); Assert.assertEquals(JSONs.requiredString(o, "id"), "bar"); }
@Test(expectedExceptions = {JSONConverterException.class}) public void testInValidRequiredString() throws JSONConverterException { JSONObject o = new JSONObject(); o.put("id", "bar"); JSONs.requiredString(o, "bar"); } |
Implies extends BinaryProp { @Override public And not() { return o.not(); } Implies(Proposition p1, Proposition p2); @Override String operator(); @Override And not(); @Override Boolean eval(Context m); } | @Test public void testNot() { Implies p = new Implies(Proposition.True, Proposition.False); And a = p.not(); Assert.assertEquals(a.first(), Proposition.True); Assert.assertEquals(a.second(), Proposition.True); } |
JSONs { public static double requiredDouble(JSONObject o, String id) throws JSONConverterException { checkKeys(o, id); Object x = o.get(id); if (!(x instanceof Number)) { throw new JSONConverterException("Number expected at key '" + id + "' but was '" + x.getClass() + "'."); } return ((Number) x).doubleValue(); } private JSONs(); static void resetCaches(int size); static int requiredInt(JSONObject o, String id); static int optInt(JSONObject o, String id, int def); static void checkKeys(JSONObject o, String... keys); static String requiredString(JSONObject o, String id); static double requiredDouble(JSONObject o, String id); static boolean requiredBoolean(JSONObject o, String id); static List<VM> vmsFromJSON(Model mo, JSONArray a); static List<Node> nodesFromJSON(Model mo, JSONArray a); static JSONArray vmsToJSON(Collection<VM> s); static JSONArray nodesToJSON(Collection<Node> s); static List<VM> requiredVMs(Model mo, JSONObject o, String id); static List<Node> requiredNodes(Model mo, JSONObject o, String id); static Set<Collection<VM>> requiredVMPart(Model mo, JSONObject o, String id); static Set<Collection<Node>> requiredNodePart(Model mo, JSONObject o, String id); static VM requiredVM(Model mo, JSONObject o, String id); static Node requiredNode(Model mo, JSONObject o, String id); static VM getVM(Model mo, int vmID); static Node getNode(Model mo, int nodeID); static Integer elementToJSON(Element e); } | @Test public void testValidRequiredDouble() throws JSONConverterException { JSONObject o = new JSONObject(); o.put("id", 1.3d); Assert.assertEquals(JSONs.requiredDouble(o, "id"), 1.3d); o.put("id", 145); Assert.assertEquals(JSONs.requiredDouble(o, "id"), 145d); }
@Test(expectedExceptions = {JSONConverterException.class}, dataProvider = "getInvalidDoubles") public void testInValidRequiredDoubles(String storeKey, String readKey, Object o) throws JSONConverterException { JSONObject obj = new JSONObject(); obj.put(storeKey, o); JSONs.requiredDouble(obj, readKey); } |
DefaultChocoScheduler implements ChocoScheduler { @Override public ReconfigurationPlan solve(Model mo, Collection<? extends SatConstraint> cstrs) throws SchedulerException { return solve(mo, cstrs, new MinMTTR()); } DefaultChocoScheduler(Parameters ps); DefaultChocoScheduler(); @Override Parameters doOptimize(boolean b); @Override boolean doOptimize(); @Override Parameters setTimeLimit(int t); @Override int getTimeLimit(); @Override Parameters doRepair(boolean b); @Override boolean doRepair(); @Override ReconfigurationPlan solve(Model mo, Collection<? extends SatConstraint> cstrs); @Override ReconfigurationPlan solve(Instance i); @Override DefaultChocoScheduler setParameters(Parameters p); @Override Parameters getParameters(); @Override ChocoMapper getMapper(); @Override DurationEvaluators getDurationEvaluators(); @Override SolvingStatistics getStatistics(); @Override Parameters setMaxEnd(int end); @Override int getMaxEnd(); @Override Parameters setVerbosity(int lvl); @Override Parameters setMapper(ChocoMapper map); @Override Parameters setDurationEvaluators(DurationEvaluators d); @Override int getVerbosity(); @Override InstanceSolver getInstanceSolver(); @Override void setInstanceSolver(InstanceSolver p); @Override Parameters setTransitionFactory(TransitionFactory amf); @Override TransitionFactory getTransitionFactory(); @Override Parameters setRandomSeed(long s); @Override long getRandomSeed(); @Override boolean addChocoView(Class<? extends ChocoView> v); @Override boolean removeChocoView(Class<? extends ChocoView> v); @Override Settings chocoSettings(); @Override Parameters chocoSettings(Settings s); @Override List<Class<? extends ChocoView>> getChocoViews(); @Override EnvironmentFactory getEnvironmentFactory(); @Override Parameters setEnvironmentFactory(EnvironmentFactory f); @Override Parameters addSolutionListener(BiConsumer<ReconfigurationProblem, ReconfigurationPlan> consumer); @Override List<BiConsumer<ReconfigurationProblem, ReconfigurationPlan>> solutionListeners(); @Override void stop(); } | @Test(expectedExceptions = {SchedulerException.class}) public void testWithUnknownVMs() throws SchedulerException { Model mo = new DefaultModel(); final VM vm1 = mo.newVM(); final VM vm2 = mo.newVM(); final VM vm3 = mo.newVM(); VM vm4 = mo.newVM(); VM vm5 = mo.newVM(); VM vm6 = mo.newVM(); Node n1 = mo.newNode(); Node n2 = mo.newNode(); Node n3 = mo.newNode(); Node n4 = mo.newNode(); mo.getMapping().on(n1, n2, n3).run(n1, vm1, vm4).run(n2, vm2).run(n3, vm3, vm5); SatConstraint cstr = mock(SatConstraint.class); when(cstr.getInvolvedVMs()).thenReturn(Arrays.asList(vm1, vm2, vm6)); when(cstr.getInvolvedNodes()).thenReturn(Arrays.asList(n1, n4)); ChocoScheduler cra = new DefaultChocoScheduler(); cra.solve(mo, Collections.singleton(cstr)); } |
COffline implements ChocoConstraint { @Override public String toString() { return cstr.toString(); } COffline(Offline o); @Override boolean inject(Parameters ps, ReconfigurationProblem rp); @Override Set<VM> getMisPlacedVMs(Instance i); @Override String toString(); } | @Test public void testInstantiation() { Model mo = new DefaultModel(); Node n1 = mo.newNode(); Offline b = new Offline(n1); COffline c = new COffline(b); Assert.assertEquals(c.toString(), b.toString()); } |
COffline implements ChocoConstraint { @Override public Set<VM> getMisPlacedVMs(Instance i) { Mapping mapping = i.getModel().getMapping(); return mapping.getRunningVMs(cstr.getInvolvedNodes().iterator().next()); } COffline(Offline o); @Override boolean inject(Parameters ps, ReconfigurationProblem rp); @Override Set<VM> getMisPlacedVMs(Instance i); @Override String toString(); } | @Test public void testGetMisplacedAndSatisfied() { Model mo = new DefaultModel(); VM vm1 = mo.newVM(); Node n1 = mo.newNode(); Node n2 = mo.newNode(); Mapping map = mo.getMapping().on(n1, n2); Offline off = new Offline(n1); COffline coff = new COffline(off); Instance i = new Instance(mo, Collections.emptyList(), new MinMTTR()); Assert.assertTrue(coff.getMisPlacedVMs(i).isEmpty()); map.addRunningVM(vm1, n1); Assert.assertEquals(coff.getMisPlacedVMs(i), map.getAllVMs()); } |
CRunning implements ChocoConstraint { @Override public Set<VM> getMisPlacedVMs(Instance i) { VM vm = cstr.getInvolvedVMs().iterator().next(); Mapping map = i.getModel().getMapping(); if (!map.isRunning(vm)) { return Collections.singleton(vm); } return Collections.emptySet(); } CRunning(Running c); @Override boolean inject(Parameters ps, ReconfigurationProblem rp); @Override Set<VM> getMisPlacedVMs(Instance i); @Override String toString(); } | @Test public void testGetMisplaced() { Model mo = new DefaultModel(); VM vm1 = mo.newVM(); VM vm2 = mo.newVM(); Node n1 = mo.newNode(); mo.getMapping().on(n1).ready(vm1).run(n1, vm2); Instance i = new Instance(mo, Collections.emptyList(), new MinMTTR()); CRunning k = new CRunning(new Running(vm1)); Assert.assertEquals(1, k.getMisPlacedVMs(i).size()); Assert.assertTrue(k.getMisPlacedVMs(i).contains(vm1)); k = new CRunning(new Running(vm2)); Assert.assertEquals(0, k.getMisPlacedVMs(i).size()); } |
CFence implements ChocoConstraint { @Override public Set<VM> getMisPlacedVMs(Instance i) { Mapping map = i.getModel().getMapping(); VM vm = cstr.getInvolvedVMs().iterator().next(); if (map.isRunning(vm) && !cstr.getInvolvedNodes().contains(map.getVMLocation(vm))) { return Collections.singleton(vm); } return Collections.emptySet(); } CFence(Fence c); @Override boolean inject(Parameters ps, ReconfigurationProblem rp); @Override Set<VM> getMisPlacedVMs(Instance i); @Override String toString(); } | @Test public void testGetMisPlaced() { Model mo = new DefaultModel(); VM vm1 = mo.newVM(); VM vm2 = mo.newVM(); VM vm3 = mo.newVM(); VM vm4 = mo.newVM(); VM vm5 = mo.newVM(); Node n1 = mo.newNode(); Node n2 = mo.newNode(); Node n3 = mo.newNode(); Node n4 = mo.newNode(); Node n5 = mo.newNode(); mo.getMapping().on(n1, n2, n3, n4) .off(n5) .run(n1, vm1, vm2) .run(n2, vm3) .run(n3, vm4) .sleep(n4, vm5); Set<VM> vms = new HashSet<>(Arrays.asList(vm1, vm2)); Set<Node> ns = new HashSet<>(Arrays.asList(n1, n2)); CFence c = new CFence(new Fence(vm1, ns)); Instance i = new Instance(mo, Collections.emptyList(), new MinMTTR()); Assert.assertTrue(c.getMisPlacedVMs(i).isEmpty()); ns.add(mo.newNode()); Assert.assertTrue(c.getMisPlacedVMs(i).isEmpty()); vms.add(vm3); Assert.assertTrue(c.getMisPlacedVMs(i).isEmpty()); vms.add(vm4); Set<VM> bad = new CFence(new Fence(vm4, ns)).getMisPlacedVMs(i); Assert.assertEquals(1, bad.size()); Assert.assertTrue(bad.contains(vm4)); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.