Datasets:

Minata
/

1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 269k rows

method2testcases stringlengths 118 6.63k
### Question: 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 { public void setConfiguration (Configuration cfg) throws ConfigurationException { if (maxCopies == 0) { maxCopies = cfg.getInt("copies", 0); } if (sleepTime == 0) { sleepTime = cfg.getInt("window") * 1000; } if (logName == null) { logName = cfg.get ("file"); } if (maxSize == 0) { maxSize = cfg.getLong("maxsize"); maxSize = maxSize <= 0 ? DEFAULT_MAXSIZE : maxSize; } rotateOnStartup = cfg.getBoolean("rotate-on-startup", false); if (fileNamePattern == null) { fileNamePattern = cfg.get("file-name-pattern", null); } if (fileNamePattern != null && !fileNamePattern.isEmpty()) { logName = fileNameFromPattern(logName, fileNamePattern); } if (timer == null) { timer = () -> { Timer timer = DefaultTimer.getTimer(); if (sleepTime != 0) timer.schedule(rotate = new Rotate(), sleepTime, sleepTime); }; } if (rotationAlgo == null) { rotationAlgo = () -> { for (int i = maxCopies; i > 0; ) { File dest = new File(logName + "." + i); File source = new File(logName + (--i > 0 ? "." + i : "")); dest.delete(); source.renameTo(dest); } }; } runPostConfiguration(); } 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 testSetConfigurationThrowsNullPointerException() throws Throwable { RotateLogListener rotateLogListener = new RotateLogListener(); Configuration cfg = new SubConfiguration(); try { rotateLogListener.setConfiguration(cfg); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"org.jpos.core.Configuration.getInt(String, int)\" because \"this.cfg\" is null", ex.getMessage(), "ex.getMessage()"); } assertNull(rotateLogListener.logName, "rotateLogListener.logName"); assertEquals(0L, rotateLogListener.sleepTime, "rotateLogListener.sleepTime"); assertEquals(0L, rotateLogListener.maxSize, "rotateLogListener.maxSize"); assertEquals(0, rotateLogListener.maxCopies, "rotateLogListener.maxCopies"); assertNull(rotateLogListener.rotate, "rotateLogListener.rotate"); assertNull(rotateLogListener.f, "rotateLogListener.f"); assertNotNull(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 accept(File dir, String name) { boolean result; String ext = currentPriority >= 0 ? (String) prio.elementAt(currentPriority) : null; if (ext != null) { if (isRegexPriorityMatching()) { if (!name.matches(ext)) return false; } else { if (!name.endsWith(ext)) return false; } } File f = new File (dir, name); if (acceptZeroLength){ result = f.isFile(); } else { result = f.isFile() && f.length() > 0; } return result; } 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 testAccept() throws Throwable { DirPoll dirPoll = new DirPoll(); dirPoll.addPriority("testDirPollFileExtension"); boolean result = dirPoll.accept(new File("testDirPollParam1"), "testDirPollName"); assertFalse(result, "result"); } @Test public void testAcceptThrowsArrayIndexOutOfBoundsException() throws Throwable { try { new DirPoll().accept(new File("testDirPollParam1"), "testDirPollName"); fail("Expected ArrayIndexOutOfBoundsException to be thrown"); } catch (ArrayIndexOutOfBoundsException ex) { assertEquals("0 >= 0", ex.getMessage(), "ex.getMessage()"); } }
### 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 void setConfiguration (Configuration cfg) throws ConfigurationException { if (cfg != null) { if (processor instanceof Configurable) { ((Configurable) processor).setConfiguration (cfg); } setRequestDir (cfg.get ("request.dir", "request")); setResponseDir(cfg.get("response.dir", "response")); setTmpDir(cfg.get("tmp.dir", "tmp")); setRunDir(cfg.get("run.dir", "run")); setBadDir(cfg.get("bad.dir", "bad")); setArchiveDir(cfg.get("archive.dir", "archive")); setResponseSuffix(cfg.get("response.suffix", null)); setShouldArchive(cfg.getBoolean("archive", false)); setShouldCompressArchive(cfg.getBoolean("archive.compress", false)); setAcceptZeroLength (cfg.getBoolean ("zero-length", false)); setArchiveDateFormat ( cfg.get ("archive.dateformat", "yyyyMMddHHmmss") ); setShouldTimestampArchive (cfg.getBoolean ("archive.timestamp", false)); setRegexPriorityMatching(cfg.getBoolean("priority.regex", false)); } } 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 testSetConfigurationThrowsNullPointerException4() throws Throwable { Configuration cfg = new SubConfiguration(); DirPoll dirPoll = new DirPoll(); try { dirPoll.setConfiguration(cfg); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"org.jpos.core.Configuration.get(String, String)\" because \"this.cfg\" is null", 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()"); }
### Question: FilterLogListener implements LogListener,Configurable { @Override public synchronized LogEvent log(LogEvent ev) { if (p != null && permitLogging(ev.getTag())) { Date d = new Date(); p.println( "<log realm=\"" + ev.getRealm() + "\" at=\"" + d.toString() + "." + d.getTime() % 1000 + "\">" ); ev.dump(p, " "); p.println("</log>"); p.flush(); } return ev; } 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 testLog() throws Throwable { FilterLogListener filterLogListener = new FilterLogListener(); filterLogListener.close(); LogEvent result = filterLogListener.log(null); assertNull(result, "result"); } @Test public void testLog1() throws Throwable { LogEvent ev = new LogEvent(new BASE24TCPChannel(), "testFilterLogListenerTag", ""); FilterLogListener filterLogListener = new FilterLogListener(); LogEvent result = filterLogListener.log(ev); assertSame(ev, result, "result"); assertNotNull(filterLogListener.p, "filterLogListener.p"); }
### Question: FilterLogListener implements LogListener,Configurable { public boolean permitLogging(String tagLevel) { Integer i = LEVELS.get(tagLevel); if (i == null) i = LEVELS.get(Log.INFO); Integer j = LEVELS.get(priority); return i >= j; } 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 testPermitLogging() throws Throwable { boolean result = new FilterLogListener().permitLogging("info"); assertTrue(result, "result"); } @Test public void testPermitLogging1() throws Throwable { boolean result = new FilterLogListener().permitLogging("trace"); assertFalse(result, "result"); } @Test public void testPermitLogging3() throws Throwable { boolean result = new FilterLogListener().permitLogging("testFilterLogListenerTagLevel"); assertTrue(result, "result"); } @Test public void testPermitLoggingThrowsNullPointerException() throws Throwable { try { new FilterLogListener().permitLogging(null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { assertNull(ex.getMessage(), "ex.getMessage()"); } }
### Question: FilterLogListener implements LogListener,Configurable { @Override public void setConfiguration (Configuration cfg) throws ConfigurationException { try { String log_priority = cfg.get("priority"); if ( log_priority != null && !log_priority.trim().equals("") && LEVELS.containsKey(log_priority) ) { priority = log_priority; } } catch (Exception e) { throw new ConfigurationException (e); } } 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 testSetConfiguration() throws Throwable { FilterLogListener filterLogListener = new FilterLogListener(); Configuration cfg = new SimpleConfiguration(); filterLogListener.setConfiguration(cfg); assertEquals("info", filterLogListener.getPriority(), "filterLogListener.getPriority()"); }
### Question: FilterLogListener implements LogListener,Configurable { public synchronized void setPrintStream(PrintStream p) { this.p = p; } 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 testSetPrintStream() throws Throwable { PrintStream p = new PrintStream(new ByteArrayOutputStream()); FilterLogListener filterLogListener = new FilterLogListener(); filterLogListener.setPrintStream(p); assertSame(p, filterLogListener.p, "filterLogListener.p"); }
### Question: FilterLogListener implements LogListener,Configurable { public void setPriority(String priority) { this.priority = 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 testSetPriority() throws Throwable { FilterLogListener filterLogListener = new FilterLogListener(new PrintStream(new ByteArrayOutputStream(), true)); filterLogListener.setPriority("testFilterLogListenerPriority"); assertEquals("testFilterLogListenerPriority", filterLogListener.getPriority(), "filterLogListener.getPriority()"); }
### Question: FSDMsg implements Loggeable, Cloneable { public void copy (String fieldName, FSDMsg msg) { fields.put (fieldName, msg.get (fieldName)); } FSDMsg(String basePath); FSDMsg(String basePath, String baseSchema); String getBasePath(); String getBaseSchema(); void setCharset(Charset charset); void setSeparator(String separatorName, char separator); void unsetSeparator(String separatorName); void unpack(InputStream is); void unpack(byte[] b); String pack(); byte[] packToBytes(); boolean isSeparator(byte b); void set(String name, String value); void setHeader(byte[] h); byte[] getHeader(); String getHexHeader(); String get(String fieldName); String get(String fieldName, String def); void copy(String fieldName, FSDMsg msg); void copy(String fieldName, FSDMsg msg, String def); byte[] getHexBytes(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name, int def); Element toXML(); Map getMap(); void setMap(Map fields); @Override void dump(PrintStream p, String indent); boolean hasField(String fieldName); @Override Object clone(); void merge(FSDMsg m); @Override boolean equals(Object o); @Override int hashCode(); static char FS; static char US; static char GS; static char RS; static char EOF; static char PIPE; static char EOM; }### Answer: @Test public void testCopy() throws Throwable { FSDMsg msg = new FSDMsg("testFSDMsgBasePath"); msg.copy("testFSDMsgFieldName", msg); assertEquals(1, msg.fields.size(), "msg.fields.size()"); assertNull(msg.fields.get("testFSDMsgFieldName"), "msg.fields.get(\"testFSDMsgFieldName\")"); } @Test public void testCopyThrowsNullPointerException() throws Throwable { FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath", "testFSDMsgBaseSchema"); try { fSDMsg.copy("testFSDMsgFieldName", 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.util.FSDMsg.get(String)\" because \"msg\" is null", ex.getMessage(), "ex.getMessage()"); } assertEquals(0, fSDMsg.fields.size(), "fSDMsg.fields.size()"); } }
### Question: FSDMsg implements Loggeable, Cloneable { @Override public void dump (PrintStream p, String indent) { String inner = indent + " "; p.println (indent + "<fsdmsg schema='" + basePath + baseSchema + "'>"); if (header != null) { append (p, "header", getHexHeader(), inner); } for (String f :fields.keySet()) append (p, f, fields.get (f), inner); p.println (indent + "</fsdmsg>"); } FSDMsg(String basePath); FSDMsg(String basePath, String baseSchema); String getBasePath(); String getBaseSchema(); void setCharset(Charset charset); void setSeparator(String separatorName, char separator); void unsetSeparator(String separatorName); void unpack(InputStream is); void unpack(byte[] b); String pack(); byte[] packToBytes(); boolean isSeparator(byte b); void set(String name, String value); void setHeader(byte[] h); byte[] getHeader(); String getHexHeader(); String get(String fieldName); String get(String fieldName, String def); void copy(String fieldName, FSDMsg msg); void copy(String fieldName, FSDMsg msg, String def); byte[] getHexBytes(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name, int def); Element toXML(); Map getMap(); void setMap(Map fields); @Override void dump(PrintStream p, String indent); boolean hasField(String fieldName); @Override Object clone(); void merge(FSDMsg m); @Override boolean equals(Object o); @Override int hashCode(); static char FS; static char US; static char GS; static char RS; static char EOF; static char PIPE; static char EOM; }### Answer: @Test public void testDump() throws Throwable { FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath"); fSDMsg.copy("testFSDMsgFieldName", new FSDMsg("testFSDMsgBasePath", "testFSDMsgBaseSchema")); byte[] h = new byte[3]; fSDMsg.setHeader(h); fSDMsg.dump(new PrintStream(new ByteArrayOutputStream(), true, "UTF-16"), "testFSDMsgIndent"); assertEquals(1, fSDMsg.fields.size(), "fSDMsg.fields.size()"); } @Test public void testDump2() throws Throwable { FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath", "testFSDMsgBaseSchema"); fSDMsg.dump(new PrintStream(new ByteArrayOutputStream(), true, "UTF-16"), "testFSDMsgIndent"); assertEquals(0, fSDMsg.fields.size(), "fSDMsg.fields.size()"); } @Test public void testDumpThrowsNullPointerException() throws Throwable { FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath"); try { fSDMsg.dump(null, "testFSDMsgIndent"); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { 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()"); } assertEquals(0, fSDMsg.fields.size(), "fSDMsg.fields.size()"); } }
### Question: FSDMsg implements Loggeable, Cloneable { public byte[] getHeader () { return header; } FSDMsg(String basePath); FSDMsg(String basePath, String baseSchema); String getBasePath(); String getBaseSchema(); void setCharset(Charset charset); void setSeparator(String separatorName, char separator); void unsetSeparator(String separatorName); void unpack(InputStream is); void unpack(byte[] b); String pack(); byte[] packToBytes(); boolean isSeparator(byte b); void set(String name, String value); void setHeader(byte[] h); byte[] getHeader(); String getHexHeader(); String get(String fieldName); String get(String fieldName, String def); void copy(String fieldName, FSDMsg msg); void copy(String fieldName, FSDMsg msg, String def); byte[] getHexBytes(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name, int def); Element toXML(); Map getMap(); void setMap(Map fields); @Override void dump(PrintStream p, String indent); boolean hasField(String fieldName); @Override Object clone(); void merge(FSDMsg m); @Override boolean equals(Object o); @Override int hashCode(); static char FS; static char US; static char GS; static char RS; static char EOF; static char PIPE; static char EOM; }### Answer: @Test public void testGetHeader() throws Throwable { FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath", "testFSDMsgBaseSchema"); byte[] h = new byte[2]; fSDMsg.setHeader(h); byte[] result = fSDMsg.getHeader(); assertSame(h, result, "result"); assertEquals((byte) 0, h[0], "h[0]"); }
### Question: FSDMsg implements Loggeable, Cloneable { public byte[] getHexBytes (String name) { String s = get (name); return s == null ? null : ISOUtil.hex2byte (s); } FSDMsg(String basePath); FSDMsg(String basePath, String baseSchema); String getBasePath(); String getBaseSchema(); void setCharset(Charset charset); void setSeparator(String separatorName, char separator); void unsetSeparator(String separatorName); void unpack(InputStream is); void unpack(byte[] b); String pack(); byte[] packToBytes(); boolean isSeparator(byte b); void set(String name, String value); void setHeader(byte[] h); byte[] getHeader(); String getHexHeader(); String get(String fieldName); String get(String fieldName, String def); void copy(String fieldName, FSDMsg msg); void copy(String fieldName, FSDMsg msg, String def); byte[] getHexBytes(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name, int def); Element toXML(); Map getMap(); void setMap(Map fields); @Override void dump(PrintStream p, String indent); boolean hasField(String fieldName); @Override Object clone(); void merge(FSDMsg m); @Override boolean equals(Object o); @Override int hashCode(); static char FS; static char US; static char GS; static char RS; static char EOF; static char PIPE; static char EOM; }### Answer: @Test public void testGetHexBytes() throws Throwable { FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath"); fSDMsg.set("testString", "testFSDMsgValue1"); byte[] result = fSDMsg.getHexBytes("testString"); assertEquals(8, result.length, "result.length"); assertEquals((byte) -2, result[0], "result[0]"); assertEquals(1, fSDMsg.fields.size(), "fSDMsg.fields.size()"); } @Test public void testGetHexBytes1() throws Throwable { FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath", "testFSDMsgBaseSchema"); byte[] result = fSDMsg.getHexBytes("testFSDMsgName"); assertNull(result, "result"); assertEquals(0, fSDMsg.fields.size(), "fSDMsg.fields.size()"); }
### Question: FSDMsg implements Loggeable, Cloneable { public String getHexHeader () { return header != null ? ISOUtil.hexString (header).substring (2) : ""; } FSDMsg(String basePath); FSDMsg(String basePath, String baseSchema); String getBasePath(); String getBaseSchema(); void setCharset(Charset charset); void setSeparator(String separatorName, char separator); void unsetSeparator(String separatorName); void unpack(InputStream is); void unpack(byte[] b); String pack(); byte[] packToBytes(); boolean isSeparator(byte b); void set(String name, String value); void setHeader(byte[] h); byte[] getHeader(); String getHexHeader(); String get(String fieldName); String get(String fieldName, String def); void copy(String fieldName, FSDMsg msg); void copy(String fieldName, FSDMsg msg, String def); byte[] getHexBytes(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name, int def); Element toXML(); Map getMap(); void setMap(Map fields); @Override void dump(PrintStream p, String indent); boolean hasField(String fieldName); @Override Object clone(); void merge(FSDMsg m); @Override boolean equals(Object o); @Override int hashCode(); static char FS; static char US; static char GS; static char RS; static char EOF; static char PIPE; static char EOM; }### Answer: @Test public void testGetHexHeader() throws Throwable { FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath"); byte[] h = new byte[1]; fSDMsg.setHeader(h); String result = fSDMsg.getHexHeader(); assertEquals("", result, "result"); } @Test public void testGetHexHeader1() throws Throwable { String result = new FSDMsg("testFSDMsgBasePath", "testFSDMsgBaseSchema").getHexHeader(); assertEquals("", result, "result"); }
### Question: FSDMsg implements Loggeable, Cloneable { @SuppressWarnings("PMD.EmptyCatchBlock") public int getInt (String name) { int i = 0; try { i = Integer.parseInt (get (name)); } catch (Exception ignored) { } return i; } FSDMsg(String basePath); FSDMsg(String basePath, String baseSchema); String getBasePath(); String getBaseSchema(); void setCharset(Charset charset); void setSeparator(String separatorName, char separator); void unsetSeparator(String separatorName); void unpack(InputStream is); void unpack(byte[] b); String pack(); byte[] packToBytes(); boolean isSeparator(byte b); void set(String name, String value); void setHeader(byte[] h); byte[] getHeader(); String getHexHeader(); String get(String fieldName); String get(String fieldName, String def); void copy(String fieldName, FSDMsg msg); void copy(String fieldName, FSDMsg msg, String def); byte[] getHexBytes(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name, int def); Element toXML(); Map getMap(); void setMap(Map fields); @Override void dump(PrintStream p, String indent); boolean hasField(String fieldName); @Override Object clone(); void merge(FSDMsg m); @Override boolean equals(Object o); @Override int hashCode(); static char FS; static char US; static char GS; static char RS; static char EOF; static char PIPE; static char EOM; }### Answer: @Test public void testGetInt() throws Throwable { FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath"); fSDMsg.set("testString", "1"); int result = fSDMsg.getInt("testString"); assertEquals(1, result, "result"); assertEquals(1, fSDMsg.fields.size(), "fSDMsg.fields.size()"); } @Test public void testGetInt1() throws Throwable { FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath"); int result = fSDMsg.getInt("testFSDMsgName"); assertEquals(0, result, "result"); assertEquals(0, fSDMsg.fields.size(), "fSDMsg.fields.size()"); }
### Question: FSDMsg implements Loggeable, Cloneable { public Map getMap () { return fields; } FSDMsg(String basePath); FSDMsg(String basePath, String baseSchema); String getBasePath(); String getBaseSchema(); void setCharset(Charset charset); void setSeparator(String separatorName, char separator); void unsetSeparator(String separatorName); void unpack(InputStream is); void unpack(byte[] b); String pack(); byte[] packToBytes(); boolean isSeparator(byte b); void set(String name, String value); void setHeader(byte[] h); byte[] getHeader(); String getHexHeader(); String get(String fieldName); String get(String fieldName, String def); void copy(String fieldName, FSDMsg msg); void copy(String fieldName, FSDMsg msg, String def); byte[] getHexBytes(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name, int def); Element toXML(); Map getMap(); void setMap(Map fields); @Override void dump(PrintStream p, String indent); boolean hasField(String fieldName); @Override Object clone(); void merge(FSDMsg m); @Override boolean equals(Object o); @Override int hashCode(); static char FS; static char US; static char GS; static char RS; static char EOF; static char PIPE; static char EOM; }### Answer: @SuppressWarnings("unchecked") @Test public void testGetMap() throws Throwable { LinkedHashMap result = (LinkedHashMap) new FSDMsg("testFSDMsgBasePath").getMap(); assertEquals(0, result.size(), "result.size()"); }
### Question: FSDMsg implements Loggeable, Cloneable { protected Element getSchema () throws JDOMException, IOException { return getSchema (baseSchema); } FSDMsg(String basePath); FSDMsg(String basePath, String baseSchema); String getBasePath(); String getBaseSchema(); void setCharset(Charset charset); void setSeparator(String separatorName, char separator); void unsetSeparator(String separatorName); void unpack(InputStream is); void unpack(byte[] b); String pack(); byte[] packToBytes(); boolean isSeparator(byte b); void set(String name, String value); void setHeader(byte[] h); byte[] getHeader(); String getHexHeader(); String get(String fieldName); String get(String fieldName, String def); void copy(String fieldName, FSDMsg msg); void copy(String fieldName, FSDMsg msg, String def); byte[] getHexBytes(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name, int def); Element toXML(); Map getMap(); void setMap(Map fields); @Override void dump(PrintStream p, String indent); boolean hasField(String fieldName); @Override Object clone(); void merge(FSDMsg m); @Override boolean equals(Object o); @Override int hashCode(); static char FS; static char US; static char GS; static char RS; static char EOF; static char PIPE; static char EOM; }### Answer: @Test public void testGetSchemaThrowsMalformedURLException() throws Throwable { assertThrows(MalformedURLException.class, () -> { FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath", "testFSDMsgBaseSchema"); fSDMsg.getSchema(); }); } @Test public void testGetSchemaThrowsMalformedURLException1() throws Throwable { assertThrows(MalformedURLException.class, () -> { FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath", "testFSDMsgBaseSchema"); fSDMsg.getSchema("testFSDMsgMessage"); }); } @Test public void testGetSchemaThrowsNullPointerException() throws Throwable { assertThrows(NullPointerException.class, () -> { FSDMsg fSDMsg = new FSDMsg(null, "testFSDMsgBaseSchema"); fSDMsg.getSchema(); }); } @Test public void testGetSchemaThrowsNullPointerException1() throws Throwable { assertThrows(NullPointerException.class, () -> { FSDMsg fSDMsg = new FSDMsg(null, "testFSDMsgBaseSchema"); fSDMsg.getSchema("testFSDMsgMessage"); }); }
### Question: FSDMsg implements Loggeable, Cloneable { public boolean hasField(String fieldName) { return fields.containsKey(fieldName); } FSDMsg(String basePath); FSDMsg(String basePath, String baseSchema); String getBasePath(); String getBaseSchema(); void setCharset(Charset charset); void setSeparator(String separatorName, char separator); void unsetSeparator(String separatorName); void unpack(InputStream is); void unpack(byte[] b); String pack(); byte[] packToBytes(); boolean isSeparator(byte b); void set(String name, String value); void setHeader(byte[] h); byte[] getHeader(); String getHexHeader(); String get(String fieldName); String get(String fieldName, String def); void copy(String fieldName, FSDMsg msg); void copy(String fieldName, FSDMsg msg, String def); byte[] getHexBytes(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name, int def); Element toXML(); Map getMap(); void setMap(Map fields); @Override void dump(PrintStream p, String indent); boolean hasField(String fieldName); @Override Object clone(); void merge(FSDMsg m); @Override boolean equals(Object o); @Override int hashCode(); static char FS; static char US; static char GS; static char RS; static char EOF; static char PIPE; static char EOM; }### Answer: @Test public void testHasField() throws Throwable { FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath", "testFSDMsgBaseSchema"); fSDMsg.readField(null, "testString", 0, "", null); boolean result = fSDMsg.hasField("testString"); assertTrue(result, "result"); assertEquals(1, fSDMsg.fields.size(), "fSDMsg.fields.size()"); } @Test public void testHasField1() throws Throwable { FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath"); boolean result = fSDMsg.hasField("testFSDMsgFieldName"); assertFalse(result, "result"); assertEquals(0, fSDMsg.fields.size(), "fSDMsg.fields.size()"); }
### Question: FSDMsg implements Loggeable, Cloneable { public String pack () throws JDOMException, IOException, ISOException { StringBuilder sb = new StringBuilder (); pack (getSchema (baseSchema), sb); return sb.toString (); } FSDMsg(String basePath); FSDMsg(String basePath, String baseSchema); String getBasePath(); String getBaseSchema(); void setCharset(Charset charset); void setSeparator(String separatorName, char separator); void unsetSeparator(String separatorName); void unpack(InputStream is); void unpack(byte[] b); String pack(); byte[] packToBytes(); boolean isSeparator(byte b); void set(String name, String value); void setHeader(byte[] h); byte[] getHeader(); String getHexHeader(); String get(String fieldName); String get(String fieldName, String def); void copy(String fieldName, FSDMsg msg); void copy(String fieldName, FSDMsg msg, String def); byte[] getHexBytes(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name, int def); Element toXML(); Map getMap(); void setMap(Map fields); @Override void dump(PrintStream p, String indent); boolean hasField(String fieldName); @Override Object clone(); void merge(FSDMsg m); @Override boolean equals(Object o); @Override int hashCode(); static char FS; static char US; static char GS; static char RS; static char EOF; static char PIPE; static char EOM; }### Answer: @Test public void testPack() throws Throwable { Element schema = new FSDMsg("testFSDMsgBasePath").toXML(); FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath", "testFSDMsgBaseSchema"); StringBuilder sb = new StringBuilder(); fSDMsg.pack(schema, sb); assertEquals(0, fSDMsg.fields.size(), "fSDMsg.fields.size()"); assertEquals("message", schema.getName(), "schema.getName()"); assertEquals("", sb.toString(), "sb.toString()"); } @Test public void testPackThrowsMalformedURLException() throws Throwable { FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath", "testFSDMsgBaseSchema"); try { fSDMsg.pack(); fail("Expected MalformedURLException to be thrown"); } catch (MalformedURLException ex) { assertEquals(MalformedURLException.class, ex.getClass(), "ex.getClass()"); assertEquals(0, fSDMsg.fields.size(), "fSDMsg.fields.size()"); assertEquals("testFSDMsgBaseSchema", fSDMsg.baseSchema, "fSDMsg.baseSchema"); } } @Test public void testPackThrowsNullPointerException() throws Throwable { FSDMsg fSDMsg = new FSDMsg(null, "testFSDMsgBaseSchema"); try { fSDMsg.pack(); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { assertEquals("basePath can not be null", ex.getMessage(), "ex.getMessage()"); assertEquals(0, fSDMsg.fields.size(), "fSDMsg.fields.size()"); assertEquals("testFSDMsgBaseSchema", fSDMsg.baseSchema, "fSDMsg.baseSchema"); } } @Test public void testPackThrowsNullPointerException1() throws Throwable { StringBuilder sb = new StringBuilder(); FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath", "testFSDMsgBaseSchema"); try { fSDMsg.pack(null, sb); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"org.jdom2.Element.getChildren(String)\" because \"schema\" is null", ex.getMessage(), "ex.getMessage()"); } assertEquals(0, fSDMsg.fields.size(), "fSDMsg.fields.size()"); assertEquals("", sb.toString(), "sb.toString()"); } }
### Question: FSDMsg implements Loggeable, Cloneable { public void set (String name, String value) { if (value != null) fields.put (name, value); else fields.remove (name); } FSDMsg(String basePath); FSDMsg(String basePath, String baseSchema); String getBasePath(); String getBaseSchema(); void setCharset(Charset charset); void setSeparator(String separatorName, char separator); void unsetSeparator(String separatorName); void unpack(InputStream is); void unpack(byte[] b); String pack(); byte[] packToBytes(); boolean isSeparator(byte b); void set(String name, String value); void setHeader(byte[] h); byte[] getHeader(); String getHexHeader(); String get(String fieldName); String get(String fieldName, String def); void copy(String fieldName, FSDMsg msg); void copy(String fieldName, FSDMsg msg, String def); byte[] getHexBytes(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name, int def); Element toXML(); Map getMap(); void setMap(Map fields); @Override void dump(PrintStream p, String indent); boolean hasField(String fieldName); @Override Object clone(); void merge(FSDMsg m); @Override boolean equals(Object o); @Override int hashCode(); static char FS; static char US; static char GS; static char RS; static char EOF; static char PIPE; static char EOM; }### Answer: @Test public void testSet() throws Throwable { FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath"); fSDMsg.set("testFSDMsgName", null); assertEquals(0, fSDMsg.fields.size(), "fSDMsg.fields.size()"); }
### Question: FSDMsg implements Loggeable, Cloneable { public void setHeader (byte[] h) { this.header = h; } FSDMsg(String basePath); FSDMsg(String basePath, String baseSchema); String getBasePath(); String getBaseSchema(); void setCharset(Charset charset); void setSeparator(String separatorName, char separator); void unsetSeparator(String separatorName); void unpack(InputStream is); void unpack(byte[] b); String pack(); byte[] packToBytes(); boolean isSeparator(byte b); void set(String name, String value); void setHeader(byte[] h); byte[] getHeader(); String getHexHeader(); String get(String fieldName); String get(String fieldName, String def); void copy(String fieldName, FSDMsg msg); void copy(String fieldName, FSDMsg msg, String def); byte[] getHexBytes(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name, int def); Element toXML(); Map getMap(); void setMap(Map fields); @Override void dump(PrintStream p, String indent); boolean hasField(String fieldName); @Override Object clone(); void merge(FSDMsg m); @Override boolean equals(Object o); @Override int hashCode(); static char FS; static char US; static char GS; static char RS; static char EOF; static char PIPE; static char EOM; }### Answer: @Test public void testSetHeader() throws Throwable { FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath", "testFSDMsgBaseSchema"); byte[] h = new byte[2]; fSDMsg.setHeader(h); assertSame(h, fSDMsg.header, "fSDMsg.header"); }
### Question: FSDMsg implements Loggeable, Cloneable { public void setSeparator(String separatorName, char separator) { separators.put(separatorName, separator); } FSDMsg(String basePath); FSDMsg(String basePath, String baseSchema); String getBasePath(); String getBaseSchema(); void setCharset(Charset charset); void setSeparator(String separatorName, char separator); void unsetSeparator(String separatorName); void unpack(InputStream is); void unpack(byte[] b); String pack(); byte[] packToBytes(); boolean isSeparator(byte b); void set(String name, String value); void setHeader(byte[] h); byte[] getHeader(); String getHexHeader(); String get(String fieldName); String get(String fieldName, String def); void copy(String fieldName, FSDMsg msg); void copy(String fieldName, FSDMsg msg, String def); byte[] getHexBytes(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name, int def); Element toXML(); Map getMap(); void setMap(Map fields); @Override void dump(PrintStream p, String indent); boolean hasField(String fieldName); @Override Object clone(); void merge(FSDMsg m); @Override boolean equals(Object o); @Override int hashCode(); static char FS; static char US; static char GS; static char RS; static char EOF; static char PIPE; static char EOM; }### Answer: @Test public void testSetSeparator() throws Throwable { FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath"); fSDMsg.setSeparator("testFSDMsgSeparatorName", ' '); assertEquals(Character.valueOf(' '), fSDMsg.separators.get("testFSDMsgSeparatorName"), "fSDMsg.separators.get(\"testFSDMsgSeparatorName\")"); }
### Question: FSDMsg implements Loggeable, Cloneable { public Element toXML () { Element e = new Element ("message"); if (header != null) { e.addContent ( new Element ("header") .setText (getHexHeader ()) ); } for (String fieldName :fields.keySet()) { Element inner = new Element (fieldName); inner.addContent (ISOUtil.normalize (fields.get (fieldName))); e.addContent (inner); } return e; } FSDMsg(String basePath); FSDMsg(String basePath, String baseSchema); String getBasePath(); String getBaseSchema(); void setCharset(Charset charset); void setSeparator(String separatorName, char separator); void unsetSeparator(String separatorName); void unpack(InputStream is); void unpack(byte[] b); String pack(); byte[] packToBytes(); boolean isSeparator(byte b); void set(String name, String value); void setHeader(byte[] h); byte[] getHeader(); String getHexHeader(); String get(String fieldName); String get(String fieldName, String def); void copy(String fieldName, FSDMsg msg); void copy(String fieldName, FSDMsg msg, String def); byte[] getHexBytes(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name, int def); Element toXML(); Map getMap(); void setMap(Map fields); @Override void dump(PrintStream p, String indent); boolean hasField(String fieldName); @Override Object clone(); void merge(FSDMsg m); @Override boolean equals(Object o); @Override int hashCode(); static char FS; static char US; static char GS; static char RS; static char EOF; static char PIPE; static char EOM; }### Answer: @Test public void testToXML() throws Throwable { FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath", "testFSDMsgBaseSchema"); byte[] h = new byte[2]; fSDMsg.setHeader(h); Element result = fSDMsg.toXML(); assertEquals("message", result.getName(), "result.getName()"); assertEquals(0, fSDMsg.fields.size(), "fSDMsg.fields.size()"); } @Test public void testToXML3() throws Throwable { FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath"); Element result = fSDMsg.toXML(); assertEquals("message", result.getName(), "result.getName()"); assertEquals(0, fSDMsg.fields.size(), "fSDMsg.fields.size()"); }
### Question: FSDMsg implements Loggeable, Cloneable { public void unsetSeparator(String separatorName) { if (!separators.containsKey(separatorName)) throw new IllegalArgumentException("unsetSeparator was attempted for "+ separatorName+" which was not previously defined."); separators.remove(separatorName); } FSDMsg(String basePath); FSDMsg(String basePath, String baseSchema); String getBasePath(); String getBaseSchema(); void setCharset(Charset charset); void setSeparator(String separatorName, char separator); void unsetSeparator(String separatorName); void unpack(InputStream is); void unpack(byte[] b); String pack(); byte[] packToBytes(); boolean isSeparator(byte b); void set(String name, String value); void setHeader(byte[] h); byte[] getHeader(); String getHexHeader(); String get(String fieldName); String get(String fieldName, String def); void copy(String fieldName, FSDMsg msg); void copy(String fieldName, FSDMsg msg, String def); byte[] getHexBytes(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name); @SuppressWarnings("PMD.EmptyCatchBlock") int getInt(String name, int def); Element toXML(); Map getMap(); void setMap(Map fields); @Override void dump(PrintStream p, String indent); boolean hasField(String fieldName); @Override Object clone(); void merge(FSDMsg m); @Override boolean equals(Object o); @Override int hashCode(); static char FS; static char US; static char GS; static char RS; static char EOF; static char PIPE; static char EOM; }### Answer: @Test public void testUnsetSeparator() throws Throwable { FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath"); fSDMsg.unsetSeparator("US"); assertFalse(fSDMsg.separators.containsKey("US"), "fSDMsg.separators.containsKey(\"US\")"); } @Test public void testUnsetSeparatorThrowsRuntimeException() throws Throwable { FSDMsg fSDMsg = new FSDMsg("testFSDMsgBasePath"); try { fSDMsg.unsetSeparator("testFSDMsgSeparatorName"); fail("Expected RuntimeException to be thrown"); } catch (RuntimeException ex) { assertEquals("unsetSeparator was attempted for testFSDMsgSeparatorName which was not previously defined.", ex.getMessage(), "ex.getMessage()"); } }
### Question: NameRegistrar implements Loggeable { public static NameRegistrar getInstance() { return instance; } private NameRegistrar(); static TSpace<String, Object> getSpace(); static Map<String,Object> getAsMap(); static NameRegistrar getInstance(); static void register(String key, Object value); static void unregister(String key); static T get(String key); static T get(String key, long timeout); static T getIfExists(String key); void dump(PrintStream p, String indent); void dump(PrintStream p, String indent, boolean detail); }### Answer: @Test public void testGetInstance() throws Throwable { NameRegistrar result = NameRegistrar.getInstance(); assertThat(result, is(sameInstance(NameRegistrar.getInstance()))); }
### Question: NameRegistrar implements Loggeable { public static <T> T get(String key) throws NotFoundException { @SuppressWarnings("unchecked") T obj = (T) sp.rdp(key); if (obj == null) { throw new NotFoundException(key); } return obj; } private NameRegistrar(); static TSpace<String, Object> getSpace(); static Map<String,Object> getAsMap(); static NameRegistrar getInstance(); static void register(String key, Object value); static void unregister(String key); static T get(String key); static T get(String key, long timeout); static T getIfExists(String key); void dump(PrintStream p, String indent); void dump(PrintStream p, String indent, boolean detail); }### Answer: @Test public void testGet() throws Exception { String value = NameRegistrar.get("test1"); assertThat(value, is("testValue1")); } @Test public void testGetThrowsNotFoundException() throws Throwable { assertThrows(NameRegistrar.NotFoundException.class, () -> { NameRegistrar.get("NonexistentKey"); }); }
### Question: NameRegistrar implements Loggeable { public static <T> T getIfExists(String key) { @SuppressWarnings("unchecked") T obj = (T) sp.rdp(key); return obj; } private NameRegistrar(); static TSpace<String, Object> getSpace(); static Map<String,Object> getAsMap(); static NameRegistrar getInstance(); static void register(String key, Object value); static void unregister(String key); static T get(String key); static T get(String key, long timeout); static T getIfExists(String key); void dump(PrintStream p, String indent); void dump(PrintStream p, String indent, boolean detail); }### Answer: @Test public void testGetIfExists() throws Throwable { String value = NameRegistrar.getIfExists("test2"); assertThat(value, is("testValue2")); } @Test public void testGetIfExistsWithNotFoundKey() throws Exception { String value = NameRegistrar.getIfExists("NonexistentKey"); assertThat(value, is(nullValue())); }
### Question: NameRegistrar implements Loggeable { public static void unregister(String key) { SpaceUtil.wipe(sp, key); } private NameRegistrar(); static TSpace<String, Object> getSpace(); static Map<String,Object> getAsMap(); static NameRegistrar getInstance(); static void register(String key, Object value); static void unregister(String key); static T get(String key); static T get(String key, long timeout); static T getIfExists(String key); void dump(PrintStream p, String indent); void dump(PrintStream p, String indent, boolean detail); }### Answer: @Test public void testUnregister() throws Exception { assertThrows(NameRegistrar.NotFoundException.class, () -> { NameRegistrar.register("test3", "someTest3Value"); assertThat(NameRegistrar.get("test3"), is("someTest3Value")); NameRegistrar.unregister("test3"); NameRegistrar.get("test3"); }); } @Test public void testUnregisterUnknownKeyDoesNotThrowException() throws Exception { NameRegistrar.unregister("unknownKey"); }
### Question: RemoveNewLinesMapper implements ByteArrayMapper, Configurable { @Override public void setConfiguration(Configuration cfg) throws ConfigurationException { combineSpaces = cfg.getBoolean("combine-spaces", false); newLineAtEnd = cfg.getBoolean("newline-at-end", true); } @Override byte[] apply(byte[] bytes); @Override void setConfiguration(Configuration cfg); }### Answer: @Test void testValuesChangedByConfiguration() throws ConfigurationException { RemoveNewLinesMapper mapper = new RemoveNewLinesMapper(); SimpleConfiguration cfg = new SimpleConfiguration(); cfg.put("combine-spaces", "true"); cfg.put("newline-at-end", "false"); mapper.setConfiguration(cfg); assertTrue(mapper.combineSpaces); assertFalse(mapper.newLineAtEnd); } @Test void testDefaultValues() throws ConfigurationException { RemoveNewLinesMapper mapper = new RemoveNewLinesMapper(); assertFalse(mapper.combineSpaces); assertTrue(mapper.newLineAtEnd); SimpleConfiguration cfg = new SimpleConfiguration(); mapper.setConfiguration(cfg); assertFalse(mapper.combineSpaces); assertTrue(mapper.newLineAtEnd); }
### Question: DefaultTimer { public static Timer getTimer() { if (defaultTimer == null) { synchronized (DefaultTimer.class) { if (defaultTimer == null) defaultTimer = new Timer(true); } } return defaultTimer; } private DefaultTimer(); static Timer getTimer(); }### Answer: @Test public void testGetTimer() throws Throwable { Timer result = DefaultTimer.getTimer(); assertNotNull(result, "result"); }
### Question: DailyLogListener extends RotateLogListener { protected void closeCompressedOutputStream(OutputStream os) throws IOException{ if (os instanceof DeflaterOutputStream) ((DeflaterOutputStream)os).finish(); os.close(); } DailyLogListener(); void setConfiguration(Configuration cfg); void deleteOldLogs(); String getSuffix(); void setSuffix(String suffix); String getPrefix(); void setPrefix(String prefix); int getRotateCount(); void setRotateCount(int rotateCount); DateFormat getDateFmt(); void setDateFmt(DateFormat dateFmt); String getLastDate(); void setLastDate(String lastDate); String getCompressedSuffix(); void setCompressedSuffix(String compressedSuffix); long getMaxAge(); void setMaxAge(long maxAge); String getDeleteRegex(); void setDeleteRegex(String deleteRegex); int getCompressionFormat(); void setCompressionFormat(int compressionFormat); int getCompressionBufferSize(); void setCompressionBufferSize(int compressionBufferSize); }### Answer: @Test public void testCloseCompressedOutputStream() throws Throwable { OutputStream os = new DeflaterOutputStream(new PrintStream(new ByteArrayOutputStream()), new Deflater()); DailyLogListener dailyLogListener = new DailyLogListener(); dailyLogListener.closeCompressedOutputStream(os); assertTrue(true, "Test completed without Exception"); } @Test public void testCloseCompressedOutputStream1() throws Throwable { DailyLogListener dailyLogListener = new DailyLogListener(); OutputStream os = new DataOutputStream(new ByteArrayOutputStream()); dailyLogListener.closeCompressedOutputStream(os); assertEquals(0, ((DataOutputStream) os).size(), "(DataOutputStream) os.size()"); } @Test public void testCloseCompressedOutputStreamThrowsNullPointerException() throws Throwable { DailyLogListener dailyLogListener = new DailyLogListener(); try { dailyLogListener.closeCompressedOutputStream(null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"java.io.OutputStream.close()\" because \"os\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: DailyLogListener extends RotateLogListener { protected void compress(File logFile) { if (getCompressionFormat() != NONE){ Thread t = getCompressorThread(logFile); try{ if (t != null) t.start(); } catch (Exception e){ logDebugEx("error compressing file",e); } } } DailyLogListener(); void setConfiguration(Configuration cfg); void deleteOldLogs(); String getSuffix(); void setSuffix(String suffix); String getPrefix(); void setPrefix(String prefix); int getRotateCount(); void setRotateCount(int rotateCount); DateFormat getDateFmt(); void setDateFmt(DateFormat dateFmt); String getLastDate(); void setLastDate(String lastDate); String getCompressedSuffix(); void setCompressedSuffix(String compressedSuffix); long getMaxAge(); void setMaxAge(long maxAge); String getDeleteRegex(); void setDeleteRegex(String deleteRegex); int getCompressionFormat(); void setCompressionFormat(int compressionFormat); int getCompressionBufferSize(); void setCompressionBufferSize(int compressionBufferSize); }### Answer: @Test public void testCompress() throws Throwable { DailyLogListener dailyLogListener = new DailyLogListener(); dailyLogListener.compress(new File("testDailyLogListenerParam1")); assertEquals(0, dailyLogListener.getCompressionFormat(), "dailyLogListener.getCompressionFormat()"); }
### Question: DailyLogListener extends RotateLogListener { protected OutputStream getCompressedOutputStream(File f) throws IOException{ OutputStream os = new BufferedOutputStream(new FileOutputStream(f)); if (getCompressionFormat() == ZIP) { ZipOutputStream ret = new ZipOutputStream(os); ret.putNextEntry(new ZipEntry(logName)); return ret; } else { return new GZIPOutputStream(os); } } DailyLogListener(); void setConfiguration(Configuration cfg); void deleteOldLogs(); String getSuffix(); void setSuffix(String suffix); String getPrefix(); void setPrefix(String prefix); int getRotateCount(); void setRotateCount(int rotateCount); DateFormat getDateFmt(); void setDateFmt(DateFormat dateFmt); String getLastDate(); void setLastDate(String lastDate); String getCompressedSuffix(); void setCompressedSuffix(String compressedSuffix); long getMaxAge(); void setMaxAge(long maxAge); String getDeleteRegex(); void setDeleteRegex(String deleteRegex); int getCompressionFormat(); void setCompressionFormat(int compressionFormat); int getCompressionBufferSize(); void setCompressionBufferSize(int compressionBufferSize); }### Answer: @Test public void testGetCompressedOutputStreamThrowsNullPointerException() throws Throwable { DailyLogListener dailyLogListener = new DailyLogListener(); try { dailyLogListener.getCompressedOutputStream(null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { } }
### Question: DailyLogListener extends RotateLogListener { protected Thread getCompressorThread(File f){ return new Thread(new Compressor(f),"DailyLogListener-Compressor"); } DailyLogListener(); void setConfiguration(Configuration cfg); void deleteOldLogs(); String getSuffix(); void setSuffix(String suffix); String getPrefix(); void setPrefix(String prefix); int getRotateCount(); void setRotateCount(int rotateCount); DateFormat getDateFmt(); void setDateFmt(DateFormat dateFmt); String getLastDate(); void setLastDate(String lastDate); String getCompressedSuffix(); void setCompressedSuffix(String compressedSuffix); long getMaxAge(); void setMaxAge(long maxAge); String getDeleteRegex(); void setDeleteRegex(String deleteRegex); int getCompressionFormat(); void setCompressionFormat(int compressionFormat); int getCompressionBufferSize(); void setCompressionBufferSize(int compressionBufferSize); }### Answer: @Test public void testGetCompressorThread() throws Throwable { DailyLogListener dailyLogListener = new DailyLogListener(); dailyLogListener.getCompressorThread(new File("testDailyLogListenerParam1")); assertTrue(true, "Test completed without Exception"); }
### Question: DailyLogListener extends RotateLogListener { protected void logDebugEx(String msg, Throwable e){ ByteArrayOutputStream os = new ByteArrayOutputStream(); PrintStream ps = new PrintStream(os); ps.println(msg); e.printStackTrace(ps); ps.close(); logDebug(os.toString()); } DailyLogListener(); void setConfiguration(Configuration cfg); void deleteOldLogs(); String getSuffix(); void setSuffix(String suffix); String getPrefix(); void setPrefix(String prefix); int getRotateCount(); void setRotateCount(int rotateCount); DateFormat getDateFmt(); void setDateFmt(DateFormat dateFmt); String getLastDate(); void setLastDate(String lastDate); String getCompressedSuffix(); void setCompressedSuffix(String compressedSuffix); long getMaxAge(); void setMaxAge(long maxAge); String getDeleteRegex(); void setDeleteRegex(String deleteRegex); int getCompressionFormat(); void setCompressionFormat(int compressionFormat); int getCompressionBufferSize(); void setCompressionBufferSize(int compressionBufferSize); }### Answer: @Test public void testLogDebugEx() throws Throwable { DailyLogListener dailyLogListener = new DailyLogListener(); dailyLogListener.logDebugEx("testDailyLogListenerMsg", new NullPointerException("testDailyLogListenerParam1")); assertNotNull(dailyLogListener.p, "dailyLogListener.p"); } @Test public void testLogDebugExThrowsNullPointerException() throws Throwable { DailyLogListener dailyLogListener = new DailyLogListener(); try { dailyLogListener.logDebugEx("testDailyLogListenerMsg", null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"java.lang.Throwable.printStackTrace(java.io.PrintStream)\" because \"e\" is null", ex.getMessage(), "ex.getMessage()"); } assertNotNull(dailyLogListener.p, "dailyLogListener.p"); } }
### Question: DailyLogListener extends RotateLogListener { public void setCompressedSuffix(String compressedSuffix) { this.compressedSuffix = compressedSuffix; } DailyLogListener(); void setConfiguration(Configuration cfg); void deleteOldLogs(); String getSuffix(); void setSuffix(String suffix); String getPrefix(); void setPrefix(String prefix); int getRotateCount(); void setRotateCount(int rotateCount); DateFormat getDateFmt(); void setDateFmt(DateFormat dateFmt); String getLastDate(); void setLastDate(String lastDate); String getCompressedSuffix(); void setCompressedSuffix(String compressedSuffix); long getMaxAge(); void setMaxAge(long maxAge); String getDeleteRegex(); void setDeleteRegex(String deleteRegex); int getCompressionFormat(); void setCompressionFormat(int compressionFormat); int getCompressionBufferSize(); void setCompressionBufferSize(int compressionBufferSize); }### Answer: @Test public void testSetCompressedSuffix() throws Throwable { DailyLogListener dailyLogListener = new DailyLogListener(); dailyLogListener.setCompressedSuffix("testDailyLogListenerCompressedSuffix"); assertEquals("testDailyLogListenerCompressedSuffix", dailyLogListener.getCompressedSuffix(), "dailyLogListener.getCompressedSuffix()"); }
### Question: DailyLogListener extends RotateLogListener { public void setCompressionBufferSize(int compressionBufferSize) { this.compressionBufferSize = compressionBufferSize >= 0 ? compressionBufferSize : DEF_BUFFER_SIZE; } DailyLogListener(); void setConfiguration(Configuration cfg); void deleteOldLogs(); String getSuffix(); void setSuffix(String suffix); String getPrefix(); void setPrefix(String prefix); int getRotateCount(); void setRotateCount(int rotateCount); DateFormat getDateFmt(); void setDateFmt(DateFormat dateFmt); String getLastDate(); void setLastDate(String lastDate); String getCompressedSuffix(); void setCompressedSuffix(String compressedSuffix); long getMaxAge(); void setMaxAge(long maxAge); String getDeleteRegex(); void setDeleteRegex(String deleteRegex); int getCompressionFormat(); void setCompressionFormat(int compressionFormat); int getCompressionBufferSize(); void setCompressionBufferSize(int compressionBufferSize); }### Answer: @Test public void testSetCompressionBufferSize() throws Throwable { DailyLogListener dailyLogListener = new DailyLogListener(); dailyLogListener.setCompressionBufferSize(-1); assertEquals(131072, dailyLogListener.getCompressionBufferSize(), "dailyLogListener.getCompressionBufferSize()"); }
### Question: DailyLogListener extends RotateLogListener { public void setCompressionFormat(int compressionFormat) { this.compressionFormat = compressionFormat; } DailyLogListener(); void setConfiguration(Configuration cfg); void deleteOldLogs(); String getSuffix(); void setSuffix(String suffix); String getPrefix(); void setPrefix(String prefix); int getRotateCount(); void setRotateCount(int rotateCount); DateFormat getDateFmt(); void setDateFmt(DateFormat dateFmt); String getLastDate(); void setLastDate(String lastDate); String getCompressedSuffix(); void setCompressedSuffix(String compressedSuffix); long getMaxAge(); void setMaxAge(long maxAge); String getDeleteRegex(); void setDeleteRegex(String deleteRegex); int getCompressionFormat(); void setCompressionFormat(int compressionFormat); int getCompressionBufferSize(); void setCompressionBufferSize(int compressionBufferSize); }### Answer: @Test public void testSetCompressionFormat() throws Throwable { DailyLogListener dailyLogListener = new DailyLogListener(); dailyLogListener.setCompressionFormat(100); assertEquals(100, dailyLogListener.getCompressionFormat(), "dailyLogListener.getCompressionFormat()"); }
### Question: DailyLogListener extends RotateLogListener { public void setDateFmt(DateFormat dateFmt) { this.dateFmt = dateFmt; } DailyLogListener(); void setConfiguration(Configuration cfg); void deleteOldLogs(); String getSuffix(); void setSuffix(String suffix); String getPrefix(); void setPrefix(String prefix); int getRotateCount(); void setRotateCount(int rotateCount); DateFormat getDateFmt(); void setDateFmt(DateFormat dateFmt); String getLastDate(); void setLastDate(String lastDate); String getCompressedSuffix(); void setCompressedSuffix(String compressedSuffix); long getMaxAge(); void setMaxAge(long maxAge); String getDeleteRegex(); void setDeleteRegex(String deleteRegex); int getCompressionFormat(); void setCompressionFormat(int compressionFormat); int getCompressionBufferSize(); void setCompressionBufferSize(int compressionBufferSize); }### Answer: @Test public void testSetDateFmt() throws Throwable { DateFormat dateFmt = DateFormat.getInstance(); DailyLogListener dailyLogListener = new DailyLogListener(); dailyLogListener.setDateFmt(dateFmt); assertSame(dateFmt, dailyLogListener.getDateFmt(), "dailyLogListener.getDateFmt()"); }
### Question: DailyLogListener extends RotateLogListener { public void setLastDate(String lastDate) { this.lastDate = lastDate; } DailyLogListener(); void setConfiguration(Configuration cfg); void deleteOldLogs(); String getSuffix(); void setSuffix(String suffix); String getPrefix(); void setPrefix(String prefix); int getRotateCount(); void setRotateCount(int rotateCount); DateFormat getDateFmt(); void setDateFmt(DateFormat dateFmt); String getLastDate(); void setLastDate(String lastDate); String getCompressedSuffix(); void setCompressedSuffix(String compressedSuffix); long getMaxAge(); void setMaxAge(long maxAge); String getDeleteRegex(); void setDeleteRegex(String deleteRegex); int getCompressionFormat(); void setCompressionFormat(int compressionFormat); int getCompressionBufferSize(); void setCompressionBufferSize(int compressionBufferSize); }### Answer: @Test public void testSetLastDate() throws Throwable { DailyLogListener dailyLogListener = new DailyLogListener(); dailyLogListener.setLastDate("testDailyLogListenerLastDate"); assertEquals("testDailyLogListenerLastDate", dailyLogListener.getLastDate(), "dailyLogListener.getLastDate()"); }

Subsets and Splits

No community queries yet

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