method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
LogManagerProperties extends Properties { static void checkLogManagerAccess() { boolean checked = false; final Object m = LOG_MANAGER; if (m != null) { try { if (m instanceof LogManager) { checked = true; ((LogManager) m).checkAccess(); } } catch (final SecurityException notAllowed) { if (checked) { throw notAllowed; } } catch (final LinkageError restricted) { } catch (final RuntimeException unexpected) { } } if (!checked) { checkLoggingAccess(); } } LogManagerProperties(final Properties parent, final String prefix); @Override @SuppressWarnings("CloneDoesntCallSuperClone") synchronized Object clone(); @Override synchronized String getProperty(final String key); @Override String getProperty(final String key, final String def); @Override synchronized Object get(final Object key); @Override synchronized Object put(final Object key, final Object value); @Override Object setProperty(String key, String value); @Override synchronized boolean containsKey(final Object key); @Override synchronized Object remove(final Object key); @Override Enumeration<?> propertyNames(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test public void testCheckAccessPresent() { LogManager m = LogManager.getLogManager(); m.checkAccess(); LogManagerProperties.checkLogManagerAccess(); LogPermSecurityManager sm = new LogPermSecurityManager(); sm.secure = false; System.setSecurityManager(sm); try { sm.secure = true; try { m.checkAccess(); fail(m.toString()); } catch (SecurityException expect) { } try { LogManagerProperties.checkLogManagerAccess(); fail(LogManagerProperties.class.getName()); } catch (SecurityException expect) { } } finally { sm.secure = false; System.setSecurityManager((SecurityManager) null); } } |
### Question:
CollectorFormatter extends Formatter { @Override public String format(final LogRecord record) { if (record == null) { throw new NullPointerException(); } boolean accepted; do { final LogRecord peek = peek(); LogRecord update = apply(peek != null ? peek : record, record); if (peek != update) { update.getSourceMethodName(); accepted = acceptAndUpdate(peek, update); } else { accepted = accept(peek, record); } } while (!accepted); return ""; } CollectorFormatter(); CollectorFormatter(String format); CollectorFormatter(String format, Formatter f,
Comparator<? super LogRecord> c); @Override String format(final LogRecord record); @Override String getTail(final Handler h); @Override String toString(); }### Answer:
@Test(expected = NullPointerException.class) public void testFormatApplyReturnsNull() { CollectorFormatter f = new ApplyReturnsNull(); for (int i = 0; i < 10; i++) { String o = f.format(new LogRecord(Level.INFO, "")); assertNotNull(o); } }
@Test(expected = NullPointerException.class) public void testFormatNull() { CollectorFormatter f = new CollectorFormatter("{1}", (Formatter) null, (Comparator<LogRecord>) null); f.format((LogRecord) null); }
@Test public void testFormat() throws Exception { final String p = CollectorFormatter.class.getName(); Properties props = new Properties(); final String expect = CollectorFormatterTest.class.getName(); props.put(p.concat(".format"), expect); LogManager manager = LogManager.getLogManager(); try { read(manager, props); CollectorFormatter cf = new CollectorFormatter(); LogRecord first = new LogRecord(Level.SEVERE, Level.SEVERE.getName()); assertEquals("", cf.format(first)); String result = cf.getTail((Handler) null); assertEquals(expect, result); } finally { manager.reset(); } } |
### Question:
LogManagerProperties extends Properties { @Override @SuppressWarnings("CloneDoesntCallSuperClone") public synchronized Object clone() { return exportCopy(defaults); } LogManagerProperties(final Properties parent, final String prefix); @Override @SuppressWarnings("CloneDoesntCallSuperClone") synchronized Object clone(); @Override synchronized String getProperty(final String key); @Override String getProperty(final String key, final String def); @Override synchronized Object get(final Object key); @Override synchronized Object put(final Object key, final Object value); @Override Object setProperty(String key, String value); @Override synchronized boolean containsKey(final Object key); @Override synchronized Object remove(final Object key); @Override Enumeration<?> propertyNames(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test public void testClone() throws Exception { String prefix = LogManagerPropertiesTest.class.getName(); Properties parent; LogManagerProperties mp; LogManager manager = LogManager.getLogManager(); try { String key = prefix.concat(".dummy"); parent = new Properties(); parent.put(key, "value"); read(manager, parent); parent = new Properties(); mp = new LogManagerProperties(parent, prefix); assertFalse(contains(mp, key, null)); assertEquals("value", mp.getProperty(key)); assertTrue(contains(mp, key, "value")); } finally { manager.reset(); } Properties clone = (Properties) mp.clone(); assertFalse(clone instanceof LogManagerProperties); assertEquals(Properties.class, clone.getClass()); assertNotSame(clone, parent); assertNotSame(clone, mp); assertEquals(mp.size(), clone.size()); assertTrue(clone.equals(mp)); } |
### Question:
DurationFilter implements Filter { @Override public String toString() { boolean idle; boolean loggable; synchronized (this) { final long millis = System.currentTimeMillis(); idle = test(0L, millis); loggable = test(records, millis); } return getClass().getName() + "{records=" + records + ", duration=" + duration + ", idle=" + idle + ", loggable=" + loggable + '}'; } DurationFilter(); DurationFilter(final long records, final long duration); @Override boolean equals(final Object obj); boolean isIdle(); @Override int hashCode(); @SuppressWarnings("override") //JDK-6954234 boolean isLoggable(final LogRecord record); boolean isLoggable(); @Override String toString(); }### Answer:
@Test public void testDeclaredClasses() throws Exception { Class<?>[] declared = DurationFilter.class.getDeclaredClasses(); assertEquals(Arrays.toString(declared), 0, declared.length); }
@Test public void testToString() { testToString(new DurationFilter()); } |
### Question:
LogManagerProperties extends Properties { static boolean isReflectionClass(String name) throws Exception { String[] names = REFLECT_NAMES; if (names == null) { REFLECT_NAMES = names = reflectionClassNames(); } for (String rf : names) { if (name.equals(rf)) { return true; } } findClass(name); return false; } LogManagerProperties(final Properties parent, final String prefix); @Override @SuppressWarnings("CloneDoesntCallSuperClone") synchronized Object clone(); @Override synchronized String getProperty(final String key); @Override String getProperty(final String key, final String def); @Override synchronized Object get(final Object key); @Override synchronized Object put(final Object key, final Object value); @Override Object setProperty(String key, String value); @Override synchronized boolean containsKey(final Object key); @Override synchronized Object remove(final Object key); @Override Enumeration<?> propertyNames(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test public void testIsReflection() throws Exception { assertTrue(LogManagerProperties.isReflectionClass(Constructor.class.getName())); assertTrue(LogManagerProperties.isReflectionClass(Method.class.getName())); } |
### Question:
DurationFilter implements Filter { @Override protected DurationFilter clone() throws CloneNotSupportedException { final DurationFilter clone = (DurationFilter) super.clone(); clone.count = 0L; clone.peak = 0L; clone.start = 0L; return clone; } DurationFilter(); DurationFilter(final long records, final long duration); @Override boolean equals(final Object obj); boolean isIdle(); @Override int hashCode(); @SuppressWarnings("override") //JDK-6954234 boolean isLoggable(final LogRecord record); boolean isLoggable(); @Override String toString(); }### Answer:
@Test public void testClone() throws Exception { DurationFilterExt source = new DurationFilterExt(); final Filter clone = source.clone(); assertNotNull(clone); assertFalse(source == clone); assertTrue(source.equals(clone)); assertEquals(source.getClass(), clone.getClass()); LogRecord r = new LogRecord(Level.INFO, ""); assertTrue(source.isLoggable(r)); assertFalse(source.equals(clone)); assertTrue(((DurationFilterExt) clone).clone().equals(clone)); } |
### Question:
DurationFilter implements Filter { @SuppressWarnings("override") public boolean isLoggable(final LogRecord record) { return accept(record.getMillis()); } DurationFilter(); DurationFilter(final long records, final long duration); @Override boolean equals(final Object obj); boolean isIdle(); @Override int hashCode(); @SuppressWarnings("override") //JDK-6954234 boolean isLoggable(final LogRecord record); boolean isLoggable(); @Override String toString(); }### Answer:
@Test public void testPredictedOverflow() { int records = 4; int duration = 4; DurationFilter sf = new DurationFilter(records, duration); for (int i = 0; i < records; i++) { LogRecord r = new LogRecord(Level.INFO, ""); setEpochMilli(r, Long.MAX_VALUE); assertTrue(sf.isLoggable(r)); } LogRecord r = new LogRecord(Level.INFO, ""); setEpochMilli(r, Long.MAX_VALUE); assertFalse(sf.isLoggable(r)); r = new LogRecord(Level.INFO, ""); setEpochMilli(r, Long.MAX_VALUE + duration); assertTrue(sf.isLoggable(r)); }
@Test(expected = NullPointerException.class) public void testIsLoggableNull() { new DurationFilter().isLoggable((LogRecord) null); } |
### Question:
DurationFilter implements Filter { @Override public boolean equals(final Object obj) { if (this == obj) { return true; } if (obj == null || getClass() != obj.getClass()) { return false; } final DurationFilter other = (DurationFilter) obj; if (this.records != other.records) { return false; } if (this.duration != other.duration) { return false; } final long c; final long p; final long s; synchronized (this) { c = this.count; p = this.peak; s = this.start; } synchronized (other) { if (c != other.count || p != other.peak || s != other.start) { return false; } } return true; } DurationFilter(); DurationFilter(final long records, final long duration); @Override boolean equals(final Object obj); boolean isIdle(); @Override int hashCode(); @SuppressWarnings("override") //JDK-6954234 boolean isLoggable(final LogRecord record); boolean isLoggable(); @Override String toString(); }### Answer:
@Test public void testEquals() { DurationFilter one = new DurationFilter(); DurationFilter two = new DurationFilter(); assertTrue(one.equals(one)); assertTrue(two.equals(two)); assertTrue(one.equals(two)); assertTrue(two.equals(one)); LogRecord r = new LogRecord(Level.INFO, ""); assertTrue(one.isLoggable(r)); assertTrue(one.equals(one)); assertTrue(two.equals(two)); assertFalse(one.equals(two)); assertFalse(two.equals(one)); assertFalse(one.equals((Object) null)); assertFalse(two.equals((Object) null)); } |
### Question:
DurationFilter implements Filter { @Override public int hashCode() { int hash = 3; hash = 89 * hash + (int) (this.records ^ (this.records >>> 32)); hash = 89 * hash + (int) (this.duration ^ (this.duration >>> 32)); return hash; } DurationFilter(); DurationFilter(final long records, final long duration); @Override boolean equals(final Object obj); boolean isIdle(); @Override int hashCode(); @SuppressWarnings("override") //JDK-6954234 boolean isLoggable(final LogRecord record); boolean isLoggable(); @Override String toString(); }### Answer:
@Test public void testHashCode() { DurationFilter one = new DurationFilter(10, 10); DurationFilter two = new DurationFilter(10, 10); DurationFilter three = new DurationFilter(3, 3); assertTrue(one.hashCode() == two.hashCode()); assertFalse(one.hashCode() == three.hashCode()); LogRecord r = new LogRecord(Level.INFO, ""); assertTrue(one.isLoggable(r)); assertTrue(one.hashCode() == two.hashCode()); assertFalse(one.hashCode() == three.hashCode()); } |
### Question:
Response { public String readAtom() { return readDelimString(ATOM_CHAR_DELIM); } Response(String s); Response(String s, boolean supportsUtf8); Response(Protocol p); Response(Response r); static Response byeResponse(Exception ex); boolean supportsUtf8(); void skipSpaces(); boolean isNextNonSpace(char c); void skipToken(); void skip(int count); byte peekByte(); byte readByte(); String readAtom(); String readString(char delim); String[] readStringList(); String[] readAtomStringList(); int readNumber(); long readLong(); String readString(); ByteArrayInputStream readBytes(); ByteArray readByteArray(); String readAtomString(); int getType(); boolean isContinuation(); boolean isTagged(); boolean isUnTagged(); boolean isOK(); boolean isNO(); boolean isBAD(); boolean isBYE(); boolean isSynthetic(); String getTag(); String getRest(); Exception getException(); void reset(); @Override String toString(); final static int TAG_MASK; final static int CONTINUATION; final static int TAGGED; final static int UNTAGGED; final static int TYPE_MASK; final static int OK; final static int NO; final static int BAD; final static int BYE; final static int SYNTHETIC; }### Answer:
@Test public void testAtom() throws Exception { for (String s : atomTests) { Response r = new Response("* " + s); assertEquals("atom", r.readAtom()); } for (String s : atomTests) { Response r = new Response("* " + s + " "); assertEquals("atom", r.readAtom()); } } |
### Question:
Response { public String readAtomString() { return (String)parseString(true, true); } Response(String s); Response(String s, boolean supportsUtf8); Response(Protocol p); Response(Response r); static Response byeResponse(Exception ex); boolean supportsUtf8(); void skipSpaces(); boolean isNextNonSpace(char c); void skipToken(); void skip(int count); byte peekByte(); byte readByte(); String readAtom(); String readString(char delim); String[] readStringList(); String[] readAtomStringList(); int readNumber(); long readLong(); String readString(); ByteArrayInputStream readBytes(); ByteArray readByteArray(); String readAtomString(); int getType(); boolean isContinuation(); boolean isTagged(); boolean isUnTagged(); boolean isOK(); boolean isNO(); boolean isBAD(); boolean isBYE(); boolean isSynthetic(); String getTag(); String getRest(); Exception getException(); void reset(); @Override String toString(); final static int TAG_MASK; final static int CONTINUATION; final static int TAGGED; final static int UNTAGGED; final static int TYPE_MASK; final static int OK; final static int NO; final static int BAD; final static int BYE; final static int SYNTHETIC; }### Answer:
@Test public void testAString() throws Exception { for (String s : astringTests) { Response r = new Response("* " + s); assertEquals("atom", r.readAtomString()); } for (String s : astringTests) { Response r = new Response("* " + s + " "); assertEquals("atom", r.readAtomString()); } }
@Test public void testAStringSpecial() throws Exception { Response r = new Response("* " + "atom] "); assertEquals("atom]", r.readAtomString()); } |
### Question:
Response { public String[] readStringList() { return readStringList(false); } Response(String s); Response(String s, boolean supportsUtf8); Response(Protocol p); Response(Response r); static Response byeResponse(Exception ex); boolean supportsUtf8(); void skipSpaces(); boolean isNextNonSpace(char c); void skipToken(); void skip(int count); byte peekByte(); byte readByte(); String readAtom(); String readString(char delim); String[] readStringList(); String[] readAtomStringList(); int readNumber(); long readLong(); String readString(); ByteArrayInputStream readBytes(); ByteArray readByteArray(); String readAtomString(); int getType(); boolean isContinuation(); boolean isTagged(); boolean isUnTagged(); boolean isOK(); boolean isNO(); boolean isBAD(); boolean isBYE(); boolean isSynthetic(); String getTag(); String getRest(); Exception getException(); void reset(); @Override String toString(); final static int TAG_MASK; final static int CONTINUATION; final static int TAGGED; final static int UNTAGGED; final static int TYPE_MASK; final static int OK; final static int NO; final static int BAD; final static int BYE; final static int SYNTHETIC; }### Answer:
@Test public void testBadStringList() throws Exception { Response response = new Response( "* (\"name\", \"test\", \"version\", \"1.0\")"); String[] list = response.readStringList(); } |
### Question:
Protocol { public String writeCommand(String command, Argument args) throws IOException, ProtocolException { String tag = tagPrefix + Integer.toString(tagCounter++); output.writeBytes(tag + " " + command); if (args != null) { output.write(' '); args.write(this); } output.write(CRLF); output.flush(); return tag; } Protocol(String host, int port,
Properties props, String prefix,
boolean isSSL, MailLogger logger); Protocol(InputStream in, PrintStream out, Properties props,
boolean debug); long getTimestamp(); void addResponseHandler(ResponseHandler h); void removeResponseHandler(ResponseHandler h); void notifyResponseHandlers(Response[] responses); Response readResponse(); boolean hasResponse(); String writeCommand(String command, Argument args); synchronized Response[] command(String command, Argument args); void handleResult(Response response); void simpleCommand(String cmd, Argument args); synchronized void startTLS(String cmd); synchronized void startCompression(String cmd); boolean isSSL(); InetAddress getInetAddress(); SocketChannel getChannel(); boolean supportsUtf8(); }### Answer:
@Test public void testTagPrefixReuse() throws IOException, ProtocolException { Properties props = new Properties(); props.setProperty("mail.imap.reusetagprefix", "true"); Protocol p = new Protocol(nullis, nullps, props, false); String tag = p.writeCommand("CMD", null); assertEquals("A0", tag); p = new Protocol(nullis, nullps, props, false); tag = p.writeCommand("CMD", null); assertEquals("A0", tag); } |
### Question:
ResponseInputStream { public ByteArray readResponse() throws IOException { return readResponse(null); } ResponseInputStream(InputStream in); ByteArray readResponse(); ByteArray readResponse(ByteArray ba); int available(); }### Answer:
@Test public void testEofWhileReadingLiteral() throws Exception { ByteArrayInputStream bis = new ByteArrayInputStream( "test{1}\r\n".getBytes("ISO-8859-1")); ResponseInputStream ris = new ResponseInputStream(bis); try { ris.readResponse(); } catch (IOException ex) { return; } fail("no exception"); } |
### Question:
ContentType { public boolean match(ContentType cType) { if (!((primaryType == null && cType.getPrimaryType() == null) || (primaryType != null && primaryType.equalsIgnoreCase(cType.getPrimaryType())))) return false; String sType = cType.getSubType(); if ((subType != null && subType.startsWith("*")) || (sType != null && sType.startsWith("*"))) return true; return (subType == null && sType == null) || (subType != null && subType.equalsIgnoreCase(sType)); } ContentType(); ContentType(String primaryType, String subType,
ParameterList list); ContentType(String s); String getPrimaryType(); String getSubType(); String getBaseType(); String getParameter(String name); ParameterList getParameterList(); void setPrimaryType(String primaryType); void setSubType(String subType); void setParameter(String name, String value); void setParameterList(ParameterList list); @Override String toString(); boolean match(ContentType cType); boolean match(String s); }### Answer:
@Test public void testMatch() throws Exception { ContentType empty = new ContentType(); assertFalse(empty.match("text/plain")); ContentType plain = new ContentType("text/plain"); assertTrue(plain.match("text/plain")); assertFalse(empty.match(plain)); assertFalse(plain.match(empty)); assertTrue(plain.match("text/*")); ContentType text = new ContentType("text/*"); assertTrue(text.match(plain)); assertTrue(plain.match(text)); } |
### Question:
MailDateFormat extends SimpleDateFormat { @Override public StringBuffer format(Date date, StringBuffer dateStrBuf, FieldPosition fieldPosition) { return super.format(date, dateStrBuf, fieldPosition); } MailDateFormat(); @Override MailDateFormat clone(); @Override StringBuffer format(Date date, StringBuffer dateStrBuf,
FieldPosition fieldPosition); @Override Date parse(String text, ParsePosition pos); @Override void setCalendar(Calendar newCalendar); @Override void setNumberFormat(NumberFormat newNumberFormat); @Override void applyLocalizedPattern(String pattern); @Override void applyPattern(String pattern); @Override Date get2DigitYearStart(); @Override void set2DigitYearStart(Date startDate); @Override void setDateFormatSymbols(DateFormatSymbols newFormatSymbols); }### Answer:
@Test() public void formatMustThrowNpeForNullArgs() { for (int mask = 0; mask < 7; mask++) { try { Date date = (mask & 1) == 1 ? new Date() : null; StringBuffer toAppendTo = (mask & 2) == 2 ? new StringBuffer() : null; FieldPosition pos = (mask & 4) == 4 ? new FieldPosition(0) : null; getDefault().format(date, toAppendTo, pos); fail("No NullPointerException thrown for mask = " + mask); } catch (NullPointerException e) { } } }
@Test public void mustUseTimeZoneForFormatting() { String input = "1 Jan 2015 00:00 +0100"; SimpleDateFormat fmt = getDefault(); Date date = mustPass(fmt, input); fmt.setTimeZone(TimeZone.getTimeZone("Etc/GMT+8")); assertThat(fmt.format(date), is("Wed, 31 Dec 2014 15:00:00 -0800 (GMT-08:00)")); } |
### Question:
MailDateFormat extends SimpleDateFormat { @Override public void setCalendar(Calendar newCalendar) { throw new UnsupportedOperationException("Method " + "setCalendar() shouldn't be called"); } MailDateFormat(); @Override MailDateFormat clone(); @Override StringBuffer format(Date date, StringBuffer dateStrBuf,
FieldPosition fieldPosition); @Override Date parse(String text, ParsePosition pos); @Override void setCalendar(Calendar newCalendar); @Override void setNumberFormat(NumberFormat newNumberFormat); @Override void applyLocalizedPattern(String pattern); @Override void applyPattern(String pattern); @Override Date get2DigitYearStart(); @Override void set2DigitYearStart(Date startDate); @Override void setDateFormatSymbols(DateFormatSymbols newFormatSymbols); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void mustProhibitSetCalendar() { getDefault().setCalendar(Calendar.getInstance()); } |
### Question:
MailDateFormat extends SimpleDateFormat { @Override public void setNumberFormat(NumberFormat newNumberFormat) { throw new UnsupportedOperationException("Method " + "setNumberFormat() shouldn't be called"); } MailDateFormat(); @Override MailDateFormat clone(); @Override StringBuffer format(Date date, StringBuffer dateStrBuf,
FieldPosition fieldPosition); @Override Date parse(String text, ParsePosition pos); @Override void setCalendar(Calendar newCalendar); @Override void setNumberFormat(NumberFormat newNumberFormat); @Override void applyLocalizedPattern(String pattern); @Override void applyPattern(String pattern); @Override Date get2DigitYearStart(); @Override void set2DigitYearStart(Date startDate); @Override void setDateFormatSymbols(DateFormatSymbols newFormatSymbols); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void mustProhibitSetNumberFormat() { getDefault().setNumberFormat(NumberFormat.getInstance()); } |
### Question:
MailDateFormat extends SimpleDateFormat { @Override public Date get2DigitYearStart() { throw new UnsupportedOperationException("Method " + "get2DigitYearStart() shouldn't be called"); } MailDateFormat(); @Override MailDateFormat clone(); @Override StringBuffer format(Date date, StringBuffer dateStrBuf,
FieldPosition fieldPosition); @Override Date parse(String text, ParsePosition pos); @Override void setCalendar(Calendar newCalendar); @Override void setNumberFormat(NumberFormat newNumberFormat); @Override void applyLocalizedPattern(String pattern); @Override void applyPattern(String pattern); @Override Date get2DigitYearStart(); @Override void set2DigitYearStart(Date startDate); @Override void setDateFormatSymbols(DateFormatSymbols newFormatSymbols); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void mustProhibitGet2DigitYearStart() { getDefault().get2DigitYearStart(); } |
### Question:
MailDateFormat extends SimpleDateFormat { @Override public void set2DigitYearStart(Date startDate) { throw new UnsupportedOperationException("Method " + "set2DigitYearStart() shouldn't be called"); } MailDateFormat(); @Override MailDateFormat clone(); @Override StringBuffer format(Date date, StringBuffer dateStrBuf,
FieldPosition fieldPosition); @Override Date parse(String text, ParsePosition pos); @Override void setCalendar(Calendar newCalendar); @Override void setNumberFormat(NumberFormat newNumberFormat); @Override void applyLocalizedPattern(String pattern); @Override void applyPattern(String pattern); @Override Date get2DigitYearStart(); @Override void set2DigitYearStart(Date startDate); @Override void setDateFormatSymbols(DateFormatSymbols newFormatSymbols); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void mustProhibitSet2DigitYearStart() { getDefault().set2DigitYearStart(new Date()); } |
### Question:
MailDateFormat extends SimpleDateFormat { @Override public void setDateFormatSymbols(DateFormatSymbols newFormatSymbols) { throw new UnsupportedOperationException("Method " + "setDateFormatSymbols() shouldn't be called"); } MailDateFormat(); @Override MailDateFormat clone(); @Override StringBuffer format(Date date, StringBuffer dateStrBuf,
FieldPosition fieldPosition); @Override Date parse(String text, ParsePosition pos); @Override void setCalendar(Calendar newCalendar); @Override void setNumberFormat(NumberFormat newNumberFormat); @Override void applyLocalizedPattern(String pattern); @Override void applyPattern(String pattern); @Override Date get2DigitYearStart(); @Override void set2DigitYearStart(Date startDate); @Override void setDateFormatSymbols(DateFormatSymbols newFormatSymbols); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void mustProhibitSetDateFormatSymbols() { SimpleDateFormat fmt = getStrict(); fmt.setDateFormatSymbols(new DateFormatSymbols(Locale.FRENCH)); Date date = mustPass(fmt, "1 Jan 2015 00:00:00 +0000"); assertThatDate(date, "jeu., 1 janv. 2015 00:00:00 +0000 (UTC)"); } |
### Question:
InternetHeaders { public String[] getHeader(String name) { Iterator<InternetHeader> e = headers.iterator(); List<String> v = new ArrayList<>(); while (e.hasNext()) { InternetHeader h = e.next(); if (name.equalsIgnoreCase(h.getName()) && h.line != null) { v.add(h.getValue()); } } if (v.size() == 0) return (null); String r[] = new String[v.size()]; r = v.toArray(r); return (r); } InternetHeaders(); InternetHeaders(InputStream is); InternetHeaders(InputStream is, boolean allowutf8); void load(InputStream is); void load(InputStream is, boolean allowutf8); String[] getHeader(String name); String getHeader(String name, String delimiter); void setHeader(String name, String value); void addHeader(String name, String value); void removeHeader(String name); Enumeration<Header> getAllHeaders(); Enumeration<Header> getMatchingHeaders(String[] names); Enumeration<Header> getNonMatchingHeaders(String[] names); void addHeaderLine(String line); Enumeration<String> getAllHeaderLines(); Enumeration<String> getMatchingHeaderLines(String[] names); Enumeration<String> getNonMatchingHeaderLines(String[] names); }### Answer:
@Test public void testContinuationLine() throws Exception { String header = "Subject: a\r\n b\r\n\r\n"; InternetHeaders ih = new InternetHeaders( new AsciiStringInputStream(header)); assertEquals(1, ih.getHeader("Subject").length); assertEquals("a\r\n b", ih.getHeader("Subject")[0]); } |
### Question:
InternetHeaders { public void load(InputStream is) throws MessagingException { load(is, false); } InternetHeaders(); InternetHeaders(InputStream is); InternetHeaders(InputStream is, boolean allowutf8); void load(InputStream is); void load(InputStream is, boolean allowutf8); String[] getHeader(String name); String getHeader(String name, String delimiter); void setHeader(String name, String value); void addHeader(String name, String value); void removeHeader(String name); Enumeration<Header> getAllHeaders(); Enumeration<Header> getMatchingHeaders(String[] names); Enumeration<Header> getNonMatchingHeaders(String[] names); void addHeaderLine(String line); Enumeration<String> getAllHeaderLines(); Enumeration<String> getMatchingHeaderLines(String[] names); Enumeration<String> getNonMatchingHeaderLines(String[] names); }### Answer:
@Test public void testInitialWhitespaceLineLoad() throws Exception { InternetHeaders ih = new InternetHeaders(); ih.load(new AsciiStringInputStream(initialWhitespaceHeader)); testInitialWhitespaceLine(ih); }
@Test public void testInitialContinuationLineLoad() throws Exception { InternetHeaders ih = new InternetHeaders(); ih.load(new AsciiStringInputStream(initialContinuationHeader)); testInitialContinuationLine(ih); } |
### Question:
URLName { public String getFile() { return file; } URLName(
String protocol,
String host,
int port,
String file,
String username,
String password
); URLName(URL url); URLName(String url); @Override String toString(); int getPort(); String getProtocol(); String getFile(); String getRef(); String getHost(); String getUsername(); String getPassword(); URL getURL(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer:
@Test public void testFile() throws Exception { URLName u = new URLName("http: assertEquals("file", u.getFile()); u = new URLName("http: assertEquals("file", u.getFile()); u = new URLName("http: assertEquals("", u.getFile()); u = new URLName("http: assertEquals(null, u.getFile()); u = new URLName("http: assertEquals(null, u.getFile()); } |
### Question:
LogManagerProperties extends Properties { @Override public synchronized Object get(final Object key) { Object value; if (key instanceof String) { value = getProperty((String) key); } else { value = null; } if (value == null) { value = defaults.get(key); if (value == null && !defaults.containsKey(key)) { value = super.get(key); } } return value; } LogManagerProperties(final Properties parent, final String prefix); @Override @SuppressWarnings("CloneDoesntCallSuperClone") synchronized Object clone(); @Override synchronized String getProperty(final String key); @Override String getProperty(final String key, final String def); @Override synchronized Object get(final Object key); @Override synchronized Object put(final Object key, final Object value); @Override Object setProperty(String key, String value); @Override synchronized boolean containsKey(final Object key); @Override synchronized Object remove(final Object key); @Override Enumeration<?> propertyNames(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test public void testGet() throws Exception { String prefix = LogManagerPropertiesTest.class.getName(); LogManager manager = LogManager.getLogManager(); try { String key = prefix.concat(".dummy"); Properties parent = new Properties(); parent.put(key, "value"); parent.put("", "empty"); read(manager, parent); parent = new Properties(); LogManagerProperties mp = new LogManagerProperties(parent, prefix); assertFalse(contains(mp, key, null)); assertEquals("value", mp.get(key)); assertTrue(contains(mp, key, "value")); parent.put(key, "newValue"); assertEquals("newValue", mp.get(key)); assertEquals("empty", mp.get("")); } finally { manager.reset(); } } |
### Question:
LogManagerProperties extends Properties { @Override public synchronized boolean containsKey(final Object key) { boolean found = key instanceof String && getProperty((String) key) != null; if (!found) { found = defaults.containsKey(key) || super.containsKey(key); } return found; } LogManagerProperties(final Properties parent, final String prefix); @Override @SuppressWarnings("CloneDoesntCallSuperClone") synchronized Object clone(); @Override synchronized String getProperty(final String key); @Override String getProperty(final String key, final String def); @Override synchronized Object get(final Object key); @Override synchronized Object put(final Object key, final Object value); @Override Object setProperty(String key, String value); @Override synchronized boolean containsKey(final Object key); @Override synchronized Object remove(final Object key); @Override Enumeration<?> propertyNames(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test public void testContainsKey() throws Exception { String prefix = LogManagerPropertiesTest.class.getName(); LogManager manager = LogManager.getLogManager(); try { String key = prefix.concat(".dummy"); Properties parent = new Properties(); parent.put(key, "value"); parent.put("", "empty"); read(manager, parent); parent = new Properties(); LogManagerProperties mp = new LogManagerProperties(parent, prefix); assertFalse(contains(mp, key, null)); assertTrue(mp.containsKey(key)); assertTrue(contains(mp, key, "value")); parent.put(key, "newValue"); assertEquals("newValue", mp.get(key)); assertTrue(mp.containsKey("")); } finally { manager.reset(); } } |
### Question:
LogManagerProperties extends Properties { @Override public synchronized Object remove(final Object key) { final Object def = preWrite(key); final Object man = super.remove(key); return man == null ? def : man; } LogManagerProperties(final Properties parent, final String prefix); @Override @SuppressWarnings("CloneDoesntCallSuperClone") synchronized Object clone(); @Override synchronized String getProperty(final String key); @Override String getProperty(final String key, final String def); @Override synchronized Object get(final Object key); @Override synchronized Object put(final Object key, final Object value); @Override Object setProperty(String key, String value); @Override synchronized boolean containsKey(final Object key); @Override synchronized Object remove(final Object key); @Override Enumeration<?> propertyNames(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test public void testRemove() throws Exception { String prefix = LogManagerPropertiesTest.class.getName(); LogManager manager = LogManager.getLogManager(); try { String key = prefix.concat(".dummy"); Properties parent = new Properties(); parent.put(key, "value"); parent.put("", "empty"); read(manager, parent); parent = new Properties(); LogManagerProperties mp = new LogManagerProperties(parent, prefix); assertFalse(contains(mp, key, null)); assertEquals("value", mp.remove(key)); assertFalse(contains(mp, key, "value")); parent.put(key, "newValue"); assertEquals("newValue", mp.remove(key)); assertEquals("empty", mp.remove("")); } finally { manager.reset(); } } |
### Question:
LogManagerProperties extends Properties { @Override public synchronized Object put(final Object key, final Object value) { if (key instanceof String && value instanceof String) { final Object def = preWrite(key); final Object man = super.put(key, value); return man == null ? def : man; } else { return super.put(key, value); } } LogManagerProperties(final Properties parent, final String prefix); @Override @SuppressWarnings("CloneDoesntCallSuperClone") synchronized Object clone(); @Override synchronized String getProperty(final String key); @Override String getProperty(final String key, final String def); @Override synchronized Object get(final Object key); @Override synchronized Object put(final Object key, final Object value); @Override Object setProperty(String key, String value); @Override synchronized boolean containsKey(final Object key); @Override synchronized Object remove(final Object key); @Override Enumeration<?> propertyNames(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test public void testPut() throws Exception { String prefix = LogManagerPropertiesTest.class.getName(); LogManager manager = LogManager.getLogManager(); try { String key = prefix.concat(".dummy"); Properties parent = new Properties(); parent.put(key, "value"); parent.put("", "empty"); read(manager, parent); parent = new Properties(); LogManagerProperties mp = new LogManagerProperties(parent, prefix); assertFalse(contains(mp, key, null)); assertEquals("value", mp.put(key, "newValue")); assertFalse(contains(mp, key, "value")); assertTrue(contains(mp, key, "newValue")); parent.put(key, "defValue"); assertEquals("newValue", mp.remove(key)); assertEquals("defValue", mp.remove(key)); assertEquals("empty", mp.put("", "")); } finally { manager.reset(); } } |
### Question:
LogManagerProperties extends Properties { @Override public Object setProperty(String key, String value) { return this.put(key, value); } LogManagerProperties(final Properties parent, final String prefix); @Override @SuppressWarnings("CloneDoesntCallSuperClone") synchronized Object clone(); @Override synchronized String getProperty(final String key); @Override String getProperty(final String key, final String def); @Override synchronized Object get(final Object key); @Override synchronized Object put(final Object key, final Object value); @Override Object setProperty(String key, String value); @Override synchronized boolean containsKey(final Object key); @Override synchronized Object remove(final Object key); @Override Enumeration<?> propertyNames(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test public void testSetProperty() throws Exception { String prefix = LogManagerPropertiesTest.class.getName(); LogManager manager = LogManager.getLogManager(); try { String key = prefix.concat(".dummy"); Properties parent = new Properties(); parent.put(key, "value"); parent.put("", "empty"); read(manager, parent); parent = new Properties(); LogManagerProperties mp = new LogManagerProperties(parent, prefix); assertFalse(contains(mp, key, null)); assertEquals("value", mp.setProperty(key, "newValue")); assertFalse(contains(mp, key, "value")); assertTrue(contains(mp, key, "newValue")); parent.put(key, "defValue"); assertEquals("newValue", mp.remove(key)); assertEquals("defValue", mp.remove(key)); assertEquals("empty", mp.setProperty("", "")); } finally { manager.reset(); } } |
### Question:
LogManagerProperties extends Properties { static Filter newFilter(String name) throws Exception { return newObjectFrom(name, Filter.class); } LogManagerProperties(final Properties parent, final String prefix); @Override @SuppressWarnings("CloneDoesntCallSuperClone") synchronized Object clone(); @Override synchronized String getProperty(final String key); @Override String getProperty(final String key, final String def); @Override synchronized Object get(final Object key); @Override synchronized Object put(final Object key, final Object value); @Override Object setProperty(String key, String value); @Override synchronized boolean containsKey(final Object key); @Override synchronized Object remove(final Object key); @Override Enumeration<?> propertyNames(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test public void testNewFilter() throws Exception { try { LogManagerProperties.newFilter(null); fail("Null was allowed."); } catch (NullPointerException expect) { } try { LogManagerProperties.newFilter(""); fail("Empty class was allowed."); } catch (ClassNotFoundException expect) { } try { LogManagerProperties.newFilter(Object.class.getName()); fail("Wrong type was allowed."); } catch (ClassCastException expect) { } final Class<?> type = ErrorFilter.class; final Filter f = LogManagerProperties.newFilter(type.getName()); assertEquals(type, f.getClass()); setPending(new RuntimeException()); try { LogManagerProperties.newFilter(type.getName()); fail("Exception was not thrown."); } catch (InvocationTargetException expect) { assertEquals(RuntimeException.class, expect.getCause().getClass()); } finally { setPending(null); } }
@Test public void testEscapingFilter() throws Exception { try { Class<?> k = ErrorFilter.class; Filter f; f = LogManagerProperties.newFilter(k.getName()); assertEquals(k, f.getClass()); setPending(new ThreadDeath()); try { f = LogManagerProperties.newFilter(k.getName()); fail(String.valueOf(f)); } catch (ThreadDeath expect) { } setPending(new OutOfMemoryError()); try { f = LogManagerProperties.newFilter(k.getName()); fail(String.valueOf(f)); } catch (OutOfMemoryError expect) { } } finally { setPending(null); } } |
### Question:
MailHandler extends Handler { public void postConstruct() { } MailHandler(); MailHandler(final int capacity); MailHandler(final Properties props); @Override boolean isLoggable(final LogRecord record); @Override void publish(final LogRecord record); void postConstruct(); void preDestroy(); void push(); @Override void flush(); @Override void close(); @Override void setLevel(final Level newLevel); @Override Level getLevel(); @Override ErrorManager getErrorManager(); @Override void setErrorManager(final ErrorManager em); @Override Filter getFilter(); @Override void setFilter(final Filter newFilter); @Override synchronized String getEncoding(); @Override void setEncoding(String encoding); @Override synchronized Formatter getFormatter(); @Override synchronized void setFormatter(Formatter newFormatter); final synchronized Level getPushLevel(); final synchronized void setPushLevel(final Level level); final synchronized Filter getPushFilter(); final synchronized void setPushFilter(final Filter filter); final synchronized Comparator<? super LogRecord> getComparator(); final synchronized void setComparator(Comparator<? super LogRecord> c); final synchronized int getCapacity(); final synchronized Authenticator getAuthenticator(); final void setAuthenticator(final Authenticator auth); final void setAuthenticator(final char... password); final void setMailProperties(Properties props); final Properties getMailProperties(); final Filter[] getAttachmentFilters(); final void setAttachmentFilters(Filter... filters); final Formatter[] getAttachmentFormatters(); final void setAttachmentFormatters(Formatter... formatters); final Formatter[] getAttachmentNames(); final void setAttachmentNames(final String... names); final void setAttachmentNames(Formatter... formatters); final synchronized Formatter getSubject(); final void setSubject(final String subject); final void setSubject(final Formatter format); }### Answer:
@Test public void testPostConstruct() { MailHandler instance = new MailHandler(createInitProperties("")); InternalErrorManager em = new InternalErrorManager(); instance.setErrorManager(em); instance.postConstruct(); assertEquals(true, em.exceptions.isEmpty()); instance.close(); } |
### Question:
PropUtil { public static boolean getBooleanProperty(Properties props, String name, boolean def) { return getBoolean(getProp(props, name), def); } private PropUtil(); static int getIntProperty(Properties props, String name, int def); static boolean getBooleanProperty(Properties props,
String name, boolean def); @Deprecated static int getIntSessionProperty(Session session,
String name, int def); @Deprecated static boolean getBooleanSessionProperty(Session session,
String name, boolean def); static boolean getBooleanSystemProperty(String name, boolean def); }### Answer:
@Test public void testBool() throws Exception { Properties props = new Properties(); props.setProperty("test", "true"); assertTrue(PropUtil.getBooleanProperty(props, "test", false)); }
@Test public void testBoolDef() throws Exception { Properties props = new Properties(); assertTrue(PropUtil.getBooleanProperty(props, "test", true)); }
@Test public void testBoolDefProp() throws Exception { Properties defprops = new Properties(); defprops.setProperty("test", "true"); Properties props = new Properties(defprops); assertTrue(PropUtil.getBooleanProperty(props, "test", false)); }
@Test public void testBoolean() throws Exception { Properties props = new Properties(); props.put("test", true); assertTrue(PropUtil.getBooleanProperty(props, "test", false)); } |
### Question:
SeverityComparator implements Comparator<LogRecord>, Serializable { public final int applyThenCompare(Throwable tc1, Throwable tc2) { return tc1 == tc2 ? 0 : compareThrowable(apply(tc1), apply(tc2)); } Throwable apply(final Throwable chain); final int applyThenCompare(Throwable tc1, Throwable tc2); int compareThrowable(final Throwable t1, final Throwable t2); @SuppressWarnings("override") //JDK-6954234 int compare(final LogRecord o1, final LogRecord o2); @Override boolean equals(final Object o); @Override int hashCode(); boolean isNormal(final Throwable t); }### Answer:
@Test public void testApplyThenCompareNull() { SeverityComparator a = new SeverityComparator(); assertEquals(0, a.applyThenCompare((Throwable) null, (Throwable) null)); } |
### Question:
SeverityComparator implements Comparator<LogRecord>, Serializable { static SeverityComparator getInstance() { return (SeverityComparator) INSTANCE; } Throwable apply(final Throwable chain); final int applyThenCompare(Throwable tc1, Throwable tc2); int compareThrowable(final Throwable t1, final Throwable t2); @SuppressWarnings("override") //JDK-6954234 int compare(final LogRecord o1, final LogRecord o2); @Override boolean equals(final Object o); @Override int hashCode(); boolean isNormal(final Throwable t); }### Answer:
@Test public void testGetInstance() { SeverityComparator a = new SeverityComparator(); assertEquals(a, SeverityComparator.getInstance()); assertEquals(a.getClass(), SeverityComparator.getInstance().getClass()); assertEquals(a.hashCode(), SeverityComparator.getInstance().hashCode()); } |
### Question:
SeverityComparator implements Comparator<LogRecord>, Serializable { @SuppressWarnings("override") public int compare(final LogRecord o1, final LogRecord o2) { if (o1 == null || o2 == null) { throw new NullPointerException(toString(o1, o2)); } if (o1 == o2) { return 0; } int cmp = compare(o1.getLevel(), o2.getLevel()); if (cmp == 0) { cmp = applyThenCompare(o1.getThrown(), o2.getThrown()); if (cmp == 0) { cmp = compare(o1.getSequenceNumber(), o2.getSequenceNumber()); if (cmp == 0) { cmp = compare(o1.getMillis(), o2.getMillis()); } } } return cmp; } Throwable apply(final Throwable chain); final int applyThenCompare(Throwable tc1, Throwable tc2); int compareThrowable(final Throwable t1, final Throwable t2); @SuppressWarnings("override") //JDK-6954234 int compare(final LogRecord o1, final LogRecord o2); @Override boolean equals(final Object o); @Override int hashCode(); boolean isNormal(final Throwable t); }### Answer:
@Test(expected = NullPointerException.class) public void testCompareNullAndNull() { SeverityComparator a = new SeverityComparator(); a.compare((LogRecord) null, (LogRecord) null); } |
### Question:
CompressionEncodingFilter implements EncodingFilter { @Override public boolean applyDecoding(final HttpHeader httpPacket) { if(! httpPacket.isRequest()) { return false; } assert httpPacket instanceof HttpRequestPacket; return canDecompressHttpRequest((HttpRequestPacket) httpPacket, compressionConfig, aliases); } CompressionEncodingFilter(final CompressionConfig compressionConfig,
final String[] aliases); CompressionEncodingFilter(CompressionModeI compressionMode,
int compressionMinSize,
String[] compressibleMimeTypes,
String[] noCompressionUserAgents,
String[] aliases); CompressionEncodingFilter(CompressionModeI compressionMode,
int compressionMinSize,
String[] compressibleMimeTypes,
String[] noCompressionUserAgents,
String[] aliases,
boolean enableDecompression); @Override boolean applyEncoding(final HttpHeader httpPacket); @Override boolean applyDecoding(final HttpHeader httpPacket); }### Answer:
@Test public void testContentEncodingProcessing() throws Exception { final CompressionEncodingFilter filter = new CompressionEncodingFilter(CompressionMode.ON, 1, new String[0], new String[0], new String[] {"gzip"}, true); HttpRequestPacket request = setContentEncoding( HttpRequestPacket.builder().method(Method.GET).protocol(Protocol.HTTP_1_1).uri("/").build(), "gzip"); assertTrue(filter.applyDecoding(request)); request = setContentEncoding( HttpRequestPacket.builder().method(Method.GET).protocol(Protocol.HTTP_1_1).uri("/").build(), "identity"); assertFalse(filter.applyDecoding(request)); request = HttpRequestPacket.builder().method(Method.GET).protocol(Protocol.HTTP_1_1).uri("/").build(); assertFalse(filter.applyDecoding(request)); } |
### Question:
CompositeBuffer implements Buffer { public abstract int bulk(BulkOperation operation); static CompositeBuffer newBuffer(); static CompositeBuffer newBuffer(final MemoryManager memoryManager); static CompositeBuffer newBuffer(final MemoryManager memoryManager,
final Buffer... buffers); static CompositeBuffer newBuffer(final MemoryManager memoryManager,
final Buffer[] buffers, final boolean isReadOnly); DisposeOrder disposeOrder(); CompositeBuffer disposeOrder(final DisposeOrder disposeOrder); abstract CompositeBuffer append(Buffer buffer); @Override abstract CompositeBuffer prepend(Buffer buffer); @Override abstract Object[] underlying(); abstract void removeAll(); abstract void allowInternalBuffersDispose(boolean allow); abstract boolean allowInternalBuffersDispose(); abstract int bulk(BulkOperation operation); abstract int bulk(BulkOperation operation, int position, int limit); abstract boolean replace(Buffer oldBuffer, Buffer newBuffer); }### Answer:
@Test public void testBulk() { final Charset ascii = Charset.forName("ASCII"); final CompositeBuffer composite = CompositeBuffer.newBuffer( mm, Buffers.wrap(mm, "hello", ascii), Buffers.wrap(mm, " world", ascii)); composite.bulk(new CompositeBuffer.BulkOperation() { @Override public boolean processByte(byte value, final Setter setter) { setter.set((byte) Character.toUpperCase(value)); return false; } }); assertEquals("HELLO WORLD", composite.toStringContent(ascii)); } |
### Question:
AbstractSupplier implements Observer, Supplier<T> { @Override public void onResume() { this.logger().log(Level.INFO, "On Resume"); dataManager().addObserver(this); this.logger().log(Level.INFO, "Syncstatus: " + this.dataManager().getSyncStatus()); switch (dataManager().getSyncStatus()) { case NOT_SYNCED: this.dataManager().sync(); break; case SYNCED: onSavingsUpdated(); break; default: } } @Override List<T> getAll(); @Override void onResume(); @Override void addDataListeningObject(DataListening observer); @Override void deregister(DataListening observer); @Override void onPause(); @Override void update(Observable observable, Object o); }### Answer:
@Test public void teste_onResume_withSyncedDataManager_shouldNotCallSync() { StubbedDataManager dataManager = new StubbedDataManager(); dataManager.setStatus(SyncStatus.SYNCED); FullfilledSupplier componenet_under_test = new FullfilledSupplier(dataManager); componenet_under_test.onResume(); assertThat(dataManager.syncCalled()).isZero(); } |
### Question:
OneDayFilter implements Filter<Transaction> { @Override public boolean shouldBeRemoved(Transaction t) { return getZeroTimeDate(t.booking().getDate()).compareTo(this.day) != 0; } OneDayFilter(Date day); @Override boolean shouldBeRemoved(Transaction t); }### Answer:
@Test public void teste_filter_withNotMatchingDay_shouldReturnLeave() throws Exception { SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy"); Date expectedDate = sdf.parse("11/07/2017"); Date bookingDate = sdf.parse("12/07/2017"); Booking booking = new Booking(); booking.setDate(bookingDate); Transaction testTransaction = new Transaction("someBank", "some bank id", booking); Filter component_under_test = new OneDayFilter(expectedDate); assertThat(component_under_test.shouldBeRemoved(testTransaction)).isTrue(); }
@Test public void teste_filter_withMatchingDay_shouldReturnStay() throws Exception { SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy"); Date expectedDate = sdf.parse("11/07/2017"); Date bookingDate = sdf.parse("11/07/2017"); Booking booking = new Booking(); booking.setDate(bookingDate); Transaction testTransaction = new Transaction("someBank", "some bank id", booking); Filter component_under_test = new OneDayFilter(expectedDate); assertThat(component_under_test.shouldBeRemoved(testTransaction)).isFalse(); } |
### Question:
ItemCheckedMap implements Filter<Transaction> { public boolean hasItemsChecked() { Boolean ret = false; Iterator iterator = this.map.entrySet().iterator(); while (iterator.hasNext() && !ret) { Map.Entry entry = (Map.Entry) iterator.next(); ret = (Boolean) entry.getValue(); } return ret; } ItemCheckedMap(HashMap<String, Boolean> map); boolean hasItemsChecked(); boolean shouldBePresented(String bankAccountID); void update(Map<String, Boolean> map); @Override boolean shouldBeRemoved(Transaction t); }### Answer:
@Test public void teste_hasItemsChecked_withEmptyMap_shouldReturnFalse() { ItemCheckedMap component_under_test = new ItemCheckedMap(new HashMap<String, Boolean>()); assertThat(component_under_test.hasItemsChecked()).isFalse(); }
@Test public void teste_hasItemsChecked_withFilledMapAndNothingChecked_shouldReturnFalse() { HashMap<String, Boolean> data = new HashMap<>(); data.put("test1", false); ItemCheckedMap component_under_test = new ItemCheckedMap(data); assertThat(component_under_test.hasItemsChecked()).isFalse(); }
@Test public void teste_hasItemsChecked_withMapwithCheckedItem_shouldReturnTrue() { HashMap<String, Boolean> data = new HashMap<>(); data.put("test1", true); ItemCheckedMap component_under_test = new ItemCheckedMap(data); assertThat(component_under_test.hasItemsChecked()).isTrue(); } |
### Question:
ItemCheckedMap implements Filter<Transaction> { public boolean shouldBePresented(String bankAccountID) { return this.map.containsKey(bankAccountID) && this.map.get(bankAccountID).booleanValue(); } ItemCheckedMap(HashMap<String, Boolean> map); boolean hasItemsChecked(); boolean shouldBePresented(String bankAccountID); void update(Map<String, Boolean> map); @Override boolean shouldBeRemoved(Transaction t); }### Answer:
@Test public void teste_shouldBePresented_withNoKeyInMap_shouldReturnFalse() { HashMap<String, Boolean> data = new HashMap<>(); data.put("test2", true); ItemCheckedMap component_under_test = new ItemCheckedMap(data); assertThat(component_under_test.shouldBePresented("test1")).isFalse(); }
@Test public void teste_shouldBePresented_withKeyInMapButValueIsFalse_shouldReturnFalse() { HashMap<String, Boolean> data = new HashMap<>(); data.put("test1", false); ItemCheckedMap component_under_test = new ItemCheckedMap(data); assertThat(component_under_test.shouldBePresented("test1")).isFalse(); }
@Test public void teste_shouldBePresented_withWithKeyInMapAndValueTrue_shouldReturnTrue() { HashMap<String, Boolean> data = new HashMap<>(); data.put("test1", true); ItemCheckedMap component_under_test = new ItemCheckedMap(data); assertThat(component_under_test.shouldBePresented("test1")).isTrue(); } |
### Question:
ItemCheckedMap implements Filter<Transaction> { @Override public boolean shouldBeRemoved(Transaction t) { if (this.map.isEmpty()) { return false; } boolean shouldStay = shouldBePresented(t.bankAccountID()); return !shouldStay; } ItemCheckedMap(HashMap<String, Boolean> map); boolean hasItemsChecked(); boolean shouldBePresented(String bankAccountID); void update(Map<String, Boolean> map); @Override boolean shouldBeRemoved(Transaction t); }### Answer:
@Test public void teste_shouldBeRemoved_withWithKeyInMapAndValueTrue_shouldReturnFalse() { HashMap<String, Boolean> data = new HashMap<>(); data.put("test1", true); ItemCheckedMap component_under_test = new ItemCheckedMap(data); assertThat(component_under_test.shouldBeRemoved(new Transaction(null, "test1", null))).isFalse(); }
@Test public void teste_shouldBeRemoved_withWithKeyInMapAndValueFalse_shouldReturnTrue() { HashMap<String, Boolean> data = new HashMap<>(); data.put("test1", false); ItemCheckedMap component_under_test = new ItemCheckedMap(data); assertThat(component_under_test.shouldBeRemoved(new Transaction(null, "test1", null))).isTrue(); }
@Test public void teste_shouldBeRemoved_withNoData_shouldReturnFalse() { ItemCheckedMap component_under_test = new ItemCheckedMap(new HashMap<String, Boolean>()); assertThat(component_under_test.shouldBeRemoved(new Transaction(null, "test1", null))).isFalse(); } |
### Question:
AbstractSupplier implements Observer, Supplier<T> { @Override public void addDataListeningObject(DataListening observer) { if (this.dataListenings.isEmpty()) { this.dataManager().addObserver(this); } this.dataListenings.add(observer); } @Override List<T> getAll(); @Override void onResume(); @Override void addDataListeningObject(DataListening observer); @Override void deregister(DataListening observer); @Override void onPause(); @Override void update(Observable observable, Object o); }### Answer:
@Test public void teste_addDataListening_shouldRegisterItselfOnDataManager() { StubbedDataManager dataManager = new StubbedDataManager(); FullfilledSupplier componenet_under_test = new FullfilledSupplier(dataManager); DummyDataListening dataListening = new DummyDataListening(); componenet_under_test.addDataListeningObject(dataListening); assertThat(dataManager.observers()).containsExactly(componenet_under_test); } |
### Question:
BankingDateInformation { public double getAmountDelta() { double amountDelta = 0.0; for (Transaction transaction : this.transactionSupplier.getAll()) { amountDelta += transaction.booking().getAmount(); } return amountDelta; } BankingDateInformation(double amount, Supplier<Transaction> transactionSupplier); double getAmount(); double getAmountDelta(); Supplier<Transaction> getTransactionSuppllier(); }### Answer:
@Test public void getAmountDelta_noBookings() { double amount = 123.456; BankingDateInformation bankingDateInformation = new BankingDateInformation(amount, new StubbedBankTransactionSupplier()); assertThat(bankingDateInformation.getAmountDelta()).isZero(); }
@Test public void getAmountDelta_bookings() { double amount = 123.456; double amount1 = 500.00; double amount2 = -100.00; Booking booking1 = new Booking(new Date(), amount1); Transaction transaction1 = new Transaction("some name","some id",booking1); Booking booking2 = new Booking(new Date(), amount2); Transaction transaction2 = new Transaction("some name","some id",booking2); BankingDateInformation bankingDateInformation = new BankingDateInformation(amount, new StubbedBankTransactionSupplier(transaction1, transaction2)); assertThat(bankingDateInformation.getAmountDelta()).isEqualTo(amount1+amount2); } |
### Question:
SavingsComparator implements Comparator<SavingsAccount> { @Override public int compare(SavingsAccount t1, SavingsAccount t2) { return t1.getFinaldate().compareTo(t2.getFinaldate()); } @Override int compare(SavingsAccount t1, SavingsAccount t2); }### Answer:
@Test public void teste_compare_withEqualSavings_shouldReturnZero() { SavingsComparator component_under_test = new SavingsComparator(); SavingsAccount account = new SavingsAccount(123, "some anme", 10, 0, any(), any()); assertThat(component_under_test.compare(account, account)).isEqualTo(0); }
@Test public void teste_compare_firstDateLaterThenSecond_shouldReturnOne() throws Exception { SavingsComparator component_under_test = new SavingsComparator(); SavingsAccount earlyAccount = new SavingsAccount(123, "some anme", 10, 0, toDate("10/10/16"), any()); SavingsAccount lateAccount = new SavingsAccount(123, "some anme", 10, 0, toDate("10/10/17"), any()); assertThat(component_under_test.compare(lateAccount, earlyAccount)).isEqualTo(1); }
@Test public void teste_compare_firstDateBeforeThenSecond_shouldReturnMinusOne() throws Exception { SavingsComparator component_under_test = new SavingsComparator(); SavingsAccount earlyAccount = new SavingsAccount(123, "some anme", 10, 0, toDate("10/10/16"), any()); SavingsAccount lateAccount = new SavingsAccount(123, "some anme", 10, 0, toDate("10/10/17"), any()); assertThat(component_under_test.compare(earlyAccount, lateAccount)).isEqualTo(-1); } |
### Question:
BankingApiFacade { public List<BankAccessBankingModel> getBankAccesses(final String userId) throws BankingException { return binder.getBankAccessEndpoint(userId).getBankAccesses(); } @Autowired BankingApiFacade(final BankingApiBinder binder); protected BankingApiFacade(); List<BankAccessBankingModel> getBankAccesses(final String userId); List<BankAccountBankingModel> getBankAccounts(final String userId, final String bankAccessId); List<BookingModel> syncBankAccount(final String userId, final String bankAccessId, final String bankAccountId, final String pin); BankAccessBankingModel addBankAccess(final String userId, final BankAccessBankingModel bankAccess); }### Answer:
@Test public void getAccessesBinderCalled() { DummyBankAccessEndpoint endpoint = mock(DummyBankAccessEndpoint.class); when(bankingApiBinder.getBankAccessEndpoint(anyString())).thenReturn(endpoint); BankingApiFacade bankingApiFacade = new BankingApiFacade(bankingApiBinder); try { bankingApiFacade.getBankAccesses("test"); } catch (BankingException ex) { fail("An Banking Exception was thrown! " + ex.getMessage()); } Mockito.verify(bankingApiBinder, times(1)).getBankAccessEndpoint(anyString()); } |
### Question:
BankingApiFacade { public List<BankAccountBankingModel> getBankAccounts(final String userId, final String bankAccessId) throws BankingException { return binder.getBankAccountEndpoint(userId).getBankAccounts(bankAccessId); } @Autowired BankingApiFacade(final BankingApiBinder binder); protected BankingApiFacade(); List<BankAccessBankingModel> getBankAccesses(final String userId); List<BankAccountBankingModel> getBankAccounts(final String userId, final String bankAccessId); List<BookingModel> syncBankAccount(final String userId, final String bankAccessId, final String bankAccountId, final String pin); BankAccessBankingModel addBankAccess(final String userId, final BankAccessBankingModel bankAccess); }### Answer:
@Test public void getAccountsBinderCalled() { DummyBankAccountEndpoint endpoint = mock(DummyBankAccountEndpoint.class); when(bankingApiBinder.getBankAccountEndpoint(anyString())).thenReturn(endpoint); BankingApiFacade bankingApiFacade = new BankingApiFacade(bankingApiBinder); try { bankingApiFacade.getBankAccounts("test", "test"); } catch (BankingException ex) { fail("An Banking Exception was thrown! " + ex.getMessage()); } Mockito.verify(bankingApiBinder, times(1)).getBankAccountEndpoint(anyString()); } |
### Question:
BankingApiFacade { public List<BookingModel> syncBankAccount(final String userId, final String bankAccessId, final String bankAccountId, final String pin) throws BankingException { return binder.getBankAccountEndpoint(userId).syncBankAccount(bankAccessId, bankAccountId, pin); } @Autowired BankingApiFacade(final BankingApiBinder binder); protected BankingApiFacade(); List<BankAccessBankingModel> getBankAccesses(final String userId); List<BankAccountBankingModel> getBankAccounts(final String userId, final String bankAccessId); List<BookingModel> syncBankAccount(final String userId, final String bankAccessId, final String bankAccountId, final String pin); BankAccessBankingModel addBankAccess(final String userId, final BankAccessBankingModel bankAccess); }### Answer:
@Test public void syncAccountBinderCalled() { DummyBankAccountEndpoint endpoint = mock(DummyBankAccountEndpoint.class); when(bankingApiBinder.getBankAccountEndpoint(anyString())).thenReturn(endpoint); BankingApiFacade bankingApiFacade = new BankingApiFacade(bankingApiBinder); try { bankingApiFacade.syncBankAccount("test", "test", "test", "test"); } catch (BankingException ex) { fail("An Banking Exception was thrown! " + ex.getMessage()); } Mockito.verify(bankingApiBinder, times(1)).getBankAccountEndpoint(anyString()); } |
### Question:
AbstractDataManager extends Observable implements DataManager<T> { @Override public SyncStatus getSyncStatus() { return syncStatus; } AbstractDataManager(DataProvider<T> dataProvider); @Override void sync(); @Override SyncStatus getSyncStatus(); @Override List<T> getAll(); @Override void add(final T element, final ServerCallStatusHandler handler); @Override void delete(final T element, final ServerCallStatusHandler handler); }### Answer:
@Test public void test_initialState_isNotInSync(){ FullfilledDataManager component_under_test = new FullfilledDataManager(new StubbedSavingsProvider()); assertThat(component_under_test.getSyncStatus()).isEqualTo(SyncStatus.NOT_SYNCED); } |
### Question:
DummyBankAccountEndpoint implements BankAccountEndpoint { @Override public List<BookingModel> syncBankAccount(String bankAccessId, String bankAccountId, String pin) throws BankingException { if (!bookingModelMap.containsKey(bankAccountId)) { generateDummyBookingModels(bankAccountId); updateAccountBalance(bankAccountId); } return bookingModelMap.get(bankAccountId); } @Autowired DummyBankAccountEndpoint(DummyBankAccountBankingModelRepository bankAccountBankingModelRepository, DummyBankAccessEndpointRepository bankAccessEndpointRepository, @Qualifier("dummy") DummyBankAccessEndpoint dummyBankAccessEndpoint); protected DummyBankAccountEndpoint(); @Override List<BankAccountBankingModel> getBankAccounts(String bankingAccessId); @Override List<BookingModel> syncBankAccount(String bankAccessId, String bankAccountId, String pin); }### Answer:
@Test public void syncBankAccountsAccountsNotExist() throws Exception { String testUserId = "userId"; DummyBankAccessEndpoint dummyBankAccessEndpoint = mock(DummyBankAccessEndpoint.class); DummyBankAccountBankingModelRepository dummyBankAccountBankingModelRepository = mock(DummyBankAccountBankingModelRepository.class); DummyBankAccessEndpointRepository dummyBankAccessEndpointRepository = mock(DummyBankAccessEndpointRepository.class); DummyBankAccountEndpoint dummyBankAccountEndpoint = new DummyBankAccountEndpoint(dummyBankAccountBankingModelRepository, dummyBankAccessEndpointRepository, dummyBankAccessEndpoint); List<BookingModel> bookings = dummyBankAccountEndpoint.syncBankAccount( "bankAccessId", "bankAccountId", "pin"); assertNotNull(bookings); assertTrue(bookings.size() >= 0); } |
### Question:
BankingApiBinder { BankAccountEndpoint getBankAccountEndpoint(final String userId) { return isTestUser(userId) ? dummyBankAccountEndpoint : httpBankAccountEndpoint; } @Autowired BankingApiBinder(final BankingApiConfiguration bankingApiConfiguration,
@Qualifier("default") final BankAccessEndpoint httpBankAccessEndpoint,
@Qualifier("dummy") final BankAccessEndpoint dummyBankAccessEndpoint,
@Qualifier("default") final BankAccountEndpoint httpBankAccountEndpoint,
@Qualifier("dummy") final BankAccountEndpoint dummyBankAccountEndpoint); protected BankingApiBinder(); }### Answer:
@Test public void getBankAccountEndpointDummy() { String username = "[email protected]"; BankingApiBinder bankingApiBinder = new BankingApiBinder(this.bankingApiConfiguration, null, null, new HttpBankAccountEndpoint(null, null), new DummyBankAccountEndpoint(null, null, null)); BankAccountEndpoint endpoint = bankingApiBinder.getBankAccountEndpoint(username); Assert.assertNotNull(endpoint); Assert.assertTrue(endpoint instanceof DummyBankAccountEndpoint); verify(bankingApiConfiguration, times(1)).getTestUserNames(); }
@Test public void getBankAccountEndpointHttp() { String username = "[email protected]"; BankingApiBinder bankingApiBinder = new BankingApiBinder(this.bankingApiConfiguration, null, null, new HttpBankAccountEndpoint(null, null), new DummyBankAccountEndpoint(null, null, null)); BankAccountEndpoint endpoint = bankingApiBinder.getBankAccountEndpoint(username); Assert.assertNotNull(endpoint); Assert.assertTrue(endpoint instanceof HttpBankAccountEndpoint); verify(bankingApiConfiguration, times(1)).getTestUserNames(); } |
### Question:
BankingApiBinder { BankAccessEndpoint getBankAccessEndpoint(final String userId) { return isTestUser(userId) ? dummyBankAccessEndpoint : httpBankAccessEndpoint; } @Autowired BankingApiBinder(final BankingApiConfiguration bankingApiConfiguration,
@Qualifier("default") final BankAccessEndpoint httpBankAccessEndpoint,
@Qualifier("dummy") final BankAccessEndpoint dummyBankAccessEndpoint,
@Qualifier("default") final BankAccountEndpoint httpBankAccountEndpoint,
@Qualifier("dummy") final BankAccountEndpoint dummyBankAccountEndpoint); protected BankingApiBinder(); }### Answer:
@Test public void getBankAccessEndpointDummy() { String username = "[email protected]"; BankingApiBinder bankingApiBinder = new BankingApiBinder(this.bankingApiConfiguration, new HttpBankAccessEndpoint(null, null), new DummyBankAccessEndpoint(), null, null); BankAccessEndpoint endpoint = bankingApiBinder.getBankAccessEndpoint(username); Assert.assertNotNull(endpoint); Assert.assertTrue(endpoint instanceof DummyBankAccessEndpoint); verify(bankingApiConfiguration, times(1)).getTestUserNames(); }
@Test public void getBankAccessEndpointHttp() { String username = "[email protected]"; BankingApiBinder bankingApiBinder = new BankingApiBinder(this.bankingApiConfiguration, new HttpBankAccessEndpoint(null, null), new DummyBankAccessEndpoint(), null, null); BankAccessEndpoint endpoint = bankingApiBinder.getBankAccessEndpoint(username); Assert.assertNotNull(endpoint); Assert.assertTrue(endpoint instanceof HttpBankAccessEndpoint); verify(bankingApiConfiguration, times(1)).getTestUserNames(); } |
### Question:
DummyBankAccessEndpoint implements BankAccessEndpoint { @Override public BankAccessBankingModel addBankAccess(BankAccessBankingModel bankAccess) throws BankingException { BankAccessBankingModel bankAccessBankingModel = new BankAccessBankingModel(); bankAccessBankingModel.setId("TestID" + number + "_" + System.nanoTime()); bankAccessBankingModel.setBankLogin(bankAccess.getBankLogin()); bankAccessBankingModel.setBankCode(bankAccess.getBankCode()); bankAccessBankingModel.setBankName("TestBank" + number); bankAccessBankingModel.setPin(null); bankAccessBankingModel.setPassportState("testPassportState"); bankAccessEndpointRepository.save(new DummyBankAccessBankingModelEntity(bankAccessBankingModel)); number++; return bankAccessBankingModel; } DummyBankAccessEndpoint(DummyBankAccessEndpointRepository bankAccessEndpointRepository); DummyBankAccessEndpoint(); @Override List<BankAccessBankingModel> getBankAccesses(); @Override BankAccessBankingModel addBankAccess(BankAccessBankingModel bankAccess); boolean existsBankAccess(String bankAccessId); }### Answer:
@Test public void addRepositoryCalled() throws Exception { String testUser = "user"; String testBankCode = "testCode"; String testBankLogin = "testLogin"; BankAccessBankingModel bankAccessBankingModel = new BankAccessBankingModel(); bankAccessBankingModel.setUserId(testUser); bankAccessBankingModel.setBankLogin(testBankLogin); bankAccessBankingModel.setBankCode(testBankCode); DummyBankAccessEndpointRepository dummyBankAccessEndpointRepository = mock(DummyBankAccessEndpointRepository.class); DummyBankAccessEndpoint dummyBankAccessEndpoint = new DummyBankAccessEndpoint(dummyBankAccessEndpointRepository); dummyBankAccessEndpoint.addBankAccess(bankAccessBankingModel); verify(dummyBankAccessEndpointRepository, times(1)).save(any(DummyBankAccessBankingModelEntity.class)); } |
### Question:
DummyBankAccessEndpoint implements BankAccessEndpoint { public boolean existsBankAccess(String bankAccessId) { return bankAccessEndpointRepository.exists(bankAccessId); } DummyBankAccessEndpoint(DummyBankAccessEndpointRepository bankAccessEndpointRepository); DummyBankAccessEndpoint(); @Override List<BankAccessBankingModel> getBankAccesses(); @Override BankAccessBankingModel addBankAccess(BankAccessBankingModel bankAccess); boolean existsBankAccess(String bankAccessId); }### Answer:
@Test public void existsRepositoryCalled() throws Exception { String testId = "test"; DummyBankAccessEndpointRepository dummyBankAccessEndpointRepository = mock(DummyBankAccessEndpointRepository.class); when(dummyBankAccessEndpointRepository.exists(anyString())).thenReturn(true); DummyBankAccessEndpoint dummyBankAccessEndpoint = new DummyBankAccessEndpoint(dummyBankAccessEndpointRepository); boolean existsPreChange = dummyBankAccessEndpoint.existsBankAccess(testId); verify(dummyBankAccessEndpointRepository, times(1)).exists(anyString()); } |
### Question:
DummyBankAccessEndpoint implements BankAccessEndpoint { @Override public List<BankAccessBankingModel> getBankAccesses() throws BankingException { List<DummyBankAccessBankingModelEntity> dummyBankAccessBankingModelEntities = bankAccessEndpointRepository.findAll(); List<BankAccessBankingModel> bankAccessBankingModelList = new ArrayList<>(); for (DummyBankAccessBankingModelEntity dummyBankAccessBankingModelEntity : dummyBankAccessBankingModelEntities) { bankAccessBankingModelList.add(dummyBankAccessBankingModelEntity.transformToBankAccessBankingModel()); } return bankAccessBankingModelList; } DummyBankAccessEndpoint(DummyBankAccessEndpointRepository bankAccessEndpointRepository); DummyBankAccessEndpoint(); @Override List<BankAccessBankingModel> getBankAccesses(); @Override BankAccessBankingModel addBankAccess(BankAccessBankingModel bankAccess); boolean existsBankAccess(String bankAccessId); }### Answer:
@Test public void getRepositoryCalled() throws Exception { String testId = "test"; DummyBankAccessEndpointRepository dummyBankAccessEndpointRepository = mock(DummyBankAccessEndpointRepository.class); when(dummyBankAccessEndpointRepository.findAll()).thenReturn(new ArrayList<DummyBankAccessBankingModelEntity>()); DummyBankAccessEndpoint dummyBankAccessEndpoint = new DummyBankAccessEndpoint(dummyBankAccessEndpointRepository); List<BankAccessBankingModel> bankAccessBankingModelList = dummyBankAccessEndpoint.getBankAccesses(); verify(dummyBankAccessEndpointRepository, times(1)).findAll(); } |
### Question:
AbstractDataManager extends Observable implements DataManager<T> { @Override public void add(final T element, final ServerCallStatusHandler handler) { logger().info("Adding element: " + element); Consumer<StringApiModel> onNext = new Consumer<StringApiModel>() { @Override public void accept(@NonNull final StringApiModel s) throws Exception { handler.onOk(); AbstractDataManager.this.sync(); } }; subscribe(handler, onNext, dataProvider.add(element)); } AbstractDataManager(DataProvider<T> dataProvider); @Override void sync(); @Override SyncStatus getSyncStatus(); @Override List<T> getAll(); @Override void add(final T element, final ServerCallStatusHandler handler); @Override void delete(final T element, final ServerCallStatusHandler handler); }### Answer:
@Test public void test_add_shouldAddItemOnDataProvider() throws Exception{ StubbedSavingsProvider dataProvider = new StubbedSavingsProvider(); FullfilledDataManager component_under_test = new FullfilledDataManager(dataProvider); SavingsAccount savingsAccount = new SavingsAccount(); component_under_test.add(savingsAccount, null); assertThat(dataProvider.accounts()).containsExactly(savingsAccount); } |
### Question:
AuthenticationController { public String register(User user) throws VirtualLedgerAuthenticationException, UserAlreadyExistsException { if (user == null || user.getEmail() == null || user.getFirstName() == null || user.getLastName() == null) { throw new VirtualLedgerAuthenticationException( "Please check your inserts! At least one was not formatted correctly!"); } if (this.userRepository.existsUserWithEmail(user.getEmail())) { throw new UserAlreadyExistsException(); } this.userRepository.save(user); return "You were registered! " + user.getEmail(); } @Autowired AuthenticationController(UserRepository userRepository); protected AuthenticationController(); String register(User user); }### Answer:
@Test(expected = UserAlreadyExistsException.class) public void testRegisterWithExistingUserShouldThrowException() throws Exception { UserRepository userRepositoryMock = mock(UserRepository.class); when(userRepositoryMock.existsUserWithEmail(someEmail())).thenReturn(Boolean.TRUE); AuthenticationController componentUnderTest = new AuthenticationController(userRepositoryMock); User user = getValidUserCredential(); user.setEmail(someEmail()); componentUnderTest.register(user); }
@Test public void testRegisterWithValidUserShouldRegister() throws Exception { UserRepository userRepositoryMock = mock(UserRepository.class); AuthenticationController componentUnderTest = new AuthenticationController(userRepositoryMock); String result = componentUnderTest.register(getValidUserCredential()); assertThat(result).isEqualTo("You were registered! [email protected]"); } |
### Question:
StringApiModelFactory { public StringApiModel createStringApiModel(String string) { StringApiModel stringApiModel = new StringApiModel(); stringApiModel.setData(string); return stringApiModel; } StringApiModel createStringApiModel(String string); }### Answer:
@Test public void createSuccessful() { String testString = "test"; StringApiModel stringApiModel = stringApiModelFactory.createStringApiModel(testString); Assert.assertNotNull(stringApiModel); Assert.assertEquals(testString, stringApiModel.getData()); } |
### Question:
AbstractDataManager extends Observable implements DataManager<T> { @Override public List<T> getAll() throws SyncFailedException { if (syncFailedException != null) throw syncFailedException; if (syncStatus != SYNCED) throw new IllegalStateException("Sync not completed"); logger().info("Number items synct: " + this.allCachedItems.size()); return new LinkedList<>(allCachedItems); } AbstractDataManager(DataProvider<T> dataProvider); @Override void sync(); @Override SyncStatus getSyncStatus(); @Override List<T> getAll(); @Override void add(final T element, final ServerCallStatusHandler handler); @Override void delete(final T element, final ServerCallStatusHandler handler); }### Answer:
@Test(expected = IllegalStateException.class) public void test_initialState_get_shouldThrowIllegalArgumentException() throws Exception{ FullfilledDataManager component_under_test = new FullfilledDataManager(new StubbedSavingsProvider()); component_under_test.getAll(); } |
### Question:
BankAccessFactory { public BankAccess createBankAccess(BankAccessBankingModel bankingModel) { BankAccess bankAccess = new BankAccess(bankingModel.getId(), bankingModel.getBankName(), bankingModel.getBankCode(), bankingModel.getBankLogin()); return bankAccess; } BankAccess createBankAccess(BankAccessBankingModel bankingModel); List<BankAccess> createBankAccesses(List<BankAccessBankingModel> bankingModelList); }### Answer:
@Test public void createSuccess() { String accessId = "accessID"; String bankName = "bankName"; String bankCode = "bankCode"; String bankLogin = "bankLogin"; BankAccessBankingModel bankAccessBankingModel = new BankAccessBankingModel(); bankAccessBankingModel.setBankName(bankName); bankAccessBankingModel.setBankCode(bankCode); bankAccessBankingModel.setBankLogin(bankLogin); bankAccessBankingModel.setId(accessId); BankAccess bankAccess = bankAccessFactory.createBankAccess(bankAccessBankingModel); Assert.assertNotNull(bankAccess); Assert.assertEquals(accessId, bankAccess.getId()); Assert.assertEquals(bankCode, bankAccess.getBankcode()); Assert.assertEquals(bankLogin, bankAccess.getBanklogin()); Assert.assertEquals(bankName, bankAccess.getName()); } |
### Question:
BankAccessFactory { public List<BankAccess> createBankAccesses(List<BankAccessBankingModel> bankingModelList) { List<BankAccess> bankAccessesResult = new ArrayList<BankAccess>(); for (BankAccessBankingModel bankingModel : bankingModelList) { bankAccessesResult.add(this.createBankAccess(bankingModel)); } return bankAccessesResult; } BankAccess createBankAccess(BankAccessBankingModel bankingModel); List<BankAccess> createBankAccesses(List<BankAccessBankingModel> bankingModelList); }### Answer:
@Test public void createListSuccess() { String accessId = "accessID"; String bankName = "bankName"; String bankCode = "bankCode"; String bankLogin = "bankLogin"; BankAccessBankingModel bankAccessBankingModel = new BankAccessBankingModel(); bankAccessBankingModel.setBankName(bankName); bankAccessBankingModel.setBankCode(bankCode); bankAccessBankingModel.setBankLogin(bankLogin); bankAccessBankingModel.setId(accessId); List<BankAccessBankingModel> bankAccessBankingModelList = new ArrayList<>(); bankAccessBankingModelList.add(bankAccessBankingModel); List<BankAccess> bankAccesses = bankAccessFactory.createBankAccesses(bankAccessBankingModelList); Assert.assertNotNull(bankAccesses); Assert.assertEquals(bankAccesses.size(), 1); Assert.assertEquals(accessId, bankAccesses.get(0).getId()); Assert.assertEquals(bankCode, bankAccesses.get(0).getBankcode()); Assert.assertEquals(bankLogin, bankAccesses.get(0).getBanklogin()); Assert.assertEquals(bankName, bankAccesses.get(0).getName()); } |
### Question:
SavingsAccountIntoEntityTransformer { public User transformContactIntoEntity(Contact contact) { return new User(contact.getEmail(), contact.getFirstName(), contact.getLastName()); } SavingsAccountEntity transformSavingAccountIntoEntity(SavingsAccount savingsAccount, User currentUser); User transformContactIntoEntity(Contact contact); List<BankAccountIdentifierEntity> transformBankAccountIdentifierIntoEntity(List<BankAccountIdentifier> assignedBankAccounts); BankAccountIdentifierEntity transformBankAccountIdentifierIntoEntity(BankAccountIdentifier bankAccountIdentifier); Set<SavingsAccountSubGoalEntity> transformSavingsAccountSubGoalIdentifierIntoEntity(List<SavingsAccountSubGoal> subGoals); SavingsAccountSubGoalEntity transformSavingsAccountSubGoalIdentifierIntoEntity(SavingsAccountSubGoal savingsAccountSubGoal); }### Answer:
@Test public void transformContactIntoEntity() { Contact contact = new Contact(userEmail, userFirstName, userLastName); User result = transformer.transformContactIntoEntity(contact); assertNotNull(result); assertEquals(userEmail, result.getEmail()); assertEquals(userFirstName, result.getFirstName()); assertEquals(userLastName, result.getLastName()); } |
### Question:
SavingsAccountIntoEntityTransformer { public List<BankAccountIdentifierEntity> transformBankAccountIdentifierIntoEntity(List<BankAccountIdentifier> assignedBankAccounts) { List<BankAccountIdentifierEntity> bankAccountIdentifierEntities = new ArrayList<>(); if (assignedBankAccounts == null) { return bankAccountIdentifierEntities; } for (BankAccountIdentifier bankAccountIdentifier : assignedBankAccounts) { bankAccountIdentifierEntities.add(transformBankAccountIdentifierIntoEntity(bankAccountIdentifier)); } return bankAccountIdentifierEntities; } SavingsAccountEntity transformSavingAccountIntoEntity(SavingsAccount savingsAccount, User currentUser); User transformContactIntoEntity(Contact contact); List<BankAccountIdentifierEntity> transformBankAccountIdentifierIntoEntity(List<BankAccountIdentifier> assignedBankAccounts); BankAccountIdentifierEntity transformBankAccountIdentifierIntoEntity(BankAccountIdentifier bankAccountIdentifier); Set<SavingsAccountSubGoalEntity> transformSavingsAccountSubGoalIdentifierIntoEntity(List<SavingsAccountSubGoal> subGoals); SavingsAccountSubGoalEntity transformSavingsAccountSubGoalIdentifierIntoEntity(SavingsAccountSubGoal savingsAccountSubGoal); }### Answer:
@Test public void transformBankAccountIdentifierListIntoEntity() { List<BankAccountIdentifier> identifiers = new ArrayList<>(); BankAccountIdentifier accountIdentifier = new BankAccountIdentifier(accessId, accountId); identifiers.add(accountIdentifier); List<BankAccountIdentifierEntity> result = transformer.transformBankAccountIdentifierIntoEntity(identifiers); assertNotNull(result); assertEquals(result.size(), identifiers.size()); }
@Test public void transformBankAccountIdentifierIntoEntityInputNull() { List<BankAccountIdentifier> identifiers = null; List<BankAccountIdentifierEntity> result = transformer.transformBankAccountIdentifierIntoEntity(identifiers); assertNotNull(result); }
@Test public void transformBankAccountIdentifierIntoEntity() { BankAccountIdentifier accountIdentifier = new BankAccountIdentifier(accessId, accountId); BankAccountIdentifierEntity result = transformer.transformBankAccountIdentifierIntoEntity(accountIdentifier); assertNotNull(result); assertEquals(result.getAccessid(), accessId); assertEquals(result.getAccountid(), accountId); } |
### Question:
BankAccessBankingModelFactory { public BankAccessBankingModel createBankAccessBankingModel(String userId, BankAccessCredential bankAccessCredential) { BankAccessBankingModel bankAccessBankingModel = new BankAccessBankingModel(); bankAccessBankingModel.setUserId(userId); bankAccessBankingModel.setBankCode(bankAccessCredential.getBankcode()); bankAccessBankingModel.setBankLogin(bankAccessCredential.getBanklogin()); bankAccessBankingModel.setPin(bankAccessCredential.getPin()); return bankAccessBankingModel; } BankAccessBankingModel createBankAccessBankingModel(String userId, BankAccessCredential bankAccessCredential); }### Answer:
@Test public void createTest() { BankAccessBankingModelFactory bankAccessBankingModelFactory = new BankAccessBankingModelFactory(); BankAccessCredential credential = new BankAccessCredential("test", "test", "test"); BankAccessBankingModel testModel = bankAccessBankingModelFactory.createBankAccessBankingModel("1", credential); Assert.assertNotNull(testModel); } |
### Question:
BankAccountFactory { public BankAccount createBankAccount(BankAccountBankingModel bankingModel) { double balance = 0; if (bankingModel.getBankAccountBalance() != null) { balance = bankingModel.getBankAccountBalance().getReadyHbciBalance(); } BankAccount bankAccount = new BankAccount(bankingModel.getId(), bankingModel.getType() != null ? bankingModel.getType() : "", balance); return bankAccount; } BankAccount createBankAccount(BankAccountBankingModel bankingModel); List<BankAccount> createBankAccounts(List<BankAccountBankingModel> bankingModelList); }### Answer:
@Test public void createSuccess() { final double testAmount = 123.22; BankAccountBalanceBankingModel bankAccountBalanceBankingModel = new BankAccountBalanceBankingModel(); bankAccountBalanceBankingModel.setReadyHbciBalance(testAmount); String accessId = "accessID"; String accountId = "accountId"; String type = "type"; BankAccountBankingModel bankAccountBankingModel = new BankAccountBankingModel(); bankAccountBankingModel.setBankAccessId(accessId); bankAccountBankingModel.setId(accountId); bankAccountBankingModel.setType(type); bankAccountBankingModel.setBankAccountBalance(bankAccountBalanceBankingModel); BankAccount bankAccount = bankAccountFactory.createBankAccount(bankAccountBankingModel); Assert.assertNotNull(bankAccount); Assert.assertEquals(accountId, bankAccount.getBankid()); Assert.assertEquals(type, bankAccount.getName()); Assert.assertEquals(testAmount, bankAccount.getBalance(), DELTA); } |
### Question:
BankAccountFactory { public List<BankAccount> createBankAccounts(List<BankAccountBankingModel> bankingModelList) { List<BankAccount> bankAccountsResult = new ArrayList<BankAccount>(); for (BankAccountBankingModel bankingModel : bankingModelList) { bankAccountsResult.add(this.createBankAccount(bankingModel)); } return bankAccountsResult; } BankAccount createBankAccount(BankAccountBankingModel bankingModel); List<BankAccount> createBankAccounts(List<BankAccountBankingModel> bankingModelList); }### Answer:
@Test public void createListSuccess() { final double testAmount = 123.22; final int bankAccountActualSize = 1; BankAccountBalanceBankingModel bankAccountBalanceBankingModel = new BankAccountBalanceBankingModel(); bankAccountBalanceBankingModel.setReadyHbciBalance(testAmount); String accessId = "accessID"; String accountId = "accountId"; String type = "type"; BankAccountBankingModel bankAccountBankingModel = new BankAccountBankingModel(); bankAccountBankingModel.setBankAccessId(accessId); bankAccountBankingModel.setId(accountId); bankAccountBankingModel.setType(type); bankAccountBankingModel.setBankAccountBalance(bankAccountBalanceBankingModel); List<BankAccountBankingModel> bankAccountBankingModelList = new ArrayList<>(); bankAccountBankingModelList.add(bankAccountBankingModel); List<BankAccount> bankAccounts = bankAccountFactory.createBankAccounts(bankAccountBankingModelList); Assert.assertNotNull(bankAccounts); Assert.assertEquals(bankAccounts.size(), bankAccountActualSize); Assert.assertEquals(accountId, bankAccounts.get(0).getBankid()); Assert.assertEquals(type, bankAccounts.get(0).getName()); Assert.assertEquals(testAmount, bankAccounts.get(0).getBalance(), DELTA); } |
### Question:
AuthMigrator { public boolean hasLegacyAuth() { return mStorageHelpers.hasDigitsSession(); } @VisibleForTesting(otherwise = PRIVATE) AuthMigrator(@NonNull FirebaseApp app, @NonNull StorageHelpers storageHelper,
@NonNull FirebaseAuth firebaseAuth); static AuthMigrator getInstance(FirebaseApp app); static AuthMigrator getInstance(); FirebaseApp getApp(); Task<Void> migrate(boolean cleanupDigitsSession); Task<Void> migrate(@NonNull RedeemableDigitsSessionBuilder builder); boolean hasLegacyAuth(); void clearLegacyAuth(); }### Answer:
@Test public void hasLegacyAuth() throws JSONException { when(mockStorageHelpers.hasDigitsSession()).thenReturn(true); AuthMigrator authMigrator = new AuthMigrator(mockFirebaseApp, mockStorageHelpers, mockFirebaseAuth); assertTrue(authMigrator.hasLegacyAuth()); } |
### Question:
AuthMigrator { public void clearLegacyAuth() { mStorageHelpers.clearDigitsSession(); } @VisibleForTesting(otherwise = PRIVATE) AuthMigrator(@NonNull FirebaseApp app, @NonNull StorageHelpers storageHelper,
@NonNull FirebaseAuth firebaseAuth); static AuthMigrator getInstance(FirebaseApp app); static AuthMigrator getInstance(); FirebaseApp getApp(); Task<Void> migrate(boolean cleanupDigitsSession); Task<Void> migrate(@NonNull RedeemableDigitsSessionBuilder builder); boolean hasLegacyAuth(); void clearLegacyAuth(); }### Answer:
@Test public void clearLegacyAuth() throws JSONException { AuthMigrator authMigrator = new AuthMigrator(mockFirebaseApp, mockStorageHelpers, mockFirebaseAuth); authMigrator.clearLegacyAuth(); verify(mockStorageHelpers).clearDigitsSession(); } |
### Question:
RedeemableDigitsSessionBuilder { @NonNull static RedeemableDigitsSessionBuilder fromSessionJson(@NonNull String json) throws JSONException { RedeemableDigitsSessionBuilder builder = new RedeemableDigitsSessionBuilder(); JSONObject jsonObject = new JSONObject(json); JSONObject emailJsonObject = safeGetJsonObject(EMAIL_KEY, jsonObject); JSONObject authTokenJsonObject = safeGetJsonObject(AUTH_TOKEN_KEY, jsonObject); builder.setPhoneNumber(safeGetString(PHONE_NUMBER_KEY, jsonObject)); builder.setId(safeGetLong(ID_KEY, jsonObject)); JSONObject nestedAuthTokenJsonObject = safeGetJsonObject(AUTH_TOKEN_KEY, authTokenJsonObject); builder.setEmail(safeGetString(EMAIL_ADDRESS_KEY, emailJsonObject)); builder.setIsEmailVerified(safeGetBoolean(IS_EMAIL_ADDRESS_VERIFIED_KEY, emailJsonObject)); builder.setAuthToken(safeGetString(NESTED_TOKEN_KEY, nestedAuthTokenJsonObject)); builder.setAuthTokenSecret(safeGetString(NESTED_TOKEN_SECRET_KEY, nestedAuthTokenJsonObject)); return builder; } RedeemableDigitsSessionBuilder setId(Long id); RedeemableDigitsSessionBuilder setPhoneNumber(@Nullable String phoneNumber); RedeemableDigitsSessionBuilder setEmail(@Nullable String email); RedeemableDigitsSessionBuilder setIsEmailVerified(@Nullable Boolean isEmailVerified); RedeemableDigitsSessionBuilder setAuthToken(@Nullable String authToken); RedeemableDigitsSessionBuilder setAuthTokenSecret(@Nullable String authTokenSecret); RedeemableDigitsSessionBuilder setConsumerKey(@Nullable String consumerKey); RedeemableDigitsSessionBuilder setConsumerSecret(@Nullable String consumerSecret); RedeemableDigitsSessionBuilder setFabricApiKey(@Nullable String fabricApiKey); ClearSessionContinuation.RedeemableDigitsSession build(); }### Answer:
@Test(expected=JSONException.class) public void testInvalidFromDigitsSessionJson() throws JSONException { RedeemableDigitsSessionBuilder.fromSessionJson("invalid_json"); } |
### Question:
StfCommander { private static JCommander createCommander(CommandContainer commandContainer, String[] args) { JCommander.Builder builder = JCommander.newBuilder(); for (String operation : commandContainer.getAllCommands()) { CommandContainer.Command command = commandContainer.getCommand(operation); builder.addCommand(operation, command); } JCommander commander = builder.build(); commander.setProgramName("stf"); commander.setCaseSensitiveOptions(false); commander.parseWithoutValidation(args); return commander; } private StfCommander(
String commandName,
CommandContainer commandContainer,
CommandContainer.Command defaultCommand,
ErrorHandler errorHandler); }### Answer:
@DisplayName("connect command is parsed with valid -l param") @Test void testConnectCommandWithValidCacheParam() throws IOException { createCommander("connect -l 1 2 3"); }
@DisplayName("connect command will throw the ParameterException if -l param is invalid") @Test void testConnectCommandWithInvalidValidCacheParam() { assertThrows(ParameterException.class, () -> createCommander("connect -l str")); }
@DisplayName("Connect command with valid -u parameter will be parsed successfully") @Test void testValidUrlParamsIsParsed() throws IOException { createCommander("connect -u http: }
@DisplayName("Connect command with valid -f parameter will be parsed successfully") @Test void testValidFileParamsIsParsed() throws IOException { createCommander("connect -f some/file.json"); }
@DisplayName("Connect command with invalid -u parameter will throw an error") @Test void testInvalidUrlParamsIsFailedToParse() { assertThrows(ParameterException.class, () -> createCommander(" connect -u not_a_url")); }
@DisplayName("Connect command with empty -u parameter will throw an error") @Test void testEmptyUrlParamsIsFailedToParse() { assertThrows(ParameterException.class, () -> createCommander(" connect -u")); }
@DisplayName("Connect command with empty -f parameter will throw an error") @Test void testEmptyFileParamsIsFailedToParse() { assertThrows(ParameterException.class, () -> createCommander(" connect -u")); } |
### Question:
FileIOUtils { public static void createDeepHardlink(File sourceDir, File destDir) throws IOException { if (!sourceDir.exists()) { throw new IOException("Source directory " + sourceDir.getPath() + " doesn't exist"); } else if (!destDir.exists()) { throw new IOException("Destination directory " + destDir.getPath() + " doesn't exist"); } else if (sourceDir.isFile() && destDir.isFile()) { throw new IOException("Source or Destination is not a directory."); } Set<String> paths = new HashSet<String>(); createDirsFindFiles(sourceDir, sourceDir, destDir, paths); StringBuffer buffer = new StringBuffer(); for (String path : paths) { File sourceLink = new File(sourceDir, path); path = "." + path; buffer.append("ln ").append(sourceLink.getAbsolutePath()).append("/*") .append(" ").append(path).append(";"); } runShellCommand(buffer.toString(), destDir); } static String getSourcePathFromClass(Class<?> containedClass); static void createDeepHardlink(File sourceDir, File destDir); static Pair<Integer, Integer> readUtf8File(File file, int offset,
int length, OutputStream stream); static LogData readUtf8File(File file, int fileOffset, int length); static JobMetaData readUtf8MetaDataFile(File file, int fileOffset,
int length); static Pair<Integer, Integer> getUtf8Range(byte[] buffer, int offset,
int length); }### Answer:
@Test public void testHardlinkCopy() throws IOException { FileIOUtils.createDeepHardlink(sourceDir, destDir); assertTrue(areDirsEqual(sourceDir, destDir, true)); FileUtils.deleteDirectory(destDir); assertTrue(areDirsEqual(baseDir, sourceDir, true)); }
@Test public void testHardlinkCopyNonSource() { boolean exception = false; try { FileIOUtils.createDeepHardlink(new File(sourceDir, "idonotexist"), destDir); } catch (IOException e) { System.out.println(e.getMessage()); System.out.println("Handled this case nicely."); exception = true; } assertTrue(exception); } |
### Question:
PatternLayoutEscaped extends PatternLayout { @Override public String format(final LoggingEvent event) { if (event.getMessage() instanceof String) { return super.format(appendStackTraceToEvent(event)); } return super.format(event); } PatternLayoutEscaped(String s); PatternLayoutEscaped(); @Override String format(final LoggingEvent event); }### Answer:
@Test public void testWithException() { try { throw new Exception("This is an exception"); } catch (Exception e) { LoggingEvent event = createEventWithException("There was an exception", e); assertTrue(layout.format(event).startsWith("There was an exception\\njava.lang.Exception: This is an exception")); } }
@Test public void testNewLine() { LoggingEvent event = createMessageEvent("This message contains \n new lines"); assertTrue(layout.format(event).equals("This message contains \\n new lines")); }
@Test public void testQuote() { LoggingEvent event = createMessageEvent("This message contains \" quotes"); assertTrue(layout.format(event).equals("This message contains \\\" quotes")); }
@Test public void testTab() { LoggingEvent event = createMessageEvent("This message contains a tab \t"); assertTrue(layout.format(event).equals("This message contains a tab \\t")); }
@Test public void testBackSlash() { LoggingEvent event = createMessageEvent("This message contains a backslash \\"); assertTrue(layout.format(event).equals("This message contains a backslash \\\\")); } |
### Question:
ExternalLinkUtils { public static String getExternalAnalyzerOnReq(Props azkProps, HttpServletRequest req) { if (!azkProps.containsKey(ServerProperties.AZKABAN_SERVER_EXTERNAL_ANALYZER_TOPIC)) { return ""; } String topic = azkProps.getString(ServerProperties.AZKABAN_SERVER_EXTERNAL_ANALYZER_TOPIC); return getLinkFromRequest(topic, azkProps, req); } static String getExternalAnalyzerOnReq(Props azkProps, HttpServletRequest req); static String getExternalLogViewer(Props azkProps, String jobId, Props jobProps); }### Answer:
@Test public void testGetExternalAnalyzerValidFormat() { azkProps.put(ServerProperties.AZKABAN_SERVER_EXTERNAL_ANALYZER_TOPIC, EXTERNAL_ANALYZER_TOPIC); azkProps.put(ServerProperties.AZKABAN_SERVER_EXTERNAL_TOPIC_URL.replace("${topic}", EXTERNAL_ANALYZER_TOPIC), EXTERNAL_ANALYZER_URL_VALID_FORMAT); when(mockRequest.getRequestURL()).thenReturn(new StringBuffer(EXEC_URL)); when(mockRequest.getQueryString()).thenReturn(EXEC_QUERY_STRING); String externalURL = ExternalLinkUtils.getExternalAnalyzerOnReq(azkProps, mockRequest); assertTrue(externalURL.equals(EXTERNAL_ANALYZER_EXPECTED_URL)); }
@Test public void testGetExternalAnalyzerNotConfigured() { String executionExternalLinkURL = ExternalLinkUtils.getExternalAnalyzerOnReq(azkProps, mockRequest); assertTrue(executionExternalLinkURL.equals("")); } |
### Question:
ExternalLinkUtils { public static String getExternalLogViewer(Props azkProps, String jobId, Props jobProps) { if (!azkProps.containsKey(ServerProperties.AZKABAN_SERVER_EXTERNAL_LOGVIEWER_TOPIC)) { return ""; } String topic = azkProps.getString(ServerProperties.AZKABAN_SERVER_EXTERNAL_LOGVIEWER_TOPIC); return getLinkFromJobAndExecId(topic, azkProps, jobId, jobProps); } static String getExternalAnalyzerOnReq(Props azkProps, HttpServletRequest req); static String getExternalLogViewer(Props azkProps, String jobId, Props jobProps); }### Answer:
@Test public void testGetExternalLogViewerValidFormat() { azkProps.put(ServerProperties.AZKABAN_SERVER_EXTERNAL_LOGVIEWER_TOPIC, EXTERNAL_LOGVIEWER_TOPIC); azkProps.put(ServerProperties.AZKABAN_SERVER_EXTERNAL_TOPIC_URL.replace("${topic}", EXTERNAL_LOGVIEWER_TOPIC), EXTERNAL_LOGVIEWER_URL_VALID_FORMAT); String externalURL = ExternalLinkUtils.getExternalLogViewer(azkProps, jobId, jobProps); assertTrue(externalURL.equals(EXTERNAL_LOGVIEWER_EXPECTED_URL)); }
@Test public void testGetLogViewerNotConfigured() { String executionExternalLinkURL = ExternalLinkUtils.getExternalLogViewer(azkProps, jobId, jobProps); assertTrue(executionExternalLinkURL.equals("")); } |
### Question:
ExternalLinkUtils { static String encodeToUTF8(String url) { try { return URLEncoder.encode(url, "UTF-8").replaceAll("\\+", "%20"); } catch (UnsupportedEncodingException e) { logger.error("Specified encoding is not supported", e); } return ""; } static String getExternalAnalyzerOnReq(Props azkProps, HttpServletRequest req); static String getExternalLogViewer(Props azkProps, String jobId, Props jobProps); }### Answer:
@Test public void testEncodingToUFT8() { assertTrue(ExternalLinkUtils.encodeToUTF8(" ").equals("%20")); assertTrue(ExternalLinkUtils.encodeToUTF8("+").equals("%2B")); assertTrue(ExternalLinkUtils.encodeToUTF8("/").equals("%2F")); assertTrue(ExternalLinkUtils.encodeToUTF8(":").equals("%3A")); assertTrue(ExternalLinkUtils.encodeToUTF8("?").equals("%3F")); assertTrue(ExternalLinkUtils.encodeToUTF8("=").equals("%3D")); } |
### Question:
ExternalLinkUtils { static String getURLForTopic(String topic, Props azkProps) { return azkProps.getString(ServerProperties.AZKABAN_SERVER_EXTERNAL_TOPIC_URL.replace("${topic}", topic), ""); } static String getExternalAnalyzerOnReq(Props azkProps, HttpServletRequest req); static String getExternalLogViewer(Props azkProps, String jobId, Props jobProps); }### Answer:
@Test public void testFetchURL() { azkProps.put(ServerProperties.AZKABAN_SERVER_EXTERNAL_TOPIC_URL.replace("${topic}", "someTopic"), "This is a link"); assertTrue(ExternalLinkUtils.getURLForTopic("someTopic", azkProps).equals("This is a link")); } |
### Question:
Emailer extends AbstractMailer implements Alerter { public void sendErrorEmail(ExecutableFlow flow, String... extraReasons) { EmailMessage message = new EmailMessage(mailHost, mailPort, mailUser, mailPassword); message.setFromAddress(mailSender); message.setTLS(tls); message.setAuth(super.hasMailAuth()); ExecutionOptions option = flow.getExecutionOptions(); MailCreator mailCreator = DefaultMailCreator.getCreator(option.getMailCreator()); logger.debug("ExecutorMailer using mail creator:" + mailCreator.getClass().getCanonicalName()); boolean mailCreated = mailCreator.createErrorEmail(flow, message, azkabanName, scheme, clientHostname, clientPortNumber, extraReasons); if (mailCreated && !testMode) { try { message.sendEmail(); } catch (MessagingException e) { logger.error("Email message send failed", e); } } } Emailer(Props props); void sendFirstErrorMessage(ExecutableFlow flow); void sendErrorEmail(ExecutableFlow flow, String... extraReasons); void sendSuccessEmail(ExecutableFlow flow); static List<String> findFailedJobs(ExecutableFlow flow); @Override void alertOnSuccess(ExecutableFlow exflow); @Override void alertOnError(ExecutableFlow exflow, String... extraReasons); @Override void alertOnFirstError(ExecutableFlow exflow); @Override void alertOnSla(SlaOption slaOption, String slaMessage); }### Answer:
@Ignore @Test public void testSendEmail() throws Exception{ Flow flow = project.getFlow("jobe"); flow.addFailureEmails(receiveAddrList); Assert.assertNotNull(flow); ExecutableFlow exFlow = new ExecutableFlow(project, flow); Emailer emailer = new Emailer(props); emailer.sendErrorEmail(exFlow); } |
### Question:
RestfulApiClient { public T httpGet(URI uri, List<NameValuePair> headerEntries) throws IOException{ if (null == uri){ logger.error(" unable to perform httpGet as the passed uri is null"); return null; } HttpGet get = new HttpGet(uri); return this.sendAndReturn((HttpGet)completeRequest(get, headerEntries)); } T httpGet(URI uri, List<NameValuePair> headerEntries); T httpPost(URI uri,
List<NameValuePair> headerEntries,
String postingBody); T httpDelete(URI uri, List<NameValuePair> headerEntries); T httpPut(URI uri, List<NameValuePair> headerEntries,
String postingBody); static URI buildUri(String host, int port, String path,
boolean isHttp, Pair<String, String>... params); static URI BuildUri(URI uri, Pair<String, String>... params); }### Answer:
@Test public void testHttpGet() throws Exception { MockRestfulApiClient mockClient = new MockRestfulApiClient(); @SuppressWarnings("unchecked") URI uri = MockRestfulApiClient.buildUri("test.com", 80, "test", true, new Pair <String,String>("Entry1","Value1")); String result = mockClient.httpGet(uri, null); Assert.assertTrue(result!= null && result.contains(uri.toString())); Assert.assertTrue(result.contains("METHOD = GET")); } |
### Question:
RestfulApiClient { public T httpPost(URI uri, List<NameValuePair> headerEntries, String postingBody) throws UnsupportedEncodingException, IOException{ if (null == uri){ logger.error(" unable to perform httpPost as the passed uri is null."); return null; } HttpPost post = new HttpPost(uri); return this.sendAndReturn(completeRequest(post,headerEntries,postingBody)); } T httpGet(URI uri, List<NameValuePair> headerEntries); T httpPost(URI uri,
List<NameValuePair> headerEntries,
String postingBody); T httpDelete(URI uri, List<NameValuePair> headerEntries); T httpPut(URI uri, List<NameValuePair> headerEntries,
String postingBody); static URI buildUri(String host, int port, String path,
boolean isHttp, Pair<String, String>... params); static URI BuildUri(URI uri, Pair<String, String>... params); }### Answer:
@Test public void testHttpPost() throws Exception { MockRestfulApiClient mockClient = new MockRestfulApiClient(); @SuppressWarnings("unchecked") URI uri = MockRestfulApiClient.buildUri("test.com", 80, "test", true, new Pair <String,String>("Entry1","Value1")); ArrayList<NameValuePair> headerItems = new ArrayList<NameValuePair>(); headerItems.add(new BasicNameValuePair("h1","v1")); headerItems.add(new BasicNameValuePair("h2","v2")); String content = "123456789"; String result = mockClient.httpPost(uri, headerItems,content); Assert.assertTrue(result!= null && result.contains(uri.toString())); Assert.assertTrue(result.contains("METHOD = POST")); Assert.assertTrue(result.contains("h1 = v1")); Assert.assertTrue(result.contains("h2 = v2")); Assert.assertTrue(result.contains(String.format("%s = %s;", "BODY", content))); } |
### Question:
RestfulApiClient { public T httpPut(URI uri, List<NameValuePair> headerEntries, String postingBody) throws UnsupportedEncodingException, IOException{ if (null == uri){ logger.error(" unable to perform httpPut as the passed url is null or empty."); return null; } HttpPut put = new HttpPut(uri); return this.sendAndReturn(completeRequest(put, headerEntries, postingBody)); } T httpGet(URI uri, List<NameValuePair> headerEntries); T httpPost(URI uri,
List<NameValuePair> headerEntries,
String postingBody); T httpDelete(URI uri, List<NameValuePair> headerEntries); T httpPut(URI uri, List<NameValuePair> headerEntries,
String postingBody); static URI buildUri(String host, int port, String path,
boolean isHttp, Pair<String, String>... params); static URI BuildUri(URI uri, Pair<String, String>... params); }### Answer:
@Test public void testHttpPut() throws Exception { MockRestfulApiClient mockClient = new MockRestfulApiClient(); @SuppressWarnings("unchecked") URI uri = MockRestfulApiClient.buildUri("test.com", 80, "test", true, new Pair <String,String>("Entry1","Value1")); ArrayList<NameValuePair> headerItems = new ArrayList<NameValuePair>(); headerItems.add(new BasicNameValuePair("h1","v1")); headerItems.add(new BasicNameValuePair("h2","v2")); String content = "123456789"; String result = mockClient.httpPut(uri, headerItems,content); Assert.assertTrue(result!= null && result.contains(uri.toString())); Assert.assertTrue(result.contains("METHOD = PUT")); Assert.assertTrue(result.contains("h1 = v1")); Assert.assertTrue(result.contains("h2 = v2")); Assert.assertTrue(result.contains(String.format("%s = %s;", "BODY", content))); } |
### Question:
RestfulApiClient { public T httpDelete(URI uri, List<NameValuePair> headerEntries) throws IOException{ if (null == uri){ logger.error(" unable to perform httpDelete as the passed uri is null."); return null; } HttpDelete delete = new HttpDelete(uri); return this.sendAndReturn((HttpDelete)completeRequest(delete, headerEntries)); } T httpGet(URI uri, List<NameValuePair> headerEntries); T httpPost(URI uri,
List<NameValuePair> headerEntries,
String postingBody); T httpDelete(URI uri, List<NameValuePair> headerEntries); T httpPut(URI uri, List<NameValuePair> headerEntries,
String postingBody); static URI buildUri(String host, int port, String path,
boolean isHttp, Pair<String, String>... params); static URI BuildUri(URI uri, Pair<String, String>... params); }### Answer:
@Test public void testHttpDelete() throws Exception { MockRestfulApiClient mockClient = new MockRestfulApiClient(); @SuppressWarnings("unchecked") URI uri = MockRestfulApiClient.buildUri("test.com", 80, "test", true, new Pair <String,String>("Entry1","Value1")); ArrayList<NameValuePair> headerItems = new ArrayList<NameValuePair>(); headerItems.add(new BasicNameValuePair("h1","v1")); headerItems.add(new BasicNameValuePair("h2","v2")); String result = mockClient.httpDelete(uri, headerItems); Assert.assertTrue(result!= null && result.contains(uri.toString())); Assert.assertTrue(result.contains("METHOD = DELETE")); Assert.assertTrue(result.contains("h1 = v1")); Assert.assertTrue(result.contains("h2 = v2")); } |
### Question:
AbstractMailer { protected EmailMessage createEmailMessage(String subject, String mimetype, Collection<String> emailList) { EmailMessage message = new EmailMessage(mailHost, mailPort, mailUser, mailPassword); message.setFromAddress(mailSender); message.addAllToAddress(emailList); message.setMimeType(mimetype); message.setSubject(subject); message.setAuth(usesAuth); message.setTLS(tls); return message; } AbstractMailer(Props props); String getReferenceURL(); EmailMessage prepareEmailMessage(String subject, String mimetype,
Collection<String> emailList); String getAzkabanName(); String getMailHost(); String getMailUser(); String getMailPassword(); String getMailSender(); int getMailPort(); long getAttachmentMaxSize(); boolean hasMailAuth(); static final int DEFAULT_SMTP_PORT; }### Answer:
@Test public void testCreateEmailMessage(){ Props props = createMailProperties(); props.put("mail.port","445"); AbstractMailer mailer = new AbstractMailer(props); EmailMessage emailMessage = mailer.createEmailMessage("subject","text/html",senderList); assert emailMessage.getMailPort()==445; } |
### Question:
HttpRequestUtils { public static boolean validateIntegerParam(Map<String, String> params, String paramName) throws ExecutorManagerException { if (params != null && params.containsKey(paramName) && !StringUtils.isNumeric(params.get(paramName))) { throw new ExecutorManagerException(paramName + " should be an integer"); } return true; } static ExecutionOptions parseFlowOptions(HttpServletRequest req); static void filterAdminOnlyFlowParams(UserManager userManager,
ExecutionOptions options, User user); static boolean validateIntegerParam(Map<String, String> params,
String paramName); static boolean hasPermission(UserManager userManager, User user,
Permission.Type type); static boolean hasParam(HttpServletRequest request, String param); static String getParam(HttpServletRequest request, String name); static String getParam(HttpServletRequest request, String name,
String defaultVal); static int getIntParam(HttpServletRequest request, String name); static int getIntParam(HttpServletRequest request, String name,
int defaultVal); static boolean getBooleanParam(HttpServletRequest request, String name); static boolean getBooleanParam(HttpServletRequest request,
String name, boolean defaultVal); static long getLongParam(HttpServletRequest request, String name); static long getLongParam(HttpServletRequest request, String name,
long defaultVal); static Map<String, String> getParamGroup(HttpServletRequest request,
String groupName); }### Answer:
@Test public void testvalidIntegerParam() throws ExecutorManagerException { Map<String, String> params = new HashMap<String, String>(); params.put("param1", "123"); HttpRequestUtils.validateIntegerParam(params, "param1"); }
@Test(expected = ExecutorManagerException.class) public void testInvalidIntegerParam() throws ExecutorManagerException { Map<String, String> params = new HashMap<String, String>(); params.put("param1", "1dff2"); HttpRequestUtils.validateIntegerParam(params, "param1"); } |
### Question:
HttpRequestUtils { public static boolean hasPermission(UserManager userManager, User user, Permission.Type type) { for (String roleName : user.getRoles()) { Role role = userManager.getRole(roleName); if (role.getPermission().isPermissionSet(type) || role.getPermission().isPermissionSet(Permission.Type.ADMIN)) { return true; } } return false; } static ExecutionOptions parseFlowOptions(HttpServletRequest req); static void filterAdminOnlyFlowParams(UserManager userManager,
ExecutionOptions options, User user); static boolean validateIntegerParam(Map<String, String> params,
String paramName); static boolean hasPermission(UserManager userManager, User user,
Permission.Type type); static boolean hasParam(HttpServletRequest request, String param); static String getParam(HttpServletRequest request, String name); static String getParam(HttpServletRequest request, String name,
String defaultVal); static int getIntParam(HttpServletRequest request, String name); static int getIntParam(HttpServletRequest request, String name,
int defaultVal); static boolean getBooleanParam(HttpServletRequest request, String name); static boolean getBooleanParam(HttpServletRequest request,
String name, boolean defaultVal); static long getLongParam(HttpServletRequest request, String name); static long getLongParam(HttpServletRequest request, String name,
long defaultVal); static Map<String, String> getParamGroup(HttpServletRequest request,
String groupName); }### Answer:
@Test public void testHasAdminPermission() throws UserManagerException { UserManager manager = TestUtils.createTestXmlUserManager(); User adminUser = manager.getUser("testAdmin", "testAdmin"); Assert.assertTrue(HttpRequestUtils.hasPermission(manager, adminUser, Type.ADMIN)); }
@Test public void testHasOrdinaryPermission() throws UserManagerException { UserManager manager = TestUtils.createTestXmlUserManager(); User testUser = manager.getUser("testUser", "testUser"); Assert.assertFalse(HttpRequestUtils.hasPermission(manager, testUser, Type.ADMIN)); } |
### Question:
ValidationReport { public void addWarnLevelInfoMsg(String msg) { if (msg != null) { _infoMsgs.add("WARN" + msg); } } ValidationReport(); void addWarnLevelInfoMsg(String msg); void addErrorLevelInfoMsg(String msg); void addWarningMsgs(Set<String> msgs); void addErrorMsgs(Set<String> msgs); ValidationStatus getStatus(); Set<String> getInfoMsgs(); Set<String> getWarningMsgs(); Set<String> getErrorMsgs(); static ValidationStatus getInfoMsgLevel(String msg); static String getInfoMsg(String msg); }### Answer:
@Test public void testAddWarnLevelInfoMsg() { ValidationReport report = new ValidationReport(); String msg = "test warn level info message."; report.addWarnLevelInfoMsg(msg); for (String info : report.getInfoMsgs()) { assertEquals("Info message added through addWarnLevelInfoMsg should have level set to WARN", ValidationReport.getInfoMsgLevel(info), ValidationStatus.WARN); assertEquals("Retrieved info message does not match the original one.", ValidationReport.getInfoMsg(info), msg); } } |
### Question:
ValidationReport { public void addErrorLevelInfoMsg(String msg) { if (msg != null) { _infoMsgs.add("ERROR" + msg); } } ValidationReport(); void addWarnLevelInfoMsg(String msg); void addErrorLevelInfoMsg(String msg); void addWarningMsgs(Set<String> msgs); void addErrorMsgs(Set<String> msgs); ValidationStatus getStatus(); Set<String> getInfoMsgs(); Set<String> getWarningMsgs(); Set<String> getErrorMsgs(); static ValidationStatus getInfoMsgLevel(String msg); static String getInfoMsg(String msg); }### Answer:
@Test public void testAddErrorLevelInfoMsg() { ValidationReport report = new ValidationReport(); String msg = "test error level error message."; report.addErrorLevelInfoMsg(msg); for (String info : report.getInfoMsgs()) { assertEquals("Info message added through addErrorLevelInfoMsg should have level set to ERROR", ValidationReport.getInfoMsgLevel(info), ValidationStatus.ERROR); assertEquals("Retrieved info message does not match the original one.", ValidationReport.getInfoMsg(info), msg); } } |
### Question:
XmlValidatorManager implements ValidatorManager { @Override public List<String> getValidatorsInfo() { List<String> info = new ArrayList<String>(); for (String key : validators.keySet()) { info.add(key); } return info; } XmlValidatorManager(Props props); @Override void loadValidators(Props props, Logger log); @Override Map<String, ValidationReport> validate(Project project, File projectDir); @Override ProjectValidator getDefaultValidator(); @Override List<String> getValidatorsInfo(); static final String AZKABAN_VALIDATOR_TAG; static final String VALIDATOR_TAG; static final String CLASSNAME_ATTR; static final String ITEM_TAG; static final String DEFAULT_VALIDATOR_KEY; }### Answer:
@Test public void testNoValidatorsDir() { Props props = new Props(baseProps); XmlValidatorManager manager = new XmlValidatorManager(props); assertEquals("XmlValidatorManager should contain only the default validator when no xml configuration " + "file is present.", manager.getValidatorsInfo().size(), 1); assertEquals("XmlValidatorManager should contain only the default validator when no xml configuration " + "file is present.", manager.getValidatorsInfo().get(0), XmlValidatorManager.DEFAULT_VALIDATOR_KEY); }
@Test public void testDefaultValidator() { Props props = new Props(baseProps); URL validatorUrl = Resources.getResource("project/testValidators"); props.put(ValidatorConfigs.VALIDATOR_PLUGIN_DIR, validatorUrl.getPath()); XmlValidatorManager manager = new XmlValidatorManager(props); assertEquals("XmlValidatorManager should contain only the default validator when no xml configuration " + "file is present.", manager.getValidatorsInfo().size(), 1); assertEquals("XmlValidatorManager should contain only the default validator when no xml configuration " + "file is present.", manager.getValidatorsInfo().get(0), XmlValidatorManager.DEFAULT_VALIDATOR_KEY); } |
### Question:
PythonJob extends LongArgJob { public PythonJob(String jobid, Props sysProps, Props jobProps, Logger log) { super(jobid, new String[] { jobProps.getString(PYTHON_BINARY_KEY, "python"), jobProps.getString(SCRIPT_KEY) }, sysProps, jobProps, log, ImmutableSet.of(PYTHON_BINARY_KEY, SCRIPT_KEY, JOB_TYPE)); } PythonJob(String jobid, Props sysProps, Props jobProps, Logger log); }### Answer:
@Ignore("Test appears to hang.") @Test public void testPythonJob() { props = new Props(); props.put(AbstractProcessJob.WORKING_DIR, "."); props.put("type", "python"); props.put("script", scriptFile); props.put("t", "90"); props.put("type", "script"); props.put("fullPath", "."); job = new PythonJob("TestProcess", props, props, log); try { job.run(); } catch (Exception e) { e.printStackTrace(System.err); Assert.fail("Python job failed:" + e.getLocalizedMessage()); } } |
### Question:
LoginAbstractAzkabanServlet extends
AbstractAzkabanServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { Session session = getSessionFromRequest(req); logRequest(req, session); if (hasParam(req, "logout")) { resp.sendRedirect(req.getContextPath()); if (session != null) { getApplication().getSessionCache() .removeSession(session.getSessionId()); } return; } if (session != null) { if (logger.isDebugEnabled()) { logger.debug("Found session " + session.getUser()); } if (handleFileGet(req, resp)) { return; } handleGet(req, resp, session); } else { if (hasParam(req, "ajax")) { HashMap<String, String> retVal = new HashMap<String, String>(); retVal.put("error", "session"); this.writeJSON(resp, retVal); } else { handleLogin(req, resp); } } } @Override void init(ServletConfig config); void setResourceDirectory(File file); }### Answer:
@Test public void testWhenGetRequestSessionIsValid() throws Exception, IOException, ServletException { String clientIp = "127.0.0.1:10000"; String sessionId = "111"; HttpServletRequest req = MockLoginAzkabanServlet.getRequestWithNoUpstream(clientIp, sessionId, "GET"); StringWriter writer = new StringWriter(); HttpServletResponse resp = getResponse(writer); MockLoginAzkabanServlet servlet = MockLoginAzkabanServlet.getServletWithSession(sessionId, "user", "127.0.0.1"); servlet.doGet(req, resp); assertEquals("SUCCESS_MOCK_LOGIN_SERVLET", writer.toString()); } |
### Question:
Permission { public void addPermissionsByName(String... list) { for (String perm : list) { Type type = Type.valueOf(perm); if (type != null) { addPermission(type); } ; } } Permission(); Permission(int flags); Permission(Type... list); void addPermissions(Permission perm); void setPermission(Type type, boolean set); void setPermissions(int flags); void addPermission(Type... list); void addPermissionsByName(String... list); void addPermissions(Collection<Type> list); void addPermissionsByName(Collection<String> list); Set<Type> getTypes(); void removePermissions(Type... list); void removePermissionsByName(String... list); boolean isPermissionSet(Type permission); boolean isPermissionNameSet(String permission); String[] toStringArray(); String toString(); @Override int hashCode(); @Override boolean equals(Object obj); int toFlags(); }### Answer:
@Test public void testEmptyPermissionCreation() throws Exception { Permission permission = new Permission(); permission.addPermissionsByName(new String[] {}); } |
### Question:
QueuedExecutions { public void enqueue(ExecutableFlow exflow, ExecutionReference ref) throws ExecutorManagerException { if (hasExecution(exflow.getExecutionId())) { String errMsg = "Flow already in queue " + exflow.getExecutionId(); throw new ExecutorManagerException(errMsg); } Pair<ExecutionReference, ExecutableFlow> pair = new Pair<ExecutionReference, ExecutableFlow>(ref, exflow); try { queuedFlowMap.put(exflow.getExecutionId(), pair); queuedFlowList.put(pair); } catch (InterruptedException e) { String errMsg = "Failed to insert flow " + exflow.getExecutionId(); logger.error(errMsg, e); throw new ExecutorManagerException(errMsg); } } QueuedExecutions(long capacity); Pair<ExecutionReference, ExecutableFlow> fetchHead(); void dequeue(int executionId); void enqueue(ExecutableFlow exflow, ExecutionReference ref); void enqueueAll(
Collection<Pair<ExecutionReference, ExecutableFlow>> collection); Collection<Pair<ExecutionReference, ExecutableFlow>> getAllEntries(); boolean hasExecution(int executionId); ExecutableFlow getFlow(int executionId); ExecutionReference getReference(int executionId); long size(); boolean isFull(); boolean isEmpty(); void clear(); }### Answer:
@Test(expected = ExecutorManagerException.class) public void testEnqueueDuplicateExecution() throws IOException, ExecutorManagerException { Pair<ExecutionReference, ExecutableFlow> pair1 = createExecutablePair("exec1", 1); QueuedExecutions queue = new QueuedExecutions(5); queue.enqueue(pair1.getSecond(), pair1.getFirst()); queue.enqueue(pair1.getSecond(), pair1.getFirst()); }
@Test(expected = ExecutorManagerException.class) public void testEnqueueOverflow() throws IOException, ExecutorManagerException { Pair<ExecutionReference, ExecutableFlow> pair1 = createExecutablePair("exec1", 1); QueuedExecutions queue = new QueuedExecutions(1); queue.enqueue(pair1.getSecond(), pair1.getFirst()); queue.enqueue(pair1.getSecond(), pair1.getFirst()); } |
### Question:
QueuedExecutions { public void enqueueAll( Collection<Pair<ExecutionReference, ExecutableFlow>> collection) throws ExecutorManagerException { for (Pair<ExecutionReference, ExecutableFlow> pair : collection) { enqueue(pair.getSecond(), pair.getFirst()); } } QueuedExecutions(long capacity); Pair<ExecutionReference, ExecutableFlow> fetchHead(); void dequeue(int executionId); void enqueue(ExecutableFlow exflow, ExecutionReference ref); void enqueueAll(
Collection<Pair<ExecutionReference, ExecutableFlow>> collection); Collection<Pair<ExecutionReference, ExecutableFlow>> getAllEntries(); boolean hasExecution(int executionId); ExecutableFlow getFlow(int executionId); ExecutionReference getReference(int executionId); long size(); boolean isFull(); boolean isEmpty(); void clear(); }### Answer:
@Test public void testEnqueueAll() throws IOException, ExecutorManagerException { QueuedExecutions queue = new QueuedExecutions(5); List<Pair<ExecutionReference, ExecutableFlow>> dataList = getDummyData(); queue.enqueueAll(dataList); Assert.assertTrue(queue.getAllEntries().containsAll(dataList)); Assert.assertTrue(dataList.containsAll(queue.getAllEntries())); } |
### Question:
QueuedExecutions { public long size() { return queuedFlowList.size(); } QueuedExecutions(long capacity); Pair<ExecutionReference, ExecutableFlow> fetchHead(); void dequeue(int executionId); void enqueue(ExecutableFlow exflow, ExecutionReference ref); void enqueueAll(
Collection<Pair<ExecutionReference, ExecutableFlow>> collection); Collection<Pair<ExecutionReference, ExecutableFlow>> getAllEntries(); boolean hasExecution(int executionId); ExecutableFlow getFlow(int executionId); ExecutionReference getReference(int executionId); long size(); boolean isFull(); boolean isEmpty(); void clear(); }### Answer:
@Test public void testSize() throws IOException, ExecutorManagerException { QueuedExecutions queue = new QueuedExecutions(5); List<Pair<ExecutionReference, ExecutableFlow>> dataList = getDummyData(); queue.enqueueAll(dataList); Assert.assertEquals(queue.size(), 2); } |
### Question:
QueuedExecutions { public void dequeue(int executionId) { if (queuedFlowMap.containsKey(executionId)) { queuedFlowList.remove(queuedFlowMap.get(executionId)); queuedFlowMap.remove(executionId); } } QueuedExecutions(long capacity); Pair<ExecutionReference, ExecutableFlow> fetchHead(); void dequeue(int executionId); void enqueue(ExecutableFlow exflow, ExecutionReference ref); void enqueueAll(
Collection<Pair<ExecutionReference, ExecutableFlow>> collection); Collection<Pair<ExecutionReference, ExecutableFlow>> getAllEntries(); boolean hasExecution(int executionId); ExecutableFlow getFlow(int executionId); ExecutionReference getReference(int executionId); long size(); boolean isFull(); boolean isEmpty(); void clear(); }### Answer:
@Test public void testDequeue() throws IOException, ExecutorManagerException { QueuedExecutions queue = new QueuedExecutions(5); List<Pair<ExecutionReference, ExecutableFlow>> dataList = getDummyData(); queue.enqueueAll(dataList); queue.dequeue(dataList.get(0).getFirst().getExecId()); Assert.assertEquals(queue.size(), 1); Assert.assertTrue(queue.getAllEntries().contains(dataList.get(1))); } |
### Question:
QueuedExecutions { public void clear() { for (Pair<ExecutionReference, ExecutableFlow> pair : queuedFlowMap.values()) { dequeue(pair.getFirst().getExecId()); } } QueuedExecutions(long capacity); Pair<ExecutionReference, ExecutableFlow> fetchHead(); void dequeue(int executionId); void enqueue(ExecutableFlow exflow, ExecutionReference ref); void enqueueAll(
Collection<Pair<ExecutionReference, ExecutableFlow>> collection); Collection<Pair<ExecutionReference, ExecutableFlow>> getAllEntries(); boolean hasExecution(int executionId); ExecutableFlow getFlow(int executionId); ExecutionReference getReference(int executionId); long size(); boolean isFull(); boolean isEmpty(); void clear(); }### Answer:
@Test public void testClear() throws IOException, ExecutorManagerException { QueuedExecutions queue = new QueuedExecutions(5); List<Pair<ExecutionReference, ExecutableFlow>> dataList = getDummyData(); queue.enqueueAll(dataList); Assert.assertEquals(queue.size(), 2); queue.clear(); Assert.assertEquals(queue.size(), 0); } |
### Question:
QueuedExecutions { public boolean isEmpty() { return queuedFlowList.isEmpty() && queuedFlowMap.isEmpty(); } QueuedExecutions(long capacity); Pair<ExecutionReference, ExecutableFlow> fetchHead(); void dequeue(int executionId); void enqueue(ExecutableFlow exflow, ExecutionReference ref); void enqueueAll(
Collection<Pair<ExecutionReference, ExecutableFlow>> collection); Collection<Pair<ExecutionReference, ExecutableFlow>> getAllEntries(); boolean hasExecution(int executionId); ExecutableFlow getFlow(int executionId); ExecutionReference getReference(int executionId); long size(); boolean isFull(); boolean isEmpty(); void clear(); }### Answer:
@Test public void testIsEmpty() throws IOException, ExecutorManagerException { QueuedExecutions queue = new QueuedExecutions(5); List<Pair<ExecutionReference, ExecutableFlow>> dataList = getDummyData(); Assert.assertTrue(queue.isEmpty()); queue.enqueueAll(dataList); Assert.assertEquals(queue.size(), 2); queue.clear(); Assert.assertTrue(queue.isEmpty()); } |
### Question:
QueuedExecutions { public Pair<ExecutionReference, ExecutableFlow> fetchHead() throws InterruptedException { Pair<ExecutionReference, ExecutableFlow> pair = queuedFlowList.take(); if (pair != null && pair.getFirst() != null) { queuedFlowMap.remove(pair.getFirst().getExecId()); } return pair; } QueuedExecutions(long capacity); Pair<ExecutionReference, ExecutableFlow> fetchHead(); void dequeue(int executionId); void enqueue(ExecutableFlow exflow, ExecutionReference ref); void enqueueAll(
Collection<Pair<ExecutionReference, ExecutableFlow>> collection); Collection<Pair<ExecutionReference, ExecutableFlow>> getAllEntries(); boolean hasExecution(int executionId); ExecutableFlow getFlow(int executionId); ExecutionReference getReference(int executionId); long size(); boolean isFull(); boolean isEmpty(); void clear(); }### Answer:
@Test public void testFetchHead() throws IOException, ExecutorManagerException, InterruptedException { QueuedExecutions queue = new QueuedExecutions(5); List<Pair<ExecutionReference, ExecutableFlow>> dataList = getDummyData(); Assert.assertTrue(queue.isEmpty()); queue.enqueueAll(dataList); Assert.assertEquals(queue.fetchHead(), dataList.get(0)); Assert.assertEquals(queue.fetchHead(), dataList.get(1)); } |
### Question:
QueuedExecutions { public boolean isFull() { return size() >= capacity; } QueuedExecutions(long capacity); Pair<ExecutionReference, ExecutableFlow> fetchHead(); void dequeue(int executionId); void enqueue(ExecutableFlow exflow, ExecutionReference ref); void enqueueAll(
Collection<Pair<ExecutionReference, ExecutableFlow>> collection); Collection<Pair<ExecutionReference, ExecutableFlow>> getAllEntries(); boolean hasExecution(int executionId); ExecutableFlow getFlow(int executionId); ExecutionReference getReference(int executionId); long size(); boolean isFull(); boolean isEmpty(); void clear(); }### Answer:
@Test public void testIsFull() throws IOException, ExecutorManagerException, InterruptedException { QueuedExecutions queue = new QueuedExecutions(2); List<Pair<ExecutionReference, ExecutableFlow>> dataList = getDummyData(); queue.enqueueAll(dataList); Assert.assertTrue(queue.isFull()); } |
### Question:
QueuedExecutions { public boolean hasExecution(int executionId) { return queuedFlowMap.containsKey(executionId); } QueuedExecutions(long capacity); Pair<ExecutionReference, ExecutableFlow> fetchHead(); void dequeue(int executionId); void enqueue(ExecutableFlow exflow, ExecutionReference ref); void enqueueAll(
Collection<Pair<ExecutionReference, ExecutableFlow>> collection); Collection<Pair<ExecutionReference, ExecutableFlow>> getAllEntries(); boolean hasExecution(int executionId); ExecutableFlow getFlow(int executionId); ExecutionReference getReference(int executionId); long size(); boolean isFull(); boolean isEmpty(); void clear(); }### Answer:
@Test public void testHasExecution() throws IOException, ExecutorManagerException, InterruptedException { QueuedExecutions queue = new QueuedExecutions(2); List<Pair<ExecutionReference, ExecutableFlow>> dataList = getDummyData(); queue.enqueueAll(dataList); for (Pair<ExecutionReference, ExecutableFlow> pair : dataList) { Assert.assertTrue(queue.hasExecution(pair.getFirst().getExecId())); } Assert.assertFalse(queue.hasExecution(5)); Assert.assertFalse(queue.hasExecution(7)); Assert.assertFalse(queue.hasExecution(15)); } |
### Question:
QueuedExecutions { public ExecutableFlow getFlow(int executionId) { if (hasExecution(executionId)) { return queuedFlowMap.get(executionId).getSecond(); } return null; } QueuedExecutions(long capacity); Pair<ExecutionReference, ExecutableFlow> fetchHead(); void dequeue(int executionId); void enqueue(ExecutableFlow exflow, ExecutionReference ref); void enqueueAll(
Collection<Pair<ExecutionReference, ExecutableFlow>> collection); Collection<Pair<ExecutionReference, ExecutableFlow>> getAllEntries(); boolean hasExecution(int executionId); ExecutableFlow getFlow(int executionId); ExecutionReference getReference(int executionId); long size(); boolean isFull(); boolean isEmpty(); void clear(); }### Answer:
@Test public void testGetFlow() throws IOException, ExecutorManagerException, InterruptedException { QueuedExecutions queue = new QueuedExecutions(2); List<Pair<ExecutionReference, ExecutableFlow>> dataList = getDummyData(); queue.enqueueAll(dataList); for (Pair<ExecutionReference, ExecutableFlow> pair : dataList) { Assert.assertEquals(pair.getSecond(), queue.getFlow(pair.getFirst().getExecId())); } } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.