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: Empty extends ERE { @Override public ERE copy() { return this; } private Empty(); static Empty get(); @Override EREType getEREType(); @Override boolean equals(Object o); @Override int compareTo(Object o); @Override ERE copy(); @Override String toString(); @Override boolean containsEpsilon(); @Override ERE derive(Symbol s); }### Answer: @Test public void testCopy() { ERE copy = empty.copy(); assertEquals(empty, copy); }
### Question: Or extends ERE { static public ERE get(List<ERE> children) { Or or = new Or(children); ERE ret = or.simplify(); return ret; } private Or(List<ERE> children); static ERE get(List<ERE> children); ERE simplify(); @Override EREType getEREType(); @Override String toString(); @Override ERE copy(); @Override boolean containsEpsilon(); @Override ERE derive(Symbol s); }### Answer: @Test public void testEquality() { ERE or_again = Or.get(new ArrayList<ERE>(Arrays.asList(a, b))); ERE or_reverse = Or.get(new ArrayList<ERE>(Arrays.asList(a, b))); assertEquals(aOrb, or_again); assertEquals(0, aOrb.compareTo(or_again)); assertEquals(aOrb, or_reverse); assertEquals(0, aOrb.compareTo(or_reverse)); } @Test public void testInequality() { Symbol c = Symbol.get("c"); ERE aOrc = Or.get(new ArrayList<ERE>(Arrays.asList(a, c))); assertFalse(aOrb.equals(aOrc)); assertFalse(0 == aOrb.compareTo(aOrc)); assertFalse(aOrb.equals(a)); assertFalse(0 == aOrb.compareTo(a)); }
### Question: Or extends ERE { @Override public ERE copy() { ArrayList<ERE> retChildren = new ArrayList<ERE>(children.size()); for(ERE child : children) { retChildren.add(child.copy()); } return new Or(retChildren); } private Or(List<ERE> children); static ERE get(List<ERE> children); ERE simplify(); @Override EREType getEREType(); @Override String toString(); @Override ERE copy(); @Override boolean containsEpsilon(); @Override ERE derive(Symbol s); }### Answer: @Test public void testCopy() { ERE copy = aOrb.copy(); assertEquals(aOrb, copy); }
### Question: Or extends ERE { @Override public EREType getEREType() { return EREType.OR; } private Or(List<ERE> children); static ERE get(List<ERE> children); ERE simplify(); @Override EREType getEREType(); @Override String toString(); @Override ERE copy(); @Override boolean containsEpsilon(); @Override ERE derive(Symbol s); }### Answer: @Test public void testEREType() { assertEquals(EREType.OR, aOrb.getEREType()); }
### Question: Or extends ERE { @Override public boolean containsEpsilon() { for(ERE child : children) { if(child.containsEpsilon()) { return true; } } return false; } private Or(List<ERE> children); static ERE get(List<ERE> children); ERE simplify(); @Override EREType getEREType(); @Override String toString(); @Override ERE copy(); @Override boolean containsEpsilon(); @Override ERE derive(Symbol s); }### Answer: @Test public void testContainsEpsilon() { assertFalse(aOrb.containsEpsilon()); Epsilon epsilon = Epsilon.get(); ERE aOrepsilon = Or.get(new ArrayList<ERE>(Arrays.asList(a, epsilon))); assertTrue(aOrepsilon.containsEpsilon()); }
### Question: Or extends ERE { @Override public ERE derive(Symbol s) { ArrayList<ERE> orChildren = new ArrayList<ERE>(children.size()); for(ERE child : children) { orChildren.add(child.derive(s)); } return Or.get(orChildren); } private Or(List<ERE> children); static ERE get(List<ERE> children); ERE simplify(); @Override EREType getEREType(); @Override String toString(); @Override ERE copy(); @Override boolean containsEpsilon(); @Override ERE derive(Symbol s); }### Answer: @Test public void testDerive() { Symbol c = Symbol.get("c"); Epsilon epsilon = Epsilon.get(); Empty empty = Empty.get(); assertEquals(epsilon, aOrb.derive(a)); assertEquals(epsilon, aOrb.derive(b)); assertEquals(empty, aOrb.derive(c)); }
### Question: Or extends ERE { public ERE simplify() { ArrayList<ERE> flattened = new ArrayList<ERE>(children.size() >> 1); ArrayList<ERE> previous = new ArrayList<ERE>(children); boolean changed = true; while(changed) { changed = false; flattened = new ArrayList<ERE>(children.size()); for(ERE child : previous) { if(child.getEREType() == EREType.OR) { flattened.addAll(child.getChildren()); changed = true; } else { flattened.add(child); } } previous = flattened; } children = flattened; Collections.sort(children); for(int i = 0; i < children.size(); ++i) { if(children.get(i) == Empty.get()) { children.remove(i); } } for(int i = 0; i < children.size() - 1; ++i) { if(children.get(i).equals(children.get(i + 1))) { children.remove(i); i--; } } if(children.size() == 0) { return Empty.get(); } else if(children.size() == 1) { return children.get(0); } return this; } private Or(List<ERE> children); static ERE get(List<ERE> children); ERE simplify(); @Override EREType getEREType(); @Override String toString(); @Override ERE copy(); @Override boolean containsEpsilon(); @Override ERE derive(Symbol s); }### Answer: @Test public void testSimplify() { Symbol c = Symbol.get("c"); Epsilon epsilon = Epsilon.get(); assertEquals(aOrb, Or.get(new ArrayList<ERE>(Arrays.asList(a, b, a, b, a, b, a, b, a)))); assertEquals(Or.get(new ArrayList<ERE>(Arrays.asList(a, b, c))), Or.get(new ArrayList<ERE>(Arrays.asList(aOrb, c)))); }
### Question: Kleene extends ERE { public static ERE get(ERE child) { return new Kleene(child); } private Kleene(ERE child); static ERE get(ERE child); @Override EREType getEREType(); @Override String toString(); @Override ERE copy(); @Override boolean containsEpsilon(); @Override ERE derive(Symbol s); }### Answer: @Test public void testEquality() { ERE aStar_again = Kleene.get(a); assertEquals(aStar, aStar_again); assertEquals(0, aStar.compareTo(aStar_again)); }
### Question: Atom extends LTLFormula { @Override public LTLFormula copy(){ return this; } private Atom(); static Atom get(String name); @Override LTLType getLTLType(); @Override boolean equals(Object o); @Override int compareTo(Object o); @Override LTLFormula copy(); @Override String toString(); @Override void subFormulae(LinkedHashSet acc); @Override ATransition d(HashMap<LTLFormula, ATransition> D); }### Answer: @Test public void testCopy() { LTLFormula a_copy = a.copy(); assertEquals(a, a_copy); assertEquals(0, a.compareTo(a_copy)); assertEquals(a.hashCode(), a_copy.hashCode()); }
### Question: Kleene extends ERE { @Override public EREType getEREType() { return EREType.STAR; } private Kleene(ERE child); static ERE get(ERE child); @Override EREType getEREType(); @Override String toString(); @Override ERE copy(); @Override boolean containsEpsilon(); @Override ERE derive(Symbol s); }### Answer: @Test public void testEREType() { assertEquals(EREType.STAR, aStar.getEREType()); }
### Question: Kleene extends ERE { @Override public String toString() { return children.get(0) + ""; } private Kleene(ERE child); static ERE get(ERE child); @Override EREType getEREType(); @Override String toString(); @Override ERE copy(); @Override boolean containsEpsilon(); @Override ERE derive(Symbol s); }### Answer: @Test public void testString() { assertEquals("a", aStar.toString()); }
### Question: Kleene extends ERE { @Override public boolean containsEpsilon() { return true; } private Kleene(ERE child); static ERE get(ERE child); @Override EREType getEREType(); @Override String toString(); @Override ERE copy(); @Override boolean containsEpsilon(); @Override ERE derive(Symbol s); }### Answer: @Test public void testContainsEpsilon() { assertTrue(aStar.containsEpsilon()); }
### Question: Kleene extends ERE { @Override public ERE copy() { return new Kleene(children.get(0).copy()); } private Kleene(ERE child); static ERE get(ERE child); @Override EREType getEREType(); @Override String toString(); @Override ERE copy(); @Override boolean containsEpsilon(); @Override ERE derive(Symbol s); }### Answer: @Test public void testCopy() { ERE copy = aStar.copy(); assertEquals(aStar, copy); }
### Question: Kleene extends ERE { @Override public ERE derive(Symbol s) { return Concat.get(children.get(0).derive(s), copy()); } private Kleene(ERE child); static ERE get(ERE child); @Override EREType getEREType(); @Override String toString(); @Override ERE copy(); @Override boolean containsEpsilon(); @Override ERE derive(Symbol s); }### Answer: @Test public void testDerive() { Epsilon epsilon = Epsilon.get(); Empty empty = Empty.get(); assertEquals(aStar, aStar.derive(a)); assertEquals(empty, aStar.derive(b)); ERE ab = Concat.get(a, b); ERE ab_Star = Kleene.get(ab); assertEquals(ab_Star, ab_Star.derive(a).derive(b)); assertEquals(empty, ab_Star.derive(b)); }
### Question: Epsilon extends ERE { @Override public EREType getEREType() { return EREType.EPS; } private Epsilon(); static Epsilon get(); @Override EREType getEREType(); @Override boolean equals(Object o); @Override int compareTo(Object o); @Override ERE copy(); @Override String toString(); @Override boolean containsEpsilon(); @Override ERE derive(Symbol s); }### Answer: @Test public void testType() { assertEquals(epsilon.getEREType(), EREType.EPS); }
### Question: Epsilon extends ERE { @Override public String toString() { return "epsilon"; } private Epsilon(); static Epsilon get(); @Override EREType getEREType(); @Override boolean equals(Object o); @Override int compareTo(Object o); @Override ERE copy(); @Override String toString(); @Override boolean containsEpsilon(); @Override ERE derive(Symbol s); }### Answer: @Test public void testString() { assertEquals("epsilon", epsilon.toString()); }
### Question: Epsilon extends ERE { @Override public ERE derive(Symbol s) { return Empty.get(); } private Epsilon(); static Epsilon get(); @Override EREType getEREType(); @Override boolean equals(Object o); @Override int compareTo(Object o); @Override ERE copy(); @Override String toString(); @Override boolean containsEpsilon(); @Override ERE derive(Symbol s); }### Answer: @Test public void testDerive() { ERE derived = epsilon.derive(Symbol.get("test")); Empty empty = Empty.get(); assertEquals(empty, derived); }
### Question: Epsilon extends ERE { @Override public boolean containsEpsilon() { return true; } private Epsilon(); static Epsilon get(); @Override EREType getEREType(); @Override boolean equals(Object o); @Override int compareTo(Object o); @Override ERE copy(); @Override String toString(); @Override boolean containsEpsilon(); @Override ERE derive(Symbol s); }### Answer: @Test public void testContainsEpsilon() { assertTrue(epsilon.containsEpsilon()); }
### Question: Epsilon extends ERE { @Override public ERE copy() { return this; } private Epsilon(); static Epsilon get(); @Override EREType getEREType(); @Override boolean equals(Object o); @Override int compareTo(Object o); @Override ERE copy(); @Override String toString(); @Override boolean containsEpsilon(); @Override ERE derive(Symbol s); }### Answer: @Test public void testCopy() { ERE copy = epsilon.copy(); assertEquals(epsilon, copy); }
### Question: Atom extends LTLFormula { @Override public String toString(){ return LTLFormula.refToString.get(this); } private Atom(); static Atom get(String name); @Override LTLType getLTLType(); @Override boolean equals(Object o); @Override int compareTo(Object o); @Override LTLFormula copy(); @Override String toString(); @Override void subFormulae(LinkedHashSet acc); @Override ATransition d(HashMap<LTLFormula, ATransition> D); }### Answer: @Test public void testToString() { assertEquals("a", a.toString()); assertEquals("b", b.toString()); }
### Question: Sequence extends ArrayList<Symbol> implements AbstractSequence { public String toString() { if(size() == 0) return "#epsilon"; StringBuilder sb = new StringBuilder(); for(Symbol s : this) { sb.append(s.toString()); sb.append(" "); } return sb.toString(); } Sequence(int size); Sequence(); Sequence(ArrayList<Symbol> symbols); String toString(); String toDotString(); Sequence copy(); static void printSequenceArray(Sequence[] arr); @Override int dotLength(); @Override void getImpl(StringBuilder sb, Map<Symbol, Integer> symToNum); }### Answer: @Test public void stringTest() { assertEquals("#epsilon", empty.toString()); assertEquals("a b ", sequenceAB.toString()); assertEquals("a b c ", sequenceABC.toString()); }
### Question: Sequence extends ArrayList<Symbol> implements AbstractSequence { public String toDotString() { if(size() == 0) return "\\#epsilon"; StringBuilder sb = new StringBuilder(); for(Symbol s : this) { sb.append(s.toDotString()); sb.append("\\ "); } String ret = sb.toString(); return ret.substring(0,ret.length() - 2); } Sequence(int size); Sequence(); Sequence(ArrayList<Symbol> symbols); String toString(); String toDotString(); Sequence copy(); static void printSequenceArray(Sequence[] arr); @Override int dotLength(); @Override void getImpl(StringBuilder sb, Map<Symbol, Integer> symToNum); }### Answer: @Test public void dotStringTest() { assertEquals("\\#epsilon", empty.toDotString()); assertEquals("a\\ b", sequenceAB.toDotString()); assertEquals("a\\ b\\ c", sequenceABC.toDotString()); }
### Question: Sequence extends ArrayList<Symbol> implements AbstractSequence { public Sequence copy() { Sequence ret = new Sequence(size()); for(Symbol s : this) { ret.add(s); } return ret; } Sequence(int size); Sequence(); Sequence(ArrayList<Symbol> symbols); String toString(); String toDotString(); Sequence copy(); static void printSequenceArray(Sequence[] arr); @Override int dotLength(); @Override void getImpl(StringBuilder sb, Map<Symbol, Integer> symToNum); }### Answer: @Test public void testCopy() { Sequence[] copies = { new Sequence(sequenceABC), sequenceABC.copy() }; for(Sequence sequenceABCD : copies) { assertEquals(3, sequenceABCD.size()); assertEquals(sequenceABC, sequenceABCD); sequenceABCD.add(d); assertEquals(4, sequenceABCD.size()); assertEquals(3, sequenceABC.size()); assertFalse(sequenceABC.equals(sequenceABCD)); } }
### Question: Sequence extends ArrayList<Symbol> implements AbstractSequence { @Override public int dotLength() { if(isEmpty()) return 8; int len = 0; for(Symbol s: this) { len += s.length(); } return len; } Sequence(int size); Sequence(); Sequence(ArrayList<Symbol> symbols); String toString(); String toDotString(); Sequence copy(); static void printSequenceArray(Sequence[] arr); @Override int dotLength(); @Override void getImpl(StringBuilder sb, Map<Symbol, Integer> symToNum); }### Answer: @Test public void testDotLength() { assertEquals(8, empty.dotLength()); assertEquals(2, sequenceAB.dotLength()); assertEquals(3, sequenceABC.dotLength()); }
### Question: SinglyLinkedList implements Iterable<E> { @Override public String toString() { if(head == null) return "#epsilon"; StringBuilder sb = new StringBuilder("["); Node node = head; while(node != null) { sb.append(node.element.toString()); sb.append(", "); node = node.next; } String ret = sb.substring(0, sb.length() - 2); return ret + "]"; } SinglyLinkedList(); SinglyLinkedList(Iterable<E> c); boolean add(E e); boolean addAll(Iterable<E> c); boolean contains(Object o); @Override boolean equals(Object o); @Override int hashCode(); boolean isEmpty(); boolean remove(Object o); int size(); void replace(Iterator<E> I, Iterator<E> J, SinglyLinkedList<E> replacement); void nonDestructiveReplace(Iterator<E> I, Iterator<E> J, Iterable<E> replacement); void printRange(Iterator<E> I, Iterator<E> J); @Override String toString(); @Override Iterator<E> iterator(); Iterator<E> iterator(Iterator<E> I); Node getHead(); Node getTail(); }### Answer: @Test public void testInit() { assertEquals("[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]", l.toString()); int i = 1; for(String s : l) { assertEquals(Integer.toString(i), s); i++; } }
### Question: SinglyLinkedList implements Iterable<E> { public boolean remove(Object o) { Iterator<E> I = iterator(); while(I.hasNext()) { E e = I.next(); if(e.equals(o)) { I.remove(); return true; } } return false; } SinglyLinkedList(); SinglyLinkedList(Iterable<E> c); boolean add(E e); boolean addAll(Iterable<E> c); boolean contains(Object o); @Override boolean equals(Object o); @Override int hashCode(); boolean isEmpty(); boolean remove(Object o); int size(); void replace(Iterator<E> I, Iterator<E> J, SinglyLinkedList<E> replacement); void nonDestructiveReplace(Iterator<E> I, Iterator<E> J, Iterable<E> replacement); void printRange(Iterator<E> I, Iterator<E> J); @Override String toString(); @Override Iterator<E> iterator(); Iterator<E> iterator(Iterator<E> I); Node getHead(); Node getTail(); }### Answer: @Test public void testRemove() { Iterator<String> I = arr.iterator(); removeOdd(I); I = l.iterator(); removeOdd(I); assertEquals(arr.toString(), l.toString()); assertEquals(arr.size(), l.size()); assertEquals("<12, <>>", "" + l.getTail()); }
### Question: Symbol { public static Symbol get(String name) { Symbol ret = symbolTable.get(name); if(ret == null) { ret = new Symbol(name); symbolTable.put(name, ret); } return ret; } protected Symbol(); protected Symbol(String name); static Symbol get(String name); String toString(); String toDotString(); int length(); }### Answer: @Test public void testEquality() { Symbol foo_again = Symbol.get("foo"); Symbol bar_again = Symbol.get("bar"); assertEquals(foo, foo_again); assertEquals(bar, bar_again); assertFalse(foo.equals(bar)); assertFalse(foo.equals(bar_again)); assertEquals(foo.hashCode(), foo_again.hashCode()); assertEquals(bar.hashCode(), bar_again.hashCode()); }
### Question: Symbol { public String toString() { return name; } protected Symbol(); protected Symbol(String name); static Symbol get(String name); String toString(); String toDotString(); int length(); }### Answer: @Test public void testString() { assertEquals("foo", foo.toString()); assertEquals("bar", bar.toString()); }
### Question: Rule { public int getNumber() { return number; } protected Rule(); Rule(Sequence lhs, AbstractSequence rhs); Sequence getLhs(); AbstractSequence getRhs(); int getNumber(); Set<Symbol> getTerminals(); @Override String toString(); String toDotString(); int dotLength(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer: @Test public void testInit() { assertFalse(ab_a.getNumber() == ab_cd.getNumber()); }
### Question: Rule { public Set<Symbol> getTerminals() { return terminals; } protected Rule(); Rule(Sequence lhs, AbstractSequence rhs); Sequence getLhs(); AbstractSequence getRhs(); int getNumber(); Set<Symbol> getTerminals(); @Override String toString(); String toDotString(); int dotLength(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer: @Test public void testTerminals() { assertTrue(ab_a.getTerminals().contains(a)); assertTrue(ab_a.getTerminals().contains(b)); assertFalse(ab_a.getTerminals().contains(c)); assertFalse(ab_a.getTerminals().contains(d)); assertTrue(ab_cd.getTerminals().contains(a)); assertTrue(ab_cd.getTerminals().contains(b)); assertTrue(ab_cd.getTerminals().contains(c)); assertTrue(ab_cd.getTerminals().contains(d)); }
### Question: Atom extends LTLFormula { @Override public LTLType getLTLType(){ return LTLType.A; } private Atom(); static Atom get(String name); @Override LTLType getLTLType(); @Override boolean equals(Object o); @Override int compareTo(Object o); @Override LTLFormula copy(); @Override String toString(); @Override void subFormulae(LinkedHashSet acc); @Override ATransition d(HashMap<LTLFormula, ATransition> D); }### Answer: @Test public void testType() { assertEquals(LTLType.A, a.getLTLType()); assertEquals(LTLType.A, b.getLTLType()); }
### Question: Rule { @Override public String toString() { return lhs.toString() + " -> " + rhs.toString(); } protected Rule(); Rule(Sequence lhs, AbstractSequence rhs); Sequence getLhs(); AbstractSequence getRhs(); int getNumber(); Set<Symbol> getTerminals(); @Override String toString(); String toDotString(); int dotLength(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer: @Test public void testString() { assertEquals("a b -> a ", ab_a.toString()); assertEquals("a b -> c d ", ab_cd.toString()); }
### Question: Rule { public String toDotString() { return lhs.toDotString() + " \\rightarrow " + rhs.toDotString(); } protected Rule(); Rule(Sequence lhs, AbstractSequence rhs); Sequence getLhs(); AbstractSequence getRhs(); int getNumber(); Set<Symbol> getTerminals(); @Override String toString(); String toDotString(); int dotLength(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer: @Test public void testDotString() { assertEquals("a\\ b \\rightarrow a", ab_a.toDotString()); assertEquals("a\\ b \\rightarrow c\\ d", ab_cd.toDotString()); }
### Question: PatternMatchAutomaton extends LinkedHashMap<State, HashMap<Symbol, ActionState>> { public String toDotString() { StringBuilder sb = new StringBuilder("digraph A"); sb.append((long) (Math.random()* 2e61d)); sb.append("{\n rankdir=TB;\n node [shape=circle];\n"); for(State state : keySet()) { sb.append(" "); sb.append(state.toFullDotString()); sb.append("\n"); } for(State state : keySet()) { HashMap<Symbol, ActionState> transition = get(state); sb.append(transitionToDotString(state, transition)); } sb.append("}"); return sb.toString(); } PatternMatchAutomaton(SRS srs); PatternMatchAutomaton(SRS srs, Symbol[] extraTerminals); PatternMatchAutomaton(SRS srs, Set<Symbol> extraTerminals); void rewrite(SinglyLinkedList<Symbol> l); void rewrite(SpliceList<Symbol> l); @Override String toString(); String toDotString(); Map<Symbol, Integer> mkSymToNum(); String toImplString(); StringBuilder transitionToDotString(State state, Map<Symbol, ActionState> transition); }### Answer: @Test public void testDotSring() { String pmaDotStr = pma.toDotString(); System.out.println(pmaDotStr); assertTrue(pmaDotStr.contains("s_0 [texlbl=\"$\\begin{array}{c}0 : 0\\end{array}$\" label=\" \"];")); assertTrue(pmaDotStr.contains("s_1 [texlbl=\"$\\begin{array}{c}1 : 1\\end{array}$\" label=\" \"];")); assertTrue(pmaDotStr.contains("s_2 [texlbl=\"$\\begin{array}{c}2 : 2\\\\ (a\\ b \\rightarrow c\\ d)\\end{array}$\" label=\" \"];")); assertTrue(pmaDotStr.contains("s_0 -> s_1 [label=\"a / 0\"];")); assertTrue(pmaDotStr.contains("s_1 -> s_2 [label=\"b / 0\"];")); }
### Question: Or extends LTLFormula { public LTLType getLTLType(){ return LTLType.OR; } Or(ArrayList<LTLFormula> children); LTLType getLTLType(); LTLFormula copy(); LinkedHashSet<LinkedHashSet<LTLFormula>> toSetForm(); ATransition d(HashMap<LTLFormula, ATransition> D); static void main(String args[]); }### Answer: @Test public void testType() { assertEquals(LTLType.OR, a_or_b.getLTLType()); assertEquals(LTLType.OR, a_or_c.getLTLType()); }
### Question: Or extends LTLFormula { protected LTLFormula normalize(boolean b) { if(b) { flatten(); for(int i = 0; i < children.size(); ++i){ children.set(i, getNegation(i, true)); } return new And(children); } else { for(int i = 0; i < children.size(); ++i){ children.set(i, getNegation(i, false)); } return this; } } Or(ArrayList<LTLFormula> children); LTLType getLTLType(); LTLFormula copy(); LinkedHashSet<LinkedHashSet<LTLFormula>> toSetForm(); ATransition d(HashMap<LTLFormula, ATransition> D); static void main(String args[]); }### Answer: @Test public void testNormalize() { { ArrayList<LTLFormula> orElements = new ArrayList<LTLFormula>( Arrays.asList(new Negation(a), new Negation(b))); Collections.sort(orElements); And expected = new And(orElements); assertEquals(expected, a_or_b.copy().normalize(true)); } assertEquals(makeOr(a, c), a_or_c.normalize(false)); }
### Question: FooController { @GetMapping("/{id}") public FooResource get(@PathVariable UUID id) { log.info("Get {}", id); Foo foo = new Foo(id, "Foo"); return assembler.toModel(foo); } FooController(EntityLinks entityLinks); @GetMapping("/{id}") FooResource get(@PathVariable UUID id); @PutMapping("/{id}") HttpEntity<FooResource> update(@PathVariable UUID id, @RequestBody FooResource fooResource); @PostMapping HttpEntity<FooResource> create(@RequestBody FooResource fooResource); }### Answer: @Test public void shouldGet() throws Exception { mockMvc.perform(get("/foos/{id}", "cafe")) .andDo(print()) .andExpect(status().isOk()) .andExpect(content().contentType("application/hal+json")) .andExpect(jsonPath("$.uuid", is("cafe"))) .andExpect(jsonPath("$._links.self.href", is("http: }
### Question: FooController { @PutMapping("/{id}") public HttpEntity<FooResource> update(@PathVariable UUID id, @RequestBody FooResource fooResource) { log.info("Update {} : {}", id, fooResource); Foo entity = new Foo(fooResource.getUuid(), fooResource.getName()); return ResponseEntity.ok(assembler.toModel(entity)); } FooController(EntityLinks entityLinks); @GetMapping("/{id}") FooResource get(@PathVariable UUID id); @PutMapping("/{id}") HttpEntity<FooResource> update(@PathVariable UUID id, @RequestBody FooResource fooResource); @PostMapping HttpEntity<FooResource> create(@RequestBody FooResource fooResource); }### Answer: @Test public void update() throws Exception { mockMvc.perform(put("/foos/{id}", "foo") .content("{\"uuid\":\"foo\",\"name\":\"Sample Foo\"}") .contentType("application/hal+json;charset=UTF-8")) .andDo(print()) .andExpect(status().isOk()); }
### Question: FooController { @GetMapping("/{id}") public HttpEntity<FooResource> get(@PathVariable UUID id) { log.info("Get {}", id); Foo foo = new Foo(id, "Foo"); FooResource fooResource = assembler.toModel(foo); return ResponseEntity.ok(fooResource); } FooController(FooResourceAssembler assembler); @GetMapping("/{id}") HttpEntity<FooResource> get(@PathVariable UUID id); @PutMapping("/{id}") HttpEntity<FooResource> update(@PathVariable UUID id, @RequestBody FooResource fooResource); @PostMapping HttpEntity<FooResource> create(@RequestBody FooResource fooResource); }### Answer: @Test public void shouldGet() throws Exception { mockMvc.perform(get("/foos/{id}", "cafe")) .andDo(print()) .andExpect(status().isOk()) .andExpect(content().contentType("application/hal+json")) .andExpect(jsonPath("$.uuid", is("cafe"))) .andExpect(jsonPath("$._links.self.href", is("http: }
### Question: FooController { @PutMapping("/{id}") public HttpEntity<FooResource> update(@PathVariable UUID id, @RequestBody FooResource fooResource) { log.info("Update {} : {}", id, fooResource); Foo entity = new Foo(fooResource.getUuid(), fooResource.getName()); return ResponseEntity.ok(assembler.toModel(entity)); } FooController(FooResourceAssembler assembler); @GetMapping("/{id}") HttpEntity<FooResource> get(@PathVariable UUID id); @PutMapping("/{id}") HttpEntity<FooResource> update(@PathVariable UUID id, @RequestBody FooResource fooResource); @PostMapping HttpEntity<FooResource> create(@RequestBody FooResource fooResource); }### Answer: @Test public void update() throws Exception { mockMvc.perform(put("/foos/{id}", "foo") .content("{\"uuid\":\"foo\",\"name\":\"Sample Foo\"}") .contentType("application/hal+json")) .andDo(print()) .andExpect(status().isOk()); }
### Question: Url62 { static UUID decode(String id) { BigInteger decoded = Base62.decode(id); return UuidConverter.toUuid(decoded); } }### Answer: @Test public void shouldExplodeWhenContainsIllegalCharacters() { assertThatThrownBy(() -> Url62.decode("Foo Bar")) .isInstanceOf(IllegalArgumentException.class) .hasMessageContaining("contains illegal characters"); } @Test public void shouldFaildOnEmptyString() { assertThatThrownBy(() -> Url62.decode("")) .isInstanceOf(IllegalArgumentException.class) .hasMessageContaining("must not be empty"); } @Test public void shouldFailsOnNullString() { assertThatThrownBy(() -> Url62.decode(null)) .isInstanceOf(NullPointerException.class) .hasMessageContaining("must not be null"); } @Test public void shouldFailsWhenStringContainsMoreThan128bitInformation() { assertThatThrownBy(() -> Url62.decode("7NLCAyd6sKR7kDHxgAWFPas")) .isInstanceOf(IllegalArgumentException.class) .hasMessageContaining("contains more than 128bit information"); }
### Question: Base62 { static BigInteger decode(final String string) { return decode(string, 128); } }### Answer: @Test public void shouldCheck128BitLimits() { assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> Base62.decode("1Vkp6axDWu5pI3q1xQO3oO0")); }
### Question: BigIntegerPairing { static BigInteger[] unpair(BigInteger value) { BigInteger[] parts = value.divideAndRemainder(HALF); BigInteger signedHi = toSigned.apply(parts[0]); BigInteger signedLo = toSigned.apply(parts[1]); return new BigInteger[]{signedHi, signedLo}; } }### Answer: @Test public void pairingLongsShouldBeReversible() { def("Arrays.equals(unpair(pair(longs)), asArray(longs))") .forAll(DataProvider.LONG_PAIRS) .suchThat(longs -> Arrays.equals(unpair(makePair(longs)), asArray(longs))) .check(-1, 100_000) .assertIsSatisfied(); }
### Question: ServerMessageFactory { public Message generateLogoutResponse(boolean success) { Message logoutResponse = MessageRegistry.getInstance().createMessage("LogoutResponse"); logoutResponse.setArgument("success", success); return logoutResponse; } Message generateLogoutResponse(boolean success); Message generateLoginResponse(boolean success, long loggedInTime); }### Answer: @Test public void testGenerateLogoutResponse() { ServerMessageFactory serverMessageFactory = new ServerMessageFactory(); Message message = serverMessageFactory.generateLogoutResponse(true); assertEquals(message.name, "LogoutResponse"); assertEquals(message.getArgument("success"), true); }
### Question: ClientHandler extends Connection { public void sendLogoutStatus(boolean success) { Message logoutResponse = getMessageFactory().generateLogoutResponse(success); getMessageIO().queueOutgoingMessage(logoutResponse); } ClientHandler(AuthServer s, MessageIO messageIO); void setHandlerId(int id); void update(); @Override void shutdown(); ServerMessageFactory getMessageFactory(); AuthServer getServer(); void sendLogoutStatus(boolean success); long getLoggedInTime(); void setLoggedInTime(long loggedInTime); int getHandlerId(); User getUser(); void setUser(User user); }### Answer: @Test public void testSendLogoutStatus() throws Exception { AuthServer server = mock(AuthServer.class); MessageInputStream mis = mock(MessageInputStream.class); MessageOutputStream mos = mock(MessageOutputStream.class); MessageIO messageIO = new MessageIO(mis, mos); ClientHandler clientHandler = new ClientHandler(server, messageIO); clientHandler.sendLogoutStatus(true); try { clientHandler.getMessageIO().writeAllMessages(); } catch (IOException e) { clientHandler.shutdown(); } verify(mos, times(1)).writeMessage(any()); }
### Question: ClientHandler extends Connection { @Override public void shutdown() { if (getUser() != null) { try { server.getAuthenticator().logOutUser(user.getUsername()); } catch (LoginException e) { LOGGER.log(Level.WARNING, "Unable to perform emergency logout.", e); } } getServer().removeClient(this); } ClientHandler(AuthServer s, MessageIO messageIO); void setHandlerId(int id); void update(); @Override void shutdown(); ServerMessageFactory getMessageFactory(); AuthServer getServer(); void sendLogoutStatus(boolean success); long getLoggedInTime(); void setLoggedInTime(long loggedInTime); int getHandlerId(); User getUser(); void setUser(User user); }### Answer: @Test public void testShutDown() throws Exception { Authenticator authenticator = mock(Authenticator.class); User user = mock(User.class); AuthServer server = mock(AuthServer.class); MessageInputStream mis = mock(MessageInputStream.class); MessageOutputStream mos = mock(MessageOutputStream.class); MessageIO messageIO = new MessageIO(mis, mos); when(server.getAuthenticator()).thenReturn(authenticator); ClientHandler clientHandler = new ClientHandler(server, messageIO); clientHandler.setUser(user); clientHandler.shutdown(); verify(authenticator).logOutUser(anyString()); verify(server).removeClient(clientHandler); }
### Question: ServerWorldFileTracker { public void requestServerWorldFile() { if (needsWorldFile()) { this.worldClient.getMessageIO().queueOutgoingMessage(this.worldClient.getMessageFactory() .generateWorldFileRequest()); } else { setWaitingForFile(false); } } ServerWorldFileTracker(WorldClient worldClient, File worldFile); void requestServerWorldFileChecksum(); void requestServerWorldFile(); void writeReceivedWorldToFile(); byte[] getChecksum(); void setChecksum(byte[] checksum); byte[] getBytes(); void setBytes(byte[] bytes); boolean isWaitingForChecksum(); void setWaitingForChecksum(boolean bool); boolean isWaitingForFile(); void setWaitingForFile(boolean waiting); void waitForWorldFile(); void waitForWorldFileChecksum(); }### Answer: @Test(timeOut = 5000) public void testRequestServerWorldFile() throws Exception { WorldClient worldClient = Mockito.mock(WorldClient.class); WorldClientMessageFactory messageFactory = Mockito.mock(WorldClientMessageFactory.class); File worldFile = Mockito.mock(File.class); Message message = Mockito.mock(Message.class); MessageIO messageIO = Mockito.mock(MessageIO.class); Mockito.when(worldClient.getMessageFactory()).thenReturn(messageFactory); Mockito.when(message.getArgument("fileBytes")).thenReturn("abc123".getBytes()); Mockito.when(messageFactory.generateWorldChecksumRequest()).thenReturn(message); Mockito.when(worldClient.getMessageIO()).thenReturn(messageIO); ServerWorldFileTracker serverWorldFileTracker = new ServerWorldFileTracker(worldClient, worldFile); Mockito.when(worldClient.getServerWorldFileTracker()).thenReturn(serverWorldFileTracker); serverWorldFileTracker.setWaitingForFile(true); serverWorldFileTracker.requestServerWorldFile(); Assert.assertTrue(serverWorldFileTracker.isWaitingForFile()); ExecutableWorldFileResponse exec = new ExecutableWorldFileResponse(worldClient, message); exec.runImmediate(); Assert.assertFalse(serverWorldFileTracker.isWaitingForFile()); Assert.assertEquals(serverWorldFileTracker.getBytes(), "abc123".getBytes()); }
### Question: WorldClientUpdater implements Runnable { @Override public void run() { worldClient.getWorld().update(); if (player != null) { EventStack eventStack = player.getEventStack(StateChangeStack.STACK_NAME); if (eventStack != null && eventStack instanceof StateChangeStack) { StateChangeStack stateChangeStack = (StateChangeStack) eventStack; List<MoveState> newStates = stateChangeStack.getStateChanges(); while (!newStates.isEmpty()) { MoveState moveState = newStates.remove(0); WorldClientMessageFactory messageFactory = worldClient.getMessageFactory(); Message stateChangeRequest = messageFactory.generateStateChangeRequest(moveState); worldClient.getMessageIO().queueOutgoingMessage(stateChangeRequest); } } } } WorldClientUpdater(WorldClient wc); @Override void run(); }### Answer: @Test public void testRun() { WorldClient worldClient = mock(WorldClient.class); Actor clientPlayer = mock(Actor.class); World world = mock(World.class); WorldObjectList worldObjectMap = new WorldObjectList(world); when(world.getWorldObjects()).thenReturn(worldObjectMap); when(worldClient.getWorld()).thenReturn(world); when(worldClient.getPlayer()).thenReturn(clientPlayer); WorldClientUpdater worldClientUpdater = new WorldClientUpdater(worldClient); int rand = (int) (Math.random() * 100); for (int i = 0; i < rand; i++) { worldClientUpdater.run(); } verify(world, times(rand)).update(); }
### Question: World { public WorldObjectList getWorldObjects() { return worldObjects; } World(); World(Zone... zones); WorldObjectList getWorldObjects(); void update(); Map<Integer, Zone> getZones(); long getLastUpdateCompleted(); long getLastUpdateStarted(); }### Answer: @Test(expectedExceptions = NullPointerException.class) public void testAddNullObject() { World world = WorldUtils.createDefaultWorld(); world.getWorldObjects().add(null); }
### Question: World { public void update() { lastUpdateStarted = System.currentTimeMillis(); synchronized (worldObjects) { worldObjects.refresh(); worldObjects.forEach(WorldObject::preUpdate); worldObjects.forEach(WorldObject::update); worldObjects.forEach(WorldObject::postUpdate); } lastUpdateCompleted = System.currentTimeMillis(); } World(); World(Zone... zones); WorldObjectList getWorldObjects(); void update(); Map<Integer, Zone> getZones(); long getLastUpdateCompleted(); long getLastUpdateStarted(); }### Answer: @Test public void testUpdate() { WorldObject worldObject = mock(WorldObject.class); when(worldObject.getVector2D()).thenReturn(Vector2D.ORIGIN); World world = WorldUtils.createDefaultWorld(); world.getWorldObjects().add(worldObject); world.update(); verify(worldObject, times(1)).preUpdate(); verify(worldObject, times(1)).update(); verify(worldObject, times(1)).postUpdate(); }
### Question: MathUtil { public static double round(double value, int decimalPlaces) { BigDecimal bd = new BigDecimal(value); BigDecimal rounded = bd.setScale(decimalPlaces, BigDecimal.ROUND_HALF_UP); return rounded.doubleValue(); } private MathUtil(); static double round(double value, int decimalPlaces); }### Answer: @Test public void testRound() { double exact = 123.45678; double round = MathUtil.round(exact, 2); Assert.assertEquals(round, 123.46, "Rounding " + exact + " to 2 decimals."); }
### Question: Vector2D { public Vector2D(Vector2D vector2D) { this(vector2D.getXCoordinate(), vector2D.getYCoordinate()); } Vector2D(Vector2D vector2D); Vector2D(double x, double y); @Override boolean equals(Object o); @Override int hashCode(); double getYCoordinate(); double getXCoordinate(); @Override String toString(); Vector2D getVectorInDirection(double distance, double angle); double getAngleToVector(Vector2D vector2D); double getDistanceToVector(Vector2D vector2D); double getSquaredDistanceToVector(Vector2D vector2D); static final Vector2D ORIGIN; }### Answer: @Test public void testVector2D() { Vector2D vector2D01 = new Vector2D(5, 7); Assert.assertEquals(7, vector2D01.getYCoordinate(), 0); Assert.assertEquals(5, vector2D01.getXCoordinate(), 0); Vector2D vector2D02 = new Vector2D(vector2D01); Assert.assertEquals(7, vector2D02.getYCoordinate(), 0); Assert.assertEquals(5, vector2D02.getXCoordinate(), 0); Assert.assertEquals(5, vector2D02.getXCoordinate(), 0); Assert.assertEquals(7, vector2D02.getYCoordinate(), 0); }
### Question: Vector2D { @Override public boolean equals(Object o) { if (this == o) return true; if (!(o instanceof Vector2D)) return false; Vector2D vector2D = (Vector2D) o; return Double.compare(vector2D.xCoordinate, xCoordinate) == 0 && Double.compare(vector2D.yCoordinate, yCoordinate) == 0; } Vector2D(Vector2D vector2D); Vector2D(double x, double y); @Override boolean equals(Object o); @Override int hashCode(); double getYCoordinate(); double getXCoordinate(); @Override String toString(); Vector2D getVectorInDirection(double distance, double angle); double getAngleToVector(Vector2D vector2D); double getDistanceToVector(Vector2D vector2D); double getSquaredDistanceToVector(Vector2D vector2D); static final Vector2D ORIGIN; }### Answer: @Test public void testEquals() { Vector2D vector1 = new Vector2D(10, 10); Vector2D vector2 = new Vector2D(10, 10); Assert.assertTrue(vector1.equals(vector2)); } @Test public void testEqualsNonVector() { Vector2D vector1 = new Vector2D(10, 10); String foo = "bar"; Assert.assertFalse(vector1.equals(foo)); }
### Question: Authenticator { public User lookUpUser(String username) throws LoginException { try (ResultSet results = makeUserQuery(username)) { if (!results.next()) { throw new LoginException("User " + username + " does not exist."); } boolean loggedIn = results.getBoolean(LOGGED_IN); String salt = results.getString(SALT); String dbPass = results.getString(PASSWORD); User user = new User(); user.setUsername(username); user.setPassword(dbPass); user.setSalt(salt); user.setLoggedIn(loggedIn); return user; } catch (SQLException e) { throw new LoginException("Unable to retrieve user " + username + " because of SQL Exception.", e); } } Authenticator(Connection dbConnection); static String getSaltedSHA256String(String input, String salt); User logInUser(String username, String password); User lookUpUser(String username); Map<String, Object> lookUpUserProperties(String username); User logOutUser(String username); Object lookUpUserProperty(String username, String propertyName); static boolean isWrapperType(Class<?> clazz); static final int HEX_CONVERSION_CONSTANT; }### Answer: @Test public void testLookUpUser() throws Exception { Authenticator connector = new Authenticator(connection); User testAccount1 = connector.lookUpUser("TestAccount1"); Assert.assertEquals(testAccount1.getUsername(), "TestAccount1"); } @Test(expectedExceptions = LoginException.class) public void testLookUpFakeUser() throws Exception { Authenticator connector = new Authenticator(connection); connector.lookUpUser("This User Doesn't Exist."); }
### Question: Vector2D { public double getAngleToVector(Vector2D vector2D) { Double angle = Double.NEGATIVE_INFINITY; if (!vector2D.equals(this)) { double xDist = vector2D.getXCoordinate() - xCoordinate; double yDist = vector2D.getYCoordinate() - yCoordinate; angle = java.lang.Math.atan2(yDist, xDist); } return angle; } Vector2D(Vector2D vector2D); Vector2D(double x, double y); @Override boolean equals(Object o); @Override int hashCode(); double getYCoordinate(); double getXCoordinate(); @Override String toString(); Vector2D getVectorInDirection(double distance, double angle); double getAngleToVector(Vector2D vector2D); double getDistanceToVector(Vector2D vector2D); double getSquaredDistanceToVector(Vector2D vector2D); static final Vector2D ORIGIN; }### Answer: @Test public void testGetAngleToVector() { Vector2D vector1 = new Vector2D(0, 0); Vector2D vector2 = new Vector2D(5, 5); double angle = vector1.getAngleToVector(vector2); double expectedAngle = Math.PI * .25; Assert.assertEquals(angle, expectedAngle); } @Test public void testGetAngleToEqualVector() { Vector2D vector1 = new Vector2D(10, 10); Vector2D vector2 = new Vector2D(10, 10); double angle = vector1.getAngleToVector(vector2); double expectedAngle = Double.NEGATIVE_INFINITY; Assert.assertEquals(angle, expectedAngle); }
### Question: Vector2D { public double getDistanceToVector(Vector2D vector2D) { double squaredDistance = getSquaredDistanceToVector(vector2D); return MathUtil.round(java.lang.Math.sqrt(squaredDistance), 4); } Vector2D(Vector2D vector2D); Vector2D(double x, double y); @Override boolean equals(Object o); @Override int hashCode(); double getYCoordinate(); double getXCoordinate(); @Override String toString(); Vector2D getVectorInDirection(double distance, double angle); double getAngleToVector(Vector2D vector2D); double getDistanceToVector(Vector2D vector2D); double getSquaredDistanceToVector(Vector2D vector2D); static final Vector2D ORIGIN; }### Answer: @Test public void testGetDistanceToVector() { Vector2D vector1 = new Vector2D(0, 0); Vector2D vector2 = new Vector2D(0, 5); double distance = vector1.getDistanceToVector(vector2); double expectedDistance = 5; Assert.assertEquals(distance, expectedDistance); }
### Question: Vector2D { @Override public int hashCode() { int result; long temp; temp = Double.doubleToLongBits(xCoordinate); result = (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(yCoordinate); result = 31 * result + (int) (temp ^ (temp >>> 32)); return result; } Vector2D(Vector2D vector2D); Vector2D(double x, double y); @Override boolean equals(Object o); @Override int hashCode(); double getYCoordinate(); double getXCoordinate(); @Override String toString(); Vector2D getVectorInDirection(double distance, double angle); double getAngleToVector(Vector2D vector2D); double getDistanceToVector(Vector2D vector2D); double getSquaredDistanceToVector(Vector2D vector2D); static final Vector2D ORIGIN; }### Answer: @Test public void testHashCode() { Vector2D vector1 = new Vector2D(10, 10); Vector2D vector2 = new Vector2D(vector1); int hash1 = vector1.hashCode(); int hash2 = vector2.hashCode(); Assert.assertEquals(hash2, hash1); }
### Question: WorldObject extends EventExecutor { public void setVector2D(Vector2D vector2D) { this.vector2D = vector2D; } WorldObject(); WorldObject(String name); Angle getAngle(); void setAngle(Angle angle); Vector2D getVector2D(); void setVector2D(Vector2D vector2D); int getResourceID(); void setResourceID(int resourceID); int getId(); void setId(int id); HashMap<String, Object> getProperties(); World getWorld(); void setWorld(World world); int getZoneID(); void setZoneID(int zoneID); String getName(); void setName(String name); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer: @Test public void testGetLocation() throws Exception { worldObject.setVector2D(vector2D); Location loc = LocationUtils.getObjectLocation(worldObject); Assert.assertTrue(loc == ZoneUtils.getLocationForCoordinates(world, 0, vector2D)); }
### Question: WorldObject extends EventExecutor { public void setId(int id) { this.id = id; } WorldObject(); WorldObject(String name); Angle getAngle(); void setAngle(Angle angle); Vector2D getVector2D(); void setVector2D(Vector2D vector2D); int getResourceID(); void setResourceID(int resourceID); int getId(); void setId(int id); HashMap<String, Object> getProperties(); World getWorld(); void setWorld(World world); int getZoneID(); void setZoneID(int zoneID); String getName(); void setName(String name); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer: @Test public void testSetId() throws Exception { WorldObject worldObject1 = new WorldObject("Test Object"); worldObject1.setId(id); Assert.assertEquals(id, worldObject1.getId()); }
### Question: WorldObject extends EventExecutor { public void setWorld(World world) { if (this.world != null) throw new IllegalArgumentException("The world has already been set for this object."); this.world = world; } WorldObject(); WorldObject(String name); Angle getAngle(); void setAngle(Angle angle); Vector2D getVector2D(); void setVector2D(Vector2D vector2D); int getResourceID(); void setResourceID(int resourceID); int getId(); void setId(int id); HashMap<String, Object> getProperties(); World getWorld(); void setWorld(World world); int getZoneID(); void setZoneID(int zoneID); String getName(); void setName(String name); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer: @Test public void testSetWorld() throws Exception { Assert.assertTrue(world == worldObject.getWorld()); }
### Question: Actor extends WorldObject { @Override public void update() { super.update(); ActorUtils.stepForward(this); } Actor(String name); @Override void preUpdate(); @Override void update(); MoveState getForcedState(); void setForcedState(MoveState forcedState); double getMoveSpeed(); void setMoveSpeed(double moveSpeed); static double DEFAULT_MOVE_SPEED; }### Answer: @Test public void testReset() { Actor actor = new Actor("Actor"); world.getWorldObjects().add(actor); world.update(); Angle angle = new Angle(0.0, Angle.FRONT); actor.setAngle(angle); actor.postUpdate(); EventStack stack = actor.getEventStack(StateChangeStack.STACK_NAME); Assert.assertNotNull(stack); Assert.assertTrue(stack instanceof StateChangeStack); Assert.assertEquals(((StateChangeStack) stack).getStateChanges().get(1).angle, angle); } @Test public void testStepToNullLocation() throws InterruptedException { Actor actor = new Actor("Actor"); world.getWorldObjects().add(actor); world.update(); Angle angle = new Angle(0.0, Angle.BACK); actor.setAngle(angle); world.update(); Thread.sleep(1000); world.update(); double distance = Vector2D.ORIGIN.getDistanceToVector(actor.getVector2D()); Assert.assertEquals(distance, 0, 0.1); }
### Question: Actor extends WorldObject { public MoveState getForcedState() { return forcedState; } Actor(String name); @Override void preUpdate(); @Override void update(); MoveState getForcedState(); void setForcedState(MoveState forcedState); double getMoveSpeed(); void setMoveSpeed(double moveSpeed); static double DEFAULT_MOVE_SPEED; }### Answer: @Test public void testGetForcedState() throws InterruptedException { Actor actor = new Actor("Actor"); world.getWorldObjects().add(actor); Angle angle = new Angle(0.0, Angle.BACK); actor.setAngle(angle); Thread.sleep(1000); world.update(); Assert.assertNotNull(actor.getForcedState()); }
### Question: Client extends Connection { public void addRepeatedTask(Runnable r) { synchronized (repeatedTasks) { repeatedTasks.add(r); } } protected Client(MessageIO messageIO); void addRepeatedTask(Runnable r); @Override void shutdown(); @Override void start(); double getAverageUPS(); }### Answer: @Test public void testAddRepeatedTask() { MessageInputStream mis = mock(MessageInputStream.class); MessageOutputStream mos = mock(MessageOutputStream.class); MessageIO messageIO = new MessageIO(mis, mos); Runnable r = mock(Runnable.class); Client client = new Client(messageIO); client.addRepeatedTask(r); client.runRepeatedTasks(); verify(r).run(); }
### Question: AuthClient extends Client { public LoginTracker getLoginTracker() { return loginTracker; } AuthClient(MessageIO messageIO, ClientUser user); static Message generateLogoutRequest(); static Message generateLoginRequest(ClientUser user); LoginTracker getLoginTracker(); ClientUser getUser(); }### Answer: @Test public void testIsLoggedIn() { MessageInputStream mis = mock(MessageInputStream.class); MessageOutputStream mos = mock(MessageOutputStream.class); MessageIO messageIO = new MessageIO(mis, mos); ClientUser clientUser = mock(ClientUser.class); boolean random = ((Math.random() * 10) % 2) == 0; AuthClient authClient = new AuthClient(messageIO, clientUser); authClient.getLoginTracker().setLoggedIn(random); Assert.assertEquals(authClient.getLoginTracker().isLoggedIn(), random, "Login status was not expected."); } @Test public void testLoggedInTime() { MessageInputStream mis = mock(MessageInputStream.class); MessageOutputStream mos = mock(MessageOutputStream.class); MessageIO messageIO = new MessageIO(mis, mos); ClientUser clientUser = mock(ClientUser.class); long random = (long) (Math.random() * 1000); AuthClient authClient = new AuthClient(messageIO, clientUser); authClient.getLoginTracker().setLoggedInTime(random); Assert.assertEquals(authClient.getLoginTracker().getLoggedInTime(), random, "Login time was incorrect."); }
### Question: AuthClient extends Client { public ClientUser getUser() { return user; } AuthClient(MessageIO messageIO, ClientUser user); static Message generateLogoutRequest(); static Message generateLoginRequest(ClientUser user); LoginTracker getLoginTracker(); ClientUser getUser(); }### Answer: @Test public void testGetUser() { MessageInputStream mis = mock(MessageInputStream.class); MessageOutputStream mos = mock(MessageOutputStream.class); MessageIO messageIO = new MessageIO(mis, mos); ClientUser clientUser = mock(ClientUser.class); AuthClient authClient = new AuthClient(messageIO, clientUser); Assert.assertEquals(authClient.getUser(), clientUser, "User was incorrect."); }
### Question: MessageOutputStream extends DataOutputStream { public void writeMessage(Message message) throws IOException { if (closed) { throw new IOException("Cannot write message: stream closed"); } Object[] args = message.getArgs(); MessageType messageType = messageRegistry.getMessageType(message.getID()); List<ArgumentType> argumentTypes = messageType.getArguments(); int id = message.getID(); writeShort(id); for (int i = 0; i < args.length; i++) writeArgument(args[i], argumentTypes.get(i).isEncrypt()); } MessageOutputStream(OutputStream out); void writeMessage(Message message); boolean isClosed(); void setPublicKey(Key publicKey); @Override void close(); }### Answer: @Test public void testWriteMessage() throws Exception { ByteArrayOutputStream bos = new ByteArrayOutputStream(); MessageOutputStream mos = new MessageOutputStream(bos); Message msg = MESSAGE_REGISTRY.createMessage("InvalidMessage"); msg.setArgument("messageID", (short) -255); msg.setArgument("messageName", "FooBar"); mos.writeMessage(msg); byte[] bytes = bos.toByteArray(); mos.close(); ByteArrayInputStream bis = new ByteArrayInputStream(bytes); MessageInputStream mis = new MessageInputStream(bis); Message readMsg = mis.readMessage(); Assert.assertEquals(readMsg.getArgs(), msg.getArgs(), "Message arguments not equal."); } @Test(expectedExceptions = IOException.class) public void testEncryptedMessageNoPublicKey() throws Exception { ByteArrayOutputStream bos = new ByteArrayOutputStream(); MessageOutputStream mos = new MessageOutputStream(bos); Message msg = MESSAGE_REGISTRY.createMessage("TestEncryptedMessage"); msg.setArgument("encryptedString", "FooBar"); mos.writeMessage(msg); }
### Question: Authenticator { public User logInUser(String username, String password) throws LoginException { User user = getUserWithValidPassword(username, password); updateLoggedinColumn(username, true); user.setLoggedIn(true); return user; } Authenticator(Connection dbConnection); static String getSaltedSHA256String(String input, String salt); User logInUser(String username, String password); User lookUpUser(String username); Map<String, Object> lookUpUserProperties(String username); User logOutUser(String username); Object lookUpUserProperty(String username, String propertyName); static boolean isWrapperType(Class<?> clazz); static final int HEX_CONVERSION_CONSTANT; }### Answer: @Test public void testLogInUser() throws Exception { Authenticator connector = new Authenticator(connection); String username = "TestAccount2"; String password = "testPassword"; connector.logInUser(username, password); User user = connector.lookUpUser(username); Assert.assertTrue(user.isLoggedIn()); } @Test(expectedExceptions = LoginException.class) public void testConcurrentLogins() throws Exception { Authenticator connector = new Authenticator(connection); String username = "TestAccount3"; String password = "testPassword"; connector.logInUser(username, password); connector.logInUser(username, password); } @Test(expectedExceptions = LoginException.class) public void testInvalidPassword() throws Exception { Authenticator connector = new Authenticator(connection); String username = "TestAccount5"; String password = "incorrectPassword"; connector.logInUser(username, password); }
### Question: Message { public void setArgument(String argumentName, Object argument) { ArgumentType argType = null; for (ArgumentType a : messageType.getArguments()) { if (argumentName.equals(a.getName())) { argType = a; } } if (argType == null) { throw new IllegalArgumentException("Invalid argument name for Message: " + argumentName + " (Message type: " + messageType.getName() + ')'); } @SuppressWarnings("rawtypes") Class argumentClass = getTypeForName(argType.getType()); if (!argumentClass.isInstance(argument)) { throw new IllegalArgumentException("Invalid argument type for Message: " + argument + " (Expected " + argType.getType() + ", got " + argument.getClass() + ')'); } argumentsByName.put(argumentName, argument); } Message(MessageType type, Object... args); Message(MessageType messageType); static Class getTypeForName(String name); void setArgument(String argumentName, Object argument); Object getArgument(String argumentName); short getID(); final Object[] getArgs(); @Override String toString(); final String name; }### Answer: @Test(expectedExceptions = IllegalArgumentException.class) public void testInvalidName() { Message msg = MESSAGE_REGISTRY.createMessage("InvalidMessage"); msg.setArgument("FooBar", 1337); } @Test(expectedExceptions = IllegalArgumentException.class) public void testInvalidArgumentType() { Message msg = MESSAGE_REGISTRY.createMessage("InvalidMessage"); msg.setArgument("messageName", "FooBar"); msg.setArgument("messageID", "I'm totally a short, you guys."); }
### Question: Message { @Override public String toString() { return "Message " + id + ' ' + name; } Message(MessageType type, Object... args); Message(MessageType messageType); static Class getTypeForName(String name); void setArgument(String argumentName, Object argument); Object getArgument(String argumentName); short getID(); final Object[] getArgs(); @Override String toString(); final String name; }### Answer: @Test public void testToString() { Message msg = MESSAGE_REGISTRY.createMessage("InvalidMessage"); msg.setArgument("messageName", "FooBar"); msg.setArgument("messageID", (short) -255); String expected = "Message 0 InvalidMessage"; String actual = msg.toString(); Assert.assertEquals(actual, expected, "Invalid message expected, not received."); }
### Question: Connection { public void shutdown() { messageIO.closeInputStream(); messageIO.closeOutputStream(); } protected Connection(MessageIO streams); static Message generatePublicKeyMessage(Key publicKey); static KeyPair generateRSAKeyPair(); void start(); void setRSAKeyPair(KeyPair rsaKeyPair); MessageIO getMessageIO(); PingTracker getPingTracker(); ExecutableMessageQueue getExecutableMessageQueue(); void shutdown(); String getName(); void setName(String name); @SuppressWarnings("ReturnOfCollectionOrArrayField") Map<InetAddress, Key> getVerifiedKeys(); }### Answer: @Test(expectedExceptions = MessageQueueException.class) public void testShutDown() throws Exception { DataInputStreamMock dataInputStreamMock = new DataInputStreamMock(); InputStream in = dataInputStreamMock.getIn(); dataInputStreamMock.mockReadShort((short) INVALID_MESSAGE_ID); ByteArrayOutputStream bos = new ByteArrayOutputStream(); MessageInputStream messageInputStream = new MessageInputStream(in); MessageOutputStream messageOutputStream = new MessageOutputStream(bos); MessageIO messageIO = new MessageIO(messageInputStream, messageOutputStream); Connection connection = new Connection(messageIO); connection.shutdown(); Message msg = MESSAGE_REGISTRY.createMessage("InvalidMessage"); msg.setArgument("messageName", "FooBar"); msg.setArgument("messageID", (short) INVALID_MESSAGE_ID); connection.getMessageIO().queueOutgoingMessage(msg); try { connection.getMessageIO().writeAllMessages(); } catch (IOException e) { connection.shutdown(); } }
### Question: WorldServerMessageFactory extends ServerMessageFactory { public Message generateNewlyVisibleMessage(WorldObject object) { Message newlyVisibleMessage; if (object instanceof Actor) { newlyVisibleMessage = generateActorVisibleMessage((Actor) object); } else { newlyVisibleMessage = generateObjectVisibleMessage(object); } return newlyVisibleMessage; } Message generateNewlyVisibleMessage(WorldObject object); List<Message> generateChangeStateMessages(Actor changedActor); Message generateForcedStateMessage(MoveState forcedState); Message generateActorMoveSpeedMessage(double moveSpeed); Message generateNewlyInvisibleMessage(WorldObject object); Message generateWorldLoginResponse(); Message generateWorldFileResponse(byte[] worldFileBytes); Message generateWorldChecksumResponse(byte[] checkSum); }### Answer: @Test public void testGenerateNewlyVisibleObjectMessage() { WorldObject object = mock(WorldObject.class); when(object.getName()).thenReturn("Foo"); when(object.getVector2D()).thenReturn(Vector2D.ORIGIN); Message message = worldServerMessageFactory.generateNewlyVisibleMessage(object); assertEquals(message.name, "ObjectVisibleMessage"); assertEquals(message.getArgument("name"), "Foo"); } @Test public void testGenerateNewlyVisibleActorMessage() { Actor actor = mock(Actor.class); when(actor.getName()).thenReturn("Foo"); when(actor.getVector2D()).thenReturn(Vector2D.ORIGIN); when(actor.getAngle()).thenReturn(new Angle()); when(actor.getWorld()).thenReturn(WorldUtils.createDefaultWorld()); Message message = worldServerMessageFactory.generateNewlyVisibleMessage(actor); assertEquals(message.name, "ActorVisibleMessage"); assertEquals(message.getArgument("name"), "Foo"); assertEquals(message.getArgument("relativeAngle"), Angle.IDLE); }
### Question: WorldServerMessageFactory extends ServerMessageFactory { public Message generateForcedStateMessage(MoveState forcedState) { Message forcedStateMessage = MessageRegistry.getInstance().createMessage("ForceStateMessage"); forcedStateMessage.setArgument("relativeAngle", forcedState.angle.getRelativeAngle()); forcedStateMessage.setArgument("absoluteAngle", forcedState.angle.getAbsoluteAngle()); forcedStateMessage.setArgument("xCoordinate", forcedState.position.getXCoordinate()); forcedStateMessage.setArgument("yCoordinate", forcedState.position.getYCoordinate()); forcedStateMessage.setArgument("timeOfForce", forcedState.timeOfChange); return forcedStateMessage; } Message generateNewlyVisibleMessage(WorldObject object); List<Message> generateChangeStateMessages(Actor changedActor); Message generateForcedStateMessage(MoveState forcedState); Message generateActorMoveSpeedMessage(double moveSpeed); Message generateNewlyInvisibleMessage(WorldObject object); Message generateWorldLoginResponse(); Message generateWorldFileResponse(byte[] worldFileBytes); Message generateWorldChecksumResponse(byte[] checkSum); }### Answer: @Test public void testGenerateForcedStateMessage() { MoveState forcedState = new MoveState(new Angle(), Vector2D.ORIGIN, 0); Message message = worldServerMessageFactory.generateForcedStateMessage(forcedState); assertEquals(message.name, "ForceStateMessage"); assertEquals(message.getArgument("relativeAngle"), forcedState.angle.getRelativeAngle()); assertEquals(message.getArgument("absoluteAngle"), forcedState.angle.getAbsoluteAngle()); assertEquals(message.getArgument("xCoordinate"), forcedState.position.getXCoordinate()); assertEquals(message.getArgument("yCoordinate"), forcedState.position.getYCoordinate()); assertEquals(message.getArgument("timeOfForce"), clientHandler.getServer().getCycleStartTime()); }
### Question: WorldServerMessageFactory extends ServerMessageFactory { public Message generateActorMoveSpeedMessage(double moveSpeed) { Message stepLengthMessage = MessageRegistry.getInstance().createMessage("ActorMoveSpeed"); stepLengthMessage.setArgument("moveSpeed", moveSpeed); return stepLengthMessage; } Message generateNewlyVisibleMessage(WorldObject object); List<Message> generateChangeStateMessages(Actor changedActor); Message generateForcedStateMessage(MoveState forcedState); Message generateActorMoveSpeedMessage(double moveSpeed); Message generateNewlyInvisibleMessage(WorldObject object); Message generateWorldLoginResponse(); Message generateWorldFileResponse(byte[] worldFileBytes); Message generateWorldChecksumResponse(byte[] checkSum); }### Answer: @Test public void testGenerateActorMoveSpeedMessage() { Message message = worldServerMessageFactory.generateActorMoveSpeedMessage(Actor.DEFAULT_MOVE_SPEED); assertEquals(message.name, "ActorMoveSpeed"); assertEquals(message.getArgument("moveSpeed"), Actor.DEFAULT_MOVE_SPEED); }
### Question: WorldServerMessageFactory extends ServerMessageFactory { public Message generateNewlyInvisibleMessage(WorldObject object) { Message newlyInvisibleMessage = MessageRegistry.getInstance().createMessage("ObjectInvisibleMessage"); newlyInvisibleMessage.setArgument("id", object.getId()); return newlyInvisibleMessage; } Message generateNewlyVisibleMessage(WorldObject object); List<Message> generateChangeStateMessages(Actor changedActor); Message generateForcedStateMessage(MoveState forcedState); Message generateActorMoveSpeedMessage(double moveSpeed); Message generateNewlyInvisibleMessage(WorldObject object); Message generateWorldLoginResponse(); Message generateWorldFileResponse(byte[] worldFileBytes); Message generateWorldChecksumResponse(byte[] checkSum); }### Answer: @Test public void testGenerateNewlyInvisibleMessage() { WorldObject o = mock(WorldObject.class); when(o.getId()).thenReturn(2468); Message message = worldServerMessageFactory.generateNewlyInvisibleMessage(o); assertEquals(message.name, "ObjectInvisibleMessage"); assertEquals(message.getArgument("id"), 2468); }
### Question: WorldServerMessageFactory extends ServerMessageFactory { public Message generateWorldFileResponse(byte[] worldFileBytes) { Message response = MessageRegistry.getInstance().createMessage("WorldFileResponse"); response.setArgument("fileBytes", worldFileBytes); return response; } Message generateNewlyVisibleMessage(WorldObject object); List<Message> generateChangeStateMessages(Actor changedActor); Message generateForcedStateMessage(MoveState forcedState); Message generateActorMoveSpeedMessage(double moveSpeed); Message generateNewlyInvisibleMessage(WorldObject object); Message generateWorldLoginResponse(); Message generateWorldFileResponse(byte[] worldFileBytes); Message generateWorldChecksumResponse(byte[] checkSum); }### Answer: @Test public void testGenerateWorldFileResponse() { byte[] fileBytes = {2, 4, 6, 8, 10}; Message message = worldServerMessageFactory.generateWorldFileResponse(fileBytes); assertEquals(message.name, "WorldFileResponse"); assertEquals(message.getArgument("fileBytes"), fileBytes); }
### Question: WorldServerMessageFactory extends ServerMessageFactory { public Message generateWorldChecksumResponse(byte[] checkSum) { Message response = MessageRegistry.getInstance().createMessage("WorldChecksumResponse"); response.setArgument("checksum", checkSum); return response; } Message generateNewlyVisibleMessage(WorldObject object); List<Message> generateChangeStateMessages(Actor changedActor); Message generateForcedStateMessage(MoveState forcedState); Message generateActorMoveSpeedMessage(double moveSpeed); Message generateNewlyInvisibleMessage(WorldObject object); Message generateWorldLoginResponse(); Message generateWorldFileResponse(byte[] worldFileBytes); Message generateWorldChecksumResponse(byte[] checkSum); }### Answer: @Test public void testGenerateWorldChecksumResponse() { byte[] checksum = {2, 4, 6, 8, 10}; Message message = worldServerMessageFactory.generateWorldChecksumResponse(checksum); assertEquals(message.name, "WorldChecksumResponse"); assertEquals(message.getArgument("checksum"), checksum); }
### Question: WorldServerMessageFactory extends ServerMessageFactory { public Message generateWorldLoginResponse() { return MessageRegistry.getInstance().createMessage("WorldLoginResponse"); } Message generateNewlyVisibleMessage(WorldObject object); List<Message> generateChangeStateMessages(Actor changedActor); Message generateForcedStateMessage(MoveState forcedState); Message generateActorMoveSpeedMessage(double moveSpeed); Message generateNewlyInvisibleMessage(WorldObject object); Message generateWorldLoginResponse(); Message generateWorldFileResponse(byte[] worldFileBytes); Message generateWorldChecksumResponse(byte[] checkSum); }### Answer: @Test public void testGenerateWorldLoginResponse() { Message message = worldServerMessageFactory.generateWorldLoginResponse(); Assert.assertEquals(message.name, "WorldLoginResponse"); }
### Question: WorldAuthenticator extends Authenticator { public void updatePlayer(WorldClientHandler worldClientHandler) { Actor player = worldClientHandler.getPlayer(); User user = worldClientHandler.getUser(); user.getProperties().put(X_COORD, player.getVector2D().getXCoordinate()); user.getProperties().put(Y_COORD, player.getVector2D().getYCoordinate()); user.getProperties().put(ZONE_ID, player.getZoneID()); try { super.updateUserProperties(user); } catch (SQLException e) { LOGGER.log(Level.SEVERE, "Unable to update player information in database!", e); } } WorldAuthenticator(Connection connection); void updatePlayer(WorldClientHandler worldClientHandler); }### Answer: @Test public void testUpdatePlayer() throws Exception { WorldClientHandler worldClientHandler = Mockito.mock(WorldClientHandler.class); WorldAuthenticator worldAuthenticator = new WorldAuthenticator(connection); Actor actor = mock(Actor.class); User user = new User(); user.setUsername("TestAccount1"); when(actor.getVector2D()).thenReturn(new Vector2D(10, 10)); when(worldClientHandler.getPlayer()).thenReturn(actor); when(worldClientHandler.getUser()).thenReturn(user); worldAuthenticator.updatePlayer(worldClientHandler); String query = "SELECT * FROM jenjin_user_properties WHERE username='TestAccount1' AND propertyName='xCoord'"; PreparedStatement statement = connection.prepareStatement(query, TYPE_SCROLL_SENSITIVE, CONCUR_UPDATABLE); ResultSet results = statement.executeQuery(); results.next(); assertEquals(results.getDouble("propertyValue"), 10d); }
### Question: Authenticator { public User logOutUser(String username) throws LoginException { User user = lookUpUser(username); if (user.isLoggedIn()) { user.setLoggedIn(false); updateLoggedinColumn(username, false); } return user; } Authenticator(Connection dbConnection); static String getSaltedSHA256String(String input, String salt); User logInUser(String username, String password); User lookUpUser(String username); Map<String, Object> lookUpUserProperties(String username); User logOutUser(String username); Object lookUpUserProperty(String username, String propertyName); static boolean isWrapperType(Class<?> clazz); static final int HEX_CONVERSION_CONSTANT; }### Answer: @Test public void testLogOutUser() throws Exception { Authenticator connector = new Authenticator(connection); String username = "TestAccount4"; String password = "testPassword"; connector.logInUser(username, password); connector.logOutUser(username); User user = connector.lookUpUser(username); Assert.assertFalse(user.isLoggedIn()); }
### Question: Authenticator { public Map<String, Object> lookUpUserProperties(String username) throws LoginException { Map<String, Object> properties = new HashMap<>(); try (ResultSet results = makePropertiesQuery(username)) { while (results.next()) { String propertyName = results.getString(PROPERTY_NAME); Object propertyValue = results.getObject(PROPERTY_VALUE); properties.put(propertyName, propertyValue); } } catch (SQLException e) { throw new LoginException("Unable to retrieve" + username + " properties because of SQL Exception.", e); } return properties; } Authenticator(Connection dbConnection); static String getSaltedSHA256String(String input, String salt); User logInUser(String username, String password); User lookUpUser(String username); Map<String, Object> lookUpUserProperties(String username); User logOutUser(String username); Object lookUpUserProperty(String username, String propertyName); static boolean isWrapperType(Class<?> clazz); static final int HEX_CONVERSION_CONSTANT; }### Answer: @Test public void testLookUpUserProperties() throws Exception { Authenticator authenticator = new Authenticator(connection); String username = "TestAccount1"; Map<String, Object> properties = authenticator.lookUpUserProperties(username); Assert.assertEquals(properties.get("Foo"), "Bar"); }
### Question: Authenticator { public Object lookUpUserProperty(String username, String propertyName) throws SQLException { String propertyQuery = "SELECT * FROM " + PROPERTIES_TABLE + " " + "WHERE " + USER + " = ? AND " + PROPERTY_NAME + " = ?"; Object r = null; synchronized (dbConnection) { PreparedStatement statement = dbConnection.prepareStatement(propertyQuery); statement.setString(1, username); statement.setString(2, propertyName); ResultSet results = statement.executeQuery(); if (results.next()) { r = results.getObject(PROPERTY_VALUE); } } return r; } Authenticator(Connection dbConnection); static String getSaltedSHA256String(String input, String salt); User logInUser(String username, String password); User lookUpUser(String username); Map<String, Object> lookUpUserProperties(String username); User logOutUser(String username); Object lookUpUserProperty(String username, String propertyName); static boolean isWrapperType(Class<?> clazz); static final int HEX_CONVERSION_CONSTANT; }### Answer: @Test public void testLookUpUserProperty() throws Exception { Authenticator authenticator = new Authenticator(connection); String username = "TestAccount1"; Object foo = authenticator.lookUpUserProperty(username, "Foo"); Assert.assertEquals(foo, "Bar"); }
### Question: AuthServer extends TaskedServer { public Authenticator getAuthenticator() { return authenticator; } AuthServer(ServerInit initInfo, Authenticator authenticator); Authenticator getAuthenticator(); }### Answer: @Test public void testConstructor() throws Exception { ServerInit serverInit = new ServerInit(); Authenticator authenticator = mock(Authenticator.class); AuthServer authServer = new AuthServer(serverInit, authenticator); authServer.shutdown(); Assert.assertEquals(authServer.getAuthenticator(), authenticator); }
### Question: StringUtils { public static String getPreview(String text, int linesCount, boolean ignoreEmptyLines, Integer maxLength) { if (maxLength != null && maxLength < 0) { throw new IllegalArgumentException("maxLength can't be negative"); } if (text == null) { return "<null>"; } if (text.isEmpty() \|\| linesCount <= 0) { return ""; } Scanner scanner = new Scanner(text); return getPreview(linesCount, ignoreEmptyLines, maxLength, scanner); } private StringUtils(); static String getPreview(String text, int linesCount, boolean ignoreEmptyLines, Integer maxLength); static String getPreview(InputStream is, String encoding, int linesCount, boolean ignoreEmptyLines, Integer maxLength); }### Answer: @Test public void test() throws IOException { String text = getResourceText("Script.groovy"); String preview = StringUtils.getPreview(text, 2, true, Integer.MAX_VALUE); assertEquals("package com.icthh.xm.lep.script\\n\\ndef description = \"'Logic Extension Point 2017'\"", preview); preview = StringUtils.getPreview(text, 2, false, Integer.MAX_VALUE); assertEquals("package com.icthh.xm.lep.script\\n", preview); }
### Question: NumberFilter extends Filter { @Override public boolean equals(Object obj) { if (! (obj instanceof NumberFilter)) return false; NumberFilter rhs = (NumberFilter) obj; return toString().equals(rhs.toString()); } NumberFilter(); NumberFilter(String str); NumberFilter(int filterValue, Type type, int threshold, int numberOfSynchronousHands); NumberFilter(String filterValue, Type type, int threshold, int numberOfSynchronousHands); void setNumberOfSynchronousHands(int numberOfSynchronousHands); @Override boolean isFulfilled(Siteswap siteswap); @Override boolean isPartlyFulfilled(Siteswap siteswap, int index); @Override String toParsableString(); @Override NumberFilter fromParsableString(String str); @Override String toString(); @Override boolean equals(Object obj); @Override int hashCode(); Type getType(); FilterValue getFilterValue(); int getThresholdValue(); static String[] getPossibleValues(int minThrow, int maxThrow, int numberOfSynchronousHands); }### Answer: @Test public void testEquals() { NumberFilter filter1 = new NumberFilter("6p", NumberFilter.Type.EQUAL, 1, 2); NumberFilter filter2 = new NumberFilter("6p", NumberFilter.Type.EQUAL, 1, 2); NumberFilter filter3 = new NumberFilter("6", NumberFilter.Type.EQUAL, 1, 2); NumberFilter filter4 = new NumberFilter("8p", NumberFilter.Type.EQUAL, 1, 2); assertEquals(filter1, filter2); assertNotEquals(filter1, filter3); assertNotEquals(filter1, filter4); }
### Question: NumberFilter extends Filter { public FilterValue getFilterValue() { return mFilterValue; } NumberFilter(); NumberFilter(String str); NumberFilter(int filterValue, Type type, int threshold, int numberOfSynchronousHands); NumberFilter(String filterValue, Type type, int threshold, int numberOfSynchronousHands); void setNumberOfSynchronousHands(int numberOfSynchronousHands); @Override boolean isFulfilled(Siteswap siteswap); @Override boolean isPartlyFulfilled(Siteswap siteswap, int index); @Override String toParsableString(); @Override NumberFilter fromParsableString(String str); @Override String toString(); @Override boolean equals(Object obj); @Override int hashCode(); Type getType(); FilterValue getFilterValue(); int getThresholdValue(); static String[] getPossibleValues(int minThrow, int maxThrow, int numberOfSynchronousHands); }### Answer: @Test public void testSynchronousPassConversion() { NumberFilter filter = new NumberFilter("9p", NumberFilter.Type.EQUAL, 1, 3); assertArrayEquals(new int[]{10, 11}, filter.getFilterValue().getValues(0)); assertArrayEquals(new int[]{8, 10}, filter.getFilterValue().getValues(1)); assertArrayEquals(new int[]{7, 8}, filter.getFilterValue().getValues(2)); }
### Question: PatternFilter extends Filter { @Override public String toParsableString() { String str = new String(); str += String.valueOf(VERSION) + ","; str += mPattern.toParsableString() + ","; str += mType.toString() + ","; return str; } PatternFilter(); PatternFilter(String str); PatternFilter(Siteswap pattern, Type type); @Override boolean isFulfilled(Siteswap siteswap); @Override boolean isPartlyFulfilled(Siteswap siteswap, int index); @Override String toParsableString(); @Override PatternFilter fromParsableString(String str); @Override String toString(); @Override boolean equals(Object obj); Type getType(); Siteswap getPattern(); }### Answer: @Test public void testParsableStringConversion() { PatternFilter filter1 = new PatternFilter(new Siteswap("ppsps"), PatternFilter.Type.EXCLUDE); PatternFilter filter2 = new PatternFilter(new Siteswap("972"), PatternFilter.Type.INCLUDE); String filter1str = filter1.toParsableString(); String filter2str = filter2.toParsableString(); PatternFilter filter1conv = new PatternFilter(filter1str); PatternFilter filter2conv = new PatternFilter(filter2str); assertEquals(filter1, filter1conv); assertEquals(filter2, filter2conv); }
### Question: ISOCurrency { public static BigDecimal parseFromISO87String (String isoamount, String currency) { int decimals = findCurrency(currency).getDecimals(); return new BigDecimal(isoamount).movePointLeft(decimals); } private ISOCurrency(); @SuppressWarnings({"EmptyCatchBlock"}) static void loadPropertiesFromClasspath(String base); static double convertFromIsoMsg(String isoamount, String currency); static String toISO87String(BigDecimal amount, String currency); static BigDecimal parseFromISO87String(String isoamount, String currency); static void addBundle(String bundleName); static String convertToIsoMsg(double amount, String currency); static Object[] decomposeComposedCurrency(String incurr); static String getIsoCodeFromAlphaCode(String alphacode); static Currency getCurrency(int code); static Currency getCurrency(String code); }### Answer: @Test public void testparseFromISO87String () { assertEquals(new BigDecimal("12.34"), ISOCurrency.parseFromISO87String("000000001234", "840"), "2 decimals"); assertEquals(new BigDecimal("1.234"), ISOCurrency.parseFromISO87String("000000001234", "048"), "3 decimals"); assertEquals(new BigDecimal("1234"), ISOCurrency.parseFromISO87String("000000001234", "020"), "no decimals"); }
### Question: ISOCurrency { public static String toISO87String (BigDecimal amount, String currency) { try { Currency c = findCurrency(currency); return ISOUtil.zeropad(amount.movePointRight(c.getDecimals()).setScale(0).toPlainString(), 12); } catch (ISOException e) { throw new IllegalArgumentException("Failed to convert amount",e); } } private ISOCurrency(); @SuppressWarnings({"EmptyCatchBlock"}) static void loadPropertiesFromClasspath(String base); static double convertFromIsoMsg(String isoamount, String currency); static String toISO87String(BigDecimal amount, String currency); static BigDecimal parseFromISO87String(String isoamount, String currency); static void addBundle(String bundleName); static String convertToIsoMsg(double amount, String currency); static Object[] decomposeComposedCurrency(String incurr); static String getIsoCodeFromAlphaCode(String alphacode); static Currency getCurrency(int code); static Currency getCurrency(String code); }### Answer: @Test public void testtoISO87String () { assertEquals("000000001234", ISOCurrency.toISO87String(new BigDecimal("12.34"), "840"), "2 decimals"); assertEquals("000000001234", ISOCurrency.toISO87String(new BigDecimal("1.234"), "048"), "3 decimals"); assertEquals("000000001234", ISOCurrency.toISO87String(new BigDecimal("1234"), "020"), "no decimals"); }
### Question: KeyStoreAdaptor extends QBeanSupport implements KeyStoreAdaptorMBean { public String getImpl() { return clazz; } KeyStoreAdaptor(); void setImpl(String clazz); String getImpl(); static final String DEFAULT_IMPL; }### Answer: @Test public void testGetImpl() throws Throwable { String result = new KeyStoreAdaptor().getImpl(); assertEquals("org.jpos.security.SimpleKeyFile", result, "result"); }
### Question: BCDInterpreter implements Interpreter { public int getPackedLength(int nDataUnits) { return (nDataUnits + 1) / 2; } private BCDInterpreter(boolean leftPadded, boolean fPadded); void interpret(String data, byte[] b, int offset); String uninterpret(byte[] rawData, int offset, int length); int getPackedLength(int nDataUnits); static final BCDInterpreter LEFT_PADDED; static final BCDInterpreter RIGHT_PADDED; static final BCDInterpreter RIGHT_PADDED_F; static final BCDInterpreter LEFT_PADDED_F; }### Answer: @Test public void testGetPackedLength() throws Throwable { int result = BCDInterpreter.LEFT_PADDED.getPackedLength(0); assertEquals(0, result, "result"); } @Test public void testGetPackedLength1() throws Throwable { int result = BCDInterpreter.RIGHT_PADDED.getPackedLength(100); assertEquals(50, result, "result"); }
### Question: BCDInterpreter implements Interpreter { public String uninterpret(byte[] rawData, int offset, int length) { return ISOUtil.bcd2str (rawData, offset, length, leftPadded); } private BCDInterpreter(boolean leftPadded, boolean fPadded); void interpret(String data, byte[] b, int offset); String uninterpret(byte[] rawData, int offset, int length); int getPackedLength(int nDataUnits); static final BCDInterpreter LEFT_PADDED; static final BCDInterpreter RIGHT_PADDED; static final BCDInterpreter RIGHT_PADDED_F; static final BCDInterpreter LEFT_PADDED_F; }### Answer: @Test public void testUninterpret() throws Throwable { byte[] rawData = new byte[3]; String result = BCDInterpreter.LEFT_PADDED.uninterpret(rawData, 0, 1); assertEquals("0", result, "result"); } @Test public void testUninterpretThrowsArrayIndexOutOfBoundsException() throws Throwable { assertThrows(ArrayIndexOutOfBoundsException.class, () -> { byte[] rawData = new byte[3]; BCDInterpreter.RIGHT_PADDED_F.uninterpret(rawData, 100, 1000); }); } @Test public void testUninterpretThrowsNegativeArraySizeException() throws Throwable { assertThrows(NegativeArraySizeException.class, () -> { byte[] rawData = new byte[0]; BCDInterpreter.LEFT_PADDED.uninterpret(rawData, 100, -1); }); } @Test public void testUninterpretThrowsNullPointerException() throws Throwable { assertThrows(NullPointerException.class, () -> { BCDInterpreter.LEFT_PADDED.uninterpret(null, 100, 1000); }); }
### Question: EbcdicInterpreter implements Interpreter { public void interpret(String data, byte[] b, int offset) { ISOUtil.asciiToEbcdic(data, b, offset); } void interpret(String data, byte[] b, int offset); String uninterpret(byte[] rawData, int offset, int length); int getPackedLength(int nDataUnits); static final EbcdicInterpreter INSTANCE; }### Answer: @Test public void testInterpret() throws Exception { byte[] b = new byte[3]; inter.interpret("123", b, 0); TestUtils.assertEquals(new byte[] {(byte)0xF1, (byte)0xF2, (byte)0xF3}, b); }
### Question: EbcdicInterpreter implements Interpreter { public String uninterpret(byte[] rawData, int offset, int length) { return ISOUtil.ebcdicToAscii(rawData, offset, length); } void interpret(String data, byte[] b, int offset); String uninterpret(byte[] rawData, int offset, int length); int getPackedLength(int nDataUnits); static final EbcdicInterpreter INSTANCE; }### Answer: @Test public void testUninterpret() throws Exception { byte[] b = new byte[] {(byte)0xF1, (byte)0xF2, (byte)0xF3}; assertEquals("123", inter.uninterpret(b, 0, 3)); }
### Question: EbcdicInterpreter implements Interpreter { public int getPackedLength(int nDataUnits) { return nDataUnits; } void interpret(String data, byte[] b, int offset); String uninterpret(byte[] rawData, int offset, int length); int getPackedLength(int nDataUnits); static final EbcdicInterpreter INSTANCE; }### Answer: @Test public void testGetPackedLength() { assertEquals(3, inter.getPackedLength(3)); }
### Question: IF_UNUSED extends ISOFieldPackager { public byte[] pack (ISOComponent c) throws ISOException { throw new ISOException("IF_UNUSED: Packager should not pack field " + c.getKey()); } IF_UNUSED(); byte[] pack(ISOComponent c); int unpack(ISOComponent c, byte[] b, int offset); int getMaxPackedLength(); }### Answer: @Test public void testPack() throws Exception { ISOField field = new ISOField(12, "ABCD"); IF_UNUSED packager = new IF_UNUSED(); try { packager.pack(field); fail("Should have thrown an exception"); } catch (Exception expected) { } }
### Question: IF_UNUSED extends ISOFieldPackager { public int unpack (ISOComponent c, byte[] b, int offset) throws ISOException { throw new ISOException("IF_UNUSED: Packager should not unpack field " + c.getKey()); } IF_UNUSED(); byte[] pack(ISOComponent c); int unpack(ISOComponent c, byte[] b, int offset); int getMaxPackedLength(); }### Answer: @Test public void testUnpack() throws Exception { byte[] raw = new byte[]{}; IF_UNUSED packager = new IF_UNUSED(); ISOField field = new ISOField(12); try { packager.unpack(field, raw, 0); fail("Should have thrown an exception"); } catch (Exception expected) { } }
### Question: EbcdicPrefixer implements Prefixer { @Override public void encodeLength(int length, byte[] b) { for (int i = nDigits - 1; i >= 0; i--) { b[i] = EBCDIC_DIGITS[length % 10]; length /= 10; } } EbcdicPrefixer(int nDigits); @Override void encodeLength(int length, byte[] b); @Override int decodeLength(byte[] b, int offset); @Override int getPackedLength(); static final EbcdicPrefixer L; static final EbcdicPrefixer LL; static final EbcdicPrefixer LLL; static final EbcdicPrefixer LLLL; }### Answer: @Test public void testEncode() throws Exception { byte[] b = new byte[2]; EbcdicPrefixer.LL.encodeLength(21, b); TestUtils.assertEquals(new byte[]{(byte)0xF2, (byte)0xF1}, b); }
### Question: EbcdicPrefixer implements Prefixer { @Override public int decodeLength(byte[] b, int offset) { int len = 0; for (int i = 0; i < nDigits; i++) { len = len * 10 + (b[offset + i] & 0x0F); } return len; } EbcdicPrefixer(int nDigits); @Override void encodeLength(int length, byte[] b); @Override int decodeLength(byte[] b, int offset); @Override int getPackedLength(); static final EbcdicPrefixer L; static final EbcdicPrefixer LL; static final EbcdicPrefixer LLL; static final EbcdicPrefixer LLLL; }### Answer: @Test public void testDecode() throws Exception { byte[] b = new byte[]{(byte)0xF2, (byte)0xF5}; assertEquals(25, EbcdicPrefixer.LL.decodeLength(b, 0)); }
### Question: ISODate { public static Date parse(String s) { return parse(s, TimeZone.getDefault()); } private ISODate(); static String formatDate(Date d, String pattern); static String formatDate(Date d, String pattern, TimeZone timeZone); static Date parse(String s); static Date parse(String s, TimeZone timeZone); static Date parseDateTime(String s); static Date parseDateTime(String s, TimeZone timeZone); static Date parseISODate(String d); static Date parseISODate(String d, TimeZone timeZone); static Date parseISODate(String d, long currentTime); static Date parseISODate(String d, long currentTime, TimeZone timeZone); static String getDateTime(Date d); static String getDateTime(Date d, TimeZone timeZone); static String getTime(Date d); static String getTime(Date d, TimeZone timeZone); static String getDate(Date d); static String getDate(Date d, TimeZone timeZone); static String getANSIDate(Date d); static String getANSIDate(Date d, TimeZone timeZone); static String getEuropeanDate(Date d); static String getEuropeanDate(Date d, TimeZone timeZone); static String getExpirationDate(Date d); static String getExpirationDate(Date d, TimeZone timeZone); static String getJulianDate(Date d); static String getJulianDate(Date d, TimeZone timeZone); static final long ONE_YEAR; }### Answer: @Test public void testParseBadInputSwallowsExceptionAndReturnsNull() { java.util.Date result = ISODate.parse("31/02/WIBBLE", aus); assertThat(result, is(nullValue())); }
### Question: ISODate { public static Date parseDateTime(String s) { return parseDateTime(s, TimeZone.getDefault()); } private ISODate(); static String formatDate(Date d, String pattern); static String formatDate(Date d, String pattern, TimeZone timeZone); static Date parse(String s); static Date parse(String s, TimeZone timeZone); static Date parseDateTime(String s); static Date parseDateTime(String s, TimeZone timeZone); static Date parseISODate(String d); static Date parseISODate(String d, TimeZone timeZone); static Date parseISODate(String d, long currentTime); static Date parseISODate(String d, long currentTime, TimeZone timeZone); static String getDateTime(Date d); static String getDateTime(Date d, TimeZone timeZone); static String getTime(Date d); static String getTime(Date d, TimeZone timeZone); static String getDate(Date d); static String getDate(Date d, TimeZone timeZone); static String getANSIDate(Date d); static String getANSIDate(Date d, TimeZone timeZone); static String getEuropeanDate(Date d); static String getEuropeanDate(Date d, TimeZone timeZone); static String getExpirationDate(Date d); static String getExpirationDate(Date d, TimeZone timeZone); static String getJulianDate(Date d); static String getJulianDate(Date d, TimeZone timeZone); static final long ONE_YEAR; }### Answer: @Test public void testParseStringTimeZoneNoTimeSentReturnsNull() { java.util.Date result = ISODate.parseDateTime("31/02/2011", aus); assertThat(result, is(nullValue())); }

Subsets and Splits

No community queries yet

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