Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: Base1SubFieldPackager extends ISOBasePackager { protected boolean emitBitMap() { return fld[0] instanceof ISOBitMapPackager; } int unpack(ISOComponent m, byte[] b); @Override byte[] pack(ISOComponent m); }### Answer: @Test public void testEmitBitMap() throws Throwable { Base1SubFieldPackager base1SubFieldPackager = new Base1SubFieldPackager(); ISOFieldPackager[] fld = new ISOFieldPackager[1]; base1SubFieldPackager.setFieldPackager(fld); boolean result = base1SubFieldPackager.emitBitMap(); assertFalse(result, "result"); } @Test public void testEmitBitMapThrowsArrayIndexOutOfBoundsException() throws Throwable { Base1SubFieldPackager f126Packager = new Base1Packager.F126Packager(); ISOFieldPackager[] fld = new ISOFieldPackager[0]; f126Packager.setFieldPackager(fld); try { f126Packager.emitBitMap(); fail("Expected ArrayIndexOutOfBoundsException to be thrown"); } catch (ArrayIndexOutOfBoundsException ex) { if (isJavaVersionAtMost(JAVA_10)) { assertEquals("0", ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Index 0 out of bounds for length 0", ex.getMessage(), "ex.getMessage()"); } } }
### Question: Base1SubFieldPackager extends ISOBasePackager { protected ISOFieldPackager getBitMapfieldPackager() { return fld[0]; } int unpack(ISOComponent m, byte[] b); @Override byte[] pack(ISOComponent m); }### Answer: @Test public void testGetBitMapfieldPackager() throws Throwable { Base1SubFieldPackager f126Packager = new Base1Packager.F126Packager(); Base1_BITMAP126 result = (Base1_BITMAP126) f126Packager.getBitMapfieldPackager(); assertEquals(2, result.getMaxPackedLength(), "result.getMaxPackedLength()"); } @Test public void testGetBitMapfieldPackagerThrowsNullPointerException() throws Throwable { Base1SubFieldPackager base1SubFieldPackager = new Base1SubFieldPackager(); try { base1SubFieldPackager.getBitMapfieldPackager(); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot load from object array because \"this.fld\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: Base1SubFieldPackager extends ISOBasePackager { protected int getFirstField() { return fld[0] instanceof ISOBitMapPackager ? 1 : 0; } int unpack(ISOComponent m, byte[] b); @Override byte[] pack(ISOComponent m); }### Answer: @Test public void testGetFirstField() throws Throwable { Base1SubFieldPackager base1SubFieldPackager = new Base1SubFieldPackager(); ISOFieldPackager[] fld = new ISOFieldPackager[2]; fld[0] = new X92_BITMAP(100, "testBase1SubFieldPackagerDescription"); base1SubFieldPackager.setFieldPackager(fld); int result = base1SubFieldPackager.getFirstField(); assertEquals(1, result, "result"); } @Test public void testGetFirstField1() throws Throwable { ISOFieldPackager[] fld = new ISOFieldPackager[1]; Base1SubFieldPackager f126Packager = new Base1Packager.F126Packager(); f126Packager.setFieldPackager(fld); int result = f126Packager.getFirstField(); assertEquals(0, result, "result"); } @Test public void testGetFirstFieldThrowsNullPointerException() throws Throwable { Base1SubFieldPackager base1SubFieldPackager = new Base1SubFieldPackager(); try { base1SubFieldPackager.getFirstField(); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot load from object array because \"this.fld\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: Base1SubFieldPackager extends ISOBasePackager { public int unpack (ISOComponent m, byte[] b) throws ISOException { LogEvent evt = new LogEvent (this, "unpack"); try { if (m.getComposite() != m) throw new ISOException ("Can't call packager on non Composite"); if (logger != null) evt.addMessage (ISOUtil.hexString (b)); int consumed=0; ISOBitMap bitmap = new ISOBitMap (-1); BitSet bmap = null; int maxField = fld.length; if (emitBitMap()) { consumed += getBitMapfieldPackager().unpack(bitmap,b,consumed); bmap = (BitSet) bitmap.getValue(); m.set (bitmap); maxField = bmap.size(); } for (int i=getFirstField(); i<maxField && consumed < b.length; i++) { if (bmap == null \|\| bmap.get(i)) { ISOComponent c = fld[i].createComponent(i); consumed += fld[i].unpack (c, b, consumed); m.set(c); } } if (b.length != consumed) { evt.addMessage ( "WARNING: unpack len=" +b.length +" consumed=" +consumed); } return consumed; } catch (ISOException e) { evt.addMessage (e); throw e; } finally { Logger.log (evt); } } int unpack(ISOComponent m, byte[] b); @Override byte[] pack(ISOComponent m); }### Answer: @Test public void testUnpack() throws Throwable { Base1SubFieldPackager base1SubFieldPackager = new Base1SubFieldPackager(); ISOFieldPackager[] fld = new ISOFieldPackager[3]; base1SubFieldPackager.setFieldPackager(fld); base1SubFieldPackager.setLogger(new Logger(), "testBase1SubFieldPackagerRealm"); byte[] b = new byte[0]; int result = base1SubFieldPackager.unpack(new ISOMsg(100), b); assertEquals(0, result, "result"); }
### Question: X92GenericPackager extends GenericPackager { protected boolean emitBitMap () { return true; } X92GenericPackager(); X92GenericPackager(String filename); X92GenericPackager(InputStream stream); }### Answer: @Test public void testEmitBitMap() throws Throwable { X92GenericPackager x92GenericPackager = new X92GenericPackager(); boolean result = x92GenericPackager.emitBitMap(); assertTrue(result, "result"); }
### Question: X92GenericPackager extends GenericPackager { protected ISOFieldPackager getBitMapfieldPackager() { return bitMapPackager; } X92GenericPackager(); X92GenericPackager(String filename); X92GenericPackager(InputStream stream); }### Answer: @Test public void testGetBitMapfieldPackager() throws Throwable { X92GenericPackager x92GenericPackager = new X92GenericPackager(); X92_BITMAP result = (X92_BITMAP) x92GenericPackager.getBitMapfieldPackager(); assertEquals(4, result.getMaxPackedLength(), "result.getMaxPackedLength()"); }
### Question: QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public String getUnhandledQueue () { return unhandled; } 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 testGetUnhandledQueue() throws Throwable { String result = new QMUX().getUnhandledQueue(); assertNull(result, "result"); }
### Question: X92GenericPackager extends GenericPackager { protected int getMaxValidField() { return 64; } X92GenericPackager(); X92GenericPackager(String filename); X92GenericPackager(InputStream stream); }### Answer: @Test public void testGetMaxValidField() throws Throwable { X92GenericPackager x92GenericPackager = new X92GenericPackager(); int result = x92GenericPackager.getMaxValidField(); assertEquals(64, result, "result"); }
### Question: CTCSubFieldPackager extends ISOBaseValidatingPackager { protected boolean emitBitMap() { return false; } CTCSubFieldPackager(); byte[] pack( ISOComponent c ); int unpack( ISOComponent m, byte[] b ); ISOComponent validate( ISOComponent c ); }### Answer: @Test public void testEmitBitMap() throws Throwable { CTCSubFieldPackager cTCSubFieldPackager = new CTCSubFieldPackager(); boolean result = cTCSubFieldPackager.emitBitMap(); assertFalse(result, "result"); }
### Question: CTCSubFieldPackager extends ISOBaseValidatingPackager { public ISOComponent validate( ISOComponent c ) throws org.jpos.iso.ISOException { LogEvent evt = new LogEvent( this, "validate" ); try { Map tab = c.getChildren(); for ( int i = 0; i < fldVld.length; i++ ) { ISOField f = (ISOField) tab.get (i); if ( f != null ) c.set( fldVld[i].validate( f ) ); } return c; } catch ( ISOVException ex ) { if ( !ex.treated() ) { c.set( ex.getErrComponent() ); ex.setTreated( true ); } evt.addMessage( ex ); throw ex; } finally { Logger.log( evt ); } } CTCSubFieldPackager(); byte[] pack( ISOComponent c ); int unpack( ISOComponent m, byte[] b ); ISOComponent validate( ISOComponent c ); }### Answer: @Test public void testValidateThrowsNullPointerException1() throws Throwable { assertThrows(NullPointerException.class, () -> { new CTCSubFieldPackager().validate(null); }); } @Test public void testValidateThrowsNullPointerException2() throws Throwable { assertThrows(NullPointerException.class, () -> { new CTCSubFieldPackager().validate(new ISOMsg()); }); } @Test public void testValidateThrowsNullPointerException3() throws Throwable { assertThrows(NullPointerException.class, () -> { CTCSubFieldPackager cTCSubFieldPackager = new CTCSubFieldPackager(); cTCSubFieldPackager.setLogger(Logger.getLogger(""), "testCTCSubFieldPackagerRealm"); ISOValidator[] fvlds = new ISOValidator[2]; cTCSubFieldPackager.setFieldValidator(fvlds); cTCSubFieldPackager.validate(new ISOMsg("testCTCSubFieldPackagerMti")); }); }
### Question: GenericPackager extends ISOBasePackager implements Configurable { @Override protected boolean emitBitMap() { return emitBitmap; } GenericPackager(); GenericPackager(String filename); GenericPackager(InputStream input); void setConfiguration(Configuration cfg); void readFile(String filename); void readFile(InputStream input); @Override void setLogger(Logger logger, String realm); @Override String getDescription(); }### Answer: @Test public void testEmitBitMap() throws Throwable { GenericPackager genericPackager = new GenericPackager(); boolean result = genericPackager.emitBitMap(); assertTrue(result, "result"); }
### Question: GenericPackager extends ISOBasePackager implements Configurable { @Override protected int getFirstField() { if (firstField != null) return Integer.parseInt (firstField); else return super.getFirstField(); } GenericPackager(); GenericPackager(String filename); GenericPackager(InputStream input); void setConfiguration(Configuration cfg); void readFile(String filename); void readFile(InputStream input); @Override void setLogger(Logger logger, String realm); @Override String getDescription(); }### Answer: @Test public void testGetFirstField() throws Throwable { GenericPackager genericValidatingPackager = new GenericValidatingPackager(); ISOFieldPackager[] fld = new ISOFieldPackager[3]; fld[1] = new IFA_BITMAP(); genericValidatingPackager.setFieldPackager(fld); int result = genericValidatingPackager.getFirstField(); assertEquals(2, result, "result"); } @Test public void testGetFirstField1() throws Throwable { GenericPackager genericPackager = new GenericPackager(); ISOFieldPackager[] fld = new ISOFieldPackager[3]; genericPackager.setFieldPackager(fld); int result = genericPackager.getFirstField(); assertEquals(1, result, "result"); } @Test public void testGetFirstFieldThrowsArrayIndexOutOfBoundsException() throws Throwable { GenericPackager genericValidatingPackager = new GenericValidatingPackager(); ISOFieldPackager[] fld = new ISOFieldPackager[1]; genericValidatingPackager.setFieldPackager(fld); assertEquals(0, genericValidatingPackager.getFirstField()); } @Test public void testGetFirstFieldThrowsNullPointerException() throws Throwable { GenericPackager genericPackager = new GenericPackager(); try { genericPackager.getFirstField(); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot load from object array because \"this.fld\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: GenericPackager extends ISOBasePackager implements Configurable { @Override protected int getMaxValidField() { return maxValidField; } GenericPackager(); GenericPackager(String filename); GenericPackager(InputStream input); void setConfiguration(Configuration cfg); void readFile(String filename); void readFile(InputStream input); @Override void setLogger(Logger logger, String realm); @Override String getDescription(); }### Answer: @Test public void testGetMaxValidField() throws Throwable { GenericPackager genericPackager = new GenericPackager(); int result = genericPackager.getMaxValidField(); assertEquals(128, result, "result"); }
### Question: GenericPackager extends ISOBasePackager implements Configurable { public void readFile(String filename) throws ISOException { try { if (filename.startsWith("jar:") && filename.length()>4) { ClassLoader cl = Thread.currentThread().getContextClassLoader(); readFile( cl.getResourceAsStream(filename.substring(4)) ); } else { createXMLReader().parse(filename); } } catch (Exception e) { throw new ISOException("Error reading " + filename, e); } } GenericPackager(); GenericPackager(String filename); GenericPackager(InputStream input); void setConfiguration(Configuration cfg); void readFile(String filename); void readFile(InputStream input); @Override void setLogger(Logger logger, String realm); @Override String getDescription(); }### Answer: @Test public void testReadFileThrowsISOException() throws Throwable { try { new GenericSubFieldPackager().readFile(new ByteArrayInputStream("".getBytes())); fail("Expected ISOException to be thrown"); } catch (ISOException ex) { assertEquals(SAXParseException.class, ex.getNested().getClass(), "ex.getNested().getClass()"); assertEquals("Premature end of file.", ex.getNested().getMessage(), "ex.getNested().getMessage()"); } } @Test public void testReadFileThrowsISOException1() throws Throwable { try { new GenericPackager().readFile("testGenericPackagerFilename"); fail("Expected ISOException to be thrown"); } catch (ISOException ex) { assertEquals(FileNotFoundException.class, ex.getNested().getClass(), "ex.getNested().getClass()"); } }
### Question: ISOBaseValidatingPackager extends ISOBasePackager implements ISOValidator { public void setFieldValidator( ISOValidator[] fvlds ){ this.fldVld = fvlds; } ISOBaseValidatingPackager(); ISOComponent validate(ISOComponent m); void setFieldValidator( ISOValidator[] fvlds ); void setMsgValidator( ISOBaseValidator[] msgVlds ); }### Answer: @Test public void testSetFieldValidator() throws Throwable { ISOValidator[] fvlds = new ISOValidator[1]; ISOBaseValidatingPackager cTCSubElementPackager = new CTCSubElementPackager(); cTCSubElementPackager.setFieldValidator(fvlds); assertSame(fvlds, ((CTCSubElementPackager) cTCSubElementPackager).fldVld, "(CTCSubElementPackager) cTCSubElementPackager.fldVld"); }
### Question: ISOBaseValidatingPackager extends ISOBasePackager implements ISOValidator { public void setMsgValidator( ISOBaseValidator[] msgVlds ){ this.msgVld = msgVlds; } ISOBaseValidatingPackager(); ISOComponent validate(ISOComponent m); void setFieldValidator( ISOValidator[] fvlds ); void setMsgValidator( ISOBaseValidator[] msgVlds ); }### Answer: @Test public void testSetMsgValidator() throws Throwable { ISOBaseValidator[] msgVlds = new ISOBaseValidator[0]; ISOBaseValidatingPackager cTCSubElementPackager = new CTCSubElementPackager(); cTCSubElementPackager.setMsgValidator(msgVlds); assertSame(msgVlds, ((CTCSubElementPackager) cTCSubElementPackager).msgVld, "(CTCSubElementPackager) cTCSubElementPackager.msgVld"); }
### Question: QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public boolean isConnected() { if (running() && ready != null && ready.length > 0) { for (String aReady : ready) if (sp.rdp(aReady) != null) return true; return false; } return running(); } 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 testIsConnected() throws Throwable { assertFalse(new QMUX().isConnected(), "result"); }
### Question: CTCSubElementPackager extends ISOBaseValidatingPackager { protected boolean emitBitMap() { return false; } CTCSubElementPackager(); byte[] pack( ISOComponent c ); int unpack( ISOComponent m, byte[] b ); ISOComponent validate( ISOComponent c ); }### Answer: @Test public void testEmitBitMap() throws Throwable { CTCSubElementPackager cTCSubElementPackager = new CTCSubElementPackager(); boolean result = cTCSubElementPackager.emitBitMap(); assertFalse(result, "result"); }
### Question: GenericValidatingPackager extends GenericPackager implements ISOValidator { public void readFile(String filename) throws org.jpos.iso.ISOException { try { XMLReader reader = XMLReaderFactory.createXMLReader( System.getProperty( "sax.parser", "org.apache.crimson.parser.XMLReaderImpl")); reader.setFeature ("http: GenericValidatorContentHandler handler = new GenericValidatorContentHandler(); reader.setContentHandler(handler); reader.setErrorHandler(handler); reader.setEntityResolver(new GenericEntityResolver()); reader.parse(filename); } catch (Exception e) { e.printStackTrace(); throw new ISOException(e); } } GenericValidatingPackager( ); GenericValidatingPackager( String fileName ); GenericValidatingPackager(InputStream stream); void readFile(String filename); void setMsgValidator( ISOBaseValidator[] msgVlds ); void setFieldValidator( ISOFieldValidator[] fvlds ); ISOComponent validate(ISOComponent m); }### Answer: @Disabled("test fails - GenericValidatingPackager is an unmaintained and going to be deprecated") @Test public void testReadFileThrowsISOException() throws Throwable { try { new GenericValidatingPackager().readFile("testGenericValidatingPackagerFilename"); fail("Expected ISOException to be thrown"); } catch (ISOException ex) { assertEquals("java.lang.ClassNotFoundException: org.apache.crimson.parser.XMLReaderImpl", ex.getMessage(), "ex.getMessage()"); assertEquals("SAX2 driver class org.apache.crimson.parser.XMLReaderImpl not found", ex .getNested().getMessage(), "ex.getNested().getMessage()"); } }
### Question: GenericValidatingPackager extends GenericPackager implements ISOValidator { public void setFieldValidator( ISOFieldValidator[] fvlds ){ this.fvlds = fvlds; } GenericValidatingPackager( ); GenericValidatingPackager( String fileName ); GenericValidatingPackager(InputStream stream); void readFile(String filename); void setMsgValidator( ISOBaseValidator[] msgVlds ); void setFieldValidator( ISOFieldValidator[] fvlds ); ISOComponent validate(ISOComponent m); }### Answer: @Test public void testSetFieldValidator() throws Throwable { GenericValidatingPackager genericValidatingPackager = new GenericValidatingPackager(); ISOFieldValidator[] fvlds = new ISOFieldValidator[1]; genericValidatingPackager.setFieldValidator(fvlds); assertSame(fvlds, genericValidatingPackager.fvlds, "genericValidatingPackager.fvlds"); }
### Question: GenericValidatingPackager extends GenericPackager implements ISOValidator { public void setMsgValidator( ISOBaseValidator[] msgVlds ){ this.mvlds = msgVlds; } GenericValidatingPackager( ); GenericValidatingPackager( String fileName ); GenericValidatingPackager(InputStream stream); void readFile(String filename); void setMsgValidator( ISOBaseValidator[] msgVlds ); void setFieldValidator( ISOFieldValidator[] fvlds ); ISOComponent validate(ISOComponent m); }### Answer: @Test public void testSetMsgValidator() throws Throwable { GenericValidatingPackager genericValidatingPackager = new GenericValidatingPackager(); ISOBaseValidator[] msgVlds = new ISOBaseValidator[3]; genericValidatingPackager.setMsgValidator(msgVlds); assertSame(msgVlds, genericValidatingPackager.mvlds, "genericValidatingPackager.mvlds"); }
### Question: GenericValidatingPackager extends GenericPackager implements ISOValidator { public ISOComponent validate(ISOComponent m) throws ISOException { LogEvent evt = new LogEvent( this, "validate" ); try { ISOComponent c; Map<Object,ISOComponent> fields = m.getChildren(); for (ISOValidator val :fvlds) { if ( (c=fields.get (((ISOFieldValidator) val).getFieldId())) != null ){ try { m.set( val.validate( c ) ); } catch ( ISOVException e ) { if ( !e.treated() ) { m.set( e.getErrComponent() ); e.setTreated( true ); } evt.addMessage( "Component Validation Error." ); throw e; } } } try { for (ISOBaseValidator mval :mvlds) m = mval.validate( m ); } catch (ISOVException ex) { evt.addMessage( "Component Validation Error." ); throw ex; } return m; } finally { Logger.log( evt ); } } GenericValidatingPackager( ); GenericValidatingPackager( String fileName ); GenericValidatingPackager(InputStream stream); void readFile(String filename); void setMsgValidator( ISOBaseValidator[] msgVlds ); void setFieldValidator( ISOFieldValidator[] fvlds ); ISOComponent validate(ISOComponent m); }### Answer: @Test public void testValidateThrowsNullPointerException1() throws Throwable { try { new GenericValidatingPackager().validate(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.iso.ISOComponent.getChildren()\" because \"m\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: X92Packager extends ISOBasePackager { protected boolean emitBitMap () { return true; } X92Packager(); }### Answer: @Test public void testEmitBitMap() throws Throwable { X92Packager x92Packager = new X92Packager(); boolean result = x92Packager.emitBitMap(); assertTrue(result, "result"); }
### Question: X92Packager extends ISOBasePackager { protected ISOFieldPackager getBitMapfieldPackager() { return bitMapPackager; } X92Packager(); }### Answer: @Test public void testGetBitMapfieldPackager() throws Throwable { X92Packager x92Packager = new X92Packager(); X92_BITMAP result = (X92_BITMAP) x92Packager.getBitMapfieldPackager(); assertEquals(4, result.getMaxPackedLength(), "result.getMaxPackedLength()"); }
### Question: X92Packager extends ISOBasePackager { protected int getMaxValidField() { return 64; } X92Packager(); }### Answer: @Test public void testGetMaxValidField() throws Throwable { X92Packager x92Packager = new X92Packager(); int result = x92Packager.getMaxValidField(); assertEquals(64, result, "result"); }
### Question: EuroPackager extends ISOBasePackager { public void setLogger (Logger logger, String realm) { this.logger = logger; this.realm = realm; } EuroPackager(); void setLogger(Logger logger, String realm); }### Answer: @Test public void testSetLogger() throws Throwable { EuroPackager euroPackager = new EuroPackager(); Logger logger = Logger.getLogger("testEuroPackagerName"); euroPackager.setLogger(logger, "testEuroPackagerRealm"); assertSame(logger, euroPackager.getLogger(), "euroPackager.getLogger()"); assertNotNull(euroPackager.f48Packager, "euroPackager.f48Packager"); assertEquals("testEuroPackagerRealm", euroPackager.getRealm(), "euroPackager.getRealm()"); }
### Question: Base1_BITMAP126 extends ISOBitMapPackager { public int getMaxPackedLength() { return getLength() >> 3; } Base1_BITMAP126(); Base1_BITMAP126(int len, String description); byte[] pack(ISOComponent c); int unpack(ISOComponent c, byte[] b, int offset); int getMaxPackedLength(); }### Answer: @Test public void testGetMaxPackedLength() throws Throwable { int result = new Base1_BITMAP126(100, "testBase1_BITMAP126Description").getMaxPackedLength(); assertEquals(12, result, "result"); } @Test public void testGetMaxPackedLength1() throws Throwable { int result = new Base1_BITMAP126(0, "testBase1_BITMAP126Description").getMaxPackedLength(); assertEquals(0, result, "result"); }
### Question: Base1_BITMAP126 extends ISOBitMapPackager { public byte[] pack (ISOComponent c) throws ISOException { return ISOUtil.bitSet2byte ((BitSet) c.getValue()); } Base1_BITMAP126(); Base1_BITMAP126(int len, String description); byte[] pack(ISOComponent c); int unpack(ISOComponent c, byte[] b, int offset); int getMaxPackedLength(); }### Answer: @Test public void testPack() throws Throwable { BitSet v = new BitSet(100); Base1_BITMAP126 base1_BITMAP126 = new Base1_BITMAP126(100, "testBase1_BITMAP126Description"); byte[] result = base1_BITMAP126.pack(new ISOBitMap(100, v)); assertEquals(0, result.length, "result.length"); } @Test public void testPackThrowsClassCastException() throws Throwable { try { new Base1_BITMAP126(100, "testBase1_BITMAP126Description").pack(new ISOMsg("testBase1_BITMAP126Mti")); fail("Expected ClassCastException to be thrown"); } catch (ClassCastException ex) { assertEquals(ClassCastException.class, ex.getClass(), "ex.getClass()"); } } @Test public void testPackThrowsNullPointerException() throws Throwable { try { new Base1_BITMAP126(100, "testBase1_BITMAP126Description").pack(new ISOBinaryField()); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"java.util.BitSet.length()\" because \"b\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: ISOMsgFieldValidatingPackager extends ISOMsgFieldPackager implements ISOValidator { public ISOComponent validate(ISOComponent m) throws ISOException { return ((ISOBaseValidatingPackager)msgPackager).validate( m ); } ISOMsgFieldValidatingPackager( ISOFieldPackager fieldPackager, ISOPackager msgPackager ); ISOComponent validate(ISOComponent m); }### Answer: @Test public void testValidateWithNonISOMsgThrowsNullPointerException() throws Throwable { try { new ISOMsgFieldValidatingPackager(new IFA_BINARY(100, "testISOMsgFieldValidatingPackagerDescription"), new ISOBaseValidatingPackager()).validate(new ISOField(100)); fail("Expected ClassCastException to be thrown"); } catch (NullPointerException ex) { assertEquals(NullPointerException.class, ex.getClass(), "ex.getClass()"); } } @Test public void testValidateThrowsNullPointerException() throws Throwable { try { new ISOMsgFieldValidatingPackager(new IFB_AMOUNT(100, "testISOMsgFieldValidatingPackagerDescription", true), new ISOBaseValidatingPackager()).validate(new ISOMsg("testISOMsgFieldValidatingPackagerMti")); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot read the array length because \"<local6>\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: NativePackager implements ISOPackager { @Override public byte[] pack(ISOComponent c) throws ISOException { ByteArrayOutputStream baos = new ByteArrayOutputStream(); try { if (c instanceof ISOMsg) { ISOMsg m = (ISOMsg)c; ISOPackager p = m.getPackager(); m.setPackager(null); ObjectOutputStream os = new ObjectOutputStream(baos); ((Externalizable)c).writeExternal(os); os.flush(); m.setPackager(p); } } catch (IOException e) { throw new ISOException (e); } return baos.toByteArray(); } @Override byte[] pack(ISOComponent c); @Override int unpack(ISOComponent m, byte[] b); @Override void unpack(ISOComponent m, InputStream in); @Override String getDescription(); @Override String getFieldDescription(ISOComponent m, int fldNumber); @Override ISOMsg createISOMsg(); }### Answer: @Test public void testPack() throws ISOException { assertArrayEquals(PACKED, m.pack(), "Expected image"); }
### Question: NativePackager implements ISOPackager { @Override public int unpack(ISOComponent m, byte[] b) throws ISOException { ByteArrayInputStream bais = new ByteArrayInputStream(b); if (m instanceof Externalizable) { try { unpack (m, bais); } catch (IOException e) { throw new ISOException (e); } } return b.length - bais.available(); } @Override byte[] pack(ISOComponent c); @Override int unpack(ISOComponent m, byte[] b); @Override void unpack(ISOComponent m, InputStream in); @Override String getDescription(); @Override String getFieldDescription(ISOComponent m, int fldNumber); @Override ISOMsg createISOMsg(); }### Answer: @Test public void testUnpack() throws ISOException { ISOMsg m1 = new ISOMsg(); m1.setPackager(p); m1.unpack(PACKED); assertEquals("0800", m1.getMTI()); assertEquals("000000", m1.getString(3)); assertEquals("000001", m1.getString(11)); assertEquals("29110001", m1.getString(41)); assertArrayEquals(ISOUtil.hex2byte("55AA1122"), m1.getBytes(55)); assertEquals("Test 127.2", m1.getString("127.2")); assertEquals("Test 127.3", m1.getString("127.3")); assertEquals("Test 127.4", m1.getString("127.4")); assertEquals("Test 127.5.1", m1.getString("127.5.1")); }
### Question: XMLPackager extends DefaultHandler implements ISOPackager, LogSource { public ISOMsg createISOMsg () { return new ISOMsg(); } XMLPackager(); void forceBinary(int ... bfields); byte[] pack(ISOComponent c); synchronized int unpack(ISOComponent c, byte[] b); synchronized void unpack(ISOComponent c, InputStream in); void startElement(String ns, String name, String qName, Attributes atts); void characters(char ch[], int start, int length); void endElement(String ns, String name, String qname); String getFieldDescription(ISOComponent m, int fldNumber); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); ISOMsg createISOMsg(); String getDescription(); void setXMLParserFeature(String fname, boolean val); static final String ISOMSG_TAG; static final String ISOFIELD_TAG; static final String ID_ATTR; static final String VALUE_ATTR; static final String TYPE_ATTR; static final String TYPE_BINARY; static final String TYPE_BITMAP; static final String TYPE_AMOUNT; static final String CURRENCY_ATTR; static final String HEADER_TAG; static final String ENCODING_ATTR; static final String ASCII_ENCODING; }### Answer: @Test public void testCreateISOMsg() throws Throwable { ISOMsg result = new XMLPackager().createISOMsg(); assertEquals(0, result.getDirection(), "result.getDirection()"); }
### Question: XMLPackager extends DefaultHandler implements ISOPackager, LogSource { public String getFieldDescription(ISOComponent m, int fldNumber) { return "Data element " + fldNumber; } XMLPackager(); void forceBinary(int ... bfields); byte[] pack(ISOComponent c); synchronized int unpack(ISOComponent c, byte[] b); synchronized void unpack(ISOComponent c, InputStream in); void startElement(String ns, String name, String qName, Attributes atts); void characters(char ch[], int start, int length); void endElement(String ns, String name, String qname); String getFieldDescription(ISOComponent m, int fldNumber); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); ISOMsg createISOMsg(); String getDescription(); void setXMLParserFeature(String fname, boolean val); static final String ISOMSG_TAG; static final String ISOFIELD_TAG; static final String ID_ATTR; static final String VALUE_ATTR; static final String TYPE_ATTR; static final String TYPE_BINARY; static final String TYPE_BITMAP; static final String TYPE_AMOUNT; static final String CURRENCY_ATTR; static final String HEADER_TAG; static final String ENCODING_ATTR; static final String ASCII_ENCODING; }### Answer: @Test public void testGetFieldDescription() throws Throwable { ISOComponent m = new ISOMsg(100); String result = xMLPackager.getFieldDescription(m, 100); assertEquals("Data element "+100, result, "result"); }
### Question: XMLPackager extends DefaultHandler implements ISOPackager, LogSource { public Logger getLogger() { return logger; } XMLPackager(); void forceBinary(int ... bfields); byte[] pack(ISOComponent c); synchronized int unpack(ISOComponent c, byte[] b); synchronized void unpack(ISOComponent c, InputStream in); void startElement(String ns, String name, String qName, Attributes atts); void characters(char ch[], int start, int length); void endElement(String ns, String name, String qname); String getFieldDescription(ISOComponent m, int fldNumber); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); ISOMsg createISOMsg(); String getDescription(); void setXMLParserFeature(String fname, boolean val); static final String ISOMSG_TAG; static final String ISOFIELD_TAG; static final String ID_ATTR; static final String VALUE_ATTR; static final String TYPE_ATTR; static final String TYPE_BINARY; static final String TYPE_BITMAP; static final String TYPE_AMOUNT; static final String CURRENCY_ATTR; static final String HEADER_TAG; static final String ENCODING_ATTR; static final String ASCII_ENCODING; }### Answer: @Test public void testGetLogger() throws Throwable { Logger logger = Logger.getLogger("testXMLPackagerName"); xMLPackager.setLogger(logger, "testXMLPackagerRealm"); Logger result = xMLPackager.getLogger(); assertSame(logger, result, "result"); }
### Question: XMLPackager extends DefaultHandler implements ISOPackager, LogSource { public String getRealm () { return realm; } XMLPackager(); void forceBinary(int ... bfields); byte[] pack(ISOComponent c); synchronized int unpack(ISOComponent c, byte[] b); synchronized void unpack(ISOComponent c, InputStream in); void startElement(String ns, String name, String qName, Attributes atts); void characters(char ch[], int start, int length); void endElement(String ns, String name, String qname); String getFieldDescription(ISOComponent m, int fldNumber); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); ISOMsg createISOMsg(); String getDescription(); void setXMLParserFeature(String fname, boolean val); static final String ISOMSG_TAG; static final String ISOFIELD_TAG; static final String ID_ATTR; static final String VALUE_ATTR; static final String TYPE_ATTR; static final String TYPE_BINARY; static final String TYPE_BITMAP; static final String TYPE_AMOUNT; static final String CURRENCY_ATTR; static final String HEADER_TAG; static final String ENCODING_ATTR; static final String ASCII_ENCODING; }### Answer: @Test public void testGetRealm() throws Throwable { String result = new XMLPackager().getRealm(); assertNull(result, "result"); }
### Question: XMLPackager extends DefaultHandler implements ISOPackager, LogSource { public void setLogger (Logger logger, String realm) { this.logger = logger; this.realm = realm; } XMLPackager(); void forceBinary(int ... bfields); byte[] pack(ISOComponent c); synchronized int unpack(ISOComponent c, byte[] b); synchronized void unpack(ISOComponent c, InputStream in); void startElement(String ns, String name, String qName, Attributes atts); void characters(char ch[], int start, int length); void endElement(String ns, String name, String qname); String getFieldDescription(ISOComponent m, int fldNumber); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); ISOMsg createISOMsg(); String getDescription(); void setXMLParserFeature(String fname, boolean val); static final String ISOMSG_TAG; static final String ISOFIELD_TAG; static final String ID_ATTR; static final String VALUE_ATTR; static final String TYPE_ATTR; static final String TYPE_BINARY; static final String TYPE_BITMAP; static final String TYPE_AMOUNT; static final String CURRENCY_ATTR; static final String HEADER_TAG; static final String ENCODING_ATTR; static final String ASCII_ENCODING; }### Answer: @Test public void testSetLogger() throws Throwable { Logger logger = Logger.getLogger("testXMLPackagerName"); xMLPackager.setLogger(logger, "testXMLPackagerRealm"); assertSame(logger, xMLPackager.logger, "xMLPackager.logger"); assertEquals("testXMLPackagerRealm", xMLPackager.realm, "xMLPackager.realm"); }
### Question: QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public boolean removeISORequestListener(ISORequestListener l) { return listeners.remove(l); } 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 testRemoveISORequestListener() throws Throwable { QMUX qMUX = new QMUX(); boolean result = qMUX.removeISORequestListener(new Connector()); assertFalse(result, "result"); assertEquals(0, qMUX.listeners.size(), "qMUX.listeners.size()"); }
### Question: EuroSubFieldPackager extends ISOBasePackager { @Override protected boolean emitBitMap() { return false; } @Override byte[] pack(ISOComponent c); @Override int unpack(ISOComponent m, byte[] b); }### Answer: @Test public void testEmitBitMap() throws Throwable { EuroSubFieldPackager euroSubFieldPackager = new EuroSubFieldPackager(); boolean result = euroSubFieldPackager.emitBitMap(); assertFalse(result, "result"); }
### Question: PostPackager extends ISOBasePackager { public void setLogger (Logger logger, String realm) { super.setLogger (logger, realm); p127.setLogger (logger, realm + ".PostPrivatePackager"); } PostPackager(); void setLogger(Logger logger, String realm); }### Answer: @Test public void testSetLogger() throws Throwable { PostPackager postPackager = new PostPackager(); Logger logger = Logger.getLogger("testPostPackagerName"); postPackager.setLogger(logger, "testPostPackagerRealm"); assertNotNull(postPackager.p127, "postPackager.p127"); assertSame(logger, postPackager.getLogger(), "postPackager.getLogger()"); assertEquals("testPostPackagerRealm", postPackager.getRealm(), "postPackager.getRealm()"); }
### Question: VISA1Packager extends SimpleLogSource implements ISOPackager, VISA1ResponseFilter { public ISOMsg createISOMsg() { return new ISOMsg(); } VISA1Packager(int[] sequence, int respField, String badResultCode, String okPattern); void setVISA1ResponseFilter(VISA1ResponseFilter filter); @Override byte[] pack(ISOComponent c); String guessAutNumber(String s); @Override int unpack(ISOComponent m, byte[] b); void unpack(ISOComponent m, InputStream in); String getFieldDescription(ISOComponent m, int fldNumber); String getDescription(); ISOMsg createISOMsg(); static final byte[] FS; }### Answer: @Test public void testCreateISOMsg() throws Throwable { int[] sequence = new int[0]; ISOMsg result = new VISA1Packager(sequence, 100, "testVISA1PackagerBadResultCode", "testVISA1PackagerOkPattern") .createISOMsg(); assertEquals(0, result.getDirection(), "result.getDirection()"); }
### Question: VISA1Packager extends SimpleLogSource implements ISOPackager, VISA1ResponseFilter { public String getFieldDescription(ISOComponent m, int fldNumber) { return "VISA 1 fld "+fldNumber; } VISA1Packager(int[] sequence, int respField, String badResultCode, String okPattern); void setVISA1ResponseFilter(VISA1ResponseFilter filter); @Override byte[] pack(ISOComponent c); String guessAutNumber(String s); @Override int unpack(ISOComponent m, byte[] b); void unpack(ISOComponent m, InputStream in); String getFieldDescription(ISOComponent m, int fldNumber); String getDescription(); ISOMsg createISOMsg(); static final byte[] FS; }### Answer: @Test public void testGetFieldDescription() throws Throwable { int[] sequence = new int[0]; VISA1Packager vISA1Packager = new VISA1Packager(sequence, 100, "testVISA1PackagerBadResultCode", "testVISA1PackagerOkPattern"); String result = vISA1Packager.getFieldDescription(new ISOMsg(100), 100); assertEquals("VISA 1 fld 100", result, "result"); }
### Question: VISA1Packager extends SimpleLogSource implements ISOPackager, VISA1ResponseFilter { public void setVISA1ResponseFilter (VISA1ResponseFilter filter) { this.filter = filter; } VISA1Packager(int[] sequence, int respField, String badResultCode, String okPattern); void setVISA1ResponseFilter(VISA1ResponseFilter filter); @Override byte[] pack(ISOComponent c); String guessAutNumber(String s); @Override int unpack(ISOComponent m, byte[] b); void unpack(ISOComponent m, InputStream in); String getFieldDescription(ISOComponent m, int fldNumber); String getDescription(); ISOMsg createISOMsg(); static final byte[] FS; }### Answer: @Test public void testSetVISA1ResponseFilter() throws Throwable { int[] sequence = new int[0]; VISA1ResponseFilter filter = new VISA1Packager(sequence, 100, "testVISA1PackagerBadResultCode", "testVISA1PackagerOkPattern"); int[] sequence2 = new int[0]; VISA1Packager vISA1Packager = new VISA1Packager(sequence2, 1000, "testVISA1PackagerBadResultCode1", "testVISA1PackagerOkPattern1"); vISA1Packager.setVISA1ResponseFilter(filter); assertEquals(100, ((VISA1Packager) vISA1Packager.filter).respField, "vISA1Packager.filter.respField"); assertEquals("testVISA1PackagerBadResultCode", ((VISA1Packager) vISA1Packager.filter).badResultCode, "vISA1Packager.filter.badResultCode"); assertEquals("testVISA1PackagerOkPattern", ((VISA1Packager) vISA1Packager.filter).okPattern, "vISA1Packager.filter.okPattern"); assertSame(filter, vISA1Packager.filter, "vISA1Packager.filter"); }
### Question: IF_NOP extends ISOFieldPackager { public byte[] pack (ISOComponent c) { return new byte[0]; } IF_NOP(); IF_NOP(int len, String description); byte[] pack(ISOComponent c); int unpack(ISOComponent c, byte[] b, int offset); int getMaxPackedLength(); }### Answer: @Test public void testPack() throws Exception { ISOField field = new ISOField(12, "ABCD"); IF_NOP packager = new IF_NOP(); assertTrue(packager.pack(field).length == 0); }
### Question: IF_NOP extends ISOFieldPackager { public int unpack (ISOComponent c, byte[] b, int offset) { return 0; } IF_NOP(); IF_NOP(int len, String description); byte[] pack(ISOComponent c); int unpack(ISOComponent c, byte[] b, int offset); int getMaxPackedLength(); }### Answer: @Test public void testUnpack() throws Exception { byte[] raw = new byte[]{}; IF_NOP packager = new IF_NOP(); ISOField field = new ISOField(12); assertEquals(0, packager.unpack(field, raw, 0)); assertNull(field.getValue()); }
### Question: VErrorParser implements LogSource, Loggeable { public void dump(PrintStream p, String indent) { } Vector getVErrors( ISOComponent c ); String parseXMLErrorList(); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void dump(PrintStream p, String indent); void resetErrors(); }### Answer: @Test public void testDump() throws Throwable { VErrorParser vErrorParser = new VErrorParser(); vErrorParser.dump(new PrintStream(new ByteArrayOutputStream(), true), "testVErrorParserIndent"); assertNull(vErrorParser.getRealm(), "vErrorParser.getRealm()"); }
### Question: VErrorParser implements LogSource, Loggeable { public Logger getLogger() { return logger; } Vector getVErrors( ISOComponent c ); String parseXMLErrorList(); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void dump(PrintStream p, String indent); void resetErrors(); }### Answer: @Test public void testGetLogger() throws Throwable { VErrorParser vErrorParser = new VErrorParser(); Logger logger = new Logger(); vErrorParser.setLogger(logger, "testVErrorParserRealm"); Logger result = vErrorParser.getLogger(); assertSame(logger, result, "result"); }
### Question: VErrorParser implements LogSource, Loggeable { public String getRealm() { return realm; } Vector getVErrors( ISOComponent c ); String parseXMLErrorList(); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void dump(PrintStream p, String indent); void resetErrors(); }### Answer: @Test public void testGetRealm() throws Throwable { String result = new VErrorParser().getRealm(); assertNull(result, "result"); }
### Question: VErrorParser implements LogSource, Loggeable { public String parseXMLErrorList(){ return ""; } Vector getVErrors( ISOComponent c ); String parseXMLErrorList(); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void dump(PrintStream p, String indent); void resetErrors(); }### Answer: @Test public void testParseXMLErrorList() throws Throwable { String result = new VErrorParser().parseXMLErrorList(); assertEquals("", result, "result"); }
### Question: VErrorParser implements LogSource, Loggeable { public void resetErrors(){ _errors = null; } Vector getVErrors( ISOComponent c ); String parseXMLErrorList(); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void dump(PrintStream p, String indent); void resetErrors(); }### Answer: @Test public void testResetErrors() throws Throwable { VErrorParser vErrorParser = new VErrorParser(); vErrorParser.resetErrors(); }
### Question: VErrorParser implements LogSource, Loggeable { public void setLogger(Logger logger, String realm) { this.logger = logger; this.realm = realm; } Vector getVErrors( ISOComponent c ); String parseXMLErrorList(); void setLogger(Logger logger, String realm); String getRealm(); Logger getLogger(); void dump(PrintStream p, String indent); void resetErrors(); }### Answer: @Test public void testSetLogger() throws Throwable { VErrorParser vErrorParser = new VErrorParser(); Logger logger = new Logger(); vErrorParser.setLogger(logger, "testVErrorParserRealm"); assertSame(logger, vErrorParser.logger, "vErrorParser.logger"); assertEquals("testVErrorParserRealm", vErrorParser.realm, "vErrorParser.realm"); }
### 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: 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: 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 { 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 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: 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"); } }

Subsets and Splits

No community queries yet

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