Datasets:
Minata
/
1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
1
method2testcases
stringlengths
118
6.63k
### Question: QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public void startService () { if (!listenerRegistered) { listenerRegistered = true; synchronized (sp) { Object[] pending = SpaceUtil.inpAll(sp, in); sp.addListener (in, this); for (Object o : pending) sp.out(in, o); } } } QMUX(); void initService(); void startService(); void stopService(); void destroyService(); static MUX getMUX(String name); ISOMsg request(ISOMsg m, long timeout); void request(ISOMsg m, long timeout, ISOResponseListener rl, Object handBack); @Override void notify(Object k, Object value); String getKey(ISOMsg m); @Override Metrics getMetrics(); synchronized void setInQueue(String in); String getInQueue(); synchronized void setOutQueue(String out); String getOutQueue(); Space getSpace(); synchronized void setUnhandledQueue(String unhandled); String getUnhandledQueue(); @SuppressWarnings("unused") String[] getReadyIndicatorNames(); void addISORequestListener(ISORequestListener l); boolean removeISORequestListener(ISORequestListener l); synchronized void resetCounters(); String getCountersAsString(); int getTXCounter(); int getRXCounter(); @Override int getTXExpired(); @Override int getTXPending(); @Override int getRXExpired(); @Override int getRXPending(); @Override int getRXUnhandled(); @Override int getRXForwarded(); long getLastTxnTimestampInMillis(); long getIdleTimeInMillis(); void send(ISOMsg m); boolean isConnected(); void dump(PrintStream p, String indent); }### Answer: @Test public void testStartServiceThrowsNullPointerException() throws Throwable { QMUX qMUX = new QMUX(); qMUX.setState(0); try { qMUX.startService(); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot enter synchronized block because \"this.sp\" is null", ex.getMessage(), "ex.getMessage()"); } assertNull(qMUX.sp, "qMUX.sp"); } }
### Question: IFA_BITMAP extends ISOBitMapPackager { public byte[] pack (ISOComponent c) throws ISOException { BitSet b = (BitSet) c.getValue(); int len = getLength() >= 8 ? b.length()+62 >>6 <<3 : getLength(); return ISOUtil.hexString(ISOUtil.bitSet2byte (b, len)).getBytes(); } IFA_BITMAP(); IFA_BITMAP(int len, String description); byte[] pack(ISOComponent c); int getMaxPackedLength(); int unpack(ISOComponent c, byte[] b, int offset); void unpack(ISOComponent c, InputStream in); }### Answer: @Test public void testThirdBitmapPack() throws Exception { byte[] b = ISOUtil.hex2byte("F23C04800AE00000"+"8000000000000108"+"63BC780000000010"); BitSet bs1 = ISOUtil.byte2BitSet(b, 0, 192); ISOBitMap bmap = new ISOBitMap(-1); bmap.setValue(bs1); IFA_BITMAP ifa = new IFA_BITMAP(24, "BITMAP"); byte[] b1 = ifa.pack(bmap); assertEquals (ISOUtil.hexString(b), new String(b1), "Pack should be equal to unpack"); }
### Question: ISOMsg extends ISOComponent implements Cloneable, Loggeable, Externalizable { public byte[] getBytes (int fldno) { byte[] b = null; if (hasField (fldno)) { Object obj = getValue(fldno); if (obj instanceof String) b = ((String) obj).getBytes(ISOUtil.CHARSET); else if (obj instanceof byte[]) b = (byte[]) obj; } return b; } ISOMsg(); ISOMsg(int fieldNumber); @SuppressWarnings("PMD.EmptyCatchBlock") ISOMsg(String mti); @Override void setFieldNumber(int fieldNumber); void setDirection(int direction); void setHeader(byte[] b); void setHeader(ISOHeader header); byte[] getHeader(); void setTrailer(byte[] trailer); byte[] getTrailer(); ISOHeader getISOHeader(); int getDirection(); boolean isIncoming(); boolean isOutgoing(); @Override int getMaxField(); void setPackager(ISOPackager p); ISOPackager getPackager(); void set(ISOComponent c); void set(int fldno, String value); void set(String fpath, String value); void set(String fpath, ISOComponent c); void set(String fpath, byte[] value); void set(int fldno, byte[] value); @Override void unset(int fldno); void unset(int ... flds); void unset(String fpath); void unset(String ... fpaths); @Override ISOComponent getComposite(); void recalcBitMap(); @Override Map getChildren(); @Override byte[] pack(); @Override int unpack(byte[] b); @Override void unpack(InputStream in); @Override void dump(PrintStream p, String indent); ISOComponent getComponent(int fldno); Object getValue(int fldno); Object getValue(String fpath); ISOComponent getComponent(String fpath); String getString(int fldno); String getString(String fpath); byte[] getBytes(int fldno); byte[] getBytes(String fpath); boolean hasField(int fldno); boolean hasFields(int[] fields); boolean hasAny(int[] fields); boolean hasAny(String... fields); boolean hasField(String fpath); boolean hasFields(); @Override void setValue(Object obj); @Override Object clone(); @SuppressWarnings("PMD.EmptyCatchBlock") Object clone(int ... fields); ISOMsg clone(String ... fpaths); @SuppressWarnings("PMD.EmptyCatchBlock") void merge(ISOMsg m); @Override String toString(); @Override Object getKey(); @Override Object getValue(); boolean isInner(); void setMTI(String mti); void move(int oldFieldNumber, int newFieldNumber); @Override int getFieldNumber(); boolean hasMTI(); String getMTI(); boolean isRequest(); boolean isResponse(); boolean isRetransmission(); void setResponseMTI(); void setRetransmissionMTI(); @Override void writeExternal(ObjectOutput out); @Override void readExternal(ObjectInput in); void setSource(ISOSource source); ISOSource getSource(); static final int INCOMING; static final int OUTGOING; }### Answer: @Test public void testGetBytes() throws Exception { ISOMsg m = new ISOMsg("0800"); m.set (3, "000000"); m.set (52, "CAFEBABE".getBytes()); m.set ("63.2.3", "Field 63.2.3"); m.set ("63.2.4", m.getBytes (52)); assertEquals ("000000", m.getString (3)); assertEquals ("000000", new String(m.getBytes(3))); assertEquals ("CAFEBABE", new String(m.getBytes(52))); assertEquals ("Field 63.2.3", m.getString ("63.2.3")); assertEquals ("CAFEBABE", new String(m.getBytes("63.2.4"))); }
### Question: ISOBasePackager implements ISOPackager, LogSource { public String getDescription () { return getClass().getName(); } void setFieldPackager(ISOFieldPackager[] fld); void setThirdBitmapField(int f); int getThirdBitmapField(); @Override byte[] pack(ISOComponent m); @Override int unpack(ISOComponent m, byte[] b); void unpack(ISOComponent m, InputStream in); String getFieldDescription(ISOComponent m, int fldNumber); ISOFieldPackager getFieldPackager(int fldNumber); void setFieldPackager(int fldNumber, ISOFieldPackager fieldPackager); ISOMsg createISOMsg(); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); int getHeaderLength(); void setHeaderLength(int len); String getDescription(); }### Answer: @Test public void testGetDescription() { assertThat(iSOBasePackager.getDescription(), is("org.jpos.iso.ISOBasePackagerTest$1")); }
### Question: ISOBasePackager implements ISOPackager, LogSource { public int getHeaderLength () { return headerLength; } void setFieldPackager(ISOFieldPackager[] fld); void setThirdBitmapField(int f); int getThirdBitmapField(); @Override byte[] pack(ISOComponent m); @Override int unpack(ISOComponent m, byte[] b); void unpack(ISOComponent m, InputStream in); String getFieldDescription(ISOComponent m, int fldNumber); ISOFieldPackager getFieldPackager(int fldNumber); void setFieldPackager(int fldNumber, ISOFieldPackager fieldPackager); ISOMsg createISOMsg(); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); int getHeaderLength(); void setHeaderLength(int len); String getDescription(); }### Answer: @Test public void testGetHeaderLength() { iSOBasePackager.setHeaderLength(9876); assertThat(iSOBasePackager.getHeaderLength(), is(9876)); }
### Question: ISOBasePackager implements ISOPackager, LogSource { public Logger getLogger() { return logger; } void setFieldPackager(ISOFieldPackager[] fld); void setThirdBitmapField(int f); int getThirdBitmapField(); @Override byte[] pack(ISOComponent m); @Override int unpack(ISOComponent m, byte[] b); void unpack(ISOComponent m, InputStream in); String getFieldDescription(ISOComponent m, int fldNumber); ISOFieldPackager getFieldPackager(int fldNumber); void setFieldPackager(int fldNumber, ISOFieldPackager fieldPackager); ISOMsg createISOMsg(); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); int getHeaderLength(); void setHeaderLength(int len); String getDescription(); }### Answer: @Test public void testGetLogger() { Logger logger = mock(Logger.class); iSOBasePackager.setLogger(logger, "testRealm"); assertThat(iSOBasePackager.getLogger(), is(logger)); }
### Question: ISOBasePackager implements ISOPackager, LogSource { public String getRealm () { return realm; } void setFieldPackager(ISOFieldPackager[] fld); void setThirdBitmapField(int f); int getThirdBitmapField(); @Override byte[] pack(ISOComponent m); @Override int unpack(ISOComponent m, byte[] b); void unpack(ISOComponent m, InputStream in); String getFieldDescription(ISOComponent m, int fldNumber); ISOFieldPackager getFieldPackager(int fldNumber); void setFieldPackager(int fldNumber, ISOFieldPackager fieldPackager); ISOMsg createISOMsg(); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); int getHeaderLength(); void setHeaderLength(int len); String getDescription(); }### Answer: @Test public void testGetRealm() { Logger logger = mock(Logger.class); iSOBasePackager.setLogger(logger, "testRealm"); assertThat(iSOBasePackager.getRealm(), is("testRealm")); }
### Question: ISOBasePackager implements ISOPackager, LogSource { protected int getMaxValidField() { return 128; } void setFieldPackager(ISOFieldPackager[] fld); void setThirdBitmapField(int f); int getThirdBitmapField(); @Override byte[] pack(ISOComponent m); @Override int unpack(ISOComponent m, byte[] b); void unpack(ISOComponent m, InputStream in); String getFieldDescription(ISOComponent m, int fldNumber); ISOFieldPackager getFieldPackager(int fldNumber); void setFieldPackager(int fldNumber, ISOFieldPackager fieldPackager); ISOMsg createISOMsg(); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); int getHeaderLength(); void setHeaderLength(int len); String getDescription(); }### Answer: @Test public void testGetMaxValidField() { assertThat(iSOBasePackager.getMaxValidField(), is(128)); }
### Question: ISOBasePackager implements ISOPackager, LogSource { public ISOMsg createISOMsg () { return new ISOMsg(); } void setFieldPackager(ISOFieldPackager[] fld); void setThirdBitmapField(int f); int getThirdBitmapField(); @Override byte[] pack(ISOComponent m); @Override int unpack(ISOComponent m, byte[] b); void unpack(ISOComponent m, InputStream in); String getFieldDescription(ISOComponent m, int fldNumber); ISOFieldPackager getFieldPackager(int fldNumber); void setFieldPackager(int fldNumber, ISOFieldPackager fieldPackager); ISOMsg createISOMsg(); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); int getHeaderLength(); void setHeaderLength(int len); String getDescription(); }### Answer: @Test public void testCreateISOMsg() { assertThat(iSOBasePackager.createISOMsg(), is(instanceOf(ISOMsg.class))); }
### Question: ISOBasePackager implements ISOPackager, LogSource { public void setFieldPackager (ISOFieldPackager[] fld) { this.fld = fld; } void setFieldPackager(ISOFieldPackager[] fld); void setThirdBitmapField(int f); int getThirdBitmapField(); @Override byte[] pack(ISOComponent m); @Override int unpack(ISOComponent m, byte[] b); void unpack(ISOComponent m, InputStream in); String getFieldDescription(ISOComponent m, int fldNumber); ISOFieldPackager getFieldPackager(int fldNumber); void setFieldPackager(int fldNumber, ISOFieldPackager fieldPackager); ISOMsg createISOMsg(); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); int getHeaderLength(); void setHeaderLength(int len); String getDescription(); }### Answer: @Test public void testSetFieldPackager() { iSOBasePackager.setFieldPackager(iSOFieldPackagers); assertThat(iSOBasePackager.getFieldPackager(0), is(iSOFieldPackager)); }
### Question: QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public void stopService () { listenerRegistered = false; sp.removeListener (in, this); } QMUX(); void initService(); void startService(); void stopService(); void destroyService(); static MUX getMUX(String name); ISOMsg request(ISOMsg m, long timeout); void request(ISOMsg m, long timeout, ISOResponseListener rl, Object handBack); @Override void notify(Object k, Object value); String getKey(ISOMsg m); @Override Metrics getMetrics(); synchronized void setInQueue(String in); String getInQueue(); synchronized void setOutQueue(String out); String getOutQueue(); Space getSpace(); synchronized void setUnhandledQueue(String unhandled); String getUnhandledQueue(); @SuppressWarnings("unused") String[] getReadyIndicatorNames(); void addISORequestListener(ISORequestListener l); boolean removeISORequestListener(ISORequestListener l); synchronized void resetCounters(); String getCountersAsString(); int getTXCounter(); int getRXCounter(); @Override int getTXExpired(); @Override int getTXPending(); @Override int getRXExpired(); @Override int getRXPending(); @Override int getRXUnhandled(); @Override int getRXForwarded(); long getLastTxnTimestampInMillis(); long getIdleTimeInMillis(); void send(ISOMsg m); boolean isConnected(); void dump(PrintStream p, String indent); }### Answer: @Test public void testStopServiceThrowsNullPointerException() throws Throwable { QMUX qMUX = new QMUX(); try { qMUX.stopService(); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"org.jpos.space.LocalSpace.removeListener(Object, org.jpos.space.SpaceListener)\" because \"this.sp\" is null", ex.getMessage(), "ex.getMessage()"); } assertNull(qMUX.sp, "qMUX.sp"); } }
### Question: TaskAdaptor extends QBeanSupport { public Object getObject () { return task; } TaskAdaptor(); Object getObject(); }### Answer: @Test public void testGetObject() throws Throwable { Object result = new TaskAdaptor().getObject(); assertNull(result, "result"); }
### Question: TaskAdaptor extends QBeanSupport { protected void initService () throws Exception { QFactory factory = getServer().getFactory(); Element e = getPersist (); task = factory.newInstance (e.getChildTextTrim ("class")); factory.setLogger (task, e); } TaskAdaptor(); Object getObject(); }### Answer: @Test public void testInitServiceThrowsNullPointerException() throws Throwable { TaskAdaptor taskAdaptor = new TaskAdaptor(); try { taskAdaptor.initService(); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"org.jpos.q2.Q2.getFactory()\" because the return value of \"org.jpos.q2.iso.TaskAdaptor.getServer()\" is null", ex.getMessage(), "ex.getMessage()"); } assertNull(taskAdaptor.task, "taskAdaptor.task"); assertTrue(taskAdaptor.isModified(), "taskAdaptor.isModified()"); } } @Test public void testInitServiceThrowsNullPointerException1() throws Throwable { TaskAdaptor taskAdaptor = new TaskAdaptor(); String[] args = new String[0]; taskAdaptor.setServer(q2); try { taskAdaptor.initService(); 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.getChildTextTrim(String)\" because \"e\" is null", ex.getMessage(), "ex.getMessage()"); } assertNull(taskAdaptor.task, "taskAdaptor.task"); assertFalse(taskAdaptor.isModified(), "taskAdaptor.isModified()"); } }
### Question: TaskAdaptor extends QBeanSupport { protected void startService () throws Exception { getServer().getFactory().setConfiguration(task, getPersist()); NameRegistrar.register (getName (), task); if (task instanceof Runnable) { new Thread ((Runnable) task).start (); } } TaskAdaptor(); Object getObject(); }### Answer: @Test public void testStartServiceThrowsNullPointerException() throws Throwable { TaskAdaptor taskAdaptor = new TaskAdaptor(); try { taskAdaptor.startService(); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"org.jpos.q2.Q2.getFactory()\" because the return value of \"org.jpos.q2.iso.TaskAdaptor.getServer()\" is null", ex.getMessage(), "ex.getMessage()"); } assertTrue(taskAdaptor.isModified(), "taskAdaptor.isModified()"); } }
### Question: TaskAdaptor extends QBeanSupport { protected void stopService () throws Exception { NameRegistrar.unregister (getName ()); if (task instanceof Destroyable) ((Destroyable)task).destroy (); } TaskAdaptor(); Object getObject(); }### Answer: @Test public void testStopService() throws Throwable { TaskAdaptor taskAdaptor = new TaskAdaptor(); taskAdaptor.setName("testTaskAdaptorName"); taskAdaptor.stopService(); assertNull(taskAdaptor.task, "taskAdaptor.task"); assertEquals("testTaskAdaptorName", taskAdaptor.getName(), "taskAdaptor.getName()"); }
### Question: DirPollAdaptor extends QBeanSupport implements DirPollAdaptorMBean { public String getPath () { return path == null ? "." : path; } DirPollAdaptor(); synchronized void setPath(String path); synchronized void setPoolSize(int size); int getPoolSize(); String getPath(); synchronized void setPollInterval(long pollInterval); long getPollInterval(); synchronized void setPriorities(String priorities); String getPriorities(); synchronized void setProcessor(String processor); String getProcessor(); }### Answer: @Test public void testGetPath() throws Throwable { String result = new DirPollAdaptor().getPath(); assertEquals(".", result, "result"); }
### Question: DirPollAdaptor extends QBeanSupport implements DirPollAdaptorMBean { public long getPollInterval () { return pollInterval; } DirPollAdaptor(); synchronized void setPath(String path); synchronized void setPoolSize(int size); int getPoolSize(); String getPath(); synchronized void setPollInterval(long pollInterval); long getPollInterval(); synchronized void setPriorities(String priorities); String getPriorities(); synchronized void setProcessor(String processor); String getProcessor(); }### Answer: @Test public void testGetPollInterval() throws Throwable { long result = new DirPollAdaptor().getPollInterval(); assertEquals(1000L, result, "result"); }
### Question: DirPollAdaptor extends QBeanSupport implements DirPollAdaptorMBean { public int getPoolSize () { return poolSize; } DirPollAdaptor(); synchronized void setPath(String path); synchronized void setPoolSize(int size); int getPoolSize(); String getPath(); synchronized void setPollInterval(long pollInterval); long getPollInterval(); synchronized void setPriorities(String priorities); String getPriorities(); synchronized void setProcessor(String processor); String getProcessor(); }### Answer: @Test public void testGetPoolSize() throws Throwable { DirPollAdaptor dirPollAdaptor = new DirPollAdaptor(); dirPollAdaptor.setPoolSize(0); int result = dirPollAdaptor.getPoolSize(); assertEquals(0, result, "result"); } @Test public void testGetPoolSize1() throws Throwable { int result = new DirPollAdaptor().getPoolSize(); assertEquals(1, result, "result"); }
### Question: DirPollAdaptor extends QBeanSupport implements DirPollAdaptorMBean { public String getPriorities () { return priorities; } DirPollAdaptor(); synchronized void setPath(String path); synchronized void setPoolSize(int size); int getPoolSize(); String getPath(); synchronized void setPollInterval(long pollInterval); long getPollInterval(); synchronized void setPriorities(String priorities); String getPriorities(); synchronized void setProcessor(String processor); String getProcessor(); }### Answer: @Test public void testGetPriorities() throws Throwable { String result = new DirPollAdaptor().getPriorities(); assertNull(result, "result"); }
### Question: DirPollAdaptor extends QBeanSupport implements DirPollAdaptorMBean { public String getProcessor() { return processorClass; } DirPollAdaptor(); synchronized void setPath(String path); synchronized void setPoolSize(int size); int getPoolSize(); String getPath(); synchronized void setPollInterval(long pollInterval); long getPollInterval(); synchronized void setPriorities(String priorities); String getPriorities(); synchronized void setProcessor(String processor); String getProcessor(); }### Answer: @Test public void testGetProcessor() throws Throwable { DirPollAdaptor dirPollAdaptor = new DirPollAdaptor(); dirPollAdaptor.setProcessor("testDirPollAdaptorProcessor"); String result = dirPollAdaptor.getProcessor(); assertEquals("testDirPollAdaptorProcessor", result, "result"); } @Test public void testGetProcessor1() throws Throwable { String result = new DirPollAdaptor().getProcessor(); assertNull(result, "result"); }
### Question: DirPollAdaptor extends QBeanSupport implements DirPollAdaptorMBean { protected void initService () throws Exception { QFactory factory = getServer().getFactory(); dirPoll = createDirPoll(); dirPoll.setPath (getPath ()); dirPoll.setThreadPool (new ThreadPool (1, poolSize)); dirPoll.setPollInterval (pollInterval); if (priorities != null) dirPoll.setPriorities (priorities); dirPoll.setLogger (getLog().getLogger(), getLog().getRealm ()); Configuration cfg = factory.getConfiguration (getPersist()); dirPoll.setConfiguration (cfg); dirPoll.createDirs (); Object dpp = factory.newInstance (getProcessor()); if (dpp instanceof LogSource) { ((LogSource) dpp).setLogger ( getLog().getLogger(), getLog().getRealm () ); } if (dpp instanceof Configurable) { ((Configurable) dpp).setConfiguration (cfg); } dirPoll.setProcessor (dpp); } DirPollAdaptor(); synchronized void setPath(String path); synchronized void setPoolSize(int size); int getPoolSize(); String getPath(); synchronized void setPollInterval(long pollInterval); long getPollInterval(); synchronized void setPriorities(String priorities); String getPriorities(); synchronized void setProcessor(String processor); String getProcessor(); }### Answer: @Test public void testInitServiceThrowsNullPointerException2() throws Throwable { DirPollAdaptor dirPollAdaptor = new DirPollAdaptor(); try { dirPollAdaptor.initService(); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"org.jpos.q2.Q2.getFactory()\" because the return value of \"org.jpos.q2.iso.DirPollAdaptor.getServer()\" is null", ex.getMessage(), "ex.getMessage()"); } assertNull(dirPollAdaptor.dirPoll, "dirPollAdaptor.dirPoll"); assertTrue(dirPollAdaptor.isModified(), "dirPollAdaptor.isModified()"); } }
### Question: DirPollAdaptor extends QBeanSupport implements DirPollAdaptorMBean { public synchronized void setPath (String path) { this.path = path; setModified (true); } DirPollAdaptor(); synchronized void setPath(String path); synchronized void setPoolSize(int size); int getPoolSize(); String getPath(); synchronized void setPollInterval(long pollInterval); long getPollInterval(); synchronized void setPriorities(String priorities); String getPriorities(); synchronized void setProcessor(String processor); String getProcessor(); }### Answer: @Test public void testSetPath() throws Throwable { DirPollAdaptor dirPollAdaptor = new DirPollAdaptor(); dirPollAdaptor.setPath("testDirPollAdaptorPath"); assertEquals("testDirPollAdaptorPath", dirPollAdaptor.path, "dirPollAdaptor.path"); assertTrue(dirPollAdaptor.isModified(), "dirPollAdaptor.isModified()"); }
### Question: DirPollAdaptor extends QBeanSupport implements DirPollAdaptorMBean { public synchronized void setPollInterval (long pollInterval) { this.pollInterval = pollInterval; setModified (true); } DirPollAdaptor(); synchronized void setPath(String path); synchronized void setPoolSize(int size); int getPoolSize(); String getPath(); synchronized void setPollInterval(long pollInterval); long getPollInterval(); synchronized void setPriorities(String priorities); String getPriorities(); synchronized void setProcessor(String processor); String getProcessor(); }### Answer: @Test public void testSetPollInterval() throws Throwable { DirPollAdaptor dirPollAdaptor = new DirPollAdaptor(); dirPollAdaptor.setPollInterval(100L); assertEquals(100L, dirPollAdaptor.pollInterval, "dirPollAdaptor.pollInterval"); assertTrue(dirPollAdaptor.isModified(), "dirPollAdaptor.isModified()"); }
### Question: DirPollAdaptor extends QBeanSupport implements DirPollAdaptorMBean { public synchronized void setPoolSize (int size) { this.poolSize = size; setModified (true); } DirPollAdaptor(); synchronized void setPath(String path); synchronized void setPoolSize(int size); int getPoolSize(); String getPath(); synchronized void setPollInterval(long pollInterval); long getPollInterval(); synchronized void setPriorities(String priorities); String getPriorities(); synchronized void setProcessor(String processor); String getProcessor(); }### Answer: @Test public void testSetPoolSize() throws Throwable { DirPollAdaptor dirPollAdaptor = new DirPollAdaptor(); dirPollAdaptor.setPoolSize(100); assertEquals(100, dirPollAdaptor.poolSize, "dirPollAdaptor.poolSize"); assertTrue(dirPollAdaptor.isModified(), "dirPollAdaptor.isModified()"); }
### Question: DirPollAdaptor extends QBeanSupport implements DirPollAdaptorMBean { public synchronized void setPriorities (String priorities) { this.priorities = priorities; setModified (true); } DirPollAdaptor(); synchronized void setPath(String path); synchronized void setPoolSize(int size); int getPoolSize(); String getPath(); synchronized void setPollInterval(long pollInterval); long getPollInterval(); synchronized void setPriorities(String priorities); String getPriorities(); synchronized void setProcessor(String processor); String getProcessor(); }### Answer: @Test public void testSetPriorities() throws Throwable { DirPollAdaptor dirPollAdaptor = new DirPollAdaptor(); dirPollAdaptor.setPriorities("testDirPollAdaptorPriorities"); assertEquals("testDirPollAdaptorPriorities", dirPollAdaptor.priorities, "dirPollAdaptor.priorities"); assertTrue(dirPollAdaptor.isModified(), "dirPollAdaptor.isModified()"); }
### Question: DirPollAdaptor extends QBeanSupport implements DirPollAdaptorMBean { public synchronized void setProcessor (String processor) { this.processorClass = processor; setModified (true); } DirPollAdaptor(); synchronized void setPath(String path); synchronized void setPoolSize(int size); int getPoolSize(); String getPath(); synchronized void setPollInterval(long pollInterval); long getPollInterval(); synchronized void setPriorities(String priorities); String getPriorities(); synchronized void setProcessor(String processor); String getProcessor(); }### Answer: @Test public void testSetProcessor() throws Throwable { DirPollAdaptor dirPollAdaptor = new DirPollAdaptor(); dirPollAdaptor.setProcessor("testDirPollAdaptorProcessor"); assertEquals("testDirPollAdaptorProcessor", dirPollAdaptor.processorClass, "dirPollAdaptor.processorClass"); assertTrue(dirPollAdaptor.isModified(), "dirPollAdaptor.isModified()"); }
### Question: DirPollAdaptor extends QBeanSupport implements DirPollAdaptorMBean { protected void startService () throws Exception { if (dirPoll == null) { throw new IllegalStateException("Not initialized!"); } synchronized (dirPoll) { dirPollThread = new Thread(dirPoll); dirPollThread.start(); } } DirPollAdaptor(); synchronized void setPath(String path); synchronized void setPoolSize(int size); int getPoolSize(); String getPath(); synchronized void setPollInterval(long pollInterval); long getPollInterval(); synchronized void setPriorities(String priorities); String getPriorities(); synchronized void setProcessor(String processor); String getProcessor(); }### Answer: @Test public void testStartService() throws Throwable { DirPollAdaptor dirPollAdaptor = new DirPollAdaptor(); try { dirPollAdaptor.startService(); } catch (IllegalStateException e) { assertNull(dirPollAdaptor.dirPoll, "dirPollAdaptor.dirPoll"); } }
### Question: DirPollAdaptor extends QBeanSupport implements DirPollAdaptorMBean { protected void stopService () throws Exception { dirPoll.destroy (); synchronized (dirPoll) { if (dirPollThread != null) { long shutdownTimeout = cfg.getLong("shutdown-timeout", 60000); try { dirPollThread.join(shutdownTimeout); } catch (InterruptedException e) { } if (dirPollThread.isAlive()) { getLog().warn(getName() + " - dirPoll thread did not finish in " + shutdownTimeout + " milliseconds. Interrupting thread now."); dirPollThread.interrupt(); } dirPollThread = null; } } } DirPollAdaptor(); synchronized void setPath(String path); synchronized void setPoolSize(int size); int getPoolSize(); String getPath(); synchronized void setPollInterval(long pollInterval); long getPollInterval(); synchronized void setPriorities(String priorities); String getPriorities(); synchronized void setProcessor(String processor); String getProcessor(); }### Answer: @Test public void testStopServiceThrowsNullPointerException() throws Throwable { DirPollAdaptor dirPollAdaptor = new DirPollAdaptor(); try { dirPollAdaptor.stopService(); 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.DirPoll.destroy()\" because \"this.dirPoll\" is null", ex.getMessage(), "ex.getMessage()"); } assertNull(dirPollAdaptor.dirPoll, "dirPollAdaptor.dirPoll"); } }
### Question: QServer extends QBeanSupport implements QServerMBean, SpaceListener, ISORequestListener { @Override public synchronized void setChannel (String channel) { channelString = channel; setAttr (getAttrs (), "channel", channelString); setModified (true); } QServer(); @Override void initService(); @Override void startService(); @Override void stopService(); @Override void destroyService(); @Override synchronized void setPort(int port); @Override int getPort(); @Override synchronized void setPackager(String packager); @Override String getPackager(); @Override synchronized void setChannel(String channel); @Override String getChannel(); @Override synchronized void setMaxSessions(int maxSessions); @Override int getMaxSessions(); @Override synchronized void setMinSessions(int minSessions); @Override int getMinSessions(); @Override synchronized void setSocketFactory(String sFactory); @Override String getSocketFactory(); @Override String getISOChannelNames(); ISOServer getISOServer(); @Override String getCountersAsString(); @Override String getCountersAsString(String isoChannelName); @Override void notify(Object key, Object value); @Override boolean process(ISOSource source, ISOMsg m); }### Answer: @Test public void testSetChannel() throws Throwable { QServer qServer = new QServer(); qServer.setPersist(new Element("testQServerName", "testQServerUri")); qServer.setChannel("testQServerChannel"); assertEquals("testQServerChannel", qServer.getChannel(), "qServer.getChannel()"); assertTrue(qServer.isModified(), "qServer.isModified()"); }
### Question: QServer extends QBeanSupport implements QServerMBean, SpaceListener, ISORequestListener { @Override public synchronized void setMaxSessions (int maxSessions) { this.maxSessions = maxSessions; setAttr (getAttrs (), "maxSessions", maxSessions); setModified (true); } QServer(); @Override void initService(); @Override void startService(); @Override void stopService(); @Override void destroyService(); @Override synchronized void setPort(int port); @Override int getPort(); @Override synchronized void setPackager(String packager); @Override String getPackager(); @Override synchronized void setChannel(String channel); @Override String getChannel(); @Override synchronized void setMaxSessions(int maxSessions); @Override int getMaxSessions(); @Override synchronized void setMinSessions(int minSessions); @Override int getMinSessions(); @Override synchronized void setSocketFactory(String sFactory); @Override String getSocketFactory(); @Override String getISOChannelNames(); ISOServer getISOServer(); @Override String getCountersAsString(); @Override String getCountersAsString(String isoChannelName); @Override void notify(Object key, Object value); @Override boolean process(ISOSource source, ISOMsg m); }### Answer: @Test public void testSetMaxSessions() throws Throwable { QServer qServer = new QServer(); qServer.setPersist(new Element("testQServerName", "testQServerUri")); qServer.setMaxSessions(1000); assertEquals(1000, qServer.getMaxSessions(), "qServer.getMaxSessions()"); assertTrue(qServer.isModified(), "qServer.isModified()"); }
### Question: QServer extends QBeanSupport implements QServerMBean, SpaceListener, ISORequestListener { @Override public synchronized void setMinSessions (int minSessions) { this.minSessions = minSessions; setAttr (getAttrs (), "minSessions", minSessions); setModified (true); } QServer(); @Override void initService(); @Override void startService(); @Override void stopService(); @Override void destroyService(); @Override synchronized void setPort(int port); @Override int getPort(); @Override synchronized void setPackager(String packager); @Override String getPackager(); @Override synchronized void setChannel(String channel); @Override String getChannel(); @Override synchronized void setMaxSessions(int maxSessions); @Override int getMaxSessions(); @Override synchronized void setMinSessions(int minSessions); @Override int getMinSessions(); @Override synchronized void setSocketFactory(String sFactory); @Override String getSocketFactory(); @Override String getISOChannelNames(); ISOServer getISOServer(); @Override String getCountersAsString(); @Override String getCountersAsString(String isoChannelName); @Override void notify(Object key, Object value); @Override boolean process(ISOSource source, ISOMsg m); }### Answer: @Test public void testSetMinSessions() throws Throwable { QServer qServer = new QServer(); qServer.setPersist(new Element("testQServerName", "testQServerUri")); qServer.setMinSessions(100); assertEquals(100, qServer.getMinSessions(), "qServer.getMinSessions()"); assertTrue(qServer.isModified(), "qServer.isModified()"); }
### Question: QServer extends QBeanSupport implements QServerMBean, SpaceListener, ISORequestListener { @Override public synchronized void setPackager (String packager) { packagerString = packager; setAttr (getAttrs (), "packager", packagerString); setModified (true); } QServer(); @Override void initService(); @Override void startService(); @Override void stopService(); @Override void destroyService(); @Override synchronized void setPort(int port); @Override int getPort(); @Override synchronized void setPackager(String packager); @Override String getPackager(); @Override synchronized void setChannel(String channel); @Override String getChannel(); @Override synchronized void setMaxSessions(int maxSessions); @Override int getMaxSessions(); @Override synchronized void setMinSessions(int minSessions); @Override int getMinSessions(); @Override synchronized void setSocketFactory(String sFactory); @Override String getSocketFactory(); @Override String getISOChannelNames(); ISOServer getISOServer(); @Override String getCountersAsString(); @Override String getCountersAsString(String isoChannelName); @Override void notify(Object key, Object value); @Override boolean process(ISOSource source, ISOMsg m); }### Answer: @Test public void testSetPackager() throws Throwable { QServer qServer = new QServer(); qServer.setPersist(new Element("testQServerName", "testQServerUri")); qServer.setPackager("testQServerPackager"); assertEquals("testQServerPackager", qServer.getPackager(), "qServer.getPackager()"); assertTrue(qServer.isModified(), "qServer.isModified()"); }
### Question: QServer extends QBeanSupport implements QServerMBean, SpaceListener, ISORequestListener { @Override public synchronized void setPort (int port) { this.port = port; setAttr (getAttrs (), "port", port); setModified (true); } QServer(); @Override void initService(); @Override void startService(); @Override void stopService(); @Override void destroyService(); @Override synchronized void setPort(int port); @Override int getPort(); @Override synchronized void setPackager(String packager); @Override String getPackager(); @Override synchronized void setChannel(String channel); @Override String getChannel(); @Override synchronized void setMaxSessions(int maxSessions); @Override int getMaxSessions(); @Override synchronized void setMinSessions(int minSessions); @Override int getMinSessions(); @Override synchronized void setSocketFactory(String sFactory); @Override String getSocketFactory(); @Override String getISOChannelNames(); ISOServer getISOServer(); @Override String getCountersAsString(); @Override String getCountersAsString(String isoChannelName); @Override void notify(Object key, Object value); @Override boolean process(ISOSource source, ISOMsg m); }### Answer: @Test public void testSetPort() throws Throwable { QServer qServer = new QServer(); qServer.setPersist(new Element("testQServerName", "testQServerUri")); qServer.setPort(100); assertEquals(100, qServer.getPort(), "qServer.getPort()"); assertTrue(qServer.isModified(), "qServer.isModified()"); }
### Question: QServer extends QBeanSupport implements QServerMBean, SpaceListener, ISORequestListener { @Override public synchronized void setSocketFactory (String sFactory) { socketFactoryString = sFactory; setAttr (getAttrs(),"socketFactory", socketFactoryString); setModified (true); } QServer(); @Override void initService(); @Override void startService(); @Override void stopService(); @Override void destroyService(); @Override synchronized void setPort(int port); @Override int getPort(); @Override synchronized void setPackager(String packager); @Override String getPackager(); @Override synchronized void setChannel(String channel); @Override String getChannel(); @Override synchronized void setMaxSessions(int maxSessions); @Override int getMaxSessions(); @Override synchronized void setMinSessions(int minSessions); @Override int getMinSessions(); @Override synchronized void setSocketFactory(String sFactory); @Override String getSocketFactory(); @Override String getISOChannelNames(); ISOServer getISOServer(); @Override String getCountersAsString(); @Override String getCountersAsString(String isoChannelName); @Override void notify(Object key, Object value); @Override boolean process(ISOSource source, ISOMsg m); }### Answer: @Test public void testSetSocketFactory() throws Throwable { QServer qServer = new QServer(); qServer.setPersist(new Element("testQServerName", "testQServerUri")); qServer.setSocketFactory("testQServerSFactory"); assertEquals("testQServerSFactory", qServer.getSocketFactory(), "qServer.getSocketFactory()"); assertTrue(qServer.isModified(), "qServer.isModified()"); }
### Question: QServer extends QBeanSupport implements QServerMBean, SpaceListener, ISORequestListener { @Override public void startService () { try { initServer (); initIn(); initOut(); initWhoToSendTo(); } catch (Exception e) { getLog().warn ("error starting service", e); } } QServer(); @Override void initService(); @Override void startService(); @Override void stopService(); @Override void destroyService(); @Override synchronized void setPort(int port); @Override int getPort(); @Override synchronized void setPackager(String packager); @Override String getPackager(); @Override synchronized void setChannel(String channel); @Override String getChannel(); @Override synchronized void setMaxSessions(int maxSessions); @Override int getMaxSessions(); @Override synchronized void setMinSessions(int minSessions); @Override int getMinSessions(); @Override synchronized void setSocketFactory(String sFactory); @Override String getSocketFactory(); @Override String getISOChannelNames(); ISOServer getISOServer(); @Override String getCountersAsString(); @Override String getCountersAsString(String isoChannelName); @Override void notify(Object key, Object value); @Override boolean process(ISOSource source, ISOMsg m); }### Answer: @Test public void testStartService() throws Throwable { QServer qServer = new QServer(); qServer.startService(); assertTrue(qServer.isModified(), "qServer.isModified()"); }
### Question: QServer extends QBeanSupport implements QServerMBean, SpaceListener, ISORequestListener { @Override public void stopService () { if (server != null) { server.shutdown (); sp.removeListener(inQueue, this); } } QServer(); @Override void initService(); @Override void startService(); @Override void stopService(); @Override void destroyService(); @Override synchronized void setPort(int port); @Override int getPort(); @Override synchronized void setPackager(String packager); @Override String getPackager(); @Override synchronized void setChannel(String channel); @Override String getChannel(); @Override synchronized void setMaxSessions(int maxSessions); @Override int getMaxSessions(); @Override synchronized void setMinSessions(int minSessions); @Override int getMinSessions(); @Override synchronized void setSocketFactory(String sFactory); @Override String getSocketFactory(); @Override String getISOChannelNames(); ISOServer getISOServer(); @Override String getCountersAsString(); @Override String getCountersAsString(String isoChannelName); @Override void notify(Object key, Object value); @Override boolean process(ISOSource source, ISOMsg m); }### Answer: @Test public void testStopService() throws Throwable { QServer qServer = new QServer(); qServer.stopService(); }
### Question: DailyTaskAdaptor extends QBeanSupport implements Runnable { public Date getWhen() { String s = cfg.get ("start")+":00:00"; int hh = Integer.parseInt(s.substring (0, 2)); int mm = Integer.parseInt(s.substring (3, 5)); int ss = Integer.parseInt(s.substring (6, 8)); Date now = new Date(); Calendar cal = new GregorianCalendar(); cal.setTime (now); cal.set (Calendar.HOUR_OF_DAY, hh); cal.set (Calendar.MINUTE, mm); cal.set (Calendar.SECOND, ss); Date when = cal.getTime(); if (when.before(now)) when = new Date(when.getTime() + 24*60*60*1000); return when; } DailyTaskAdaptor(); void run(); Date getWhen(); }### Answer: @Test public void testGetWhenThrowsNullPointerException() throws Throwable { DailyTaskAdaptor dailyTaskAdaptor = new DailyTaskAdaptor(); try { dailyTaskAdaptor.getWhen(); 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)\" because \"this.cfg\" is null", ex.getMessage(), "ex.getMessage()"); } assertNull(dailyTaskAdaptor.getConfiguration(), "dailyTaskAdaptor.getConfiguration()"); } } @Test public void testGetWhenThrowsNumberFormatException() throws Throwable { Configuration cfg = new SimpleConfiguration(); DailyTaskAdaptor dailyTaskAdaptor = new DailyTaskAdaptor(); dailyTaskAdaptor.setConfiguration(cfg); try { dailyTaskAdaptor.getWhen(); fail("Expected NumberFormatException to be thrown"); } catch (NumberFormatException ex) { assertEquals("For input string: \":0\"", ex.getMessage(), "ex.getMessage()"); assertSame(cfg, dailyTaskAdaptor.getConfiguration(), "dailyTaskAdaptor.getConfiguration()"); } } @Test public void testGetWhen() { }
### Question: DailyTaskAdaptor extends QBeanSupport implements Runnable { protected void initService () throws Exception { QFactory factory = getServer().getFactory(); Element e = getPersist (); task = (Runnable) factory.newInstance (e.getChildTextTrim ("class")); factory.setLogger (task, e); } DailyTaskAdaptor(); void run(); Date getWhen(); }### Answer: @Test public void testInitServiceThrowsNullPointerException() throws Throwable { DailyTaskAdaptor dailyTaskAdaptor = new DailyTaskAdaptor(); try { dailyTaskAdaptor.initService(); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"org.jpos.q2.Q2.getFactory()\" because the return value of \"org.jpos.q2.iso.DailyTaskAdaptor.getServer()\" is null", ex.getMessage(), "ex.getMessage()"); } assertTrue(dailyTaskAdaptor.isModified(), "dailyTaskAdaptor.isModified()"); assertNull(dailyTaskAdaptor.task, "dailyTaskAdaptor.task"); } } @Test public void testInitServiceThrowsNullPointerException1() throws Throwable { DailyTaskAdaptor dailyTaskAdaptor = new DailyTaskAdaptor(); String[] args = new String[3]; args[0] = "vI"; args[1] = "e."; args[2] = "testString"; dailyTaskAdaptor.setServer(q2); try { dailyTaskAdaptor.initService(); 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.getChildTextTrim(String)\" because \"e\" is null", ex.getMessage(), "ex.getMessage()"); } assertFalse(dailyTaskAdaptor.isModified(), "dailyTaskAdaptor.isModified()"); assertNull(dailyTaskAdaptor.task, "dailyTaskAdaptor.task"); } }
### Question: DailyTaskAdaptor extends QBeanSupport implements Runnable { public void run () { while (running()) { waitUntilStartTime(); if (running()) { Thread taskThread = new Thread(task); taskThread.setDaemon (true); taskThread.start(); ISOUtil.sleep (1000); } } } DailyTaskAdaptor(); void run(); Date getWhen(); }### Answer: @Test public void testRun() throws Throwable { DailyTaskAdaptor dailyTaskAdaptor = new DailyTaskAdaptor(); dailyTaskAdaptor.run(); assertNull(dailyTaskAdaptor.getConfiguration(), "dailyTaskAdaptor.getConfiguration()"); } @Test public void testRunThrowsNullPointerException() throws Throwable { DailyTaskAdaptor dailyTaskAdaptor = new DailyTaskAdaptor(); dailyTaskAdaptor.setState(2); try { dailyTaskAdaptor.run(); 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)\" because \"this.cfg\" is null", ex.getMessage(), "ex.getMessage()"); } assertNull(dailyTaskAdaptor.getConfiguration(), "dailyTaskAdaptor.getConfiguration()"); } } @Test public void testRunThrowsNumberFormatException() throws Throwable { Configuration cfg = new SimpleConfiguration(); DailyTaskAdaptor dailyTaskAdaptor = new DailyTaskAdaptor(); dailyTaskAdaptor.setState(2); dailyTaskAdaptor.setConfiguration(cfg); try { dailyTaskAdaptor.run(); fail("Expected NumberFormatException to be thrown"); } catch (NumberFormatException ex) { assertEquals("For input string: \":0\"", ex.getMessage(), "ex.getMessage()"); assertSame(cfg, dailyTaskAdaptor.getConfiguration(), "dailyTaskAdaptor.getConfiguration()"); } }
### Question: DailyTaskAdaptor extends QBeanSupport implements Runnable { protected void startService () throws Exception { if (task instanceof Configurable) { Element e = getPersist (); QFactory factory = getServer().getFactory(); ((Configurable)task).setConfiguration ( factory.getConfiguration (e) ); } (thisThread = new Thread(this)).start(); } DailyTaskAdaptor(); void run(); Date getWhen(); }### Answer: @Test public void testStartService() throws Throwable { DailyTaskAdaptor dailyTaskAdaptor = new DailyTaskAdaptor(); dailyTaskAdaptor.startService(); assertTrue(true, "Test completed without Exception"); }
### Question: DailyTaskAdaptor extends QBeanSupport implements Runnable { protected void stopService () throws Exception { if (thisThread != null) thisThread.interrupt(); } DailyTaskAdaptor(); void run(); Date getWhen(); }### Answer: @Test public void testStopService() throws Throwable { DailyTaskAdaptor dailyTaskAdaptor = new DailyTaskAdaptor(); dailyTaskAdaptor.startService(); dailyTaskAdaptor.stopService(); assertTrue(true, "Test completed without Exception"); } @Test public void testStopService1() throws Throwable { DailyTaskAdaptor dailyTaskAdaptor = new DailyTaskAdaptor(); dailyTaskAdaptor.stopService(); assertNull(dailyTaskAdaptor.thisThread, "dailyTaskAdaptor.thisThread"); }
### Question: DailyTaskAdaptor extends QBeanSupport implements Runnable { protected void waitUntilStartTime() { Date when = getWhen(); while (running()) { Date now = new GregorianCalendar().getTime(); if (now.before (when)) { long sleepTime = when.getTime() - now.getTime(); if (sleepTime <= 0) { ISOUtil.sleep(1000); continue; } getLog().info ("sleeping", sleepTime/1000 + " secs until " + when.toString() ); try { Thread.sleep (sleepTime); } catch (InterruptedException e) { when = getWhen(); } } else break; } } DailyTaskAdaptor(); void run(); Date getWhen(); }### Answer: @Test public void testWaitUntilStartTimeThrowsNullPointerException() throws Throwable { DailyTaskAdaptor dailyTaskAdaptor = new DailyTaskAdaptor(); try { dailyTaskAdaptor.waitUntilStartTime(); 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)\" because \"this.cfg\" is null", ex.getMessage(), "ex.getMessage()"); } assertNull(dailyTaskAdaptor.getConfiguration(), "dailyTaskAdaptor.getConfiguration()"); } } @Test public void testWaitUntilStartTimeThrowsNumberFormatException() throws Throwable { DailyTaskAdaptor dailyTaskAdaptor = new DailyTaskAdaptor(); Configuration cfg = new SimpleConfiguration(); dailyTaskAdaptor.setConfiguration(cfg); try { dailyTaskAdaptor.waitUntilStartTime(); fail("Expected NumberFormatException to be thrown"); } catch (NumberFormatException ex) { assertEquals("For input string: \":0\"", ex.getMessage(), "ex.getMessage()"); assertSame(cfg, dailyTaskAdaptor.getConfiguration(), "dailyTaskAdaptor.getConfiguration()"); } }
### Question: CharTagMap extends HashMap<String, CharTag> { public void unpack(CharSequence data) throws IllegalArgumentException { if (data == null) throw new IllegalArgumentException("TLV data are required to unpack"); CharBuffer buffer = CharBuffer.wrap(data); CharTag currentTag; while (buffer.hasRemaining()) { currentTag = getTLVMsg(buffer); put(currentTag.getTagId(), currentTag); } } static CharTagMap getInstance(); void unpack(CharSequence data); String pack(); CharTagMap addTag(String tagId, String value); CharTag createTLV(String tagId, String value); String getTagValue(String tagId); boolean hasTag(String tagId); }### Answer: @Test public void testUnpackEmptyTag() { instance.unpack("02000"); assertAll( () -> assertEquals(1, instance.size()), () -> assertEquals("02", instance.get("02").getTagId()), () -> assertEquals("", instance.get("02").getValue()) ); } @Test public void testUnpackOneTag() { instance.unpack("02008ValueXyZ"); assertAll( () -> assertEquals(1, instance.size()), () -> assertEquals("02", instance.get("02").getTagId()), () -> assertEquals("ValueXyZ", instance.get("02").getValue()) ); } @Test public void testUnpackOneTagAndMissing() { instance.unpack("02008ValueXyZ"); assertAll( () -> assertEquals(1, instance.size()), () -> assertEquals("02", instance.get("02").getTagId()), () -> assertEquals("ValueXyZ", instance.get("02").getValue()), () -> assertNull(instance.get("03")) ); } @Test public void testUnpackTwoTag() { instance.unpack("02008ValueXyZ03007ValueAb"); assertAll( () -> assertEquals(2, instance.size()), () -> assertEquals("02", instance.get("02").getTagId()), () -> assertEquals("ValueXyZ", instance.get("02").getValue()), () -> assertEquals("03", instance.get("03").getTagId()), () -> assertEquals("ValueAb", instance.get("03").getValue()) ); } @Test public void testUnpackTwoTagReverted() { instance.unpack("03007ValueAb02008ValueXyZ"); assertAll( () -> assertEquals(2, instance.size()), () -> assertEquals("02", instance.get("02").getTagId()), () -> assertEquals("ValueXyZ", instance.get("02").getValue()), () -> assertEquals("03", instance.get("03").getTagId()), () -> assertEquals("ValueAb", instance.get("03").getValue()) ); } @Test public void testUnpackTwoTagShortTag() { thrown = assertThrows(IllegalArgumentException.class, () -> instance.unpack("03008wartosc20") ); } @Test public void testUnpackTwoTagShortLength() { thrown = assertThrows(IllegalArgumentException.class, () -> instance.unpack("0400") ); } @Test public void testUnpackRevertedTwoTagShortValue() { thrown = assertThrows(IllegalArgumentException.class, () -> instance.unpack("04008wa") ); } @Test public void testUnpackNull() { thrown = assertThrows(IllegalArgumentException.class, () -> instance.unpack(null) ); }
### Question: CLICommandInterface { public String[] parseCommand(String line) throws IOException { if (line == null) { return new String[0]; } List<String> matchList = new ArrayList<String>(); Pattern regex = Pattern.compile("[^\\s\"']+|\"([^\"]*)\"|'([^']*)'"); Matcher regexMatcher = regex.matcher(line); while (regexMatcher.find()) { if (regexMatcher.group(1) != null) { matchList.add(regexMatcher.group(1)); } else if (regexMatcher.group(2) != null) { matchList.add(regexMatcher.group(2)); } else { matchList.add(regexMatcher.group()); } } String[] args = new String[matchList.size()]; matchList.toArray(args); return args; } CLICommandInterface(CLIContext ctx); List<String> getPrefixes(); void addPrefix(String prefix); void execCommand(String line); String[] parseCommand(String line); }### Answer: @Test public void testparseCommand_LineIsNull() throws IOException { String[] args = cliCommandInterface.parseCommand(null); assertThat(args).isEmpty(); } @Test public void testparseCommand_LineContainsSpacesOnly() throws IOException { String line = " "; String[] args = cliCommandInterface.parseCommand(line); assertThat(args).isEmpty(); } @Test public void testparseCommand_NoQuotes() throws IOException { String line = "arg1 arg2 arg3"; String[] args = cliCommandInterface.parseCommand(line); assertThat(Arrays.asList(args)) .containsSequence("arg1", "arg2", "arg3"); } @Test public void testparseCommand_SimpleQuotesArmuredArgWithoutSpaceWithin() throws IOException { String line = "arg1 'arg2' arg3"; String[] args = cliCommandInterface.parseCommand(line); assertThat(Arrays.asList(args)) .containsSequence("arg1", "arg2", "arg3"); } @Test public void testparseCommand_SimpleQuotesArmuredArgWithSpacesWithin() throws IOException { String line = "arg1 'arg2 with spaces within' arg3"; String[] args = cliCommandInterface.parseCommand(line); assertThat(Arrays.asList(args)).containsSequence("arg1", "arg2 with spaces within", "arg3"); } @Test public void testparseCommand_SimpleQuotesArmuredArgWithSpacesAndDoubleQuotesWithin() throws IOException { String line = "arg1 'arg2 with spaces and \"double quotes\" within' arg3"; String[] args = cliCommandInterface.parseCommand(line); assertThat(Arrays.asList(args)).containsSequence("arg1", "arg2 with spaces and \"double quotes\" within", "arg3"); } @Test public void testparseCommand_DoubleQuotesArmuredArgWithoutSpacesWithin() throws IOException { String line = "arg1 \"arg2\" arg3"; String[] args = cliCommandInterface.parseCommand(line); assertThat(Arrays.asList(args)) .containsSequence("arg1", "arg2", "arg3"); } @Test public void testparseCommand_DoubleQuotesArmuredArgWithSpacesWithin() throws IOException { String line = "arg1 \"arg2 with spaces within\" arg3"; String[] args = cliCommandInterface.parseCommand(line); assertThat(Arrays.asList(args)).containsSequence("arg1", "arg2 with spaces within", "arg3"); } @Test public void testparseCommand_DoubleQuotesArmuredArgWithSpacesAndSimplequotesWithin() throws IOException { String line = "arg1 \"arg2 with spaces and 'simple quotes' within\" arg3"; String[] args = cliCommandInterface.parseCommand(line); assertThat(Arrays.asList(args)).containsSequence("arg1", "arg2 with spaces and 'simple quotes' within", "arg3"); } @Test public void testparseCommand_SimpleQuotesArmuredEmptyArg() throws IOException { String line = "arg1 '' arg3"; String[] args = cliCommandInterface.parseCommand(line); assertThat(Arrays.asList(args)) .containsSequence("arg1", "", "arg3"); } @Test public void testparseCommand_DoubleQuotesArmuredEmptyArg() throws IOException { String line = "arg1 \"\" arg3"; String[] args = cliCommandInterface.parseCommand(line); assertThat(Arrays.asList(args)) .containsSequence("arg1", "", "arg3"); }
### Question: MappingLogEventWriter extends BaseLogEventWriter implements XmlConfigurable { protected LogEvent mapEvents(LogEvent ev) { if (eventMappers != null) { for (LogEventMapper mapper : eventMappers) { ev = mapper.apply(ev); } } return ev; } @Override void setPrintStream(PrintStream p); @Override synchronized void close(); @Override void write(LogEvent ev); @Override void setConfiguration(Element e); }### Answer: @Test void testMapEventsShouldCallEventMappersInOrderAndReturnFinalResult() { MappingLogEventWriter writer = new MappingLogEventWriter(); List<LogEventMapper> mappers = new ArrayList<>(); writer.eventMappers = mappers; mappers.add(logEvent -> { logEvent.addMessage("1"); return logEvent; }); mappers.add(logEvent -> { logEvent.addMessage("2"); return logEvent; }); LogEvent ev = new LogEvent(); LogEvent logEvent = writer.mapEvents(ev); assertEquals(2, logEvent.getPayLoad().size()); assertEquals("1", logEvent.getPayLoad().get(0)); assertEquals("2", logEvent.getPayLoad().get(1)); } @Test void testMapEventsShouldNotThrowExceptionWhenEventMappersIsNull() { MappingLogEventWriter writer = new MappingLogEventWriter(); assertDoesNotThrow(() -> writer.mapEvents(new LogEvent())); }
### Question: IFELPE_LLLCHAR extends ISOFieldPackager { @Override public byte[] pack(final ISOComponent c) throws ISOException { final String s = (String) c.getValue(); final int len = s.length(); final byte[] payload = new byte[len + TAG_HEADER_LENGTH]; final String tagHeader = ISOUtil.zeropad(Integer.toString(len + TAG_BYTE_LENGTH), LENGTH_BYTE_LENGTH) + ISOUtil.zeropad(c.getKey().toString(), TAG_BYTE_LENGTH); System.arraycopy(ISOUtil.asciiToEbcdic(tagHeader), 0, payload, 0, TAG_HEADER_LENGTH); System.arraycopy(ISOUtil.asciiToEbcdic(s), 0, payload, TAG_HEADER_LENGTH, len); return payload; } IFELPE_LLLCHAR(); IFELPE_LLLCHAR(int len, String description); @Override byte[] pack(final ISOComponent c); @Override int unpack(final ISOComponent c, final byte[] b, final int offset); @Override void unpack(final ISOComponent c, final InputStream in); @Override int getMaxPackedLength(); }### Answer: @Test public void testPack() throws Exception { ISOField field = new ISOField(92, "123"); IFELPE_LLLCHAR packager = new IFELPE_LLLCHAR(92, "Should be F0F0F5F9F2F1F2F3"); TestUtils.assertEquals(new byte[] {(byte)0xF0, (byte)0xF0,(byte)0xf5, (byte)0xF9, (byte)0xF2, (byte)0xF1, (byte)0xF2, (byte)0xF3}, packager.pack(field)); }
### Question: IFELPE_LLLCHAR extends ISOFieldPackager { @Override public int unpack(final ISOComponent c, final byte[] b, final int offset) throws ISOException { final String asciiResult = ISOUtil.ebcdicToAscii(b, offset, LENGTH_BYTE_LENGTH); final int len = Integer.parseInt(asciiResult) - TAG_BYTE_LENGTH; if (!(c instanceof ISOField)) throw new ISOException(c.getClass() .getName() + " is not an ISOField"); c.setFieldNumber(Integer.parseInt(ISOUtil.ebcdicToAscii(b, offset + LENGTH_BYTE_LENGTH, TAG_BYTE_LENGTH))); c.setValue(ISOUtil.ebcdicToAscii(b, offset + TAG_HEADER_LENGTH, len)); return len + 5; } IFELPE_LLLCHAR(); IFELPE_LLLCHAR(int len, String description); @Override byte[] pack(final ISOComponent c); @Override int unpack(final ISOComponent c, final byte[] b, final int offset); @Override void unpack(final ISOComponent c, final InputStream in); @Override int getMaxPackedLength(); }### Answer: @Test public void testUnpack() throws Exception { byte[] raw = new byte[] {(byte)0xF0, (byte)0xF0,(byte)0xf5, (byte)0xF9, (byte)0xF2, (byte)0xF1, (byte)0xF2, (byte)0xF3}; IFELPE_LLLCHAR packager = new IFELPE_LLLCHAR(10, "Should be F0F0F5F9F2F1F2F3"); ISOField field = new ISOField(); int len = packager.unpack(field, raw, 0); assertEquals(raw.length, len); assertEquals("123", (String) field.getValue()); assertEquals(92, field.fieldNumber); }
### Question: Connector implements ISORequestListener, LogSource, Configurable { public Logger getLogger() { return logger; } Connector(); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setConfiguration(Configuration cfg); boolean process(ISOSource source, ISOMsg m); }### Answer: @Test public void testGetLogger() throws Throwable { Connector connector = new Connector(); Logger logger = new Logger(); connector.setLogger(logger, "testConnectorRealm"); Logger result = connector.getLogger(); assertSame(logger, result, "result"); }
### Question: Connector implements ISORequestListener, LogSource, Configurable { public String getRealm () { return realm; } Connector(); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setConfiguration(Configuration cfg); boolean process(ISOSource source, ISOMsg m); }### Answer: @Test public void testGetRealm() throws Throwable { String result = new Connector().getRealm(); assertNull(result, "result"); }
### Question: Connector implements ISORequestListener, LogSource, Configurable { public boolean process (ISOSource source, ISOMsg m) { if (pool == null) pool = new ThreadPool (1, 10); pool.execute (new Process (source, m)); return true; } Connector(); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setConfiguration(Configuration cfg); boolean process(ISOSource source, ISOMsg m); }### Answer: @Test public void testProcess() throws Throwable { Connector connector = new Connector(); boolean result = connector.process(new XMLChannel(), new ISOMsg(100)); assertTrue(result, "result"); }
### Question: Connector implements ISORequestListener, LogSource, Configurable { public void setConfiguration (Configuration cfg) throws ConfigurationException { timeout = cfg.getInt ("timeout"); if (pool == null) pool = new ThreadPool (1, cfg.getInt ("poolsize", 10)); muxName = cfg.get ("destination-mux", null); channelName = cfg.get ("destination-channel", null); preserveSourceHeader = cfg.getBoolean ("preserve-source-header", true); if (muxName == null && channelName == null) { throw new ConfigurationException("Neither destination mux nor channel were specified."); } } Connector(); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setConfiguration(Configuration cfg); boolean process(ISOSource source, ISOMsg m); }### Answer: @Test public void testSetConfigurationThrowsNullPointerException() throws Throwable { Connector connector = new Connector(); Configuration cfg = new SubConfiguration(); try { connector.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)\" because \"this.cfg\" is null", ex.getMessage(), "ex.getMessage()"); } assertEquals(0, connector.timeout, "connector.timeout"); assertNull(connector.channelName, "connector.channelName"); assertNull(connector.muxName, "connector.muxName"); } }
### Question: Connector implements ISORequestListener, LogSource, Configurable { public void setLogger (Logger logger, String realm) { this.logger = logger; this.realm = realm; } Connector(); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setConfiguration(Configuration cfg); boolean process(ISOSource source, ISOMsg m); }### Answer: @Test public void testSetLogger() throws Throwable { Connector connector = new Connector(); Logger logger = new Logger(); connector.setLogger(logger, "testConnectorRealm"); assertSame(logger, connector.getLogger(), "connector.getLogger()"); assertEquals("testConnectorRealm", connector.getRealm(), "connector.getRealm()"); }
### Question: MD5Template implements Template, Serializable { public Object getKey () { return key; } MD5Template(Object key, Object value); MD5Template(Object key, byte[] digest); byte[] digest(Object obj); @Override boolean equals(Object obj); @Override int hashCode(); Object getKey(); byte[] getDigest(); String getDigestAsString(); String toString(); static byte[] serialize(Object obj); }### Answer: @Test public void testGetKey() throws Throwable { byte[] digest = new byte[1]; Integer key = Integer.valueOf(0); Integer result = (Integer) new MD5Template(key, digest).getKey(); assertSame(key, result, "result"); } @Test public void testGetKey1() throws Throwable { byte[] key = new byte[1]; byte[] result = (byte[]) new MD5Template(key, "testString".getBytes()).getKey(); assertSame(key, result, "result"); } @Test public void testGetKey2() throws Throwable { String result = (String) new MD5Template("testString", "\n".getBytes()).getKey(); assertEquals("testString", result, "result"); }
### Question: MappingLogEventWriter extends BaseLogEventWriter implements XmlConfigurable { protected byte[] mapOutput(byte[] output) { if (outputMappers != null) { for (ByteArrayMapper mapper : outputMappers) { output = mapper.apply(output); } } return output; } @Override void setPrintStream(PrintStream p); @Override synchronized void close(); @Override void write(LogEvent ev); @Override void setConfiguration(Element e); }### Answer: @Test void testMapOutputsShouldCallOutputMappersInOrderAndReturnFinalResult() { MappingLogEventWriter writer = new MappingLogEventWriter(); List<ByteArrayMapper> mappers = new ArrayList<>(); writer.outputMappers = mappers; mappers.add(b -> { byte[] temp = Arrays.copyOf(b, b.length + 1); temp[temp.length - 1] = '1'; return temp; }); mappers.add(b -> { byte[] temp = Arrays.copyOf(b, b.length + 1); temp[temp.length - 1] = '2'; return temp; }); byte[] b = {'0'}; byte[] r = writer.mapOutput(b); assertArrayEquals(new byte[]{'0','1','2'}, r); } @Test void testMapOutputShouldNotThrowExceptionWhenOutputMappersIsNull() { MappingLogEventWriter writer = new MappingLogEventWriter(); assertDoesNotThrow(() -> writer.mapOutput(new byte[]{})); }
### Question: SpaceInterceptor implements Space<K,V> { public V in (K key) { return sp.in (key); } SpaceInterceptor(Space<K,V> sp); void out(K key, V value); void out(K key, V value, long timeout); void push(K key, V value); void push(K key, V value, long timeout); void put(K key, V value); void put(K key, V value, long timeout); V in(K key); V rd(K key); V in(K key, long timeout); V rd(K key, long timeout); V inp(K key); V rdp(K key); @Override void nrd(K key); @Override V nrd(K key, long timeout); boolean existAny(K[] keys); boolean existAny(K[] keys, long timeout); }### Answer: @Test public void testInThrowsNullPointerException() throws Throwable { SpaceInterceptor spaceInterceptor = new SpaceInterceptor(null); try { spaceInterceptor.in(""); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"org.jpos.space.Space.in(Object)\" because \"this.sp\" is null", ex.getMessage(), "ex.getMessage()"); } assertNull(spaceInterceptor.sp, "spaceInterceptor.sp"); } }
### Question: SpaceInterceptor implements Space<K,V> { public void out (K key, V value) { sp.out (key, value); } SpaceInterceptor(Space<K,V> sp); void out(K key, V value); void out(K key, V value, long timeout); void push(K key, V value); void push(K key, V value, long timeout); void put(K key, V value); void put(K key, V value, long timeout); V in(K key); V rd(K key); V in(K key, long timeout); V rd(K key, long timeout); V inp(K key); V rdp(K key); @Override void nrd(K key); @Override V nrd(K key, long timeout); boolean existAny(K[] keys); boolean existAny(K[] keys, long timeout); }### Answer: @Test public void testOut() throws Throwable { TSpace sp = mock(TSpace.class); SpaceInterceptor spaceInterceptor = new SpaceInterceptor(sp); sp.out("testString", "1", 0L); spaceInterceptor.out("testString", "1", 0L); assertSame(sp, spaceInterceptor.sp, "spaceInterceptor.sp"); verify(sp, times(2)).out("testString", "1", 0L); } @Test public void testOutThrowsNullPointerException() throws Throwable { SpaceInterceptor spaceInterceptor = new SpaceInterceptor(null); try { spaceInterceptor.out(Integer.valueOf(-1), "1", 100L); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"org.jpos.space.Space.out(Object, Object, long)\" because \"this.sp\" is null", ex.getMessage(), "ex.getMessage()"); } assertNull(spaceInterceptor.sp, "spaceInterceptor.sp"); } }
### Question: SpaceInterceptor implements Space<K,V> { public V rdp (K key) { return sp.rdp (key); } SpaceInterceptor(Space<K,V> sp); void out(K key, V value); void out(K key, V value, long timeout); void push(K key, V value); void push(K key, V value, long timeout); void put(K key, V value); void put(K key, V value, long timeout); V in(K key); V rd(K key); V in(K key, long timeout); V rd(K key, long timeout); V inp(K key); V rdp(K key); @Override void nrd(K key); @Override V nrd(K key, long timeout); boolean existAny(K[] keys); boolean existAny(K[] keys, long timeout); }### Answer: @Test public void testRdp() throws Throwable { Space sp = SpaceFactory.getSpace(); SpaceInterceptor spaceInterceptor = new SpaceInterceptor(sp); Object result = spaceInterceptor.rdp(sp); assertNull(result, "result"); assertSame(sp, spaceInterceptor.sp, "spaceInterceptor.sp"); } @Test public void testRdpThrowsNullPointerException() throws Throwable { SpaceInterceptor spaceInterceptor = new SpaceInterceptor(null); try { spaceInterceptor.rdp("testString"); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"org.jpos.space.Space.rdp(Object)\" because \"this.sp\" is null", ex.getMessage(), "ex.getMessage()"); } assertNull(spaceInterceptor.sp, "spaceInterceptor.sp"); } }
### Question: SpaceInterceptor implements Space<K,V> { public V rd (K key) { return sp.rd (key); } SpaceInterceptor(Space<K,V> sp); void out(K key, V value); void out(K key, V value, long timeout); void push(K key, V value); void push(K key, V value, long timeout); void put(K key, V value); void put(K key, V value, long timeout); V in(K key); V rd(K key); V in(K key, long timeout); V rd(K key, long timeout); V inp(K key); V rdp(K key); @Override void nrd(K key); @Override V nrd(K key, long timeout); boolean existAny(K[] keys); boolean existAny(K[] keys, long timeout); }### Answer: @Test public void testRdThrowsNullPointerException() throws Throwable { SpaceInterceptor spaceInterceptor = new SpaceInterceptor(null); try { spaceInterceptor.rd("", -1L); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"org.jpos.space.Space.rd(Object, long)\" because \"this.sp\" is null", ex.getMessage(), "ex.getMessage()"); } assertNull(spaceInterceptor.sp, "spaceInterceptor.sp"); } }
### Question: JDBMSpace extends TimerTask implements Space<K,V> { static void putLong (byte[] b, int off, long val) { b[off+7] = (byte) val; b[off+6] = (byte) (val >>> 8); b[off+5] = (byte) (val >>> 16); b[off+4] = (byte) (val >>> 24); b[off+3] = (byte) (val >>> 32); b[off+2] = (byte) (val >>> 40); b[off+1] = (byte) (val >>> 48); b[off] = (byte) (val >>> 56); } protected JDBMSpace(String name, String filename); static JDBMSpace getSpace(); static JDBMSpace getSpace(String name); synchronized static JDBMSpace getSpace(String name, String filename); void setAutoCommit(boolean b); void commit(); void rollback(); void close(); void out(K key, V value); void out(K key, V value, long timeout); void push(K key, V value); void push(Object key, Object value, long timeout); synchronized V rdp(Object key); synchronized V inp(Object key); synchronized V in(Object key); synchronized V in(Object key, long timeout); synchronized V rd(Object key); synchronized V rd(Object key, long timeout); synchronized void nrd(Object key); synchronized V nrd(Object key, long timeout); long size(Object key); boolean existAny(Object[] keys); boolean existAny(Object[] keys, long timeout); synchronized void put(K key, V value, long timeout); synchronized void put(K key, V value); void run(); void gc(); String getKeys(); static final long GCDELAY; }### Answer: @Test public void testPutLong() throws Throwable { byte[] b = new byte[66]; JDBMSpace.putLong(b, 0, 100L); assertEquals((byte) 100, b[7], "b[7]"); } @Test public void testPutLongThrowsArrayIndexOutOfBoundsException() throws Throwable { byte[] b = "42".getBytes(); try { JDBMSpace.putLong(b, -6, 100L); fail("Expected ArrayIndexOutOfBoundsException to be thrown"); } catch (ArrayIndexOutOfBoundsException ex) { assertEquals((byte) 0, b[0], "b[0]"); if (isJavaVersionAtMost(JAVA_10)) { assertEquals("-1", ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Index -1 out of bounds for length 2", ex.getMessage(), "ex.getMessage()"); } assertEquals(2, b.length, "b.length"); } } @Test public void testPutLongThrowsArrayIndexOutOfBoundsException1() throws Throwable { byte[] b = new byte[3]; try { JDBMSpace.putLong(b, 100, 100L); fail("Expected ArrayIndexOutOfBoundsException to be thrown"); } catch (ArrayIndexOutOfBoundsException ex) { if (isJavaVersionAtMost(JAVA_10)) { assertEquals("107", ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Index 107 out of bounds for length 3", ex.getMessage(), "ex.getMessage()"); } assertEquals(3, b.length, "b.length"); } } @Test public void testPutLongThrowsNullPointerException() throws Throwable { try { JDBMSpace.putLong(null, 100, 100L); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot store to byte/boolean array because \"b\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: MappingLogEventWriter extends BaseLogEventWriter implements XmlConfigurable { @Override public void setConfiguration(Element e) throws ConfigurationException { configureEventMappers(e); configureOutputMappers(e); } @Override void setPrintStream(PrintStream p); @Override synchronized void close(); @Override void write(LogEvent ev); @Override void setConfiguration(Element e); }### Answer: @Test void testConfigureEventMappersShouldThrowExceptionWhenFailOnNewInstance() { Element root = new Element("root"); Element em = new Element("event-mapper"); em.setAttribute("class", "i.dont.Exist"); root.addContent(em); MappingLogEventWriter writer = new MappingLogEventWriter(); assertThrows(ConfigurationException.class, () -> writer.setConfiguration(root)); } @Test void testConfigureOutputMappersShouldThrowExceptionWhenFailOnNewInstance() { Element root = new Element("root"); Element om = new Element("output-mapper"); om.setAttribute("class", "i.dont.Exist"); root.addContent(om); MappingLogEventWriter writer = new MappingLogEventWriter(); assertThrows(ConfigurationException.class, () -> writer.setConfiguration(root)); } @Test void testShouldAddEventMapperWhenConfigured() throws ConfigurationException { Element root = new Element("root"); Element em = new Element("event-mapper"); em.setAttribute("class", "org.jpos.util.function.TestLogEventMapper"); root.addContent(em); MappingLogEventWriter writer = new MappingLogEventWriter(); assertNull(writer.eventMappers); writer.setConfiguration(root); assertNotNull(writer.eventMappers); assertEquals(1, writer.eventMappers.size()); assertTrue(writer.eventMappers.get(0) instanceof TestLogEventMapper); } @Test void testShouldAddOutputMapperWhenConfigured() throws ConfigurationException { Element root = new Element("root"); Element om = new Element("output-mapper"); om.setAttribute("class", "org.jpos.util.function.RemoveNewLinesMapper"); root.addContent(om); MappingLogEventWriter writer = new MappingLogEventWriter(); assertNull(writer.outputMappers); writer.setConfiguration(root); assertNotNull(writer.outputMappers); assertEquals(1, writer.outputMappers.size()); assertTrue(writer.outputMappers.get(0) instanceof RemoveNewLinesMapper); }
### Question: TSpace implements LocalSpace<K,V>, Loggeable, Runnable { @Override public synchronized int size (Object key) { int size = 0; List l = (List) entries.get (key); if (l != null) size = l.size(); return size; } TSpace(); @Override void out(K key, V value); @Override void out(K key, V value, long timeout); @Override synchronized V rdp(Object key); @Override synchronized V inp(Object key); @Override synchronized V in(Object key); @Override synchronized V in(Object key, long timeout); @Override synchronized V rd(Object key); @Override synchronized V rd(Object key, long timeout); @Override synchronized void nrd(Object key); @Override synchronized V nrd(Object key, long timeout); @Override void run(); void gc(); @Override synchronized int size(Object key); @Override synchronized void addListener(Object key, SpaceListener listener); @Override synchronized void addListener(Object key, SpaceListener listener, long timeout); @Override synchronized void removeListener(Object key, SpaceListener listener); boolean isEmpty(); @Override synchronized Set<K> getKeySet(); String getKeysAsString(); @Override void dump(PrintStream p, String indent); void notifyListeners(Object key, Object value); @Override void push(K key, V value); @Override void push(K key, V value, long timeout); @Override void put(K key, V value); @Override void put(K key, V value, long timeout); @Override boolean existAny(K[] keys); @Override boolean existAny(K[] keys, long timeout); Map getEntries(); void setEntries(Map entries); static final long GCDELAY; }### Answer: @Test public void testConstructor() throws Throwable { TSpace tSpace = new TSpace(); assertEquals(0, tSpace.entries.size(), "tSpace.entries.size()"); }
### Question: TSpace implements LocalSpace<K,V>, Loggeable, Runnable { @Override public void dump(PrintStream p, String indent) { Object[] keys; int size = entries.size(); if (size > MAX_ENTRIES_IN_DUMP * 100) { p.printf ("%sWARNING - space too big, size=%d%n", indent, size); return; } synchronized (this) { keys = entries.keySet().toArray(); } int i=0; for (Object key : keys) { p.printf("%s<key count='%d'>%s</key>%n", indent, size(key), key); if (i++ > MAX_ENTRIES_IN_DUMP) { p.printf ("%s...%n", indent); p.printf ("%s...%n", indent); break; } } p.printf("%s key-count: %d%n", indent, keys.length); int exp0, exp1; synchronized (this) { exp0 = expirables[0].size(); exp1 = expirables[1].size(); } p.printf("%s gcinfo: %d,%d%n", indent, exp0, exp1); } TSpace(); @Override void out(K key, V value); @Override void out(K key, V value, long timeout); @Override synchronized V rdp(Object key); @Override synchronized V inp(Object key); @Override synchronized V in(Object key); @Override synchronized V in(Object key, long timeout); @Override synchronized V rd(Object key); @Override synchronized V rd(Object key, long timeout); @Override synchronized void nrd(Object key); @Override synchronized V nrd(Object key, long timeout); @Override void run(); void gc(); @Override synchronized int size(Object key); @Override synchronized void addListener(Object key, SpaceListener listener); @Override synchronized void addListener(Object key, SpaceListener listener, long timeout); @Override synchronized void removeListener(Object key, SpaceListener listener); boolean isEmpty(); @Override synchronized Set<K> getKeySet(); String getKeysAsString(); @Override void dump(PrintStream p, String indent); void notifyListeners(Object key, Object value); @Override void push(K key, V value); @Override void push(K key, V value, long timeout); @Override void put(K key, V value); @Override void put(K key, V value, long timeout); @Override boolean existAny(K[] keys); @Override boolean existAny(K[] keys, long timeout); Map getEntries(); void setEntries(Map entries); static final long GCDELAY; }### Answer: @Test public void testDump() throws Throwable { TSpace tSpace = new TSpace(); tSpace.out("", "testString"); tSpace.out(Integer.valueOf(0), Integer.valueOf(-1)); tSpace.out(Integer.valueOf(31), ""); PrintStream p = new PrintStream(new ByteArrayOutputStream(), true); tSpace.dump(p, "testTSpaceIndent"); assertEquals(3, tSpace.entries.size(), "tSpace.entries.size()"); }
### Question: TSpace implements LocalSpace<K,V>, Loggeable, Runnable { public void gc () { gc(0); if (System.currentTimeMillis() - lastLongGC > GCLONG) { gc(1); lastLongGC = System.currentTimeMillis(); } } TSpace(); @Override void out(K key, V value); @Override void out(K key, V value, long timeout); @Override synchronized V rdp(Object key); @Override synchronized V inp(Object key); @Override synchronized V in(Object key); @Override synchronized V in(Object key, long timeout); @Override synchronized V rd(Object key); @Override synchronized V rd(Object key, long timeout); @Override synchronized void nrd(Object key); @Override synchronized V nrd(Object key, long timeout); @Override void run(); void gc(); @Override synchronized int size(Object key); @Override synchronized void addListener(Object key, SpaceListener listener); @Override synchronized void addListener(Object key, SpaceListener listener, long timeout); @Override synchronized void removeListener(Object key, SpaceListener listener); boolean isEmpty(); @Override synchronized Set<K> getKeySet(); String getKeysAsString(); @Override void dump(PrintStream p, String indent); void notifyListeners(Object key, Object value); @Override void push(K key, V value); @Override void push(K key, V value, long timeout); @Override void put(K key, V value); @Override void put(K key, V value, long timeout); @Override boolean existAny(K[] keys); @Override boolean existAny(K[] keys, long timeout); Map getEntries(); void setEntries(Map entries); static final long GCDELAY; }### Answer: @Test public void testGc() throws Throwable { TSpace tSpace = new TSpace(); tSpace.gc(); assertEquals(0, tSpace.entries.size(), "tSpace.entries.size()"); }
### Question: TSpace implements LocalSpace<K,V>, Loggeable, Runnable { public String getKeysAsString () { StringBuilder sb = new StringBuilder(); Object[] keys; synchronized (this) { keys = entries.keySet().toArray(); } for (int i=0; i<keys.length; i++) { if (i > 0) sb.append (' '); sb.append (keys[i]); } return sb.toString(); } TSpace(); @Override void out(K key, V value); @Override void out(K key, V value, long timeout); @Override synchronized V rdp(Object key); @Override synchronized V inp(Object key); @Override synchronized V in(Object key); @Override synchronized V in(Object key, long timeout); @Override synchronized V rd(Object key); @Override synchronized V rd(Object key, long timeout); @Override synchronized void nrd(Object key); @Override synchronized V nrd(Object key, long timeout); @Override void run(); void gc(); @Override synchronized int size(Object key); @Override synchronized void addListener(Object key, SpaceListener listener); @Override synchronized void addListener(Object key, SpaceListener listener, long timeout); @Override synchronized void removeListener(Object key, SpaceListener listener); boolean isEmpty(); @Override synchronized Set<K> getKeySet(); String getKeysAsString(); @Override void dump(PrintStream p, String indent); void notifyListeners(Object key, Object value); @Override void push(K key, V value); @Override void push(K key, V value, long timeout); @Override void put(K key, V value); @Override void put(K key, V value, long timeout); @Override boolean existAny(K[] keys); @Override boolean existAny(K[] keys, long timeout); Map getEntries(); void setEntries(Map entries); static final long GCDELAY; }### Answer: @Test public void testGetKeysAsString() throws Throwable { TSpace tSpace = new TSpace(); String result = tSpace.getKeysAsString(); assertEquals("", result, "result"); assertEquals(0, tSpace.entries.size(), "tSpace.entries.size()"); }
### Question: TSpace implements LocalSpace<K,V>, Loggeable, Runnable { @Override public synchronized Set<K> getKeySet() { return new HashSet<K>(entries.keySet()); } TSpace(); @Override void out(K key, V value); @Override void out(K key, V value, long timeout); @Override synchronized V rdp(Object key); @Override synchronized V inp(Object key); @Override synchronized V in(Object key); @Override synchronized V in(Object key, long timeout); @Override synchronized V rd(Object key); @Override synchronized V rd(Object key, long timeout); @Override synchronized void nrd(Object key); @Override synchronized V nrd(Object key, long timeout); @Override void run(); void gc(); @Override synchronized int size(Object key); @Override synchronized void addListener(Object key, SpaceListener listener); @Override synchronized void addListener(Object key, SpaceListener listener, long timeout); @Override synchronized void removeListener(Object key, SpaceListener listener); boolean isEmpty(); @Override synchronized Set<K> getKeySet(); String getKeysAsString(); @Override void dump(PrintStream p, String indent); void notifyListeners(Object key, Object value); @Override void push(K key, V value); @Override void push(K key, V value, long timeout); @Override void put(K key, V value); @Override void put(K key, V value, long timeout); @Override boolean existAny(K[] keys); @Override boolean existAny(K[] keys, long timeout); Map getEntries(); void setEntries(Map entries); static final long GCDELAY; }### Answer: @Test public void testGetKeySet() throws Throwable { TSpace tSpace = new TSpace(); AbstractSet result = (AbstractSet) tSpace.getKeySet(); assertEquals(0, result.size(), "result.size()"); assertEquals(0, tSpace.entries.size(), "tSpace.entries.size()"); }
### Question: TSpace implements LocalSpace<K,V>, Loggeable, Runnable { @Override public synchronized V in (Object key) { Object obj; while ((obj = inp (key)) == null) { try { this.wait (); } catch (InterruptedException e) { } } return (V) obj; } TSpace(); @Override void out(K key, V value); @Override void out(K key, V value, long timeout); @Override synchronized V rdp(Object key); @Override synchronized V inp(Object key); @Override synchronized V in(Object key); @Override synchronized V in(Object key, long timeout); @Override synchronized V rd(Object key); @Override synchronized V rd(Object key, long timeout); @Override synchronized void nrd(Object key); @Override synchronized V nrd(Object key, long timeout); @Override void run(); void gc(); @Override synchronized int size(Object key); @Override synchronized void addListener(Object key, SpaceListener listener); @Override synchronized void addListener(Object key, SpaceListener listener, long timeout); @Override synchronized void removeListener(Object key, SpaceListener listener); boolean isEmpty(); @Override synchronized Set<K> getKeySet(); String getKeysAsString(); @Override void dump(PrintStream p, String indent); void notifyListeners(Object key, Object value); @Override void push(K key, V value); @Override void push(K key, V value, long timeout); @Override void put(K key, V value); @Override void put(K key, V value, long timeout); @Override boolean existAny(K[] keys); @Override boolean existAny(K[] keys, long timeout); Map getEntries(); void setEntries(Map entries); static final long GCDELAY; }### Answer: @Test public void testIn() throws Throwable { TSpace tSpace = new TSpace(); Object result = tSpace.in(Long.valueOf(0L), 1L); assertNull(result, "result"); assertEquals(0, tSpace.entries.size(), "tSpace.entries.size()"); }
### Question: TSpace implements LocalSpace<K,V>, Loggeable, Runnable { @Override public synchronized V inp (Object key) { if (key instanceof Template) return (V) getObject ((Template) key, true); return (V) getHead (key, true); } TSpace(); @Override void out(K key, V value); @Override void out(K key, V value, long timeout); @Override synchronized V rdp(Object key); @Override synchronized V inp(Object key); @Override synchronized V in(Object key); @Override synchronized V in(Object key, long timeout); @Override synchronized V rd(Object key); @Override synchronized V rd(Object key, long timeout); @Override synchronized void nrd(Object key); @Override synchronized V nrd(Object key, long timeout); @Override void run(); void gc(); @Override synchronized int size(Object key); @Override synchronized void addListener(Object key, SpaceListener listener); @Override synchronized void addListener(Object key, SpaceListener listener, long timeout); @Override synchronized void removeListener(Object key, SpaceListener listener); boolean isEmpty(); @Override synchronized Set<K> getKeySet(); String getKeysAsString(); @Override void dump(PrintStream p, String indent); void notifyListeners(Object key, Object value); @Override void push(K key, V value); @Override void push(K key, V value, long timeout); @Override void put(K key, V value); @Override void put(K key, V value, long timeout); @Override boolean existAny(K[] keys); @Override boolean existAny(K[] keys, long timeout); Map getEntries(); void setEntries(Map entries); static final long GCDELAY; }### Answer: @Test public void testInp() throws Throwable { TSpace tSpace = new TSpace(); MD5Template key = new MD5Template("", ""); Object result = tSpace.inp(key); assertNull(result, "result"); assertEquals(0, tSpace.entries.size(), "tSpace.entries.size()"); }
### Question: TSpace implements LocalSpace<K,V>, Loggeable, Runnable { public boolean isEmpty() { return entries.isEmpty(); } TSpace(); @Override void out(K key, V value); @Override void out(K key, V value, long timeout); @Override synchronized V rdp(Object key); @Override synchronized V inp(Object key); @Override synchronized V in(Object key); @Override synchronized V in(Object key, long timeout); @Override synchronized V rd(Object key); @Override synchronized V rd(Object key, long timeout); @Override synchronized void nrd(Object key); @Override synchronized V nrd(Object key, long timeout); @Override void run(); void gc(); @Override synchronized int size(Object key); @Override synchronized void addListener(Object key, SpaceListener listener); @Override synchronized void addListener(Object key, SpaceListener listener, long timeout); @Override synchronized void removeListener(Object key, SpaceListener listener); boolean isEmpty(); @Override synchronized Set<K> getKeySet(); String getKeysAsString(); @Override void dump(PrintStream p, String indent); void notifyListeners(Object key, Object value); @Override void push(K key, V value); @Override void push(K key, V value, long timeout); @Override void put(K key, V value); @Override void put(K key, V value, long timeout); @Override boolean existAny(K[] keys); @Override boolean existAny(K[] keys, long timeout); Map getEntries(); void setEntries(Map entries); static final long GCDELAY; }### Answer: @Test public void testIsEmpty() throws Throwable { TSpace tSpace = new TSpace(); boolean result = tSpace.isEmpty(); assertTrue(result, "result"); assertEquals(0, tSpace.entries.size(), "tSpace.entries.size()"); }
### Question: TSpace implements LocalSpace<K,V>, Loggeable, Runnable { @Override public void out (K key, V value) { if (key == null || value == null) throw new NullPointerException ("key=" + key + ", value=" + value); synchronized(this) { List l = getList(key); l.add (value); if (l.size() == 1) this.notifyAll (); } if (sl != null) notifyListeners(key, value); } TSpace(); @Override void out(K key, V value); @Override void out(K key, V value, long timeout); @Override synchronized V rdp(Object key); @Override synchronized V inp(Object key); @Override synchronized V in(Object key); @Override synchronized V in(Object key, long timeout); @Override synchronized V rd(Object key); @Override synchronized V rd(Object key, long timeout); @Override synchronized void nrd(Object key); @Override synchronized V nrd(Object key, long timeout); @Override void run(); void gc(); @Override synchronized int size(Object key); @Override synchronized void addListener(Object key, SpaceListener listener); @Override synchronized void addListener(Object key, SpaceListener listener, long timeout); @Override synchronized void removeListener(Object key, SpaceListener listener); boolean isEmpty(); @Override synchronized Set<K> getKeySet(); String getKeysAsString(); @Override void dump(PrintStream p, String indent); void notifyListeners(Object key, Object value); @Override void push(K key, V value); @Override void push(K key, V value, long timeout); @Override void put(K key, V value); @Override void put(K key, V value, long timeout); @Override boolean existAny(K[] keys); @Override boolean existAny(K[] keys, long timeout); Map getEntries(); void setEntries(Map entries); static final long GCDELAY; }### Answer: @Test public void testOut() throws Throwable { TSpace tSpace = new TSpace(); tSpace.out(Integer.valueOf(0), "testString", 100L); assertEquals(1, tSpace.entries.size(), "tSpace.entries.size()"); }
### Question: ObjectTemplate implements Template { public Object getKey() { return key; } ObjectTemplate(Object key, Object value); Object getKey(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testGetKey() throws Throwable { Integer key = Integer.valueOf(0); Integer result = (Integer) new ObjectTemplate(key, Integer.valueOf(0)).getKey(); assertSame(key, result, "result"); } @Test public void testGetKey1() throws Throwable { Integer key = Integer.valueOf(100); Integer result = (Integer) new ObjectTemplate(key, "2").getKey(); assertSame(key, result, "result"); } @Test public void testGetKey2() throws Throwable { String result = (String) new ObjectTemplate("testString", "").getKey(); assertEquals("testString", result, "result"); }
### Question: ObjectTemplate implements Template { @Override public boolean equals(Object obj) { return value.equals(obj); } ObjectTemplate(Object key, Object value); Object getKey(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testNotEqualsItSelfOrAnother() { String value = "someValue"; ObjectTemplate objectTemplateA = new ObjectTemplate("key", value); ObjectTemplate objectTemplateB = new ObjectTemplate("key", value); assertFalse(objectTemplateA.equals(objectTemplateA), "should only equals on the template value"); assertFalse(objectTemplateA.equals(objectTemplateB), "should only equals on the template value"); }
### Question: ObjectTemplate implements Template { @Override public int hashCode() { return value.hashCode(); } ObjectTemplate(Object key, Object value); Object getKey(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testHaveHashCodeOfValue() { String value = "someValue"; ObjectTemplate objectTemplate = new ObjectTemplate("key", value); assertEquals(objectTemplate.hashCode(), value.hashCode(), "Should implement hashCode on the template value"); assertEquals(objectTemplate.hashCode(), value.hashCode(), "objectTemplate hashCode and value hashCode should be same"); }
### Question: SpaceTap implements SpaceListener { public void close() { if (ssp != null) { ssp.removeListener (key, this); ssp = null; } } SpaceTap(LocalSpace sp, Object key, Object tapKey, long tapTimeout); SpaceTap(LocalSpace ssp, LocalSpace dsp, Object key, Object tapKey, long tapTimeout); void notify(Object key, Object value); void close(); }### Answer: @Test public void testClose() throws Throwable { SpaceTap spaceTap = new SpaceTap(new TSpace(), "\u0001 ", Integer.valueOf(1), 100L); spaceTap.close(); assertNull(spaceTap.ssp, "spaceTap.ssp"); } @Test public void testClose1() throws Throwable { LocalSpace ssp = new TSpace(); SpaceTap spaceTap = new SpaceTap(ssp, ssp, new Object(), "", 100L); spaceTap.close(); spaceTap.close(); assertNull(spaceTap.ssp, "spaceTap.ssp"); }
### Question: SpaceUtil { public static Object[] inpAll (Space sp, Object key) { List list = new ArrayList(); Object value; do { value = sp.inp (key); if (value != null) { list.add (value); } } while (value != null); return list.toArray(); } static Object[] inpAll(Space sp, Object key); static void wipe(Space sp, Object key); static void wipeAndOut(Space sp, Object key, Object value); static void wipeAndOut(Space sp, Object key, Object value, long timeout); static long nextLong(Space sp, Object key); static boolean outIfEmpty(Space sp, Object key, Object value, long nrdTimeout, long outTimeout); static void outWhenEmpty(Space sp, Object key, Object value, long timeout); static void outWhenEmpty(Space sp, Object key, Object value); }### Answer: @Test public void testInpAll() throws Throwable { Object[] result = SpaceUtil.inpAll(new TSpace(), "testString"); assertEquals(0, result.length, "result.length"); } @Test public void testInpAllThrowsNullPointerException() throws Throwable { try { SpaceUtil.inpAll(null, ""); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"org.jpos.space.Space.inp(Object)\" because \"sp\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: SpaceUtil { public static long nextLong (Space sp, Object key) { long l = 0L; synchronized (sp) { Object obj = sp.inp (key); wipe (sp, key); if (obj instanceof Long) l = (Long) obj; sp.out (key, ++l); } return l; } static Object[] inpAll(Space sp, Object key); static void wipe(Space sp, Object key); static void wipeAndOut(Space sp, Object key, Object value); static void wipeAndOut(Space sp, Object key, Object value, long timeout); static long nextLong(Space sp, Object key); static boolean outIfEmpty(Space sp, Object key, Object value, long nrdTimeout, long outTimeout); static void outWhenEmpty(Space sp, Object key, Object value, long timeout); static void outWhenEmpty(Space sp, Object key, Object value); }### Answer: @Test public void testNextLong() throws Throwable { Space sp = new TSpace(); long result = SpaceUtil.nextLong(sp, ""); assertEquals(1, ((TSpace) sp).entries.size(), "(TSpace) sp.entries.size()"); assertEquals(1L, result, "result"); } @Test public void testNextLongThrowsNullPointerException() throws Throwable { Space sp = new TSpace(); try { SpaceUtil.nextLong(sp, null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { assertEquals("key=null, value=1", ex.getMessage(), "ex.getMessage()"); assertTrue(((TSpace) sp).isEmpty(), "(TSpace) sp.isEmpty()"); } } @Test public void testNextLongThrowsNullPointerException1() throws Throwable { try { SpaceUtil.nextLong(null, ""); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot enter synchronized block because \"sp\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: SpaceUtil { public static void wipe (Space sp, Object key) { while (sp.inp (key) != null) ; } static Object[] inpAll(Space sp, Object key); static void wipe(Space sp, Object key); static void wipeAndOut(Space sp, Object key, Object value); static void wipeAndOut(Space sp, Object key, Object value, long timeout); static long nextLong(Space sp, Object key); static boolean outIfEmpty(Space sp, Object key, Object value, long nrdTimeout, long outTimeout); static void outWhenEmpty(Space sp, Object key, Object value, long timeout); static void outWhenEmpty(Space sp, Object key, Object value); }### Answer: @Test public void testWipe1() throws Throwable { SpaceUtil.wipe(SpaceFactory.getSpace(), ""); assertTrue(true, "Test completed without Exception"); } @Test public void testWipeThrowsNullPointerException() throws Throwable { try { SpaceUtil.wipe(null, ""); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"org.jpos.space.Space.inp(Object)\" because \"sp\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: SpaceFactory { public static Space getSpace () { return getSpace (TSPACE, DEFAULT, null); } static Space getSpace(); static Space getSpace(String spaceUri); static Space getSpace(String scheme, String name, String param); static ScheduledThreadPoolExecutor getGCExecutor(); static final String TSPACE; static final String TRANSIENT; static final String PERSISTENT; static final String SPACELET; static final String JDBM; static final String JE; static final String DEFAULT; }### Answer: @Test public void testGetSpace2() throws Throwable { TSpace result = (TSpace) SpaceFactory.getSpace("testString"); assertTrue(result.isEmpty(), "result.isEmpty()"); } @Test public void testGetSpaceThrowsNullPointerException2() throws Throwable { assertThrows(NullPointerException.class, () -> { SpaceFactory.getSpace("testSpaceFactoryScheme", "testSpaceFactoryName", null); }); } @Test public void testGetSpaceThrowsSpaceError() throws Throwable { try { SpaceFactory.getSpace("spacelet", "testSpaceFactoryName", "testSpaceFactoryParam"); fail("Expected SpaceError to be thrown"); } catch (SpaceError ex) { assertEquals( "spacelet:testSpaceFactoryName:testSpaceFactoryParam not found.", ex.getMessage(), "ex.getMessage()"); } }
### Question: Log implements LogSource { public Logger getLogger() { return logger; } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testConstructor() throws Throwable { Logger logger = Logger.getLogger("testLogName"); Log log = new Log(logger, "testLogRealm"); assertEquals("testLogRealm", log.realm, "m_log.realm"); assertSame(logger, log.logger, "m_log.logger"); } @Test public void testGetLogger() throws Throwable { Logger logger = new Logger(); Log bSHRequestListener = new BSHRequestListener(); bSHRequestListener.setLogger(logger, "testLogRealm"); Logger result = bSHRequestListener.getLogger(); assertSame(logger, result, "result"); }
### Question: Log implements LogSource { public String getRealm () { return realm; } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testConstructor1() throws Throwable { Log log = new Log(); assertNull(log.getRealm(), "m_log.getRealm()"); } @Test public void testGetRealm() throws Throwable { String result = Log.getLog("testLogLogName", "testLogRealm").getRealm(); assertEquals("testLogRealm", result, "result"); }
### Question: Log implements LogSource { public LogEvent createDebug() { return createLogEvent (DEBUG); } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testCreateDebug() throws Throwable { LogEvent result = new BSHRequestListener().createDebug("testString"); assertNull(result.getRealm(), "result.getRealm()"); }
### Question: Log implements LogSource { public LogEvent createError () { return createLogEvent (ERROR); } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testCreateError() throws Throwable { LogEvent result = new Debug().createError(); assertNull(result.getRealm(), "result.getRealm()"); }
### Question: Log implements LogSource { public LogEvent createFatal () { return createLogEvent (FATAL); } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testCreateFatal() throws Throwable { LogEvent result = new Debug().createFatal("t7r"); assertNull(result.getRealm(), "result.getRealm()"); }
### Question: Log implements LogSource { public LogEvent createInfo () { return createLogEvent (INFO); } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testCreateInfo() throws Throwable { LogEvent result = Log.getLog("testLogLogName", "testLogRealm").createInfo("testString"); assertEquals("testLogRealm", result.getRealm(), "result.getRealm()"); }
### Question: Log implements LogSource { public LogEvent createLogEvent (String level) { return new LogEvent (this, level); } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testCreateLogEvent() throws Throwable { LogEvent result = new BSHRequestListener().createLogEvent("testLogLevel", ""); assertNull(result.getRealm(), "result.getRealm()"); }
### Question: Log implements LogSource { public LogEvent createTrace () { return createLogEvent (TRACE); } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testCreateTrace() throws Throwable { LogEvent result = Log.getLog("testLogLogName", "testLogRealm").createTrace(); assertEquals("testLogRealm", result.getRealm(), "result.getRealm()"); }
### Question: Log implements LogSource { public LogEvent createWarn () { return createLogEvent (WARN); } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testCreateWarn() throws Throwable { LogEvent result = new Log().createWarn("testString"); assertNull(result.getRealm(), "result.getRealm()"); }
### Question: Log implements LogSource { public void debug (Object detail) { Logger.log (createDebug (detail)); } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testDebug() throws Throwable { new BSHRequestListener().debug("testString", Integer.valueOf(0)); assertTrue(true, "Test completed without Exception"); } @Test public void testDebug1() throws Throwable { new BSHRequestListener().debug(""); assertTrue(true, "Test completed without Exception"); }
### Question: Log implements LogSource { public void error (Object detail) { Logger.log (createError (detail)); } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testError() throws Throwable { new Debug().error(new Object()); assertTrue(true, "Test completed without Exception"); } @Test public void testError1() throws Throwable { new BSHRequestListener().error("", Integer.valueOf(18)); assertTrue(true, "Test completed without Exception"); }
### Question: Log implements LogSource { public static Log getLog (String logName, String realm) { return new Log (Logger.getLogger (logName), realm); } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testGetLog() throws Throwable { Log result = Log.getLog("testLogLogName", "testLogRealm"); assertEquals("testLogRealm", result.getRealm(), "result.getRealm()"); }
### Question: Log implements LogSource { public void info (Object detail) { Logger.log (createInfo (detail)); } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testInfo1() throws Throwable { new BSHRequestListener().info("", ""); assertTrue(true, "Test completed without Exception"); }
### Question: Log implements LogSource { public void setLogger (Logger logger, String realm) { this.logger = logger; this.realm = realm; } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testSetLogger() throws Throwable { Logger logger = new Logger(); Log bSHRequestListener = new BSHRequestListener(); bSHRequestListener.setLogger(logger, "testLogRealm"); assertEquals("testLogRealm", ((BSHRequestListener) bSHRequestListener).realm, "(BSHRequestListener) bSHRequestListener.realm"); assertSame(logger, ((BSHRequestListener) bSHRequestListener).logger, "(BSHRequestListener) bSHRequestListener.logger"); } @Test public void testSetLogger1() throws Throwable { Log bSHRequestListener = new BSHRequestListener(); Logger logger = new Logger(); bSHRequestListener.setLogger(logger); assertSame(logger, ((BSHRequestListener) bSHRequestListener).logger, "(BSHRequestListener) bSHRequestListener.logger"); }
### Question: Log implements LogSource { public void setRealm (String realm) { this.realm = realm; } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testSetRealm() throws Throwable { Log bSHRequestListener = new BSHRequestListener(); bSHRequestListener.setRealm("testLogRealm"); assertEquals("testLogRealm", ((BSHRequestListener) bSHRequestListener).realm, "(BSHRequestListener) bSHRequestListener.realm"); }
### Question: Log implements LogSource { public void trace (Object detail) { Logger.log (createTrace (detail)); } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testTrace() throws Throwable { new BSHRequestListener().trace("x", "x"); assertTrue(true, "Test completed without Exception"); } @Test public void testTrace1() throws Throwable { new BSHRequestListener().trace("testString"); assertTrue(true, "Test completed without Exception"); }
### Question: Log implements LogSource { public void warn (Object detail) { Logger.log (createWarn (detail)); } Log(); Log(Logger logger, String realm); static Log getLog(String logName, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setLogger(Logger logger); void setRealm(String realm); void trace(Object detail); void trace(Object detail, Object obj); void debug(Object detail); void debug(Object detail, Object obj); void info(Object detail); void info(Object detail, Object obj); void warn(Object detail); void warn(Object detail, Object obj); void error(Object detail); void error(Object detail, Object obj); void fatal(Object detail); void fatal(Object detail, Object obj); LogEvent createLogEvent(String level); LogEvent createLogEvent(String level, Object detail); LogEvent createTrace(); LogEvent createTrace(Object detail); LogEvent createDebug(); LogEvent createDebug(Object detail); LogEvent createInfo(); LogEvent createInfo(Object detail); LogEvent createWarn(); LogEvent createWarn(Object detail); LogEvent createError(); LogEvent createError(Object detail); LogEvent createFatal(); LogEvent createFatal(Object detail); static final String TRACE; static final String DEBUG; static final String INFO; static final String WARN; static final String ERROR; static final String FATAL; }### Answer: @Test public void testWarn() throws Throwable { new BSHRequestListener().warn("", ""); assertTrue(true, "Test completed without Exception"); } @Test public void testWarn1() throws Throwable { new BSHRequestListener().warn(new Object()); assertTrue(true, "Test completed without Exception"); }
### Question: StopWatch { public StopWatch (long period, TimeUnit unit) { end = System.currentTimeMillis() + TimeUnit.MILLISECONDS.convert(period, unit); } StopWatch(long period, TimeUnit unit); StopWatch(long periodInMillis); void finish(); boolean isFinished(); static T get(long period, TimeUnit unit, Supplier<T> f); static T get(long period, Supplier<T> f); }### Answer: @Test public void testStopWatch() throws Throwable { long now = System.currentTimeMillis(); StopWatch sw = new StopWatch (500, TimeUnit.MILLISECONDS); assertFalse(sw.isFinished()); sw.finish(); assertTrue(System.currentTimeMillis() - now >= 500); assertTrue (sw.isFinished()); }
### Question: StopWatch { public static <T> T get(long period, TimeUnit unit, Supplier<T> f) { StopWatch w = new StopWatch(period, unit); T t = f.get(); w.finish(); return t; } StopWatch(long period, TimeUnit unit); StopWatch(long periodInMillis); void finish(); boolean isFinished(); static T get(long period, TimeUnit unit, Supplier<T> f); static T get(long period, Supplier<T> f); }### Answer: @Test public void testStopWatchStatic() throws Throwable { long now = System.currentTimeMillis(); String s = StopWatch.get(500, TimeUnit.MILLISECONDS, () -> "The Quick Brown Fox jumps over the laxy dog"); assertTrue(System.currentTimeMillis() - now >= 500); }
### Question: FlatLogListener implements LogListener, Configurable, Destroyable { @Override public void setConfiguration(Configuration cfg) throws ConfigurationException { mapper.setConfiguration(cfg); } @Override void setConfiguration(Configuration cfg); @Override synchronized LogEvent log(LogEvent ev); @Override void destroy(); }### Answer: @Test void testShouldDelegateSetConfigurationToMapper() throws ConfigurationException { FlatLogListener listener = new FlatLogListener(); listener.mapper = mock(RemoveNewLinesMapper.class); SimpleConfiguration cfg = new SimpleConfiguration(); listener.setConfiguration(cfg); verify(listener.mapper).setConfiguration(cfg); }
### Question: FlatLogListener implements LogListener, Configurable, Destroyable { @Override public void destroy() { if (p != null) { p.close(); p = null; captureStream = null; } } @Override void setConfiguration(Configuration cfg); @Override synchronized LogEvent log(LogEvent ev); @Override void destroy(); }### Answer: @Test void testDestroyShouldCallCloseOnPrintStream() { FlatLogListener listener = new FlatLogListener(); PrintStream printStream = mock(PrintStream.class); listener.p = printStream; listener.destroy(); verify(printStream).close(); }
### Question: FlatLogListener implements LogListener, Configurable, Destroyable { @Override public synchronized LogEvent log(LogEvent ev) { ev.dump(p, ""); byte[] result = mapper.apply(captureStream.toByteArray()); captureStream.reset(); return new FrozenLogEvent(new String(result)); } @Override void setConfiguration(Configuration cfg); @Override synchronized LogEvent log(LogEvent ev); @Override void destroy(); }### Answer: @Test void testLog() throws IOException { FlatLogListener listener = new FlatLogListener(); LogEvent ev = new LogEvent(); ev.setNoArmor(true); ev.addMessage("Test"); ev.addMessage("More"); LogEvent r = listener.log(ev); ByteArrayOutputStream captureStream = new ByteArrayOutputStream(); PrintStream capturePrintStream = new PrintStream(captureStream); r.dump(capturePrintStream, ""); BufferedReader reader = new BufferedReader( new InputStreamReader(new ByteArrayInputStream(captureStream.toByteArray()))); assertEquals(" <info> Test More </info>", reader.readLine()); capturePrintStream.close(); reader.close(); } @Test void testLogCorrectlyMultipleEventsAKACaptureStreamResets() throws IOException { FlatLogListener listener = new FlatLogListener(); LogEvent ev = new LogEvent(); ev.setNoArmor(true); ev.addMessage("Test"); ev.addMessage("More"); LogEvent r = listener.log(ev); ByteArrayOutputStream captureStream = new ByteArrayOutputStream(); PrintStream capturePrintStream = new PrintStream(captureStream); r.dump(capturePrintStream, ""); BufferedReader reader = new BufferedReader( new InputStreamReader(new ByteArrayInputStream(captureStream.toByteArray()))); captureStream.reset(); assertEquals(" <info> Test More </info>", reader.readLine()); assertFalse(reader.ready()); reader.close(); r = listener.log(ev); r.dump(capturePrintStream, ""); reader = new BufferedReader( new InputStreamReader(new ByteArrayInputStream(captureStream.toByteArray()))); assertEquals(" <info> Test More </info>", reader.readLine()); assertFalse(reader.ready()); capturePrintStream.close(); reader.close(); }
### Question: SimpleLogSource implements LogSource { public void error (String detail) { Logger.log (new LogEvent (this, "error", detail)); } SimpleLogSource(); SimpleLogSource(Logger logger, String realm); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void setRealm(String realm); void info(String detail); void info(String detail, Object obj); void warning(String detail); void warning(String detail, Object obj); void error(String detail); void error(String detail, Object obj); }### Answer: @Test public void testError() throws Throwable { new BSHTransactionParticipant().error("testSimpleLogSourceDetail", Integer.valueOf(0)); assertTrue(true, "Test completed without Exception"); }