Datasets:

Minata
/

1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 269k rows

method2testcases stringlengths 118 6.63k
### Question: JSONBeanUtil { @SuppressWarnings("unchecked") public static String toJSONBean(final List<Object> list) { String json = null; if (list.size() == 1) { final Map<String, Object> map = (Map<String, Object>) list.get(0); json = JSONBeanUtil.toJSONBean(map); } else if (list.size() > 1) { final StringBuilder stringBuilder = new StringBuilder("["); for (int i = 0; i < list.size(); i++) { final Map<String, Object> map = (Map<String, Object>) list.get(i); stringBuilder.append(JSONBeanUtil.toJSONBean(map)); if (i < list.size() - 1) { stringBuilder.append(','); } } stringBuilder.append(']'); json = stringBuilder.toString(); } return json; } private JSONBeanUtil(); static Properties parsePropertiesFromJSONBean(final String json); static Map<String, SqlParameterValue> parseSqlParametersFromJSONBean(final String json, final Map<String, Integer> jdbcTypeMap); @SuppressWarnings("unchecked") static String toJSONBean(final List<Object> list); static String toJSONBean(final Map<String, Object> map); static List<String> toJSONBeans(Message in); static List<String> toJSONBeansFromHeader(Message in, String autoIncrementColumnName); }### Answer: @Test public void mapToJsonBeanTest() throws JsonProcessingException { final ObjectMapper mapper = new ObjectMapper(); final SimpleOutputBean bean = new SimpleOutputBean(); bean.setC(50); final String jsonBeanExpected = mapper.writeValueAsString(bean); final Map<String, Object> map = new HashMap<>(); map.put("c", 50); map.put("#update-count-1", 0); final String jsonBeanActual = JSONBeanUtil.toJSONBean(map); Assert.assertEquals(jsonBeanExpected, jsonBeanActual); }
### Question: JSONBeanUtil { public static Properties parsePropertiesFromJSONBean(final String json) { final Map<String, String> parsed; try { parsed = MAPPER.readerFor(STRING_STRING_MAP).readValue(json); } catch (final IOException e) { throw new IllegalArgumentException("Unable to parse given JSON", e); } final Properties ret = new Properties(); if (parsed != null) { parsed.entrySet().stream() .filter(e -> e.getKey() != null && e.getValue() != null) .forEach(e -> ret.put(e.getKey(), e.getValue())); } return ret; } private JSONBeanUtil(); static Properties parsePropertiesFromJSONBean(final String json); static Map<String, SqlParameterValue> parseSqlParametersFromJSONBean(final String json, final Map<String, Integer> jdbcTypeMap); @SuppressWarnings("unchecked") static String toJSONBean(final List<Object> list); static String toJSONBean(final Map<String, Object> map); static List<String> toJSONBeans(Message in); static List<String> toJSONBeansFromHeader(Message in, String autoIncrementColumnName); }### Answer: @Test public void parsePropertiesFromJSONBeanTest() throws JsonProcessingException { final ObjectMapper mapper = new ObjectMapper(); final SimpleInputBean bean = new SimpleInputBean(); bean.setA(20); bean.setB(30); final String jsonBean = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(bean); final Properties properties = JSONBeanUtil.parsePropertiesFromJSONBean(jsonBean); Assert.assertTrue(properties.containsKey("a")); Assert.assertEquals("20", properties.get("a")); Assert.assertTrue(properties.containsKey("b")); Assert.assertEquals("30", properties.get("b")); }
### Question: JSONBeanUtil { public static Map<String, SqlParameterValue> parseSqlParametersFromJSONBean(final String json, final Map<String, Integer> jdbcTypeMap) { if (!isValidJSONBean(json)) { return Collections.emptyMap(); } final Map<String, String> parsed; try { parsed = MAPPER.readerFor(STRING_STRING_MAP).readValue(json); } catch (final IOException e) { throw new IllegalArgumentException("Unable to parse given JSON", e); } final Map<String,SqlParameterValue> ret = new HashMap<>(); for (Map.Entry<String, String> entry : parsed.entrySet()) { String key = entry.getKey(); String value = entry.getValue(); Integer jdbcType = null; if (jdbcTypeMap != null) { jdbcType = jdbcTypeMap.get(key); } if (jdbcType == null) { jdbcType = Types.VARCHAR; } SqlParameterValue sqlParam = new SqlParameterValue(jdbcType, value); ret.put(key, sqlParam); } return Collections.unmodifiableMap(ret); } private JSONBeanUtil(); static Properties parsePropertiesFromJSONBean(final String json); static Map<String, SqlParameterValue> parseSqlParametersFromJSONBean(final String json, final Map<String, Integer> jdbcTypeMap); @SuppressWarnings("unchecked") static String toJSONBean(final List<Object> list); static String toJSONBean(final Map<String, Object> map); static List<String> toJSONBeans(Message in); static List<String> toJSONBeansFromHeader(Message in, String autoIncrementColumnName); }### Answer: @Test public void parseSqlParametersFromJSONBeanWhenNoParameters() throws JsonProcessingException { try { String[] jsonParamValues = { null, "", "{}", "[]", "something else" }; for (int i = 0; i < jsonParamValues.length; ++i) { Map<String, SqlParameterValue> retMap = JSONBeanUtil.parseSqlParametersFromJSONBean(jsonParamValues[i], new HashMap<>()); assertThat(retMap).isEmpty(); } } catch (Exception ex) { throw new AssertionError("Should not throw exception when json parameter is empty", ex); } try { String jsonParamValue = "{ \"arg1\": \"blah\" }"; Map<String, SqlParameterValue> retMap = JSONBeanUtil.parseSqlParametersFromJSONBean(jsonParamValue, null); SqlParameterValue paramValue = retMap.get("arg1"); assertNotNull(paramValue); assertEquals(Types.VARCHAR, paramValue.getSqlType()); } catch (Exception ex) { throw new AssertionError("Should not throw exception when json parameter is empty", ex); } }
### Question: JsonSimplePredicate implements Predicate { static String toOgnl(final Matcher matcher) { final String expression = matcher.group(1); if (!(expression.startsWith("body.") \|\| expression.startsWith("body[")) \|\| isCollectionPath(expression)) { return expression; } final StringBuilder ognl = new StringBuilder(expression.length() + 5); final char[] chars = expression.toCharArray(); boolean start = true; for (final char ch : chars) { if (ch == '.' \|\| ch == '[') { if (!start) { ognl.append(']'); } start = false; ognl.append('['); } else if (ch == '$') { ognl.append("\\$"); } else if (ch != ']') { ognl.append(ch); } } if (!start) { ognl.append(']'); } return ognl.toString(); } JsonSimplePredicate(final String expression, final CamelContext context); @Override @SuppressFBWarnings({"NP_LOAD_OF_KNOWN_NULL_VALUE", "RCN_REDUNDANT_NULLCHECK_OF_NONNULL_VALUE", "RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE"}) // https://github.com/spotbugs/spotbugs/issues/868 though this code is fishy (TODO) boolean matches(final Exchange exchange); }### Answer: @Test @Parameters({"body.prop, body[prop]", "body.size(), body.size()", "body[3], body[3]", "body[3].prop, body[3][prop]", "body.fr_op.gl$op.ml0op[3], body[fr_op][gl\\$op][ml0op][3]"}) public void shouldConvertSimpleToOgnl(final String simple, final String ognl) { final Matcher matcher = Pattern.compile("(.*)").matcher(simple); matcher.find(); assertThat(JsonSimplePredicate.toOgnl(matcher)).isEqualTo(ognl); }
### Question: And extends LTLFormula { @Override public LTLType getLTLType(){ return LTLType.AND; } And(ArrayList<LTLFormula> children); @Override LTLType getLTLType(); @Override LTLFormula copy(); @Override LinkedHashSet<LinkedHashSet<LTLFormula>> toSetForm(); @Override ATransition d(HashMap<LTLFormula, ATransition> D); static void main(String args[]); }### Answer: @Test public void testType() { assertEquals(LTLType.AND, a_and_b.getLTLType()); assertEquals(LTLType.AND, a_and_c.getLTLType()); }
### Question: Or extends LTLFormula { public LTLFormula copy() { ArrayList<LTLFormula> copiedChildren = new ArrayList<LTLFormula>(children.size()); for(LTLFormula child : children){ copiedChildren.add(child.copy()); } return new Or(copiedChildren); } 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 testCopy() { assertEquals(a_or_b, a_or_b.copy()); assertEquals(a_or_c, a_or_c.copy()); }
### Question: XOr extends LTLFormula { @Override public LTLType getLTLType(){ return LTLType.XOR; } XOr(ArrayList<LTLFormula> children); @Override LTLType getLTLType(); @Override LTLFormula normalize(); @Override LTLFormula copy(); static void main(String[] args); }### Answer: @Test public void testType() { assertEquals(LTLType.XOR, a_xor_b.getLTLType()); assertEquals(LTLType.XOR, a_xor_c.getLTLType()); }
### Question: XOr extends LTLFormula { @Override protected LTLFormula lower(){ for(int i = 0; i < children.size(); ++i){ children.set(i,children.get(i).lower()); } ArrayList<LTLFormula> nextChildren; LTLFormula left = children.get(0); for(int i = 1; i < children.size(); ++i){ nextChildren = new ArrayList<LTLFormula>(2); LTLFormula right = children.get(i); nextChildren.add(new Negation(left.copy())); nextChildren.add(right.copy()); LTLFormula And1 = new And(nextChildren); nextChildren = new ArrayList<LTLFormula>(2); nextChildren.add(left); nextChildren.add(new Negation(right)); LTLFormula And2 = new And(nextChildren); nextChildren = new ArrayList<LTLFormula>(2); nextChildren.add(And1); nextChildren.add(And2); left = new Or(nextChildren); } return left; } XOr(ArrayList<LTLFormula> children); @Override LTLType getLTLType(); @Override LTLFormula normalize(); @Override LTLFormula copy(); static void main(String[] args); }### Answer: @Test public void testLower() { LTLFormula expected = OrTest.makeOr(AndTest.makeAnd(new Negation(a), b), AndTest.makeAnd(a, new Negation(b))); assertEquals(expected, a_xor_b.simplify()); }
### Question: XOr extends LTLFormula { @Override public LTLFormula copy() { ArrayList<LTLFormula> copiedChildren = new ArrayList<LTLFormula>(children.size()); for(LTLFormula child : children){ copiedChildren.add(child.copy()); } return new XOr(copiedChildren); } XOr(ArrayList<LTLFormula> children); @Override LTLType getLTLType(); @Override LTLFormula normalize(); @Override LTLFormula copy(); static void main(String[] args); }### Answer: @Test public void testCopy() { assertEquals(a_xor_b, a_xor_b.copy()); assertEquals(a_xor_c, a_xor_c.copy()); }
### Question: Repeat { public static ERE get(ERE child, int num) { if(num < 1) { return Empty.get(); } else if(num == 1) { return child; } else { ERE ret = Concat.get(child, child); for(int i = 2; i < num; ++i) { ret = Concat.get(child, ret); } return ret; } } static ERE get(ERE child, int num); }### Answer: @Test public void equalityTest() { ERE a_x5_again = Repeat.get(a, 5); assertEquals(a_x5, a_x5_again); assertEquals(0, a_x5.compareTo(a_x5_again)); } @Test public void inequalityTest() { ERE a_x10 = Repeat.get(a, 10); Symbol b = Symbol.get("b"); ERE b_x5 = Repeat.get(b, 5); assertFalse(a_x5.equals(a_x10)); assertFalse(0 == a_x5.compareTo(a_x10)); assertFalse(a_x5.equals(b_x5)); assertFalse(0 == a_x5.compareTo(b_x5)); } @Test public void deriveTest() { Symbol a = Symbol.get("a"); Epsilon epsilon = Epsilon.get(); assertEquals(epsilon, a_x3.derive(a).derive(a).derive(a)); Empty empty = Empty.get(); assertEquals(empty, a_x3.derive(a).derive(a).derive(a).derive(a)); Symbol b = Symbol.get("b"); assertEquals(empty, a_x3.derive(b)); }
### Question: Concat extends ERE { public static ERE get(ERE left, ERE right) { Concat cat = new Concat(left, right); ERE ret = cat.simplify(); return ret; } private Concat(ERE left, ERE right); static ERE get(ERE left, ERE right); @Override EREType getEREType(); @Override String toString(); @Override ERE copy(); @Override boolean containsEpsilon(); @Override ERE derive(Symbol s); }### Answer: @Test public void testEquality() { ERE one = Concat.get(a, b); ERE two = Concat.get(a, b); assertEquals(one, two); assertEquals(0, one.compareTo(two)); } @Test public void testInequality() { ERE one = Concat.get(a, b); ERE two = Concat.get(a, c); assertFalse(one.equals(two)); assertFalse(0 == one.compareTo(two)); assertFalse(one.equals(a)); assertFalse(0 == one.compareTo(a)); }
### Question: Concat extends ERE { @Override public boolean containsEpsilon() { for(ERE child : children) { if(!child.containsEpsilon()) { return false; } } return true; } private Concat(ERE left, ERE right); static ERE get(ERE left, ERE right); @Override EREType getEREType(); @Override String toString(); @Override ERE copy(); @Override boolean containsEpsilon(); @Override ERE derive(Symbol s); }### Answer: @Test public void testContainsEpsilon() { Epsilon epsilon = Epsilon.get(); assertFalse(Concat.get(a, b).containsEpsilon()); assertFalse(Concat.get(a, epsilon).containsEpsilon()); assertFalse(Concat.get(epsilon, b).containsEpsilon()); assertTrue(Concat.get(epsilon, epsilon).containsEpsilon()); }
### Question: And extends LTLFormula { @Override protected LTLFormula normalize(boolean b) { if(b) { flatten(); for(int i = 0; i < children.size(); ++i){ children.set(i, getNegation(i, true)); } return new Or(children); } else { for(int i = 0; i < children.size(); ++i){ children.set(i, getNegation(i, false)); } return this; } } And(ArrayList<LTLFormula> children); @Override LTLType getLTLType(); @Override LTLFormula copy(); @Override LinkedHashSet<LinkedHashSet<LTLFormula>> toSetForm(); @Override 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); Or expected = new Or(orElements); assertEquals(expected, a_and_b.copy().normalize(true)); } assertEquals(makeAnd(a, c), a_and_c.normalize(false)); }
### Question: Concat extends ERE { private ERE simplify(){ if(children.get(0) == Empty.get()) { return Empty.get(); } else if(children.get(1) == Empty.get()) { return Empty.get(); } else if(children.get(0) == Epsilon.get()) { return children.get(1); } else if(children.get(1) == Epsilon.get()) { return children.get(0); } return this; } private Concat(ERE left, ERE right); static ERE get(ERE left, ERE right); @Override EREType getEREType(); @Override String toString(); @Override ERE copy(); @Override boolean containsEpsilon(); @Override ERE derive(Symbol s); }### Answer: @Test public void testSimplify() { Epsilon epsilon = Epsilon.get(); Empty empty = Empty.get(); assertEquals(empty, Concat.get(a, empty)); assertEquals(empty, Concat.get(empty, a)); assertEquals(a, Concat.get(a, epsilon)); assertEquals(a, Concat.get(epsilon, a)); assertEquals(empty, Concat.get(epsilon, empty)); assertEquals(empty, Concat.get(empty, epsilon)); }
### Question: Concat extends ERE { @Override public ERE copy() { return new Concat(children.get(0).copy(), children.get(1).copy()); } private Concat(ERE left, ERE right); static ERE get(ERE left, ERE right); @Override EREType getEREType(); @Override String toString(); @Override ERE copy(); @Override boolean containsEpsilon(); @Override ERE derive(Symbol s); }### Answer: @Test public void testCopy() { ERE concat = Concat.get(a, b); ERE copy = concat.copy(); assertEquals(concat, copy); }
### Question: Concat extends ERE { @Override public ERE derive(Symbol s){ ERE left = children.get(0); ERE right = children.get(1); if(left.containsEpsilon()) { ArrayList<ERE> orChildren = new ArrayList<ERE>(2); orChildren.add(Concat.get(left.derive(s), right.copy())); orChildren.add(right.derive(s)); return Or.get(orChildren); } return Concat.get(left.derive(s), right.copy()); } private Concat(ERE left, ERE right); static ERE get(ERE left, ERE right); @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(); ERE ab = Concat.get(a, b); assertEquals(b, ab.derive(a)); assertEquals(empty, ab.derive(b)); ERE aStar = Kleene.get(a); ERE aStarb = Concat.get(aStar, b); assertEquals(aStarb, aStarb.derive(a)); assertEquals(epsilon, aStarb.derive(b)); assertEquals(empty, aStarb.derive(c)); }
### Question: FSM { static public FSM get(ERE input, Symbol[] events) { return new FSM(input, events); } private FSM(ERE input, Symbol[] events); static FSM get(ERE input, Symbol[] events); void print(PrintStream p); public LinkedHashMap<ERE, LinkedHashMap<Symbol, ERE>> contents; public LinkedHashSet<ERE> match; }### Answer: @Test public void testConcat() { ERE ab = Concat.get(a, b); String fsm = "s0 [" + NEWLINE + " a -> s1" + NEWLINE + "]" + NEWLINE + "s1 [" + NEWLINE + " b -> s2" + NEWLINE + "]" + NEWLINE + "s2 [" + NEWLINE + "]" + NEWLINE + "alias match = s2 " + NEWLINE; assertEquals(fsm, printFSM(ab, a, b)); } @Test public void testOr() { ERE or = Or.get(new ArrayList<ERE>(Arrays.asList(a, b))); String fsm = "s0 [" + NEWLINE + " a -> s1" + NEWLINE + " b -> s1" + NEWLINE + "]" + NEWLINE + "s1 [" + NEWLINE + "]" + NEWLINE + "alias match = s1 " + NEWLINE; assertEquals(fsm, printFSM(or, a, b)); } @Test public void testKleene() { ERE aStar = Kleene.get(a); String fsm = "s0 [" + NEWLINE + " a -> s0" + NEWLINE + "]" + NEWLINE + "alias match = s0 " + NEWLINE; assertEquals(fsm, printFSM(aStar, a)); }
### Question: Negation extends ERE { public static ERE get(ERE child) { if(child.getEREType() == EREType.NEG) return child.children.get(0); return new Negation(child); } private Negation(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 one = Negation.get(symbol); ERE one_again = Negation.get(symbol); assertEquals(one, one_again); assertEquals(0, one.compareTo(one_again)); } @Test public void testInequality() { Epsilon epsilon = Epsilon.get(); ERE one = Negation.get(symbol); ERE two = Negation.get(epsilon); assertFalse(one.equals(two)); assertFalse(0 == one.compareTo(two)); } @Test public void testSimplification() { ERE negation = Negation.get(symbol); ERE doubleNegation = Negation.get(negation); assertEquals(symbol, doubleNegation); }
### Question: Negation extends ERE { @Override public boolean containsEpsilon() { return !(children.get(0).containsEpsilon()); } private Negation(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() { ERE negateEmpty = Negation.get(empty); ERE negateEpsilon = Negation.get(epsilon); assertTrue(negateEmpty.containsEpsilon()); assertFalse(negateEpsilon.containsEpsilon()); }
### Question: And extends LTLFormula { @Override protected LTLFormula reduce(){ for(int i = 0; i < children.size(); ++i){ children.set(i, children.get(i).reduce()); } flatten(); Collections.sort(children); for(int i = 0; ; ++i){ if(i >= children.size()) return this; if(children.get(i) == False.get()){ return False.get(); } if(children.get(i) == True.get()){ children.remove(i); --i; continue; } if(children.get(i).getLTLType() == LTLType.A){ for(int j = i; j < children.size(); ++j){ LTLFormula child = children.get(j); if(child.getLTLType().compareTo(LTLType.NEG) > 0){ break; } if(child.getLTLType() == LTLType.NEG && child.getChildren().get(0) == children.get(i)){ return False.get(); } } } if(i + 1 < children.size() && children.get(i).equals(children.get(i + 1))){ children.remove(i); --i; } if(children.size() == 1) return children.get(0); } } And(ArrayList<LTLFormula> children); @Override LTLType getLTLType(); @Override LTLFormula copy(); @Override LinkedHashSet<LinkedHashSet<LTLFormula>> toSetForm(); @Override ATransition d(HashMap<LTLFormula, ATransition> D); static void main(String args[]); }### Answer: @Test public void testReduce() { { And duplicate = makeAnd(a, b, c, a, b, c); assertEquals(makeAnd(a, b, c), duplicate.reduce()); } { And combined = makeAnd(a_and_b,a_and_c); assertEquals(makeAnd(a, b, c), combined.reduce()); } { And withTrue = makeAnd(a, b, True.get()); assertEquals(a_and_b, withTrue.reduce()); } { And withFalse = makeAnd(a, b, False.get()); assertEquals(False.get(), withFalse.reduce()); } { And solitaryWithTrue = makeAnd(a, True.get()); assertEquals(a, solitaryWithTrue.reduce()); } }
### Question: Negation extends ERE { @Override public ERE derive(Symbol s) { return Negation.get(children.get(0).derive(s)); } private Negation(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() { ERE negateEmpty = Negation.get(empty); ERE negateEpsilon = Negation.get(epsilon); ERE derived = negateEpsilon.derive(Symbol.get("test")); assertEquals(negateEmpty, derived); }
### Question: Negation extends ERE { @Override public ERE copy() { return new Negation(children.get(0).copy()); } private Negation(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 negation = Negation.get(empty); ERE copy = negation.copy(); assertEquals(negation, copy); }
### Question: Symbol extends ERE { @Override public ERE copy() { return this; } private Symbol(); static Symbol get(String name); @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 = one.copy(); assertEquals(one, copy); }
### Question: Symbol extends ERE { @Override public EREType getEREType() { return EREType.S; } private Symbol(); static Symbol get(String name); @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 testEREType() { EREType type = one.getEREType(); assertEquals(EREType.S, type); }
### Question: Symbol extends ERE { @Override public boolean containsEpsilon() { return false; } private Symbol(); static Symbol get(String name); @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() { assertFalse(one.containsEpsilon()); }
### Question: Symbol extends ERE { @Override public ERE derive(Symbol s) { if(this == s) { return Epsilon.get(); } return Empty.get(); } private Symbol(); static Symbol get(String name); @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() { Empty empty = Empty.get(); Epsilon epsilon = Epsilon.get(); assertEquals(epsilon, one.derive(one)); assertEquals(empty, one.derive(two)); assertEquals(epsilon, two.derive(two)); assertEquals(empty, two.derive(one)); }
### Question: Symbol extends ERE { @Override public String toString() { return refToString.get(this); } private Symbol(); static Symbol get(String name); @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("one", one.toString()); assertEquals("two", two.toString()); }
### Question: Empty extends ERE { @Override public EREType getEREType() { return EREType.EMP; } 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 testType() { assertEquals(empty.getEREType(), EREType.EMP); }
### Question: Empty extends ERE { @Override public String toString() { return "empty"; } 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 testString() { assertEquals("empty", empty.toString()); }
### Question: Empty extends ERE { @Override public ERE derive(Symbol s) { return empty; } 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 testDerive() { ERE derived = empty.derive(Symbol.get("test")); assertEquals(empty, derived); }
### Question: And extends LTLFormula { @Override public LTLFormula copy() { ArrayList<LTLFormula> copiedChildren = new ArrayList<LTLFormula>(children.size()); for(LTLFormula child : children){ copiedChildren.add(child.copy()); } return new And(copiedChildren); } And(ArrayList<LTLFormula> children); @Override LTLType getLTLType(); @Override LTLFormula copy(); @Override LinkedHashSet<LinkedHashSet<LTLFormula>> toSetForm(); @Override ATransition d(HashMap<LTLFormula, ATransition> D); static void main(String args[]); }### Answer: @Test public void testCopy() { assertEquals(a_and_b, a_and_b.copy()); assertEquals(a_and_c, a_and_c.copy()); }
### Question: Empty extends ERE { @Override public boolean containsEpsilon() { return false; } 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 testContainsEpsilon() { assertFalse(empty.containsEpsilon()); }
### 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>> { @Override public String toString() { StringBuilder sb = new StringBuilder("\n"); sb.append(needsBegin); sb.append("\n"); sb.append(needsEnd); sb.append("\n"); for(State state : keySet()) { sb.append(state); sb.append("\n["); HashMap<Symbol, ActionState> transition = get(state); for(Symbol symbol : transition.keySet()) { sb.append(" "); sb.append(symbol); sb.append(" -> "); sb.append(transition.get(symbol)); sb.append("\n"); } sb.append("]\n"); } 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 testString() { String pmaStr = pma.toString(); String zeroAtZero = pmaStr.substring(pmaStr.indexOf("\n<0 @ 0"), pmaStr.indexOf("\n<1 @ 1")); assertTrue(zeroAtZero.contains("d -> [0] <0 @ 0>")); assertTrue(zeroAtZero.contains("c -> [0] <0 @ 0>")); assertTrue(zeroAtZero.contains("b -> [0] <0 @ 0>")); assertTrue(zeroAtZero.contains("a -> [0] <1 @ 1>")); String oneAtOne = pmaStr.substring(pmaStr.indexOf("\n<1 @ 1"), pmaStr.indexOf("\n<2 @ 2")); assertTrue(oneAtOne.contains("d -> [1] <0 @ 0>")); assertTrue(oneAtOne.contains("c -> [1] <0 @ 0>")); assertTrue(oneAtOne.contains("a -> [1] <0 @ 0>")); assertTrue(oneAtOne.contains("b -> [0] <2 @ 2 matches a b -> c d >")); String twoAtTwo = pmaStr.substring(pmaStr.indexOf("\n<2 @ 2")); assertTrue(twoAtTwo.contains("d -> [2] <0 @ 0>")); assertTrue(twoAtTwo.contains("c -> [2] <0 @ 0>")); assertTrue(twoAtTwo.contains("b -> [2] <0 @ 0>")); assertTrue(twoAtTwo.contains("a -> [2] <0 @ 0>")); }
### 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: Or extends LTLFormula { @Override protected LTLFormula reduce(){ for(int i = 0; i < children.size(); ++i){ children.set(i, children.get(i).reduce()); } flatten(); Collections.sort(children); for(int i = 0; ; ++i){ if(i >= children.size()) return this; if(children.get(i) == True.get()){ return True.get(); } if(children.get(i) == False.get()){ children.remove(i); --i; continue; } if(children.get(i).getLTLType() == LTLType.A){ for(int j = i; j < children.size(); ++j){ LTLFormula child = children.get(j); if(child.getLTLType().compareTo(LTLType.NEG) > 0){ break; } if(child.getLTLType() == LTLType.NEG && child.getChildren().get(0) == children.get(i)){ return True.get(); } } } if(i + 1 < children.size() && children.get(i).equals(children.get(i + 1))){ children.remove(i); --i; } if(children.size() == 1) return children.get(0); } } 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 testReduce() { { Or duplicate = makeOr(a, b, c, a, b, c); assertEquals(makeOr(a, b, c), duplicate.reduce()); } { Or combined = makeOr(a_or_b,a_or_c); assertEquals(makeOr(a, b, c), combined.reduce()); } { Or withTrue = makeOr(a, b, True.get()); assertEquals(True.get(), withTrue.reduce()); } { Or withFalse = makeOr(a, b, False.get()); assertEquals(a_or_b, withFalse.reduce()); } }
### 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); }

Subsets and Splits

No community queries yet

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