Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: ContinuousViolationException extends SatConstraintViolationException { public Action getAction() { return action; } ContinuousViolationException(SatConstraint cstr, Action action); Action getAction(); }### Answer: @Test public void test() { SatConstraint c = Mockito.mock(SatConstraint.class); Action a = Mockito.mock(Action.class); ContinuousViolationException ex = new ContinuousViolationException(c, a); Assert.assertEquals(ex.getAction(), a); Assert.assertEquals(ex.getConstraint(), c); Assert.assertFalse(ex.toString().contains("null")); }
### Question: DiscreteViolationException extends SatConstraintViolationException { public Model getModel() { return mo; } DiscreteViolationException(SatConstraint cstr, Model mo); Model getModel(); }### Answer: @Test public void test() { SatConstraint c = Mockito.mock(SatConstraint.class); Model m = new DefaultModel(); DiscreteViolationException ex = new DiscreteViolationException(c, m); Assert.assertEquals(ex.getModel(), m); Assert.assertEquals(ex.getConstraint(), c); Assert.assertFalse(ex.toString().contains("null")); }
### Question: DefaultReconfigurationPlan implements ReconfigurationPlan { @Override public String toString() { List<Action> l = new ArrayList<>(actions); l.sort(sorter); StringJoiner joiner = new StringJoiner("\n"); for (Action a : l) { joiner.add(String.format("%d:%d %s", a.getStart(), a.getEnd(), a.toString())); } return joiner.toString(); } DefaultReconfigurationPlan(Model m); @Override Model getOrigin(); @Override boolean add(Action a); @Override int getSize(); @Override int getDuration(); @Override Set<Action> getActions(); @Override Iterator<Action> iterator(); @Override Model getResult(); @Override String toString(); @Override boolean isApplyable(); @Override boolean equals(Object o); @Override int hashCode(); @Override Set<Action> getDirectDependencies(Action a); @Override ReconfigurationPlanApplier getReconfigurationApplier(); @Override void setReconfigurationApplier(ReconfigurationPlanApplier ra); }### Answer: @Test public void testToString() { Model mo = new DefaultModel(); VM v1 = mo.newVM(); VM v2 = mo.newVM(); Node n1 = mo.newNode(); Node n2 = mo.newNode(); mo.getMapping().addOnlineNode(n1); mo.getMapping().addOnlineNode(n2); mo.getMapping().addRunningVM(v1, n1); mo.getMapping().addRunningVM(v2, n1); ReconfigurationPlan p1 = new DefaultReconfigurationPlan(mo); p1.add(new MigrateVM(v1, n1, n2, 1, 2)); p1.add(new MigrateVM(v2, n1, n2, 1, 2)); String s = p1.toString(); Assert.assertNotEquals(s.indexOf("migrate("), s.lastIndexOf("migrate(")); System.err.println(p1.toString()); System.err.flush(); }
### Question: DefaultReconfigurationPlan implements ReconfigurationPlan { @Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null \|\| getClass() != o.getClass()) { return false; } ReconfigurationPlan op = (ReconfigurationPlan) o; return actions.equals(op.getActions()) && src.equals(op.getOrigin()); } DefaultReconfigurationPlan(Model m); @Override Model getOrigin(); @Override boolean add(Action a); @Override int getSize(); @Override int getDuration(); @Override Set<Action> getActions(); @Override Iterator<Action> iterator(); @Override Model getResult(); @Override String toString(); @Override boolean isApplyable(); @Override boolean equals(Object o); @Override int hashCode(); @Override Set<Action> getDirectDependencies(Action a); @Override ReconfigurationPlanApplier getReconfigurationApplier(); @Override void setReconfigurationApplier(ReconfigurationPlanApplier ra); }### Answer: @Test public void testEquals() { Model mo = new DefaultModel(); VM v = mo.newVM(); Node n1 = mo.newNode(); Node n2 = mo.newNode(); mo.getMapping().addOnlineNode(n1); mo.getMapping().addOnlineNode(n2); mo.getMapping().addRunningVM(v, n1); ReconfigurationPlan p1 = new DefaultReconfigurationPlan(mo); p1.add(new ShutdownNode(n1, 1, 2)); p1.add(new ShutdownNode(n2, 1, 2)); ReconfigurationPlan p2 = new DefaultReconfigurationPlan(mo.copy()); p2.add(new ShutdownNode(n1, 1, 2)); p2.add(new ShutdownNode(n2, 1, 2)); Assert.assertEquals(p1, p2); }
### Question: RootConverter implements ConstraintConverter<Root> { @Override public String getJSONId() { return "root"; } @Override Class<Root> getSupportedConstraint(); @Override String getJSONId(); @Override Root fromJSON(Model mo, JSONObject o); @Override JSONObject toJSON(Root o); }### Answer: @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Root.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new RootConverter().getJSONId())); }
### Question: SuspendVM extends Action implements VMStateTransition { @Override public boolean equals(Object o) { if (!super.equals(o)) { return false; } SuspendVM that = (SuspendVM) o; return this.vm.equals(that.vm) && this.src.equals(that.src) && this.dst.equals(that.dst); } SuspendVM(VM v, Node from, Node to, int start, int end); @Override String pretty(); @Override boolean applyAction(Model m); @Override boolean equals(Object o); @Override int hashCode(); Node getDestinationNode(); Node getSourceNode(); @Override VM getVM(); @Override VMState getCurrentState(); @Override VMState getNextState(); @Override Object visit(ActionVisitor v); }### Answer: @Test(dependsOnMethods = {"testInstantiate"}) public void testEquals() { SuspendVM a = new SuspendVM(vms.get(0), ns.get(0), ns.get(1), 3, 5); SuspendVM b = new SuspendVM(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()); Assert.assertNotSame(a, new SuspendVM(vms.get(0), ns.get(0), ns.get(1), 4, 5)); Assert.assertNotSame(a, new SuspendVM(vms.get(0), ns.get(0), ns.get(1), 3, 4)); Assert.assertNotSame(a, new SuspendVM(vms.get(1), ns.get(0), ns.get(1), 3, 5)); Assert.assertNotSame(a, new SuspendVM(vms.get(0), ns.get(2), ns.get(1), 3, 5)); Assert.assertNotSame(a, new SuspendVM(vms.get(0), ns.get(0), ns.get(2), 3, 5)); }
### Question: SuspendVM extends Action implements VMStateTransition { @Override public Object visit(ActionVisitor v) { return v.visit(this); } SuspendVM(VM v, Node from, Node to, int start, int end); @Override String pretty(); @Override boolean applyAction(Model m); @Override boolean equals(Object o); @Override int hashCode(); Node getDestinationNode(); Node getSourceNode(); @Override VM getVM(); @Override VMState getCurrentState(); @Override VMState getNextState(); @Override Object visit(ActionVisitor v); }### Answer: @Test public void testVisit() { ActionVisitor visitor = mock(ActionVisitor.class); a.visit(visitor); verify(visitor).visit(a); }
### Question: ResumeVM extends Action implements VMStateTransition, RunningVMPlacement { @Override public boolean equals(Object o) { if (!super.equals(o)) { return false; } ResumeVM that = (ResumeVM) o; return this.vm.equals(that.vm) && this.src.equals(that.src) && this.dst.equals(that.dst); } ResumeVM(VM v, Node from, Node to, int start, int end); @Override VM getVM(); @Override Node getDestinationNode(); Node getSourceNode(); @Override String pretty(); @Override boolean applyAction(Model m); @Override boolean equals(Object o); @Override int hashCode(); @Override VMState getCurrentState(); @Override VMState getNextState(); @Override Object visit(ActionVisitor v); }### Answer: @Test(dependsOnMethods = {"testInstantiate"}) public void testEquals() { ResumeVM a = new ResumeVM(vms.get(0), ns.get(0), ns.get(1), 3, 5); ResumeVM b = new ResumeVM(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()); Assert.assertNotSame(a, new ResumeVM(vms.get(0), ns.get(0), ns.get(1), 4, 5)); Assert.assertNotSame(a, new ResumeVM(vms.get(0), ns.get(0), ns.get(1), 3, 4)); Assert.assertNotSame(a, new ResumeVM(vms.get(1), ns.get(0), ns.get(1), 3, 5)); Assert.assertNotSame(a, new ResumeVM(vms.get(0), ns.get(2), ns.get(1), 3, 5)); Assert.assertNotSame(a, new ResumeVM(vms.get(0), ns.get(0), ns.get(2), 3, 5)); }
### Question: ResumeVM extends Action implements VMStateTransition, RunningVMPlacement { @Override public Object visit(ActionVisitor v) { return v.visit(this); } ResumeVM(VM v, Node from, Node to, int start, int end); @Override VM getVM(); @Override Node getDestinationNode(); Node getSourceNode(); @Override String pretty(); @Override boolean applyAction(Model m); @Override boolean equals(Object o); @Override int hashCode(); @Override VMState getCurrentState(); @Override VMState getNextState(); @Override Object visit(ActionVisitor v); }### Answer: @Test public void testVisit() { ActionVisitor visitor = mock(ActionVisitor.class); a.visit(visitor); verify(visitor).visit(a); }
### Question: GatherConverter implements ConstraintConverter<Gather> { @Override public String getJSONId() { return "gather"; } @Override Class<Gather> getSupportedConstraint(); @Override String getJSONId(); @Override Gather fromJSON(Model mo, JSONObject o); @Override JSONObject toJSON(Gather o); }### Answer: @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Gather.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new GatherConverter().getJSONId())); }
### Question: Allocate extends Action implements VMEvent { @Override public Object visit(ActionVisitor v) { return v.visit(this); } Allocate(VM vm, Node on, String rc, int amount, int start, int end); Node getHost(); @Override VM getVM(); String getResourceId(); int getAmount(); @Override boolean applyAction(Model i); @Override String pretty(); @Override boolean equals(Object o); @Override int hashCode(); @Override Object visit(ActionVisitor v); }### Answer: @Test public void testVisit() { ActionVisitor visitor = mock(ActionVisitor.class); a.visit(visitor); verify(visitor).visit(a); }
### Question: BootNode extends Action implements NodeEvent { @Override public Node getNode() { return 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); }### Answer: @Test public void testInstantiate() { BootNode a = new BootNode(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")); }
### Question: 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); }### Answer: @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)); }
### Question: 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); }### Answer: @Test public void testVisit() { ActionVisitor visitor = mock(ActionVisitor.class); a.visit(visitor); verify(visitor).visit(a); }
### Question: 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); }### Answer: @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")); }
### Question: 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); }### Answer: @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)); }
### Question: 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); }### Answer: @Test public void testVisit() { ActionVisitor visitor = mock(ActionVisitor.class); a.visit(visitor); verify(visitor).visit(a); }
### Question: 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); }### Answer: @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)); }
### Question: 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); }### Answer: @Test public void testVisit() { ActionVisitor visitor = mock(ActionVisitor.class); a.visit(visitor); verify(visitor).visit(a); }
### Question: 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); }### Answer: @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Ready.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new ReadyConverter().getJSONId())); }
### Question: 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); }### Answer: @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)); }
### Question: 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); }### Answer: @Test public void testVisit() { ActionVisitor visitor = mock(ActionVisitor.class); a.visit(visitor); verify(visitor).visit(a); }
### Question: 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(); }### Answer: @Test public void testVisit() { ActionVisitor visitor = mock(ActionVisitor.class); s.visit(visitor); verify(visitor).visit(s); }
### Question: 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(); }### Answer: @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)); }
### Question: 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); }### Answer: @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))); }
### Question: 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); }### Answer: @Test public void testVisit() { ActionVisitor visitor = mock(ActionVisitor.class); a.visit(visitor); verify(visitor).visit(a); }
### Question: 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); }### Answer: @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)); }
### Question: 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); }### Answer: @Test public void testVisit() { ActionVisitor visitor = mock(ActionVisitor.class); a.visit(visitor); verify(visitor).visit(a); }
### Question: 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); }### Answer: @Test public void testVisit() { ActionVisitor visitor = mock(ActionVisitor.class); a.visit(visitor); verify(visitor).visit(a); }
### Question: 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); }### Answer: @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(ResourceCapacity.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new ResourceCapacityConverter().getJSONId())); }
### Question: 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); }### Answer: @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)); }
### Question: 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); }### Answer: @Test public void testVisit() { ActionVisitor visitor = mock(ActionVisitor.class); a.visit(visitor); verify(visitor).visit(a); }
### Question: InconsistentSolutionException extends SchedulerModelingException { public ReconfigurationPlan getResult() { return plan; } InconsistentSolutionException(ReconfigurationPlan p, String msg); ReconfigurationPlan getResult(); }### Answer: @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"); }
### Question: SchedulerException extends RuntimeException { public Model getModel() { return model; } SchedulerException(Model m, String msg); SchedulerException(Model m, String msg, Throwable t); Model getModel(); }### Answer: @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); }
### Question: UnstatableProblemException extends SchedulerException { public int timeout() { return duration; } UnstatableProblemException(Model m, int to); int timeout(); }### Answer: @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")); }
### Question: 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); }### Answer: @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); }
### Question: 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); }### Answer: @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Among.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new AmongConverter().getJSONId())); }
### Question: 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); }### Answer: @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)); }
### Question: 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); }### Answer: @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)); }
### Question: 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); }### Answer: @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)); }
### Question: 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); }### Answer: @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)); }
### Question: 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); }### Answer: @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Quarantine.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new QuarantineConverter().getJSONId())); }
### Question: 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); }### Answer: @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)); }
### Question: 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); }### Answer: @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)); }
### Question: 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); }### Answer: @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)); }
### Question: 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; }### Answer: @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); }
### Question: 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; }### Answer: @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); }
### Question: 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; }### Answer: @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); }
### Question: 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; }### Answer: @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); }
### Question: 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); }### Answer: @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Killed.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new KilledConverter().getJSONId())); }
### Question: 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; }### Answer: @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); }
### Question: 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; }### Answer: @Test(expectedExceptions = {UnsupportedOperationException.class}) public void testIncorrectNot() { BtrpNumber i = new BtrpNumber(2.5); i.not(); }
### Question: 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); }### Answer: @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Running.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new RunningConverter().getJSONId())); }
### Question: 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); }### Answer: @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Spread.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new SpreadConverter().getJSONId())); }
### Question: 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(); }### Answer: @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); }
### Question: 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); }### Answer: @Test public void testInstantiation() { DefaultTemplateFactory tplf = new DefaultTemplateFactory(NamingService.newNodeNS(), NamingService.newVMNS(), new DefaultModel()); Assert.assertTrue(tplf.getAvailables().isEmpty()); }
### Question: 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); }### Answer: @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); }
### Question: 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); }### Answer: @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Seq.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new SeqConverter().getJSONId())); }
### Question: 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); }### Answer: @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Precedence.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new PrecedenceConverter().getJSONId())); }
### Question: 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); }### Answer: @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Sync.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new SyncConverter().getJSONId())); }
### Question: 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); }### Answer: @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Deadline.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new DeadlineConverter().getJSONId())); }
### Question: 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); }### Answer: @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Serialize.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new SerializeConverter().getJSONId())); }
### Question: 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); }### Answer: @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Preserve.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new PreserveConverter().getJSONId())); }
### Question: 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); }### Answer: @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Overbook.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new OverbookConverter().getJSONId())); }
### Question: 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); }### Answer: @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Fence.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new FenceConverter().getJSONId())); }
### Question: 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); }### Answer: @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(RunningCapacity.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new RunningCapacityConverter().getJSONId())); }
### Question: 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); }### Answer: @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(NoDelay.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new NoDelayConverter().getJSONId())); }
### Question: 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); }### Answer: @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); }
### Question: 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); }### Answer: @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Lonely.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new LonelyConverter().getJSONId())); }
### Question: 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); }### Answer: @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Offline.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new OfflineConverter().getJSONId())); }
### Question: 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); }### Answer: @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Online.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new OnlineConverter().getJSONId())); }
### Question: 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); }### Answer: @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")); }
### Question: 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); }### Answer: @Test(dependsOnMethods = {"testRegister"}, expectedExceptions = {JSONConverterException.class}) public void testToJSonWithNoConverters() throws JSONConverterException { ConstraintsConverter c = new ConstraintsConverter(); MockSatConstraint m = new MockSatConstraint("bar"); c.toJSON(m); }
### Question: 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); }### Answer: @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); }
### Question: 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); }### Answer: @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(MinMigrations.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new MinMigrationsConverter().getJSONId())); }
### Question: 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); }### Answer: @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(SplitAmong.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new SplitAmongConverter().getJSONId())); }
### Question: 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); }### Answer: @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Sleeping.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new SleepingConverter().getJSONId())); }
### Question: 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); }### Answer: @Test public void testBundle() { Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJavaConstraints().contains(Split.class)); Assert.assertTrue(ConstraintsConverter.newBundle().getSupportedJSONConstraints().contains(new SplitConverter().getJSONId())); }
### Question: 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); }### Answer: @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); }
### Question: 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; }### Answer: @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)); }
### Question: 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); }### Answer: @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")); }
### Question: 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); }### Answer: @Test(dependsOnMethods = {"testRegister"}, expectedExceptions = {JSONConverterException.class}) public void testToJSonWithNoConverters() throws JSONConverterException { ModelViewsConverter c = new ModelViewsConverter(); MockModelView m = new MockModelView("bar"); c.toJSON(m); }
### Question: 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); }### Answer: @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); }
### Question: 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); }### Answer: @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); }
### Question: 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; }### Answer: @Test public void testAccessors() { ModelConverter mc = new ModelConverter(); ReconfigurationPlanConverter rcp = new ReconfigurationPlanConverter(mc); Assert.assertEquals(rcp.getModelConverter(), mc); }
### Question: 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; }### Answer: @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); }
### Question: 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); }### Answer: @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); }
### Question: 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); }### Answer: @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"); }
### Question: 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); }### Answer: @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); }
### Question: 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(); }### Answer: @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()); }
### Question: 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(); }### Answer: @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()); }
### Question: 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(); }### Answer: @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()); }
### Question: Or extends BinaryProp { @Override public Boolean eval(Context m) { Boolean r1 = p1.eval(m); if (r1 == null) { return null; } if (r1) { return true; } return p2.eval(m); } Or(Proposition p1, Proposition p2); @Override String operator(); @Override And not(); @Override Boolean eval(Context m); @Override String toString(); }### Answer: @Test(dataProvider = "input") public void testTruthTable(Proposition a, Proposition b, Boolean r) { Or p = new Or(a, b); Assert.assertEquals(p.eval(new Context()), r); }
### Question: CKilled implements ChocoConstraint { @Override public Set<VM> getMisPlacedVMs(Instance i) { Mapping map = i.getModel().getMapping(); VM v = cstr.getInvolvedVMs().iterator().next(); if (map.contains(v)) { return Collections.singleton(v); } return Collections.emptySet(); } CKilled(Killed c); @Override boolean inject(Parameters ps, ReconfigurationProblem rp); @Override Set<VM> getMisPlacedVMs(Instance i); @Override String toString(); }### Answer: @Test public void testGetMisplaced() { Model mo = new DefaultModel(); VM vm1 = mo.newVM(); VM vm2 = mo.newVM(); VM vm5 = mo.newVM(); Node n1 = mo.newNode(); mo.getMapping().ready(vm1).on(n1).run(n1, vm2); CKilled k = new CKilled(new Killed(vm5)); Instance i = new Instance(mo, Collections.emptyList(), new MinMTTR()); Assert.assertTrue(k.getMisPlacedVMs(i).isEmpty()); k = new CKilled(new Killed(vm2)); Assert.assertEquals(1, k.getMisPlacedVMs(i).size()); Assert.assertTrue(k.getMisPlacedVMs(i).contains(vm2)); k = new CKilled(new Killed(vm1)); Assert.assertEquals(1, k.getMisPlacedVMs(i).size()); Assert.assertTrue(k.getMisPlacedVMs(i).contains(vm1)); }
### Question: COverbook implements ChocoConstraint { @Override public Set<VM> getMisPlacedVMs(Instance i) { return Collections.emptySet(); } COverbook(Overbook o); @Override boolean inject(Parameters ps, ReconfigurationProblem rp); @Override Set<VM> getMisPlacedVMs(Instance i); @Override String toString(); }### Answer: @Test public void testGetMisplaced() throws SchedulerException { Model mo = new DefaultModel(); VM vm1 = mo.newVM(); VM vm2 = mo.newVM(); 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(); mo.getMapping().on(n1, n2, n3) .run(n1, vm1) .run(n2, vm2, vm3) .run(n3, vm4, vm5, vm6); ShareableResource rcCPU = new ShareableResource("cpu", 1, 1); mo.attach(rcCPU); Overbook o1 = new Overbook(n1, "cpu", 1); Overbook o2 = new Overbook(n2, "cpu", 2); Overbook o3 = new Overbook(n3, "cpu", 3); COverbook co1 = new COverbook(o1); COverbook co2 = new COverbook(o2); COverbook co3 = new COverbook(o3); Instance i = new Instance(mo, Collections.emptyList(), new MinMTTR()); Assert.assertTrue(co1.getMisPlacedVMs(i).isEmpty()); Assert.assertTrue(co2.getMisPlacedVMs(i).isEmpty()); Assert.assertEquals(o3.getInvolvedVMs(), co3.getMisPlacedVMs(i)); }
### Question: CAmong implements ChocoConstraint { @Override public Set<VM> getMisPlacedVMs(Instance i) { if (!cstr.isSatisfied(i.getModel())) { return new HashSet<>(cstr.getInvolvedVMs()); } return Collections.emptySet(); } CAmong(Among a); IntVar getGroupVariable(); @Override boolean inject(Parameters ps, ReconfigurationProblem rp); int getGroup(Node n, List<Collection<Node>> grps); @Override Set<VM> getMisPlacedVMs(Instance i); @Override String toString(); static final String GROUP_LABEL; }### Answer: @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(); Mapping map = mo.getMapping() .on(n1, n2, n3, n4) .run(n1, vm1).run(n2, vm2, vm3) .ready(vm4, vm5); Set<VM> vms = new HashSet<>(Arrays.asList(vm1, vm2, vm5)); Collection<Node> s1 = new HashSet<>(Arrays.asList(n1, n2)); Collection<Node> s2 = new HashSet<>(Arrays.asList(n3, n4)); Collection<Collection<Node>> pGrps = new HashSet<>(Arrays.asList(s1, s2)); Among a = new Among(vms, pGrps); CAmong ca = new CAmong(a); Instance i = new Instance(mo, Collections.emptyList(), new MinMTTR()); Assert.assertEquals(ca.getMisPlacedVMs(i), Collections.emptySet()); map.addRunningVM(vm5, n3); Assert.assertEquals(ca.getMisPlacedVMs(i), vms); }
### Question: CSpread implements ChocoConstraint { @Override public Set<VM> getMisPlacedVMs(Instance i) { Map<Node, Set<VM>> spots = new HashMap<>(); Set<VM> bad = new HashSet<>(); Mapping map = i.getModel().getMapping(); for (VM vm : cstr.getInvolvedVMs()) { Node h = map.getVMLocation(vm); if (map.isRunning(vm)) { if (!spots.containsKey(h)) { spots.put(h, new HashSet<>()); } spots.get(h).add(vm); } } for (Map.Entry<Node, Set<VM>> e : spots.entrySet()) { if (e.getValue().size() > 1) { bad.addAll(e.getValue()); } } return bad; } CSpread(Spread s); @Override boolean inject(Parameters ps, ReconfigurationProblem rp); @Override Set<VM> getMisPlacedVMs(Instance i); @Override String toString(); }### Answer: @Test public void testGetMisplaced() { Model mo = new DefaultModel(); VM vm1 = mo.newVM(); VM vm2 = mo.newVM(); VM vm3 = mo.newVM(); Node n1 = mo.newNode(); Node n2 = mo.newNode(); Mapping map = mo.getMapping().on(n1, n2) .run(n1, vm1, vm3) .run(n2, vm2); Set<VM> vms = new HashSet<>(Arrays.asList(vm1, vm2)); Spread s = new Spread(vms); CSpread cs = new CSpread(s); Instance i = new Instance(mo, Collections.emptyList(), new MinMTTR()); Assert.assertTrue(cs.getMisPlacedVMs(i).isEmpty()); vms.add(vm3); Assert.assertEquals(map.getRunningVMs(n1), cs.getMisPlacedVMs(i)); }
### Question: CLonely implements ChocoConstraint { @Override public Set<VM> getMisPlacedVMs(Instance i) { Set<VM> bad = new HashSet<>(); Set<Node> hosts = new HashSet<>(); Collection<VM> vms = cstr.getInvolvedVMs(); Mapping map = i.getModel().getMapping(); for (VM vm : vms) { if (map.isRunning(vm)) { hosts.add(map.getVMLocation(vm)); } } for (Node n : hosts) { for (VM vm : map.getRunningVMs(n)) { if (!vms.contains(vm)) { bad.addAll(map.getRunningVMs(n)); break; } } } return bad; } CLonely(Lonely c); @Override boolean inject(Parameters ps, ReconfigurationProblem rp); @Override Set<VM> getMisPlacedVMs(Instance i); @Override String toString(); }### Answer: @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(); Mapping map = mo.getMapping().on(n1, n2, n3) .run(n1, vm1, vm2, vm3) .run(n2, vm4, vm5); Set<VM> mine = new HashSet<>(Arrays.asList(vm1, vm2, vm3)); CLonely c = new CLonely(new Lonely(mine)); Instance i = new Instance(mo, Collections.emptyList(), new MinMTTR()); Assert.assertTrue(c.getMisPlacedVMs(i).isEmpty()); map.addRunningVM(vm2, n2); Assert.assertEquals(c.getMisPlacedVMs(i), map.getRunningVMs(n2)); }
### Question: COnline implements ChocoConstraint { @Override public String toString() { return cstr.toString(); } COnline(Online o); @Override boolean inject(Parameters ps, ReconfigurationProblem rp); @Override Set<VM> getMisPlacedVMs(Instance i); @Override String toString(); }### Answer: @Test public void testInstantiation() { Model mo = new DefaultModel(); Node n1 = mo.newNode(); Online on = new Online(n1); COnline con = new COnline(on); Assert.assertEquals(con.toString(), on.toString()); }
### Question: CBan implements ChocoConstraint { @Override public Set<VM> getMisPlacedVMs(Instance i) { Mapping map = i.getModel().getMapping(); VM vm = ban.getInvolvedVMs().iterator().next(); if (map.isRunning(vm) && ban.getInvolvedNodes().contains(map.getVMLocation(vm))) { return Collections.singleton(vm); } return Collections.emptySet(); } CBan(Ban b); @Override boolean inject(Parameters ps, ReconfigurationProblem rp); @Override Set<VM> getMisPlacedVMs(Instance i); @Override String toString(); }### Answer: @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, n5) .run(n1, vm1, vm2) .run(n2, vm3) .run(n3, vm4) .sleep(n4, vm5); Set<Node> ns = new HashSet<>(Arrays.asList(n3, n4)); CBan c = new CBan(new Ban(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()); ns.add(n1); Set<VM> bad = c.getMisPlacedVMs(i); Assert.assertEquals(1, bad.size()); Assert.assertTrue(bad.contains(vm1)); }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.