Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: TSpace implements LocalSpace<K,V>, Loggeable, Runnable { @Override public synchronized int size (Object key) { int size = 0; List l = (List) entries.get (key); if (l != null) size = l.size(); return size; } TSpace(); @Override void out(K key, V value); @Override void out(K key, V value, long timeout); @Override synchronized V rdp(Object key); @Override synchronized V inp(Object key); @Override synchronized V in(Object key); @Override synchronized V in(Object key, long timeout); @Override synchronized V rd(Object key); @Override synchronized V rd(Object key, long timeout); @Override synchronized void nrd(Object key); @Override synchronized V nrd(Object key, long timeout); @Override void run(); void gc(); @Override synchronized int size(Object key); @Override synchronized void addListener(Object key, SpaceListener listener); @Override synchronized void addListener(Object key, SpaceListener listener, long timeout); @Override synchronized void removeListener(Object key, SpaceListener listener); boolean isEmpty(); @Override synchronized Set<K> getKeySet(); String getKeysAsString(); @Override void dump(PrintStream p, String indent); void notifyListeners(Object key, Object value); @Override void push(K key, V value); @Override void push(K key, V value, long timeout); @Override void put(K key, V value); @Override void put(K key, V value, long timeout); @Override boolean existAny(K[] keys); @Override boolean existAny(K[] keys, long timeout); Map getEntries(); void setEntries(Map entries); static final long GCDELAY; }### Answer: @Test public void testConstructor() throws Throwable { TSpace tSpace = new TSpace(); assertEquals(0, tSpace.entries.size(), "tSpace.entries.size()"); }
### Question: TSpace implements LocalSpace<K,V>, Loggeable, Runnable { public void gc () { gc(0); if (System.currentTimeMillis() - lastLongGC > GCLONG) { gc(1); lastLongGC = System.currentTimeMillis(); } } TSpace(); @Override void out(K key, V value); @Override void out(K key, V value, long timeout); @Override synchronized V rdp(Object key); @Override synchronized V inp(Object key); @Override synchronized V in(Object key); @Override synchronized V in(Object key, long timeout); @Override synchronized V rd(Object key); @Override synchronized V rd(Object key, long timeout); @Override synchronized void nrd(Object key); @Override synchronized V nrd(Object key, long timeout); @Override void run(); void gc(); @Override synchronized int size(Object key); @Override synchronized void addListener(Object key, SpaceListener listener); @Override synchronized void addListener(Object key, SpaceListener listener, long timeout); @Override synchronized void removeListener(Object key, SpaceListener listener); boolean isEmpty(); @Override synchronized Set<K> getKeySet(); String getKeysAsString(); @Override void dump(PrintStream p, String indent); void notifyListeners(Object key, Object value); @Override void push(K key, V value); @Override void push(K key, V value, long timeout); @Override void put(K key, V value); @Override void put(K key, V value, long timeout); @Override boolean existAny(K[] keys); @Override boolean existAny(K[] keys, long timeout); Map getEntries(); void setEntries(Map entries); static final long GCDELAY; }### Answer: @Test public void testGc() throws Throwable { TSpace tSpace = new TSpace(); tSpace.gc(); assertEquals(0, tSpace.entries.size(), "tSpace.entries.size()"); }
### Question: TSpace implements LocalSpace<K,V>, Loggeable, Runnable { public String getKeysAsString () { StringBuilder sb = new StringBuilder(); Object[] keys; synchronized (this) { keys = entries.keySet().toArray(); } for (int i=0; i<keys.length; i++) { if (i > 0) sb.append (' '); sb.append (keys[i]); } return sb.toString(); } TSpace(); @Override void out(K key, V value); @Override void out(K key, V value, long timeout); @Override synchronized V rdp(Object key); @Override synchronized V inp(Object key); @Override synchronized V in(Object key); @Override synchronized V in(Object key, long timeout); @Override synchronized V rd(Object key); @Override synchronized V rd(Object key, long timeout); @Override synchronized void nrd(Object key); @Override synchronized V nrd(Object key, long timeout); @Override void run(); void gc(); @Override synchronized int size(Object key); @Override synchronized void addListener(Object key, SpaceListener listener); @Override synchronized void addListener(Object key, SpaceListener listener, long timeout); @Override synchronized void removeListener(Object key, SpaceListener listener); boolean isEmpty(); @Override synchronized Set<K> getKeySet(); String getKeysAsString(); @Override void dump(PrintStream p, String indent); void notifyListeners(Object key, Object value); @Override void push(K key, V value); @Override void push(K key, V value, long timeout); @Override void put(K key, V value); @Override void put(K key, V value, long timeout); @Override boolean existAny(K[] keys); @Override boolean existAny(K[] keys, long timeout); Map getEntries(); void setEntries(Map entries); static final long GCDELAY; }### Answer: @Test public void testGetKeysAsString() throws Throwable { TSpace tSpace = new TSpace(); String result = tSpace.getKeysAsString(); assertEquals("", result, "result"); assertEquals(0, tSpace.entries.size(), "tSpace.entries.size()"); }
### Question: TSpace implements LocalSpace<K,V>, Loggeable, Runnable { @Override public synchronized Set<K> getKeySet() { return new HashSet<K>(entries.keySet()); } TSpace(); @Override void out(K key, V value); @Override void out(K key, V value, long timeout); @Override synchronized V rdp(Object key); @Override synchronized V inp(Object key); @Override synchronized V in(Object key); @Override synchronized V in(Object key, long timeout); @Override synchronized V rd(Object key); @Override synchronized V rd(Object key, long timeout); @Override synchronized void nrd(Object key); @Override synchronized V nrd(Object key, long timeout); @Override void run(); void gc(); @Override synchronized int size(Object key); @Override synchronized void addListener(Object key, SpaceListener listener); @Override synchronized void addListener(Object key, SpaceListener listener, long timeout); @Override synchronized void removeListener(Object key, SpaceListener listener); boolean isEmpty(); @Override synchronized Set<K> getKeySet(); String getKeysAsString(); @Override void dump(PrintStream p, String indent); void notifyListeners(Object key, Object value); @Override void push(K key, V value); @Override void push(K key, V value, long timeout); @Override void put(K key, V value); @Override void put(K key, V value, long timeout); @Override boolean existAny(K[] keys); @Override boolean existAny(K[] keys, long timeout); Map getEntries(); void setEntries(Map entries); static final long GCDELAY; }### Answer: @Test public void testGetKeySet() throws Throwable { TSpace tSpace = new TSpace(); AbstractSet result = (AbstractSet) tSpace.getKeySet(); assertEquals(0, result.size(), "result.size()"); assertEquals(0, tSpace.entries.size(), "tSpace.entries.size()"); }
### Question: TSpace implements LocalSpace<K,V>, Loggeable, Runnable { @Override public synchronized V in (Object key) { Object obj; while ((obj = inp (key)) == null) { try { this.wait (); } catch (InterruptedException e) { } } return (V) obj; } TSpace(); @Override void out(K key, V value); @Override void out(K key, V value, long timeout); @Override synchronized V rdp(Object key); @Override synchronized V inp(Object key); @Override synchronized V in(Object key); @Override synchronized V in(Object key, long timeout); @Override synchronized V rd(Object key); @Override synchronized V rd(Object key, long timeout); @Override synchronized void nrd(Object key); @Override synchronized V nrd(Object key, long timeout); @Override void run(); void gc(); @Override synchronized int size(Object key); @Override synchronized void addListener(Object key, SpaceListener listener); @Override synchronized void addListener(Object key, SpaceListener listener, long timeout); @Override synchronized void removeListener(Object key, SpaceListener listener); boolean isEmpty(); @Override synchronized Set<K> getKeySet(); String getKeysAsString(); @Override void dump(PrintStream p, String indent); void notifyListeners(Object key, Object value); @Override void push(K key, V value); @Override void push(K key, V value, long timeout); @Override void put(K key, V value); @Override void put(K key, V value, long timeout); @Override boolean existAny(K[] keys); @Override boolean existAny(K[] keys, long timeout); Map getEntries(); void setEntries(Map entries); static final long GCDELAY; }### Answer: @Test public void testIn() throws Throwable { TSpace tSpace = new TSpace(); Object result = tSpace.in(Long.valueOf(0L), 1L); assertNull(result, "result"); assertEquals(0, tSpace.entries.size(), "tSpace.entries.size()"); }
### Question: TSpace implements LocalSpace<K,V>, Loggeable, Runnable { @Override public synchronized V inp (Object key) { if (key instanceof Template) return (V) getObject ((Template) key, true); return (V) getHead (key, true); } TSpace(); @Override void out(K key, V value); @Override void out(K key, V value, long timeout); @Override synchronized V rdp(Object key); @Override synchronized V inp(Object key); @Override synchronized V in(Object key); @Override synchronized V in(Object key, long timeout); @Override synchronized V rd(Object key); @Override synchronized V rd(Object key, long timeout); @Override synchronized void nrd(Object key); @Override synchronized V nrd(Object key, long timeout); @Override void run(); void gc(); @Override synchronized int size(Object key); @Override synchronized void addListener(Object key, SpaceListener listener); @Override synchronized void addListener(Object key, SpaceListener listener, long timeout); @Override synchronized void removeListener(Object key, SpaceListener listener); boolean isEmpty(); @Override synchronized Set<K> getKeySet(); String getKeysAsString(); @Override void dump(PrintStream p, String indent); void notifyListeners(Object key, Object value); @Override void push(K key, V value); @Override void push(K key, V value, long timeout); @Override void put(K key, V value); @Override void put(K key, V value, long timeout); @Override boolean existAny(K[] keys); @Override boolean existAny(K[] keys, long timeout); Map getEntries(); void setEntries(Map entries); static final long GCDELAY; }### Answer: @Test public void testInp() throws Throwable { TSpace tSpace = new TSpace(); MD5Template key = new MD5Template("", ""); Object result = tSpace.inp(key); assertNull(result, "result"); assertEquals(0, tSpace.entries.size(), "tSpace.entries.size()"); }
### Question: TSpace implements LocalSpace<K,V>, Loggeable, Runnable { public boolean isEmpty() { return entries.isEmpty(); } TSpace(); @Override void out(K key, V value); @Override void out(K key, V value, long timeout); @Override synchronized V rdp(Object key); @Override synchronized V inp(Object key); @Override synchronized V in(Object key); @Override synchronized V in(Object key, long timeout); @Override synchronized V rd(Object key); @Override synchronized V rd(Object key, long timeout); @Override synchronized void nrd(Object key); @Override synchronized V nrd(Object key, long timeout); @Override void run(); void gc(); @Override synchronized int size(Object key); @Override synchronized void addListener(Object key, SpaceListener listener); @Override synchronized void addListener(Object key, SpaceListener listener, long timeout); @Override synchronized void removeListener(Object key, SpaceListener listener); boolean isEmpty(); @Override synchronized Set<K> getKeySet(); String getKeysAsString(); @Override void dump(PrintStream p, String indent); void notifyListeners(Object key, Object value); @Override void push(K key, V value); @Override void push(K key, V value, long timeout); @Override void put(K key, V value); @Override void put(K key, V value, long timeout); @Override boolean existAny(K[] keys); @Override boolean existAny(K[] keys, long timeout); Map getEntries(); void setEntries(Map entries); static final long GCDELAY; }### Answer: @Test public void testIsEmpty() throws Throwable { TSpace tSpace = new TSpace(); boolean result = tSpace.isEmpty(); assertTrue(result, "result"); assertEquals(0, tSpace.entries.size(), "tSpace.entries.size()"); }
### Question: TSpace implements LocalSpace<K,V>, Loggeable, Runnable { @Override public void out (K key, V value) { if (key == null \|\| value == null) throw new NullPointerException ("key=" + key + ", value=" + value); synchronized(this) { List l = getList(key); l.add (value); if (l.size() == 1) this.notifyAll (); } if (sl != null) notifyListeners(key, value); } TSpace(); @Override void out(K key, V value); @Override void out(K key, V value, long timeout); @Override synchronized V rdp(Object key); @Override synchronized V inp(Object key); @Override synchronized V in(Object key); @Override synchronized V in(Object key, long timeout); @Override synchronized V rd(Object key); @Override synchronized V rd(Object key, long timeout); @Override synchronized void nrd(Object key); @Override synchronized V nrd(Object key, long timeout); @Override void run(); void gc(); @Override synchronized int size(Object key); @Override synchronized void addListener(Object key, SpaceListener listener); @Override synchronized void addListener(Object key, SpaceListener listener, long timeout); @Override synchronized void removeListener(Object key, SpaceListener listener); boolean isEmpty(); @Override synchronized Set<K> getKeySet(); String getKeysAsString(); @Override void dump(PrintStream p, String indent); void notifyListeners(Object key, Object value); @Override void push(K key, V value); @Override void push(K key, V value, long timeout); @Override void put(K key, V value); @Override void put(K key, V value, long timeout); @Override boolean existAny(K[] keys); @Override boolean existAny(K[] keys, long timeout); Map getEntries(); void setEntries(Map entries); static final long GCDELAY; }### Answer: @Test public void testOut() throws Throwable { TSpace tSpace = new TSpace(); tSpace.out(Integer.valueOf(0), "testString", 100L); assertEquals(1, tSpace.entries.size(), "tSpace.entries.size()"); }
### Question: ObjectTemplate implements Template { public Object getKey() { return key; } ObjectTemplate(Object key, Object value); Object getKey(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testGetKey() throws Throwable { Integer key = Integer.valueOf(0); Integer result = (Integer) new ObjectTemplate(key, Integer.valueOf(0)).getKey(); assertSame(key, result, "result"); } @Test public void testGetKey1() throws Throwable { Integer key = Integer.valueOf(100); Integer result = (Integer) new ObjectTemplate(key, "2").getKey(); assertSame(key, result, "result"); } @Test public void testGetKey2() throws Throwable { String result = (String) new ObjectTemplate("testString", "").getKey(); assertEquals("testString", result, "result"); }
### Question: ObjectTemplate implements Template { @Override public boolean equals(Object obj) { return value.equals(obj); } ObjectTemplate(Object key, Object value); Object getKey(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testNotEqualsItSelfOrAnother() { String value = "someValue"; ObjectTemplate objectTemplateA = new ObjectTemplate("key", value); ObjectTemplate objectTemplateB = new ObjectTemplate("key", value); assertFalse(objectTemplateA.equals(objectTemplateA), "should only equals on the template value"); assertFalse(objectTemplateA.equals(objectTemplateB), "should only equals on the template value"); }
### Question: ObjectTemplate implements Template { @Override public int hashCode() { return value.hashCode(); } ObjectTemplate(Object key, Object value); Object getKey(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testHaveHashCodeOfValue() { String value = "someValue"; ObjectTemplate objectTemplate = new ObjectTemplate("key", value); assertEquals(objectTemplate.hashCode(), value.hashCode(), "Should implement hashCode on the template value"); assertEquals(objectTemplate.hashCode(), value.hashCode(), "objectTemplate hashCode and value hashCode should be same"); }
### Question: SpaceTap implements SpaceListener { public void close() { if (ssp != null) { ssp.removeListener (key, this); ssp = null; } } SpaceTap(LocalSpace sp, Object key, Object tapKey, long tapTimeout); SpaceTap(LocalSpace ssp, LocalSpace dsp, Object key, Object tapKey, long tapTimeout); void notify(Object key, Object value); void close(); }### Answer: @Test public void testClose() throws Throwable { SpaceTap spaceTap = new SpaceTap(new TSpace(), "\u0001 ", Integer.valueOf(1), 100L); spaceTap.close(); assertNull(spaceTap.ssp, "spaceTap.ssp"); } @Test public void testClose1() throws Throwable { LocalSpace ssp = new TSpace(); SpaceTap spaceTap = new SpaceTap(ssp, ssp, new Object(), "", 100L); spaceTap.close(); spaceTap.close(); assertNull(spaceTap.ssp, "spaceTap.ssp"); }
### Question: SpaceUtil { public static Object[] inpAll (Space sp, Object key) { List list = new ArrayList(); Object value; do { value = sp.inp (key); if (value != null) { list.add (value); } } while (value != null); return list.toArray(); } static Object[] inpAll(Space sp, Object key); static void wipe(Space sp, Object key); static void wipeAndOut(Space sp, Object key, Object value); static void wipeAndOut(Space sp, Object key, Object value, long timeout); static long nextLong(Space sp, Object key); static boolean outIfEmpty(Space sp, Object key, Object value, long nrdTimeout, long outTimeout); static void outWhenEmpty(Space sp, Object key, Object value, long timeout); static void outWhenEmpty(Space sp, Object key, Object value); }### Answer: @Test public void testInpAll() throws Throwable { Object[] result = SpaceUtil.inpAll(new TSpace(), "testString"); assertEquals(0, result.length, "result.length"); } @Test public void testInpAllThrowsNullPointerException() throws Throwable { try { SpaceUtil.inpAll(null, ""); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"org.jpos.space.Space.inp(Object)\" because \"sp\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: SpaceUtil { public static long nextLong (Space sp, Object key) { long l = 0L; synchronized (sp) { Object obj = sp.inp (key); wipe (sp, key); if (obj instanceof Long) l = (Long) obj; sp.out (key, ++l); } return l; } static Object[] inpAll(Space sp, Object key); static void wipe(Space sp, Object key); static void wipeAndOut(Space sp, Object key, Object value); static void wipeAndOut(Space sp, Object key, Object value, long timeout); static long nextLong(Space sp, Object key); static boolean outIfEmpty(Space sp, Object key, Object value, long nrdTimeout, long outTimeout); static void outWhenEmpty(Space sp, Object key, Object value, long timeout); static void outWhenEmpty(Space sp, Object key, Object value); }### Answer: @Test public void testNextLong() throws Throwable { Space sp = new TSpace(); long result = SpaceUtil.nextLong(sp, ""); assertEquals(1, ((TSpace) sp).entries.size(), "(TSpace) sp.entries.size()"); assertEquals(1L, result, "result"); } @Test public void testNextLongThrowsNullPointerException() throws Throwable { Space sp = new TSpace(); try { SpaceUtil.nextLong(sp, null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { assertEquals("key=null, value=1", ex.getMessage(), "ex.getMessage()"); assertTrue(((TSpace) sp).isEmpty(), "(TSpace) sp.isEmpty()"); } } @Test public void testNextLongThrowsNullPointerException1() throws Throwable { try { SpaceUtil.nextLong(null, ""); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot enter synchronized block because \"sp\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: SpaceUtil { public static void wipe (Space sp, Object key) { while (sp.inp (key) != null) ; } static Object[] inpAll(Space sp, Object key); static void wipe(Space sp, Object key); static void wipeAndOut(Space sp, Object key, Object value); static void wipeAndOut(Space sp, Object key, Object value, long timeout); static long nextLong(Space sp, Object key); static boolean outIfEmpty(Space sp, Object key, Object value, long nrdTimeout, long outTimeout); static void outWhenEmpty(Space sp, Object key, Object value, long timeout); static void outWhenEmpty(Space sp, Object key, Object value); }### Answer: @Test public void testWipe1() throws Throwable { SpaceUtil.wipe(SpaceFactory.getSpace(), ""); assertTrue(true, "Test completed without Exception"); } @Test public void testWipeThrowsNullPointerException() throws Throwable { try { SpaceUtil.wipe(null, ""); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"org.jpos.space.Space.inp(Object)\" because \"sp\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: SpaceFactory { public static Space getSpace () { return getSpace (TSPACE, DEFAULT, null); } static Space getSpace(); static Space getSpace(String spaceUri); static Space getSpace(String scheme, String name, String param); static ScheduledThreadPoolExecutor getGCExecutor(); static final String TSPACE; static final String TRANSIENT; static final String PERSISTENT; static final String SPACELET; static final String JDBM; static final String JE; static final String DEFAULT; }### Answer: @Test public void testGetSpace2() throws Throwable { TSpace result = (TSpace) SpaceFactory.getSpace("testString"); assertTrue(result.isEmpty(), "result.isEmpty()"); } @Test public void testGetSpaceThrowsNullPointerException2() throws Throwable { assertThrows(NullPointerException.class, () -> { SpaceFactory.getSpace("testSpaceFactoryScheme", "testSpaceFactoryName", null); }); } @Test public void testGetSpaceThrowsSpaceError() throws Throwable { try { SpaceFactory.getSpace("spacelet", "testSpaceFactoryName", "testSpaceFactoryParam"); fail("Expected SpaceError to be thrown"); } catch (SpaceError ex) { assertEquals( "spacelet:testSpaceFactoryName:testSpaceFactoryParam not found.", ex.getMessage(), "ex.getMessage()"); } }
### Question: Log implements LogSource { public Logger getLogger() { return logger; } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testConstructor() throws Throwable { Logger logger = Logger.getLogger("testLogName"); Log log = new Log(logger, "testLogRealm"); assertEquals("testLogRealm", log.realm, "m_log.realm"); assertSame(logger, log.logger, "m_log.logger"); } @Test public void testGetLogger() throws Throwable { Logger logger = new Logger(); Log bSHRequestListener = new BSHRequestListener(); bSHRequestListener.setLogger(logger, "testLogRealm"); Logger result = bSHRequestListener.getLogger(); assertSame(logger, result, "result"); }
### Question: Log implements LogSource { public String getRealm () { return realm; } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testConstructor1() throws Throwable { Log log = new Log(); assertNull(log.getRealm(), "m_log.getRealm()"); } @Test public void testGetRealm() throws Throwable { String result = Log.getLog("testLogLogName", "testLogRealm").getRealm(); assertEquals("testLogRealm", result, "result"); }
### Question: Log implements LogSource { public LogEvent createDebug() { return createLogEvent (DEBUG); } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testCreateDebug() throws Throwable { LogEvent result = new BSHRequestListener().createDebug("testString"); assertNull(result.getRealm(), "result.getRealm()"); }
### Question: Log implements LogSource { public LogEvent createError () { return createLogEvent (ERROR); } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testCreateError() throws Throwable { LogEvent result = new Debug().createError(); assertNull(result.getRealm(), "result.getRealm()"); }
### Question: Log implements LogSource { public LogEvent createFatal () { return createLogEvent (FATAL); } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testCreateFatal() throws Throwable { LogEvent result = new Debug().createFatal("t7r"); assertNull(result.getRealm(), "result.getRealm()"); }
### Question: Log implements LogSource { public LogEvent createInfo () { return createLogEvent (INFO); } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testCreateInfo() throws Throwable { LogEvent result = Log.getLog("testLogLogName", "testLogRealm").createInfo("testString"); assertEquals("testLogRealm", result.getRealm(), "result.getRealm()"); }
### Question: Log implements LogSource { public LogEvent createLogEvent (String level) { return new LogEvent (this, level); } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testCreateLogEvent() throws Throwable { LogEvent result = new BSHRequestListener().createLogEvent("testLogLevel", ""); assertNull(result.getRealm(), "result.getRealm()"); }
### Question: Log implements LogSource { public LogEvent createTrace () { return createLogEvent (TRACE); } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testCreateTrace() throws Throwable { LogEvent result = Log.getLog("testLogLogName", "testLogRealm").createTrace(); assertEquals("testLogRealm", result.getRealm(), "result.getRealm()"); }
### Question: Log implements LogSource { public LogEvent createWarn () { return createLogEvent (WARN); } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testCreateWarn() throws Throwable { LogEvent result = new Log().createWarn("testString"); assertNull(result.getRealm(), "result.getRealm()"); }
### Question: Log implements LogSource { public void debug (Object detail) { Logger.log (createDebug (detail)); } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testDebug() throws Throwable { new BSHRequestListener().debug("testString", Integer.valueOf(0)); assertTrue(true, "Test completed without Exception"); } @Test public void testDebug1() throws Throwable { new BSHRequestListener().debug(""); assertTrue(true, "Test completed without Exception"); }
### Question: Log implements LogSource { public void error (Object detail) { Logger.log (createError (detail)); } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testError() throws Throwable { new Debug().error(new Object()); assertTrue(true, "Test completed without Exception"); } @Test public void testError1() throws Throwable { new BSHRequestListener().error("", Integer.valueOf(18)); assertTrue(true, "Test completed without Exception"); }
### Question: Log implements LogSource { public static Log getLog (String logName, String realm) { return new Log (Logger.getLogger (logName), realm); } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testGetLog() throws Throwable { Log result = Log.getLog("testLogLogName", "testLogRealm"); assertEquals("testLogRealm", result.getRealm(), "result.getRealm()"); }
### Question: Log implements LogSource { public void info (Object detail) { Logger.log (createInfo (detail)); } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testInfo1() throws Throwable { new BSHRequestListener().info("", ""); assertTrue(true, "Test completed without Exception"); }
### Question: Log implements LogSource { public void setLogger (Logger logger, String realm) { this.logger = logger; this.realm = realm; } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testSetLogger() throws Throwable { Logger logger = new Logger(); Log bSHRequestListener = new BSHRequestListener(); bSHRequestListener.setLogger(logger, "testLogRealm"); assertEquals("testLogRealm", ((BSHRequestListener) bSHRequestListener).realm, "(BSHRequestListener) bSHRequestListener.realm"); assertSame(logger, ((BSHRequestListener) bSHRequestListener).logger, "(BSHRequestListener) bSHRequestListener.logger"); } @Test public void testSetLogger1() throws Throwable { Log bSHRequestListener = new BSHRequestListener(); Logger logger = new Logger(); bSHRequestListener.setLogger(logger); assertSame(logger, ((BSHRequestListener) bSHRequestListener).logger, "(BSHRequestListener) bSHRequestListener.logger"); }
### Question: Log implements LogSource { public void setRealm (String realm) { this.realm = realm; } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testSetRealm() throws Throwable { Log bSHRequestListener = new BSHRequestListener(); bSHRequestListener.setRealm("testLogRealm"); assertEquals("testLogRealm", ((BSHRequestListener) bSHRequestListener).realm, "(BSHRequestListener) bSHRequestListener.realm"); }
### Question: Log implements LogSource { public void trace (Object detail) { Logger.log (createTrace (detail)); } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testTrace() throws Throwable { new BSHRequestListener().trace("x", "x"); assertTrue(true, "Test completed without Exception"); } @Test public void testTrace1() throws Throwable { new BSHRequestListener().trace("testString"); assertTrue(true, "Test completed without Exception"); }
### Question: Log implements LogSource { public void warn (Object detail) { Logger.log (createWarn (detail)); } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testWarn() throws Throwable { new BSHRequestListener().warn("", ""); assertTrue(true, "Test completed without Exception"); } @Test public void testWarn1() throws Throwable { new BSHRequestListener().warn(new Object()); assertTrue(true, "Test completed without Exception"); }
### Question: StopWatch { public StopWatch (long period, TimeUnit unit) { end = System.currentTimeMillis() + TimeUnit.MILLISECONDS.convert(period, unit); } StopWatch(long period, TimeUnit unit); StopWatch(long periodInMillis); void finish(); boolean isFinished(); static T get(long period, TimeUnit unit, Supplier<T> f); static T get(long period, Supplier<T> f); }### Answer: @Test public void testStopWatch() throws Throwable { long now = System.currentTimeMillis(); StopWatch sw = new StopWatch (500, TimeUnit.MILLISECONDS); assertFalse(sw.isFinished()); sw.finish(); assertTrue(System.currentTimeMillis() - now >= 500); assertTrue (sw.isFinished()); }
### Question: StopWatch { public static <T> T get(long period, TimeUnit unit, Supplier<T> f) { StopWatch w = new StopWatch(period, unit); T t = f.get(); w.finish(); return t; } StopWatch(long period, TimeUnit unit); StopWatch(long periodInMillis); void finish(); boolean isFinished(); static T get(long period, TimeUnit unit, Supplier<T> f); static T get(long period, Supplier<T> f); }### Answer: @Test public void testStopWatchStatic() throws Throwable { long now = System.currentTimeMillis(); String s = StopWatch.get(500, TimeUnit.MILLISECONDS, () -> "The Quick Brown Fox jumps over the laxy dog"); assertTrue(System.currentTimeMillis() - now >= 500); }
### Question: FlatLogListener implements LogListener, Configurable, Destroyable { @Override public void setConfiguration(Configuration cfg) throws ConfigurationException { mapper.setConfiguration(cfg); } @Override void setConfiguration(Configuration cfg); @Override synchronized LogEvent log(LogEvent ev); @Override void destroy(); }### Answer: @Test void testShouldDelegateSetConfigurationToMapper() throws ConfigurationException { FlatLogListener listener = new FlatLogListener(); listener.mapper = mock(RemoveNewLinesMapper.class); SimpleConfiguration cfg = new SimpleConfiguration(); listener.setConfiguration(cfg); verify(listener.mapper).setConfiguration(cfg); }
### Question: FlatLogListener implements LogListener, Configurable, Destroyable { @Override public void destroy() { if (p != null) { p.close(); p = null; captureStream = null; } } @Override void setConfiguration(Configuration cfg); @Override synchronized LogEvent log(LogEvent ev); @Override void destroy(); }### Answer: @Test void testDestroyShouldCallCloseOnPrintStream() { FlatLogListener listener = new FlatLogListener(); PrintStream printStream = mock(PrintStream.class); listener.p = printStream; listener.destroy(); verify(printStream).close(); }
### Question: FlatLogListener implements LogListener, Configurable, Destroyable { @Override public synchronized LogEvent log(LogEvent ev) { ev.dump(p, ""); byte[] result = mapper.apply(captureStream.toByteArray()); captureStream.reset(); return new FrozenLogEvent(new String(result)); } @Override void setConfiguration(Configuration cfg); @Override synchronized LogEvent log(LogEvent ev); @Override void destroy(); }### Answer: @Test void testLog() throws IOException { FlatLogListener listener = new FlatLogListener(); LogEvent ev = new LogEvent(); ev.setNoArmor(true); ev.addMessage("Test"); ev.addMessage("More"); LogEvent r = listener.log(ev); ByteArrayOutputStream captureStream = new ByteArrayOutputStream(); PrintStream capturePrintStream = new PrintStream(captureStream); r.dump(capturePrintStream, ""); BufferedReader reader = new BufferedReader( new InputStreamReader(new ByteArrayInputStream(captureStream.toByteArray()))); assertEquals(" <info> Test More </info>", reader.readLine()); capturePrintStream.close(); reader.close(); } @Test void testLogCorrectlyMultipleEventsAKACaptureStreamResets() throws IOException { FlatLogListener listener = new FlatLogListener(); LogEvent ev = new LogEvent(); ev.setNoArmor(true); ev.addMessage("Test"); ev.addMessage("More"); LogEvent r = listener.log(ev); ByteArrayOutputStream captureStream = new ByteArrayOutputStream(); PrintStream capturePrintStream = new PrintStream(captureStream); r.dump(capturePrintStream, ""); BufferedReader reader = new BufferedReader( new InputStreamReader(new ByteArrayInputStream(captureStream.toByteArray()))); captureStream.reset(); assertEquals(" <info> Test More </info>", reader.readLine()); assertFalse(reader.ready()); reader.close(); r = listener.log(ev); r.dump(capturePrintStream, ""); reader = new BufferedReader( new InputStreamReader(new ByteArrayInputStream(captureStream.toByteArray()))); assertEquals(" <info> Test More </info>", reader.readLine()); assertFalse(reader.ready()); capturePrintStream.close(); reader.close(); }
### Question: SimpleLogSource implements LogSource { public void error (String detail) { Logger.log (new LogEvent (this, "error", detail)); } SimpleLogSource(); SimpleLogSource(Logger logger, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setRealm(String realm); void info(String detail); void info(String detail, Object obj); void warning(String detail); void warning(String detail, Object obj); void error(String detail); void error(String detail, Object obj); }### Answer: @Test public void testError() throws Throwable { new BSHTransactionParticipant().error("testSimpleLogSourceDetail", Integer.valueOf(0)); assertTrue(true, "Test completed without Exception"); }
### Question: SimpleLogSource implements LogSource { public Logger getLogger() { return logger; } SimpleLogSource(); SimpleLogSource(Logger logger, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setRealm(String realm); void info(String detail); void info(String detail, Object obj); void warning(String detail); void warning(String detail, Object obj); void error(String detail); void error(String detail, Object obj); }### Answer: @Test public void testGetLogger() throws Throwable { Logger logger = new Logger(); SimpleLogSource bSHTransactionParticipant = new BSHTransactionParticipant(); bSHTransactionParticipant.setLogger(logger, "testSimpleLogSourceRealm"); Logger result = bSHTransactionParticipant.getLogger(); assertSame(logger, result, "result"); }
### Question: SimpleLogSource implements LogSource { public String getRealm () { return realm; } SimpleLogSource(); SimpleLogSource(Logger logger, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setRealm(String realm); void info(String detail); void info(String detail, Object obj); void warning(String detail); void warning(String detail, Object obj); void error(String detail); void error(String detail, Object obj); }### Answer: @Test public void testGetRealm() throws Throwable { SimpleLogSource bSHTransactionParticipant = new BSHTransactionParticipant(); bSHTransactionParticipant.setRealm("testSimpleLogSourceRealm"); String result = bSHTransactionParticipant.getRealm(); assertEquals("testSimpleLogSourceRealm", result, "result"); } @Test public void testGetRealm1() throws Throwable { String result = new BSHTransactionParticipant().getRealm(); assertNull(result, "result"); }
### Question: SimpleLogSource implements LogSource { public void info (String detail) { Logger.log (new LogEvent (this, "info", detail)); } SimpleLogSource(); SimpleLogSource(Logger logger, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setRealm(String realm); void info(String detail); void info(String detail, Object obj); void warning(String detail); void warning(String detail, Object obj); void error(String detail); void error(String detail, Object obj); }### Answer: @Test public void testInfo1() throws Throwable { new BSHTransactionParticipant().info("testSimpleLogSourceDetail", "testString"); assertTrue(true, "Test completed without Exception"); }
### Question: SimpleLogSource implements LogSource { public void setLogger (Logger logger, String realm) { this.logger = logger; this.realm = realm; } SimpleLogSource(); SimpleLogSource(Logger logger, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setRealm(String realm); void info(String detail); void info(String detail, Object obj); void warning(String detail); void warning(String detail, Object obj); void error(String detail); void error(String detail, Object obj); }### Answer: @Test public void testSetLogger() throws Throwable { Logger logger = new Logger(); SimpleLogSource bSHTransactionParticipant = new BSHTransactionParticipant(); bSHTransactionParticipant.setLogger(logger, "testSimpleLogSourceRealm"); assertEquals("testSimpleLogSourceRealm", ((BSHTransactionParticipant) bSHTransactionParticipant).realm, "(BSHTransactionParticipant) bSHTransactionParticipant.realm"); assertSame(logger, ((BSHTransactionParticipant) bSHTransactionParticipant).logger, "(BSHTransactionParticipant) bSHTransactionParticipant.logger"); }
### Question: SimpleLogSource implements LogSource { public void setRealm (String realm) { this.realm = realm; } SimpleLogSource(); SimpleLogSource(Logger logger, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setRealm(String realm); void info(String detail); void info(String detail, Object obj); void warning(String detail); void warning(String detail, Object obj); void error(String detail); void error(String detail, Object obj); }### Answer: @Test public void testSetRealm() throws Throwable { SimpleLogSource bSHTransactionParticipant = new BSHTransactionParticipant(); bSHTransactionParticipant.setRealm("testSimpleLogSourceRealm"); assertEquals("testSimpleLogSourceRealm", ((BSHTransactionParticipant) bSHTransactionParticipant).realm, "(BSHTransactionParticipant) bSHTransactionParticipant.realm"); }
### Question: SimpleLogSource implements LogSource { public void warning (String detail) { Logger.log (new LogEvent (this, "warning", detail)); } SimpleLogSource(); SimpleLogSource(Logger logger, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setRealm(String realm); void info(String detail); void info(String detail, Object obj); void warning(String detail); void warning(String detail, Object obj); void error(String detail); void error(String detail, Object obj); }### Answer: @Test public void testWarning() throws Throwable { new BSHTransactionParticipant().warning("testSimpleLogSourceDetail", ""); assertTrue(true, "Test completed without Exception"); }
### Question: RotateLogListener extends SimpleLogListener implements Configurable, Destroyable { protected synchronized void openLogFile() throws IOException { if (f != null) f.close(); f = new FileOutputStream (logName, true); setPrintStream (new PrintStream(f)); p.println ("<?xml version=\"1.0\" encoding=\"UTF-8\"?>"); p.println ("<logger class=\"" + getClass().getName() + "\">"); } RotateLogListener(); void setConfiguration(Configuration cfg); synchronized LogEvent log(LogEvent ev); void logRotate(); synchronized void logRotate(boolean isStartup); void destroy(); static final int CHECK_INTERVAL; static final long DEFAULT_MAXSIZE; }### Answer: @Test public void testCheckSizeThrowsNullPointerException() throws Throwable { RotateLogListener rotateLogListener = new RotateLogListener(); try { rotateLogListener.openLogFile(); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { assertNull(ex.getMessage(), "ex.getMessage()"); assertNull(rotateLogListener.f, "rotateLogListener.f"); assertNotNull(rotateLogListener.p, "rotateLogListener.p"); } } @Test public void testOpenLogFileThrowsNullPointerException() throws Throwable { RotateLogListener dailyLogListener = new DailyLogListener(); try { dailyLogListener.openLogFile(); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { assertNull(((DailyLogListener) dailyLogListener).f, "(DailyLogListener) dailyLogListener.f"); assertNotNull(((DailyLogListener) dailyLogListener).p, "(DailyLogListener) dailyLogListener.p"); } }
### Question: RotateLogListener extends SimpleLogListener implements Configurable, Destroyable { protected synchronized void closeLogFile() throws IOException { p.println ("</logger>"); if (f != null) f.close(); f = null; } RotateLogListener(); void setConfiguration(Configuration cfg); synchronized LogEvent log(LogEvent ev); void logRotate(); synchronized void logRotate(boolean isStartup); void destroy(); static final int CHECK_INTERVAL; static final long DEFAULT_MAXSIZE; }### Answer: @Test @Disabled("test causes problems, closes stdout") public void testCloseLogFile() throws Throwable { RotateLogListener rotateLogListener = new RotateLogListener(); rotateLogListener.closeLogFile(); assertNull(rotateLogListener.f, "rotateLogListener.f"); }
### Question: RotateLogListener extends SimpleLogListener implements Configurable, Destroyable { public void destroy () { if (rotate != null) rotate.cancel(); try { closeLogFile (); } catch (IOException e) { logDebug(e.getMessage()); } } RotateLogListener(); void setConfiguration(Configuration cfg); synchronized LogEvent log(LogEvent ev); void logRotate(); synchronized void logRotate(boolean isStartup); void destroy(); static final int CHECK_INTERVAL; static final long DEFAULT_MAXSIZE; }### Answer: @Test public void testDestroy() throws Throwable { RotateLogListener dailyLogListener = new DailyLogListener(); dailyLogListener.destroy(); assertNull(((DailyLogListener) dailyLogListener).f, "(DailyLogListener) dailyLogListener.f"); }
### Question: RotateLogListener extends SimpleLogListener implements Configurable, Destroyable { public synchronized LogEvent log (LogEvent ev) { if (msgCount++ > CHECK_INTERVAL) { checkSize(); msgCount = 0; } return super.log (ev); } RotateLogListener(); void setConfiguration(Configuration cfg); synchronized LogEvent log(LogEvent ev); void logRotate(); synchronized void logRotate(boolean isStartup); void destroy(); static final int CHECK_INTERVAL; static final long DEFAULT_MAXSIZE; }### Answer: @Test @Disabled("test causes problems, closes stdout") public void testLog() throws Throwable { RotateLogListener dailyLogListener = new DailyLogListener(); dailyLogListener.close(); LogEvent ev = new LogEvent(); LogEvent result = dailyLogListener.log(ev); assertSame(ev, result, "result"); assertNull(((DailyLogListener) dailyLogListener).p, "(DailyLogListener) dailyLogListener.p"); assertEquals(1, ((DailyLogListener) dailyLogListener).msgCount, "(DailyLogListener) dailyLogListener.msgCount"); } @Test @Disabled("test causes problems, closes stdout") public void testLog1() throws Throwable { RotateLogListener dailyLogListener = new DailyLogListener(); dailyLogListener.close(); LogEvent result = dailyLogListener.log(null); assertNull(result, "result"); assertNull(((DailyLogListener) dailyLogListener).p, "(DailyLogListener) dailyLogListener.p"); assertEquals(1, ((DailyLogListener) dailyLogListener).msgCount, "(DailyLogListener) dailyLogListener.msgCount"); }
### Question: RotateLogListener extends SimpleLogListener implements Configurable, Destroyable { protected synchronized void logDebug (String msg) { if (p != null) { p.println ("<log realm=\"rotate-log-listener\" at=\""+new Date().toString() +"\">"); p.println (" "+msg); p.println ("</log>"); } } RotateLogListener(); void setConfiguration(Configuration cfg); synchronized LogEvent log(LogEvent ev); void logRotate(); synchronized void logRotate(boolean isStartup); void destroy(); static final int CHECK_INTERVAL; static final long DEFAULT_MAXSIZE; }### Answer: @Test public void testLogDebug() throws Throwable { RotateLogListener dailyLogListener = new DailyLogListener(); dailyLogListener.logDebug("testRotateLogListenerMsg"); assertNotNull(((DailyLogListener) dailyLogListener).p, "(DailyLogListener) dailyLogListener.p"); } @Test @Disabled("test causes problems, closes stdout") public void testLogDebug1() throws Throwable { RotateLogListener dailyLogListener = new DailyLogListener(); dailyLogListener.close(); dailyLogListener.logDebug("testRotateLogListenerMsg"); assertNull(((DailyLogListener) dailyLogListener).p, "(DailyLogListener) dailyLogListener.p"); }
### Question: RotateLogListener extends SimpleLogListener implements Configurable, Destroyable { public void logRotate () throws IOException { logRotate(false); } RotateLogListener(); void setConfiguration(Configuration cfg); synchronized LogEvent log(LogEvent ev); void logRotate(); synchronized void logRotate(boolean isStartup); void destroy(); static final int CHECK_INTERVAL; static final long DEFAULT_MAXSIZE; }### Answer: @Test @Disabled("test causes problems, closes stdout") public void testLogRotateThrowsNullPointerException() throws Throwable { RotateLogListener rotateLogListener = new RotateLogListener(); try { rotateLogListener.logRotate(); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { assertNull(rotateLogListener.f, "rotateLogListener.f"); assertNull(rotateLogListener.p, "rotateLogListener.p"); } }
### Question: RotateLogListener extends SimpleLogListener implements Configurable, Destroyable { protected String fileNameFromPattern(String inFileName, String patternCodes) { String[] computedValues; String[] codes = patternCodes.split(","); computedValues = new String[codes.length]; for (int i = 0; i < codes.length; i++) { if (codes[i].equals("h")) { try { computedValues[i] = InetAddress.getLocalHost().getHostName(); } catch (UnknownHostException e) { computedValues[i] = "#h"; } } else if (codes[i].startsWith("e")) { try { String envVar = codes[i].substring(2, codes[i].length()-1); computedValues[i] = System.getenv(envVar); } catch (Exception e) { computedValues[i] = "#e"; } } } return String.format(inFileName, (Object[]) computedValues); } RotateLogListener(); void setConfiguration(Configuration cfg); synchronized LogEvent log(LogEvent ev); void logRotate(); synchronized void logRotate(boolean isStartup); void destroy(); static final int CHECK_INTERVAL; static final long DEFAULT_MAXSIZE; }### Answer: @Test public void testEnvironmentCodeParsing() { Map<String, String> env = System.getenv(); RotateLogListener listener = new RotateLogListener(); Map.Entry<String, String> entry = env.entrySet().iterator().next(); String replaced = listener.fileNameFromPattern("%s-log", "e{" + entry.getKey() + "}"); assertEquals(entry.getValue() + "-log", replaced); }
### Question: BlockingQueue { public synchronized void close() { closed = true; notifyAll(); } synchronized void enqueue(Object o); synchronized void requeue(Object o); synchronized Object dequeue(); synchronized Object dequeue(long timeout); synchronized void close(); synchronized int consumerCount(); synchronized int consumerDeficit(); synchronized boolean ready(); synchronized int pending(); LinkedList getQueue(); void setQueue(LinkedList queue); }### Answer: @Test public void testClose() { BlockingQueue blockingQueue = new BlockingQueue(); blockingQueue.close(); assertFalse(blockingQueue.ready(), "blockingQueue.ready()"); }
### Question: BlockingQueue { public synchronized int consumerCount() { return consumers; } synchronized void enqueue(Object o); synchronized void requeue(Object o); synchronized Object dequeue(); synchronized Object dequeue(long timeout); synchronized void close(); synchronized int consumerCount(); synchronized int consumerDeficit(); synchronized boolean ready(); synchronized int pending(); LinkedList getQueue(); void setQueue(LinkedList queue); }### Answer: @Test public void testConsumerCount() throws Throwable { int result = new BlockingQueue().consumerCount(); assertEquals(0, result, "result"); }
### Question: BlockingQueue { public synchronized Object dequeue() throws InterruptedException, Closed { consumers++; try { while (queue.size() == 0) { wait(); if (closed) throw new Closed(); } } finally { consumers--; } return queue.removeFirst(); } synchronized void enqueue(Object o); synchronized void requeue(Object o); synchronized Object dequeue(); synchronized Object dequeue(long timeout); synchronized void close(); synchronized int consumerCount(); synchronized int consumerDeficit(); synchronized boolean ready(); synchronized int pending(); LinkedList getQueue(); void setQueue(LinkedList queue); }### Answer: @SuppressWarnings("unchecked") @Test public void testDequeue() throws Throwable { BlockingQueue blockingQueue = new BlockingQueue(); LinkedList queue = new LinkedList<Object>(); Boolean boolean2 = Boolean.TRUE; queue.add(true); queue.add(""); blockingQueue.setQueue(queue); Boolean result = (Boolean) blockingQueue.dequeue(-1L); assertSame(queue, blockingQueue.getQueue(), "blockingQueue.getQueue()"); assertFalse(boolean2.equals(blockingQueue.getQueue().get(0)), "blockingQueue.getQueue().get(0) had boolean2 removed"); assertSame(true, result, "result"); assertEquals(0, blockingQueue.consumerCount(), "blockingQueue.consumerCount()"); }
### Question: BlockingQueue { public synchronized void enqueue (Object o) throws Closed { if (closed) throw new Closed(); queue.addLast (o); notify(); } synchronized void enqueue(Object o); synchronized void requeue(Object o); synchronized Object dequeue(); synchronized Object dequeue(long timeout); synchronized void close(); synchronized int consumerCount(); synchronized int consumerDeficit(); synchronized boolean ready(); synchronized int pending(); LinkedList getQueue(); void setQueue(LinkedList queue); }### Answer: @Test public void testEnqueue() throws Throwable { BlockingQueue blockingQueue = new BlockingQueue(); blockingQueue.enqueue("testString"); assertEquals(1, blockingQueue.getQueue().size(), "blockingQueue.getQueue().size()"); assertEquals("testString", blockingQueue.getQueue().get(0), "blockingQueue.getQueue().get(0)"); }
### Question: BlockingQueue { public synchronized int pending() { return queue.size(); } synchronized void enqueue(Object o); synchronized void requeue(Object o); synchronized Object dequeue(); synchronized Object dequeue(long timeout); synchronized void close(); synchronized int consumerCount(); synchronized int consumerDeficit(); synchronized boolean ready(); synchronized int pending(); LinkedList getQueue(); void setQueue(LinkedList queue); }### Answer: @SuppressWarnings("unchecked") @Test public void testPending() throws Throwable { BlockingQueue blockingQueue = new BlockingQueue(); LinkedList queue = new LinkedList(); queue.add(Integer.valueOf(100)); blockingQueue.setQueue(queue); int result = blockingQueue.pending(); assertEquals(1, result, "result"); }
### Question: BlockingQueue { public synchronized boolean ready() { return !closed; } synchronized void enqueue(Object o); synchronized void requeue(Object o); synchronized Object dequeue(); synchronized Object dequeue(long timeout); synchronized void close(); synchronized int consumerCount(); synchronized int consumerDeficit(); synchronized boolean ready(); synchronized int pending(); LinkedList getQueue(); void setQueue(LinkedList queue); }### Answer: @Test public void testReady() throws Throwable { boolean result = new BlockingQueue().ready(); assertTrue(result, "result"); }
### Question: BlockingQueue { public synchronized void requeue (Object o) throws Closed { if (closed) throw new Closed(); queue.addFirst (o); notify(); } synchronized void enqueue(Object o); synchronized void requeue(Object o); synchronized Object dequeue(); synchronized Object dequeue(long timeout); synchronized void close(); synchronized int consumerCount(); synchronized int consumerDeficit(); synchronized boolean ready(); synchronized int pending(); LinkedList getQueue(); void setQueue(LinkedList queue); }### Answer: @Test public void testRequeue() throws Throwable { BlockingQueue blockingQueue = new BlockingQueue(); blockingQueue.requeue("testString"); assertEquals(1, blockingQueue.getQueue().size(), "blockingQueue.getQueue().size()"); assertEquals("testString", blockingQueue.getQueue().get(0), "blockingQueue.getQueue().get(0)"); }
### Question: BlockingQueue { public void setQueue (LinkedList queue) { this.queue = queue; } synchronized void enqueue(Object o); synchronized void requeue(Object o); synchronized Object dequeue(); synchronized Object dequeue(long timeout); synchronized void close(); synchronized int consumerCount(); synchronized int consumerDeficit(); synchronized boolean ready(); synchronized int pending(); LinkedList getQueue(); void setQueue(LinkedList queue); }### Answer: @SuppressWarnings("unchecked") @Test public void testSetQueue() throws Throwable { LinkedList queue = new LinkedList(); BlockingQueue blockingQueue = new BlockingQueue(); blockingQueue.setQueue(queue); assertSame(queue, blockingQueue.getQueue(), "blockingQueue.getQueue()"); }
### Question: ExceptionLogFilter implements LogListener { public synchronized LogEvent log (LogEvent evt) { synchronized (evt.getPayLoad()) { for (Object o : evt.getPayLoad()) { if (o instanceof Throwable) return evt; } } return null; } ExceptionLogFilter(); synchronized LogEvent log(LogEvent evt); }### Answer: @Test public void testLog() throws Throwable { LogEvent result = new ExceptionLogFilter().log(new LogEvent()); assertNull(result, "result"); }
### Question: SimpleLogListener implements LogListener, XmlConfigurable, Consumer<LogEventWriter> { public synchronized void close() { if (writer != null) { writer.close(); p = null; } if (p != null) { p.close(); p = null; } } SimpleLogListener(); SimpleLogListener(PrintStream p); synchronized void setPrintStream(PrintStream p); synchronized void close(); synchronized LogEvent log(LogEvent ev); @Override void accept(LogEventWriter writer); @Override void setConfiguration(Element e); }### Answer: @Test public void testClose() throws Throwable { SimpleLogListener simpleLogListener = new SimpleLogListener(new PrintStream(new ByteArrayOutputStream(), true)); simpleLogListener.close(); assertNull(simpleLogListener.p, "simpleLogListener.p"); } @Test public void testClose1() throws Throwable { SimpleLogListener simpleLogListener = new SimpleLogListener(null); simpleLogListener.close(); assertNull(simpleLogListener.p, "simpleLogListener.p"); }
### Question: SimpleLogListener implements LogListener, XmlConfigurable, Consumer<LogEventWriter> { public synchronized LogEvent log (LogEvent ev) { if (writer != null) { writer.write(ev); } else { if (p != null) { ev.dump(p, ""); p.flush(); } } return ev; } SimpleLogListener(); SimpleLogListener(PrintStream p); synchronized void setPrintStream(PrintStream p); synchronized void close(); synchronized LogEvent log(LogEvent ev); @Override void accept(LogEventWriter writer); @Override void setConfiguration(Element e); }### Answer: @Test public void testLog() throws Throwable { LogEvent result = new SimpleLogListener(null).log(null); assertNull(result, "result"); } @Test public void testLog1() throws Throwable { LogEvent ev = new LogEvent("testSimpleLogListenerTag", "1"); LogEvent result = new SimpleLogListener(null).log(ev); assertSame(ev, result, "result"); }
### Question: SimpleLogListener implements LogListener, XmlConfigurable, Consumer<LogEventWriter> { public synchronized void setPrintStream (PrintStream p) { this.p = p; if (writer != null) { writer.setPrintStream(p); } } SimpleLogListener(); SimpleLogListener(PrintStream p); synchronized void setPrintStream(PrintStream p); synchronized void close(); synchronized LogEvent log(LogEvent ev); @Override void accept(LogEventWriter writer); @Override void setConfiguration(Element e); }### Answer: @Test public void testSetPrintStream() throws Throwable { SimpleLogListener simpleLogListener = new SimpleLogListener(); PrintStream p = new PrintStream(new ByteArrayOutputStream(), true); simpleLogListener.setPrintStream(p); assertSame(p, simpleLogListener.p, "simpleLogListener.p"); }
### Question: SimpleLogListener implements LogListener, XmlConfigurable, Consumer<LogEventWriter> { @Override public void setConfiguration(Element e) throws ConfigurationException { Element ew = e.getChild("writer"); LogEventWriter writer; if (ew != null) { String clazz = ew.getAttributeValue("class"); if (clazz != null) { try { writer = (LogEventWriter) Class.forName(clazz).newInstance(); } catch (Exception ex) { throw new ConfigurationException(ex); } if (writer != null) { if (writer instanceof Configurable) { SimpleConfigurationFactory factory = new SimpleConfigurationFactory(); ((Configurable) writer).setConfiguration(factory.getConfiguration(ew)); } if (writer instanceof XmlConfigurable) { ((XmlConfigurable) writer).setConfiguration(ew); } accept(writer); } } else { throw new ConfigurationException("The writer configuration requires a class attribute"); } } } SimpleLogListener(); SimpleLogListener(PrintStream p); synchronized void setPrintStream(PrintStream p); synchronized void close(); synchronized LogEvent log(LogEvent ev); @Override void accept(LogEventWriter writer); @Override void setConfiguration(Element e); }### Answer: @Test void testSetConfigurationShouldNotCreateAndSetWriterIfNotPresent() throws ConfigurationException { SimpleLogListener simpleLogListener = new SimpleLogListener(); Element root = new Element("root"); simpleLogListener.setConfiguration(root); assertNull(simpleLogListener.writer); } @Test void testSetConfigurationShouldThrowConfigurationExceptionOnNewInstanceFailure() { SimpleLogListener simpleLogListener = new SimpleLogListener(); Element root = new Element("root"); Element we = new Element("writer"); Element prop = new Element("property"); we.setAttribute("class", "org.jpos.util.FakeLogEventWriter"); we.addContent(prop); root.addContent(we); assertThrows(ConfigurationException.class, () -> simpleLogListener.setConfiguration(root)); } @Test void testSetConfigurationShouldThrowConfigurationExceptionWhenWriterClassAttributeMissing() { SimpleLogListener simpleLogListener = new SimpleLogListener(); Element root = new Element("root"); Element we = new Element("writer"); root.addContent(we); assertThrows(ConfigurationException.class, () -> simpleLogListener.setConfiguration(root)); }
### Question: DirPoll extends SimpleLogSource implements Runnable, FilenameFilter, Configurable, Destroyable { public boolean isPaused() { synchronized (this) { return paused; } } DirPoll(); synchronized void setPath(String base); void setShouldTimestampArchive(boolean shouldTimestampArchive); void setArchiveDateFormat(String dateFormat); void setShouldArchive(boolean shouldArchive); void setShouldCompressArchive(boolean shouldCompressArchive); void setAcceptZeroLength(boolean acceptZeroLength); String getPath(); void setRequestDir(String dir); void setResponseDir(String dir); void setTmpDir(String dir); void setBadDir(String dir); void setRunDir(String dir); void setArchiveDir(String dir); void setPollInterval(long pollInterval); void setResponseSuffix(String suffix); long getPollInterval(); void setProcessor(Object processor); boolean isRegexPriorityMatching(); void setRegexPriorityMatching(boolean regexPriorityMatching); Object getProcessor(); void setConfiguration(Configuration cfg); void setPriorities(String priorities); synchronized void setThreadPool(ThreadPool pool); boolean accept(File dir, String name); void run(); void destroy(); void createDirs(); void addPriority(String fileExtension); void pause(); void unpause(); boolean isPaused(); }### Answer: @Test public void testIsPaused() throws Throwable { boolean result = new DirPoll().isPaused(); assertFalse(result, "result"); }
### Question: DirPoll extends SimpleLogSource implements Runnable, FilenameFilter, Configurable, Destroyable { public void pause() { synchronized (this) { if (!paused) { paused = true; notify(); } } } DirPoll(); synchronized void setPath(String base); void setShouldTimestampArchive(boolean shouldTimestampArchive); void setArchiveDateFormat(String dateFormat); void setShouldArchive(boolean shouldArchive); void setShouldCompressArchive(boolean shouldCompressArchive); void setAcceptZeroLength(boolean acceptZeroLength); String getPath(); void setRequestDir(String dir); void setResponseDir(String dir); void setTmpDir(String dir); void setBadDir(String dir); void setRunDir(String dir); void setArchiveDir(String dir); void setPollInterval(long pollInterval); void setResponseSuffix(String suffix); long getPollInterval(); void setProcessor(Object processor); boolean isRegexPriorityMatching(); void setRegexPriorityMatching(boolean regexPriorityMatching); Object getProcessor(); void setConfiguration(Configuration cfg); void setPriorities(String priorities); synchronized void setThreadPool(ThreadPool pool); boolean accept(File dir, String name); void run(); void destroy(); void createDirs(); void addPriority(String fileExtension); void pause(); void unpause(); boolean isPaused(); }### Answer: @Test public void testPause() throws Throwable { DirPoll dirPoll = new DirPoll(); dirPoll.pause(); assertTrue(dirPoll.isPaused(), "dirPoll.isPaused()"); }
### Question: DirPoll extends SimpleLogSource implements Runnable, FilenameFilter, Configurable, Destroyable { public void setArchiveDir (String dir) { archiveDir = new File (basePath, dir); } DirPoll(); synchronized void setPath(String base); void setShouldTimestampArchive(boolean shouldTimestampArchive); void setArchiveDateFormat(String dateFormat); void setShouldArchive(boolean shouldArchive); void setShouldCompressArchive(boolean shouldCompressArchive); void setAcceptZeroLength(boolean acceptZeroLength); String getPath(); void setRequestDir(String dir); void setResponseDir(String dir); void setTmpDir(String dir); void setBadDir(String dir); void setRunDir(String dir); void setArchiveDir(String dir); void setPollInterval(long pollInterval); void setResponseSuffix(String suffix); long getPollInterval(); void setProcessor(Object processor); boolean isRegexPriorityMatching(); void setRegexPriorityMatching(boolean regexPriorityMatching); Object getProcessor(); void setConfiguration(Configuration cfg); void setPriorities(String priorities); synchronized void setThreadPool(ThreadPool pool); boolean accept(File dir, String name); void run(); void destroy(); void createDirs(); void addPriority(String fileExtension); void pause(); void unpause(); boolean isPaused(); }### Answer: @Test public void testSetArchiveDirThrowsNullPointerException() throws Throwable { DirPoll dirPoll = new DirPoll(); try { dirPoll.setArchiveDir(null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { assertNull(ex.getMessage(), "ex.getMessage()"); } }
### Question: CharTag { public String getTLV() { int vLen = 0; if (value != null) vLen = value.length(); String length = ISOUtil.zeropad(vLen, lengthSize); String tlv; if (swapTagWithLength) tlv = length + tagId; else tlv = tagId + length; if (vLen == 0) return tlv; return tlv + value; } protected CharTag(String tagId, String value); String getTLV(); String getTagId(); String getValue(); @Override String toString(); }### Answer: @Test void testTLVNullValue() { instance = tagMap.createTLV("02", null); assertEquals("02000", instance.getTLV()); }
### Question: DirPoll extends SimpleLogSource implements Runnable, FilenameFilter, Configurable, Destroyable { public void setBadDir (String dir) { badDir = new File (basePath, dir); } DirPoll(); synchronized void setPath(String base); void setShouldTimestampArchive(boolean shouldTimestampArchive); void setArchiveDateFormat(String dateFormat); void setShouldArchive(boolean shouldArchive); void setShouldCompressArchive(boolean shouldCompressArchive); void setAcceptZeroLength(boolean acceptZeroLength); String getPath(); void setRequestDir(String dir); void setResponseDir(String dir); void setTmpDir(String dir); void setBadDir(String dir); void setRunDir(String dir); void setArchiveDir(String dir); void setPollInterval(long pollInterval); void setResponseSuffix(String suffix); long getPollInterval(); void setProcessor(Object processor); boolean isRegexPriorityMatching(); void setRegexPriorityMatching(boolean regexPriorityMatching); Object getProcessor(); void setConfiguration(Configuration cfg); void setPriorities(String priorities); synchronized void setThreadPool(ThreadPool pool); boolean accept(File dir, String name); void run(); void destroy(); void createDirs(); void addPriority(String fileExtension); void pause(); void unpause(); boolean isPaused(); }### Answer: @Test public void testSetBadDirThrowsNullPointerException() throws Throwable { DirPoll dirPoll = new DirPoll(); try { dirPoll.setBadDir(null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { assertNull(ex.getMessage(), "ex.getMessage()"); } }
### Question: DirPoll extends SimpleLogSource implements Runnable, FilenameFilter, Configurable, Destroyable { public synchronized void setPath(String base) { this.basePath = base; requestDir = new File(base, "request"); responseDir = new File(base, "response"); tmpDir = new File(base, "tmp"); badDir = new File(base, "bad"); runDir = new File(base, "run"); archiveDir = new File(base, "archive"); } DirPoll(); synchronized void setPath(String base); void setShouldTimestampArchive(boolean shouldTimestampArchive); void setArchiveDateFormat(String dateFormat); void setShouldArchive(boolean shouldArchive); void setShouldCompressArchive(boolean shouldCompressArchive); void setAcceptZeroLength(boolean acceptZeroLength); String getPath(); void setRequestDir(String dir); void setResponseDir(String dir); void setTmpDir(String dir); void setBadDir(String dir); void setRunDir(String dir); void setArchiveDir(String dir); void setPollInterval(long pollInterval); void setResponseSuffix(String suffix); long getPollInterval(); void setProcessor(Object processor); boolean isRegexPriorityMatching(); void setRegexPriorityMatching(boolean regexPriorityMatching); Object getProcessor(); void setConfiguration(Configuration cfg); void setPriorities(String priorities); synchronized void setThreadPool(ThreadPool pool); boolean accept(File dir, String name); void run(); void destroy(); void createDirs(); void addPriority(String fileExtension); void pause(); void unpause(); boolean isPaused(); }### Answer: @Test public void testSetPath() throws Throwable { DirPoll dirPoll = new DirPoll(); dirPoll.setPath("testDirPollBase"); assertEquals("testDirPollBase", dirPoll.getPath(), "dirPoll.getPath()"); }
### Question: DirPoll extends SimpleLogSource implements Runnable, FilenameFilter, Configurable, Destroyable { public void setPollInterval(long pollInterval) { this.pollInterval = pollInterval; } DirPoll(); synchronized void setPath(String base); void setShouldTimestampArchive(boolean shouldTimestampArchive); void setArchiveDateFormat(String dateFormat); void setShouldArchive(boolean shouldArchive); void setShouldCompressArchive(boolean shouldCompressArchive); void setAcceptZeroLength(boolean acceptZeroLength); String getPath(); void setRequestDir(String dir); void setResponseDir(String dir); void setTmpDir(String dir); void setBadDir(String dir); void setRunDir(String dir); void setArchiveDir(String dir); void setPollInterval(long pollInterval); void setResponseSuffix(String suffix); long getPollInterval(); void setProcessor(Object processor); boolean isRegexPriorityMatching(); void setRegexPriorityMatching(boolean regexPriorityMatching); Object getProcessor(); void setConfiguration(Configuration cfg); void setPriorities(String priorities); synchronized void setThreadPool(ThreadPool pool); boolean accept(File dir, String name); void run(); void destroy(); void createDirs(); void addPriority(String fileExtension); void pause(); void unpause(); boolean isPaused(); }### Answer: @Test public void testSetPollInterval() throws Throwable { DirPoll dirPoll = new DirPoll(); dirPoll.setPollInterval(100L); assertEquals(100L, dirPoll.getPollInterval(), "dirPoll.getPollInterval()"); }
### Question: DirPoll extends SimpleLogSource implements Runnable, FilenameFilter, Configurable, Destroyable { public void setPriorities (String priorities) { StringTokenizer st = new StringTokenizer (priorities); Vector v = new Vector(); while (st.hasMoreTokens()) { String ext = st.nextToken(); v.addElement (ext.equals ("*") ? "" : ext); } if (v.isEmpty()) v.addElement (""); synchronized (this) { prio = v; } } DirPoll(); synchronized void setPath(String base); void setShouldTimestampArchive(boolean shouldTimestampArchive); void setArchiveDateFormat(String dateFormat); void setShouldArchive(boolean shouldArchive); void setShouldCompressArchive(boolean shouldCompressArchive); void setAcceptZeroLength(boolean acceptZeroLength); String getPath(); void setRequestDir(String dir); void setResponseDir(String dir); void setTmpDir(String dir); void setBadDir(String dir); void setRunDir(String dir); void setArchiveDir(String dir); void setPollInterval(long pollInterval); void setResponseSuffix(String suffix); long getPollInterval(); void setProcessor(Object processor); boolean isRegexPriorityMatching(); void setRegexPriorityMatching(boolean regexPriorityMatching); Object getProcessor(); void setConfiguration(Configuration cfg); void setPriorities(String priorities); synchronized void setThreadPool(ThreadPool pool); boolean accept(File dir, String name); void run(); void destroy(); void createDirs(); void addPriority(String fileExtension); void pause(); void unpause(); boolean isPaused(); }### Answer: @Test public void testSetPrioritiesThrowsNullPointerException() throws Throwable { DirPoll dirPoll = new DirPoll(); try { dirPoll.setPriorities(null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"String.length()\" because \"str\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: DirPoll extends SimpleLogSource implements Runnable, FilenameFilter, Configurable, Destroyable { public void setRequestDir (String dir) { requestDir = new File (basePath, dir); } DirPoll(); synchronized void setPath(String base); void setShouldTimestampArchive(boolean shouldTimestampArchive); void setArchiveDateFormat(String dateFormat); void setShouldArchive(boolean shouldArchive); void setShouldCompressArchive(boolean shouldCompressArchive); void setAcceptZeroLength(boolean acceptZeroLength); String getPath(); void setRequestDir(String dir); void setResponseDir(String dir); void setTmpDir(String dir); void setBadDir(String dir); void setRunDir(String dir); void setArchiveDir(String dir); void setPollInterval(long pollInterval); void setResponseSuffix(String suffix); long getPollInterval(); void setProcessor(Object processor); boolean isRegexPriorityMatching(); void setRegexPriorityMatching(boolean regexPriorityMatching); Object getProcessor(); void setConfiguration(Configuration cfg); void setPriorities(String priorities); synchronized void setThreadPool(ThreadPool pool); boolean accept(File dir, String name); void run(); void destroy(); void createDirs(); void addPriority(String fileExtension); void pause(); void unpause(); boolean isPaused(); }### Answer: @Test public void testSetRequestDirThrowsNullPointerException() throws Throwable { DirPoll dirPoll = new DirPoll(); try { dirPoll.setRequestDir(null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { assertNull(ex.getMessage(), "ex.getMessage()"); } }
### Question: DirPoll extends SimpleLogSource implements Runnable, FilenameFilter, Configurable, Destroyable { public void setResponseDir (String dir) { responseDir = new File (basePath, dir); } DirPoll(); synchronized void setPath(String base); void setShouldTimestampArchive(boolean shouldTimestampArchive); void setArchiveDateFormat(String dateFormat); void setShouldArchive(boolean shouldArchive); void setShouldCompressArchive(boolean shouldCompressArchive); void setAcceptZeroLength(boolean acceptZeroLength); String getPath(); void setRequestDir(String dir); void setResponseDir(String dir); void setTmpDir(String dir); void setBadDir(String dir); void setRunDir(String dir); void setArchiveDir(String dir); void setPollInterval(long pollInterval); void setResponseSuffix(String suffix); long getPollInterval(); void setProcessor(Object processor); boolean isRegexPriorityMatching(); void setRegexPriorityMatching(boolean regexPriorityMatching); Object getProcessor(); void setConfiguration(Configuration cfg); void setPriorities(String priorities); synchronized void setThreadPool(ThreadPool pool); boolean accept(File dir, String name); void run(); void destroy(); void createDirs(); void addPriority(String fileExtension); void pause(); void unpause(); boolean isPaused(); }### Answer: @Test public void testSetResponseDirThrowsNullPointerException() throws Throwable { DirPoll dirPoll = new DirPoll(); try { dirPoll.setResponseDir(null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { assertNull(ex.getMessage(), "ex.getMessage()"); } }
### Question: DirPoll extends SimpleLogSource implements Runnable, FilenameFilter, Configurable, Destroyable { public void setRunDir (String dir) { runDir = new File (basePath, dir); } DirPoll(); synchronized void setPath(String base); void setShouldTimestampArchive(boolean shouldTimestampArchive); void setArchiveDateFormat(String dateFormat); void setShouldArchive(boolean shouldArchive); void setShouldCompressArchive(boolean shouldCompressArchive); void setAcceptZeroLength(boolean acceptZeroLength); String getPath(); void setRequestDir(String dir); void setResponseDir(String dir); void setTmpDir(String dir); void setBadDir(String dir); void setRunDir(String dir); void setArchiveDir(String dir); void setPollInterval(long pollInterval); void setResponseSuffix(String suffix); long getPollInterval(); void setProcessor(Object processor); boolean isRegexPriorityMatching(); void setRegexPriorityMatching(boolean regexPriorityMatching); Object getProcessor(); void setConfiguration(Configuration cfg); void setPriorities(String priorities); synchronized void setThreadPool(ThreadPool pool); boolean accept(File dir, String name); void run(); void destroy(); void createDirs(); void addPriority(String fileExtension); void pause(); void unpause(); boolean isPaused(); }### Answer: @Test public void testSetRunDirThrowsNullPointerException() throws Throwable { DirPoll dirPoll = new DirPoll(); try { dirPoll.setRunDir(null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { assertNull(ex.getMessage(), "ex.getMessage()"); } }
### Question: DirPoll extends SimpleLogSource implements Runnable, FilenameFilter, Configurable, Destroyable { public void setTmpDir (String dir) { tmpDir = new File (basePath, dir); } DirPoll(); synchronized void setPath(String base); void setShouldTimestampArchive(boolean shouldTimestampArchive); void setArchiveDateFormat(String dateFormat); void setShouldArchive(boolean shouldArchive); void setShouldCompressArchive(boolean shouldCompressArchive); void setAcceptZeroLength(boolean acceptZeroLength); String getPath(); void setRequestDir(String dir); void setResponseDir(String dir); void setTmpDir(String dir); void setBadDir(String dir); void setRunDir(String dir); void setArchiveDir(String dir); void setPollInterval(long pollInterval); void setResponseSuffix(String suffix); long getPollInterval(); void setProcessor(Object processor); boolean isRegexPriorityMatching(); void setRegexPriorityMatching(boolean regexPriorityMatching); Object getProcessor(); void setConfiguration(Configuration cfg); void setPriorities(String priorities); synchronized void setThreadPool(ThreadPool pool); boolean accept(File dir, String name); void run(); void destroy(); void createDirs(); void addPriority(String fileExtension); void pause(); void unpause(); boolean isPaused(); }### Answer: @Test public void testSetTmpDirThrowsNullPointerException() throws Throwable { DirPoll dirPoll = new DirPoll(); try { dirPoll.setTmpDir(null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { assertNull(ex.getMessage(), "ex.getMessage()"); } }
### Question: DirPoll extends SimpleLogSource implements Runnable, FilenameFilter, Configurable, Destroyable { public void unpause() { synchronized (this) { if (paused) { paused = false; notify(); } } } DirPoll(); synchronized void setPath(String base); void setShouldTimestampArchive(boolean shouldTimestampArchive); void setArchiveDateFormat(String dateFormat); void setShouldArchive(boolean shouldArchive); void setShouldCompressArchive(boolean shouldCompressArchive); void setAcceptZeroLength(boolean acceptZeroLength); String getPath(); void setRequestDir(String dir); void setResponseDir(String dir); void setTmpDir(String dir); void setBadDir(String dir); void setRunDir(String dir); void setArchiveDir(String dir); void setPollInterval(long pollInterval); void setResponseSuffix(String suffix); long getPollInterval(); void setProcessor(Object processor); boolean isRegexPriorityMatching(); void setRegexPriorityMatching(boolean regexPriorityMatching); Object getProcessor(); void setConfiguration(Configuration cfg); void setPriorities(String priorities); synchronized void setThreadPool(ThreadPool pool); boolean accept(File dir, String name); void run(); void destroy(); void createDirs(); void addPriority(String fileExtension); void pause(); void unpause(); boolean isPaused(); }### Answer: @Test public void testUnpause() throws Throwable { DirPoll dirPoll = new DirPoll(); dirPoll.unpause(); dirPoll.unpause(); assertFalse(dirPoll.isPaused(), "dirPoll.isPaused()"); }
### Question: CharTag { @Override public String toString() { int vLen = 0; if (value != null) vLen = value.length(); int sbSize = tagId.length() + lengthSize + vLen + 32; StringBuilder sb = new StringBuilder(sbSize) .append("tag: ") .append(tagId) .append(", len: ") .append(vLen); if (vLen > 0) sb.append(", value: ") .append(value); return sb.toString(); } protected CharTag(String tagId, String value); String getTLV(); String getTagId(); String getValue(); @Override String toString(); }### Answer: @Test void testToString() { assertEquals("tag: 02, len: 8, value: valueXYZ", instance.toString()); } @Test void testToStringNullValue() { instance = tagMap.createTLV("K7", null); assertEquals("tag: K7, len: 0", instance.toString()); }
### Question: Tags implements Serializable { @Override public String toString() { StringBuilder sb = new StringBuilder(); for (String s : ts) { if (sb.length() > 0) sb.append(','); for (int i = 0; i<s.length(); i++) { char c = s.charAt(i); switch (c) { case '\\': case ',' : sb.append('\\'); break; } sb.append(c); } } return sb.toString(); } Tags(); Tags(String tags); Tags(String... tags); void setTags(String tags); boolean add(String t); boolean remove(String t); boolean contains(String t); Iterator<String> iterator(); int size(); boolean containsAll(Tags tags); boolean containsAny(Tags tags); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer: @Test public void testEmpty () { Tags ts = new Tags(); assertEquals("", ts.toString()); } @Test public void testOrder () { Tags ts = new Tags("def,abc"); assertEquals("abc,def", ts.toString()); } @Test public void testEscape () { Tags ts = new Tags("d\\,ef,abc\\\\"); assertEquals("abc\\\\,d\\,ef", ts.toString()); }
### Question: Tags implements Serializable { public int size() { return ts.size(); } Tags(); Tags(String tags); Tags(String... tags); void setTags(String tags); boolean add(String t); boolean remove(String t); boolean contains(String t); Iterator<String> iterator(); int size(); boolean containsAll(Tags tags); boolean containsAny(Tags tags); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer: @Test public void testNullTags() { Tags ts = new Tags((String) null); assertEquals(0, ts.size(), "size=0"); assertEquals(new Tags(), ts, "empty tags"); assertEquals(new Tags(""), ts, "empty tags \"\""); assertEquals(new Tags(" "), ts, "empty tags (blank)"); }
### Question: Tags implements Serializable { public boolean containsAll (Tags tags) { return ts.containsAll(tags.ts); } Tags(); Tags(String tags); Tags(String... tags); void setTags(String tags); boolean add(String t); boolean remove(String t); boolean contains(String t); Iterator<String> iterator(); int size(); boolean containsAll(Tags tags); boolean containsAny(Tags tags); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer: @Test public void testContainsAll() { Tags ts = new Tags("abc,def,ghi"); assertTrue(ts.containsAll(new Tags("def,ghi"))); assertTrue(ts.containsAll(new Tags("abc,def"))); assertTrue(ts.containsAll(new Tags("abc,ghi,def"))); assertTrue(ts.containsAll(new Tags())); assertTrue(new Tags().containsAll(new Tags())); assertFalse(ts.containsAll(new Tags("abc,jkl"))); }
### Question: Tags implements Serializable { public boolean containsAny (Tags tags) { for (String s : tags.ts) { if (ts.contains(s)) return true; } return tags.size() == 0; } Tags(); Tags(String tags); Tags(String... tags); void setTags(String tags); boolean add(String t); boolean remove(String t); boolean contains(String t); Iterator<String> iterator(); int size(); boolean containsAll(Tags tags); boolean containsAny(Tags tags); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer: @Test public void testContainsAny() { Tags ts = new Tags("abc,def,ghi"); assertTrue(ts.containsAny(new Tags("abc,def"))); assertTrue(ts.containsAny(new Tags("abc,jkl"))); assertTrue(ts.containsAny(new Tags(""))); assertTrue(new Tags().containsAny(new Tags())); assertFalse(ts.containsAny(new Tags("jkl,mno"))); }
### Question: Logger implements LogProducer,Configurable { public void addListener (LogListener l) { listeners.add(l); } Logger(); Configuration getConfiguration(); @Override void setConfiguration(Configuration cfg); void addListener(LogListener l); void removeListener(LogListener l); void removeAllListeners(); static void log(LogEvent evt); void setName(String name); void destroy(); synchronized static Logger getLogger(String name); String getName(); boolean hasListeners(); static final String NRPREFIX; }### Answer: @Test public void testAddListener() throws Throwable { Logger logger = new Logger(); LogListener l = new SimpleLogListener(); logger.addListener(l); assertEquals(1, logger.listeners.size(), "m_logger.listeners.size()"); assertSame(l, logger.listeners.get(0), "m_logger.listeners.get(0)"); }
### Question: Logger implements LogProducer,Configurable { public void destroy () { NameRegistrar.unregister (NRPREFIX+name); removeAllListeners (); } Logger(); Configuration getConfiguration(); @Override void setConfiguration(Configuration cfg); void addListener(LogListener l); void removeListener(LogListener l); void removeAllListeners(); static void log(LogEvent evt); void setName(String name); void destroy(); synchronized static Logger getLogger(String name); String getName(); boolean hasListeners(); static final String NRPREFIX; }### Answer: @Test public void testDestroy() throws Throwable { Logger logger = new Logger(); LogListener l = new SimpleLogListener(); logger.addListener(l); logger.destroy(); assertEquals(0, logger.listeners.size(), "m_logger.listeners.size()"); assertFalse(logger.listeners.contains(l), "m_logger.listeners.contains(l)"); }
### Question: Logger implements LogProducer,Configurable { public synchronized static Logger getLogger (String name) { Logger l; try { l = NameRegistrar.get (NRPREFIX+name); } catch (NameRegistrar.NotFoundException e) { l = new Logger(); l.setName (name); } return l; } Logger(); Configuration getConfiguration(); @Override void setConfiguration(Configuration cfg); void addListener(LogListener l); void removeListener(LogListener l); void removeAllListeners(); static void log(LogEvent evt); void setName(String name); void destroy(); synchronized static Logger getLogger(String name); String getName(); boolean hasListeners(); static final String NRPREFIX; }### Answer: @Test public void testGetLogger() throws Throwable { Logger result = Logger.getLogger("testLoggerName"); assertEquals("testLoggerName", result.getName(), "result.getName()"); }
### Question: Logger implements LogProducer,Configurable { public String getName() { return this.name; } Logger(); Configuration getConfiguration(); @Override void setConfiguration(Configuration cfg); void addListener(LogListener l); void removeListener(LogListener l); void removeAllListeners(); static void log(LogEvent evt); void setName(String name); void destroy(); synchronized static Logger getLogger(String name); String getName(); boolean hasListeners(); static final String NRPREFIX; }### Answer: @Test public void testGetName() throws Throwable { String result = new Logger().getName(); assertEquals("", result, "result"); }
### Question: Logger implements LogProducer,Configurable { public boolean hasListeners() { return !listeners.isEmpty(); } Logger(); Configuration getConfiguration(); @Override void setConfiguration(Configuration cfg); void addListener(LogListener l); void removeListener(LogListener l); void removeAllListeners(); static void log(LogEvent evt); void setName(String name); void destroy(); synchronized static Logger getLogger(String name); String getName(); boolean hasListeners(); static final String NRPREFIX; }### Answer: @Test public void testHasListeners() throws Throwable { Logger logger = new Logger(); logger.addListener(new SimpleLogListener()); boolean result = logger.hasListeners(); assertTrue(result, "result"); } @Test public void testHasListeners1() throws Throwable { boolean result = new Logger().hasListeners(); assertFalse(result, "result"); }
### Question: Logger implements LogProducer,Configurable { public static void log (LogEvent evt) { Logger l = null; LogSource source = evt.getSource(); if (source != null) l = source.getLogger(); if (l == null && !evt.isHonorSourceLogger()) { l = getLogger(Q2.LOGGER_NAME); } if (l != null && l.hasListeners ()) { Iterator i = l.listeners.iterator(); while (i.hasNext() && evt != null) { try { evt = ((LogListener) i.next()).log(evt); } catch (ConcurrentModificationException e) { break; } catch (Throwable t) { evt.addMessage (t); } } } } Logger(); Configuration getConfiguration(); @Override void setConfiguration(Configuration cfg); void addListener(LogListener l); void removeListener(LogListener l); void removeAllListeners(); static void log(LogEvent evt); void setName(String name); void destroy(); synchronized static Logger getLogger(String name); String getName(); boolean hasListeners(); static final String NRPREFIX; }### Answer: @Test public void testLog() throws Throwable { Logger.log(new LogEvent(new SimpleLogSource(Logger.getLogger("testLoggerName"), "testLoggerRealm"), "testLoggerTag", "testString")); assertTrue(true, "Test completed without Exception"); } @Test public void testLog1() throws Throwable { Logger.log(new LogEvent(new Log(), "testLoggerTag", "testString")); assertTrue(true, "Test completed without Exception"); } @Test public void testLog2() throws Throwable { Logger.log(new LogEvent(null, "testLoggerTag", "")); assertTrue(true, "Test completed without Exception"); } @Test public void testLogThrowsNullPointerException() throws Throwable { try { Logger.log(null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { assertNull(ex.getMessage(), "ex.getMessage()"); } }
### Question: Logger implements LogProducer,Configurable { public void removeAllListeners () { for (Object l : listeners) { if (l instanceof Destroyable) { ((Destroyable) l).destroy(); } } listeners.clear (); } Logger(); Configuration getConfiguration(); @Override void setConfiguration(Configuration cfg); void addListener(LogListener l); void removeListener(LogListener l); void removeAllListeners(); static void log(LogEvent evt); void setName(String name); void destroy(); synchronized static Logger getLogger(String name); String getName(); boolean hasListeners(); static final String NRPREFIX; }### Answer: @Test public void testRemoveAllListeners() throws Throwable { Logger logger = Logger.getLogger("testLoggerName"); LogListener l = new SimpleLogListener(); logger.addListener(l); logger.removeAllListeners(); assertEquals(0, logger.listeners.size(), "m_logger.listeners.size()"); assertFalse(logger.listeners.contains(l), "m_logger.listeners.contains(l)"); } @Test public void testRemoveAllListeners3() throws Throwable { Logger logger = new Logger(); logger.removeAllListeners(); assertEquals(0, logger.listeners.size(), "m_logger.listeners.size()"); }
### Question: Logger implements LogProducer,Configurable { public void removeListener (LogListener l) { listeners.remove(l); } Logger(); Configuration getConfiguration(); @Override void setConfiguration(Configuration cfg); void addListener(LogListener l); void removeListener(LogListener l); void removeAllListeners(); static void log(LogEvent evt); void setName(String name); void destroy(); synchronized static Logger getLogger(String name); String getName(); boolean hasListeners(); static final String NRPREFIX; }### Answer: @Test public void testRemoveListener() throws Throwable { Logger logger = new Logger(); logger.removeListener(new SimpleLogListener()); assertEquals(0, logger.listeners.size(), "m_logger.listeners.size()"); }
### Question: Logger implements LogProducer,Configurable { public void setName (String name) { this.name = name; NameRegistrar.register (NRPREFIX+name, this); } Logger(); Configuration getConfiguration(); @Override void setConfiguration(Configuration cfg); void addListener(LogListener l); void removeListener(LogListener l); void removeAllListeners(); static void log(LogEvent evt); void setName(String name); void destroy(); synchronized static Logger getLogger(String name); String getName(); boolean hasListeners(); static final String NRPREFIX; }### Answer: @Test public void testSetName() throws Throwable { Logger logger = new Logger(); logger.setName("testLoggerName"); assertEquals("testLoggerName", logger.name, "m_logger.name"); }
### Question: Profiler implements Loggeable { @SuppressWarnings("unchecked") public synchronized void checkPoint (String detail) { long now = System.nanoTime(); Entry e = new Entry(); e.setDurationInNanos(now - partial); e.setTotalDurationInNanos(now - start); if (events.containsKey(detail)) { for (int i=1; ;i++) { String d = detail + "-" + i; if (!events.containsKey (d)) { detail = d; break; } } } e.setEventName(detail); events.put (detail, e); partial = now; } Profiler(); void reset(); @SuppressWarnings("unchecked") synchronized void checkPoint(String detail); long getElapsed(); long getElapsedInMillis(); long getPartial(); long getPartialInMillis(); void dump(PrintStream p, String indent); LinkedHashMap<String, Entry> getEvents(); Entry getEntry(String eventName); void reenable(); static final int TO_MILLIS; }### Answer: @Test public void testCheckPoint() throws Throwable { Profiler profiler = new Profiler(); profiler.checkPoint("testProfilerDetail1"); } @Test public void testCheckPointNull() throws Throwable { Profiler profiler = new Profiler(); profiler.checkPoint(null); assertEquals(1, profiler.events.size(), "profiler.events.size()"); }
### Question: Profiler implements Loggeable { public void dump (PrintStream p, String indent) { String inner = indent + " "; if (!events.containsKey("end")) checkPoint ("end"); Collection c = events.values(); Iterator iter = c.iterator(); p.println (indent + "<profiler>"); while (iter.hasNext()) p.println (inner + ISOUtil.normalize(iter.next().toString())); p.println (indent + "</profiler>"); } Profiler(); void reset(); @SuppressWarnings("unchecked") synchronized void checkPoint(String detail); long getElapsed(); long getElapsedInMillis(); long getPartial(); long getPartialInMillis(); void dump(PrintStream p, String indent); LinkedHashMap<String, Entry> getEvents(); Entry getEntry(String eventName); void reenable(); static final int TO_MILLIS; }### Answer: @Test public void testDump() throws Throwable { Profiler profiler = new Profiler(); profiler.dump(new PrintStream(new ByteArrayOutputStream()), "testProfilerIndent"); assertEquals(1, profiler.events.size(), "profiler.events.size()"); } @Test public void testDumpThrowsNullPointerException() throws Throwable { Profiler profiler = new Profiler(); try { profiler.dump(null, "testProfilerIndent"); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { assertEquals(1, profiler.events.size(), "profiler.events.size()"); if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"java.io.PrintStream.println(String)\" because \"p\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: Profiler implements Loggeable { public long getPartial() { return System.nanoTime() - partial; } Profiler(); void reset(); @SuppressWarnings("unchecked") synchronized void checkPoint(String detail); long getElapsed(); long getElapsedInMillis(); long getPartial(); long getPartialInMillis(); void dump(PrintStream p, String indent); LinkedHashMap<String, Entry> getEvents(); Entry getEntry(String eventName); void reenable(); static final int TO_MILLIS; }### Answer: @Test public void testGetPartial() throws Throwable { new Profiler().getPartial(); assertTrue(true, "Test completed without Exception"); }
### Question: Profiler implements Loggeable { public void reset() { start = partial = System.nanoTime(); events = new LinkedHashMap<>(); } Profiler(); void reset(); @SuppressWarnings("unchecked") synchronized void checkPoint(String detail); long getElapsed(); long getElapsedInMillis(); long getPartial(); long getPartialInMillis(); void dump(PrintStream p, String indent); LinkedHashMap<String, Entry> getEvents(); Entry getEntry(String eventName); void reenable(); static final int TO_MILLIS; }### Answer: @Test public void testReset() throws Throwable { Profiler profiler = new Profiler(); profiler.reset(); assertEquals(0, profiler.events.size(), "profiler.events.size()"); }
### Question: Recyclable implements Supplier<T> { public Recyclable(Supplier<T> supplier, long maxCycles) { this.supplier = supplier; this.maxCycles = maxCycles; } Recyclable(Supplier<T> supplier, long maxCycles); @Override T get(); }### Answer: @Test public void testRecyclable() { long maxCycles = 1000; Recyclable<Object> r = new Recyclable<>(Object::new, maxCycles); Object o = r.get(); for (int i=0; i < maxCycles; i++) { assertEquals(o, r.get(), "i=" + i); } assertNotEquals(o, r.get()); }
### Question: BaseLogEventWriter implements LogEventWriter { @Override public void setPrintStream(PrintStream p) { if (p == null) { close(); return; } if (this.p == p) return; if (this.p != null) close(); this.p = p; } @Override void setPrintStream(PrintStream p); @Override synchronized void close(); @Override void write(LogEvent ev); }### Answer: @Test void testShouldNotAttemptCloseOnNullPrintStream() { LogEventWriter writer = new TestLogEventWriter(); writer.setPrintStream(null); assertDoesNotThrow(writer::close); }
### Question: FilterLogListener implements LogListener,Configurable { public synchronized void close() { if (p != null) { p.close(); p = null; } } FilterLogListener(); FilterLogListener(PrintStream p); @Override void setConfiguration(Configuration cfg); synchronized void setPrintStream(PrintStream p); synchronized void close(); String getPriority(); void setPriority(String priority); boolean permitLogging(String tagLevel); @Override synchronized LogEvent log(LogEvent ev); }### Answer: @Test public void testClose() throws Throwable { FilterLogListener filterLogListener = new FilterLogListener(); filterLogListener.close(); filterLogListener.close(); assertNull(filterLogListener.p, "filterLogListener.p"); } @Test public void testClose1() throws Throwable { FilterLogListener filterLogListener = new FilterLogListener(); filterLogListener.close(); assertNull(filterLogListener.p, "filterLogListener.p"); }
### Question: FilterLogListener implements LogListener,Configurable { public String getPriority() { return priority; } FilterLogListener(); FilterLogListener(PrintStream p); @Override void setConfiguration(Configuration cfg); synchronized void setPrintStream(PrintStream p); synchronized void close(); String getPriority(); void setPriority(String priority); boolean permitLogging(String tagLevel); @Override synchronized LogEvent log(LogEvent ev); }### Answer: @Test public void testConstructor() throws Throwable { PrintStream p = new PrintStream(new ByteArrayOutputStream(), true); FilterLogListener filterLogListener = new FilterLogListener(p); assertSame(p, filterLogListener.p, "filterLogListener.p"); assertEquals("info", filterLogListener.getPriority(), "filterLogListener.getPriority()"); } @Test public void testConstructor1() throws Throwable { FilterLogListener filterLogListener = new FilterLogListener(); assertNotNull(filterLogListener.p, "filterLogListener.p"); assertEquals("info", filterLogListener.getPriority(), "filterLogListener.getPriority()"); }

Subsets and Splits

No community queries yet

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