Datasets:

Minata
/

1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 269k rows

method2testcases stringlengths 118 6.63k
### Question: RightPadder implements Padder { public String pad(String data, int maxLength) throws ISOException { int len = data.length(); if (len < maxLength) { StringBuilder padded = new StringBuilder(maxLength); padded.append(data); for (; len < maxLength; len++) { padded.append(pad); } data = padded.toString(); } else if (len > maxLength) { throw new ISOException("Data is too long. Max = " + maxLength); } return data; } RightPadder(char pad); String pad(String data, int maxLength); String unpad(String paddedData); static final RightPadder SPACE_PADDER; }### Answer: @Test public void testPaddingNeeded() throws Exception { assertEquals("123000", padder.pad("123", 6)); } @Test public void testNoPaddingNeeded() throws Exception { assertEquals("123", padder.pad("123", 3)); } @Test public void testPadLengthTooShort() throws Exception { try { padder.pad("123", 2); fail("Padding a bigger string into a smaller buffer should throw an exception"); } catch (Exception asIExpected) { } }
### Question: RightPadder implements Padder { public String unpad(String paddedData) { int len = paddedData.length(); for (int i = len; i > 0; i--) { if (paddedData.charAt(i - 1) != pad) { return paddedData.substring(0, i); } } return ""; } RightPadder(char pad); String pad(String data, int maxLength); String unpad(String paddedData); static final RightPadder SPACE_PADDER; }### Answer: @Test public void testUnpad1() throws Exception { assertEquals("123", padder.unpad("123000")); } @Test public void testUnpad2() throws Exception { assertEquals("123", padder.unpad("123")); } @Test public void testUnpad3() throws Exception { assertEquals("1203", padder.unpad("1203000")); } @Test public void testUnpadAllPadding() throws Exception { assertEquals("", padder.unpad("000")); }
### Question: RightTPadder extends RightPadder { public String pad(String data, int maxLength) throws ISOException { if (data.length() > maxLength) { return super.pad(data.substring(0,maxLength), maxLength); } else { return super.pad(data, maxLength); } } RightTPadder(char pad); String pad(String data, int maxLength); static final RightTPadder SPACE_PADDER; }### Answer: @Test public void testPad() throws Throwable { String result = new RightTPadder(' ').pad("10Characte", 10); assertEquals("10Characte", result, "result"); } @Test public void testPad1() throws Throwable { String result = RightTPadder.SPACE_PADDER.pad("", 100); assertEquals(" ", result, "result"); } @Test public void testPad2() throws Throwable { String result = new RightTPadder(' ').pad("testRightTPadderData", 0); assertEquals("", result, "result"); } @Test public void testPadThrowsNullPointerException() throws Throwable { try { new RightTPadder(' ').pad(null, 100); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"String.length()\" because \"data\" is null", ex.getMessage(), "ex.getMessage()"); } } } @Test public void testPadThrowsStringIndexOutOfBoundsException() throws Throwable { try { new RightTPadder(' ').pad("testRightTPadderData", -1); fail("Expected StringIndexOutOfBoundsException to be thrown"); } catch (StringIndexOutOfBoundsException ex) { if (isJavaVersionAtMost(JAVA_1_8)) { assertEquals("String index out of range: -1", ex.getMessage(), "ex.getMessage()"); } else { assertEquals("begin 0, end -1, length 20", ex.getMessage(), "ex.getMessage()"); } } }
### Question: QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public String getInQueue () { return in; } 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 testGetInQueue() throws Throwable { String result = new QMUX().getInQueue(); assertNull(result, "result"); }
### Question: AsciiPrefixer implements Prefixer { @Override public void encodeLength(int length, byte[] b) throws ISOException { int n = length; for (int i = nDigits - 1; i >= 0; i--) { b[i] = (byte)(n % 10 + '0'); n /= 10; } if (n != 0) { throw new ISOException("invalid len "+ length + ". Prefixing digits = " + nDigits); } } AsciiPrefixer(int nDigits); @Override void encodeLength(int length, byte[] b); @Override int decodeLength(byte[] b, int offset); @Override int getPackedLength(); static final AsciiPrefixer L; static final AsciiPrefixer LL; static final AsciiPrefixer LLL; static final AsciiPrefixer LLLL; static final AsciiPrefixer LLLLL; static final AsciiPrefixer LLLLLL; }### Answer: @Test public void testEncode() throws Exception { byte[] b = new byte[2]; AsciiPrefixer.LL.encodeLength(21, b); TestUtils.assertEquals(new byte[]{0x32, 0x31}, b); } @Test public void testEncodeShortLength() throws Exception { byte[] b = new byte[2]; AsciiPrefixer.LL.encodeLength(3, b); TestUtils.assertEquals(new byte[]{0x30, 0x33}, b); }
### Question: AsciiPrefixer implements Prefixer { @Override public int decodeLength(byte[] b, int offset) throws ISOException { int len = 0; for (int i = 0; i < nDigits; i++) { byte d = b[offset + i]; if(d < '0' \|\| d > '9') { throw new ISOException("Invalid character found. Expected digit."); } len = len * 10 + d - (byte)'0'; } return len; } AsciiPrefixer(int nDigits); @Override void encodeLength(int length, byte[] b); @Override int decodeLength(byte[] b, int offset); @Override int getPackedLength(); static final AsciiPrefixer L; static final AsciiPrefixer LL; static final AsciiPrefixer LLL; static final AsciiPrefixer LLLL; static final AsciiPrefixer LLLLL; static final AsciiPrefixer LLLLLL; }### Answer: @Test public void testDecode() throws Exception { byte[] b = new byte[]{0x32, 0x35}; assertEquals(25, AsciiPrefixer.LL.decodeLength(b, 0)); }
### Question: AsciiInterpreter implements Interpreter { @Override public void interpret(String data, byte[] b, int offset) { System.arraycopy(data.getBytes(ISOUtil.CHARSET), 0, b, offset, data.length()); } @Override void interpret(String data, byte[] b, int offset); @Override String uninterpret(byte[] rawData, int offset, int length); @Override int getPackedLength(int nDataUnits); static final AsciiInterpreter INSTANCE; }### Answer: @Test public void testInterpret() throws Exception { byte[] b = new byte[3]; inter.interpret("123", b, 0); TestUtils.assertEquals(new byte[] {49, 50, 51}, b); }
### Question: AsciiInterpreter implements Interpreter { @Override public String uninterpret (byte[] rawData, int offset, int length) { byte[] ret = new byte[length]; try { System.arraycopy(rawData, offset, ret, 0, length); return new String(ret, ISOUtil.CHARSET); } catch (IndexOutOfBoundsException e) { throw new RuntimeException( String.format("Required %d but just got %d bytes", length, rawData.length-offset) ); } } @Override void interpret(String data, byte[] b, int offset); @Override String uninterpret(byte[] rawData, int offset, int length); @Override int getPackedLength(int nDataUnits); static final AsciiInterpreter INSTANCE; }### Answer: @Test public void testUninterpret() throws Exception { byte[] b = new byte[] {49, 50, 51}; assertEquals("123", inter.uninterpret(b, 0, 3)); }
### Question: AsciiInterpreter implements Interpreter { @Override public int getPackedLength(int nDataUnits) { return nDataUnits; } @Override void interpret(String data, byte[] b, int offset); @Override String uninterpret(byte[] rawData, int offset, int length); @Override int getPackedLength(int nDataUnits); static final AsciiInterpreter INSTANCE; }### Answer: @Test public void testGetPackedLength() throws Exception { assertEquals(3, inter.getPackedLength(3)); }
### Question: ISOField extends ISOComponent implements Cloneable, Externalizable { @Override public void dump (PrintStream p, String indent) { if (value != null) { if (value.indexOf('<') >= 0) { p.print(indent + "<" + XMLPackager.ISOFIELD_TAG + " " + XMLPackager.ID_ATTR + "=\"" + fieldNumber + "\"><![CDATA["); p.print(value); p.println("]]></" + XMLPackager.ISOFIELD_TAG + ">"); } else if (value.startsWith("{")) { p.print(indent + "<" + XMLPackager.ISOFIELD_TAG + " " + XMLPackager.ID_ATTR + "=\"" + fieldNumber + "\"><![CDATA["); p.print(value); p.println("]]></" + XMLPackager.ISOFIELD_TAG + ">"); } else { p.println(indent + "<" + XMLPackager.ISOFIELD_TAG + " " + XMLPackager.ID_ATTR + "=\"" + fieldNumber + "\" " + XMLPackager.VALUE_ATTR + "=\"" + ISOUtil.normalize(value) + "\"/>"); } } } ISOField(); ISOField(int n); ISOField(int n, String v); @Override byte[] pack(); @Override int unpack(byte[] b); @Override void unpack(InputStream in); @Override Object getKey(); @Override Object getValue(); @Override void setValue(Object obj); @Override byte[] getBytes(); @Override void dump(PrintStream p, String indent); @Override void setFieldNumber(int fieldNumber); @Override int getFieldNumber(); @Override void writeExternal(ObjectOutput out); @Override void readExternal(ObjectInput in); }### Answer: @Test public void testDump() throws Throwable { PrintStream p = new PrintStream(new ByteArrayOutputStream(), true); new ISOField(100, "testISOFieldv").dump(p, "testISOFieldIndent"); assertTrue(true, "Test completed without Exception"); }
### Question: ISOField extends ISOComponent implements Cloneable, Externalizable { @Override public byte[] getBytes() { return value != null ? value.getBytes(ISOUtil.CHARSET) : new byte[] {}; } ISOField(); ISOField(int n); ISOField(int n, String v); @Override byte[] pack(); @Override int unpack(byte[] b); @Override void unpack(InputStream in); @Override Object getKey(); @Override Object getValue(); @Override void setValue(Object obj); @Override byte[] getBytes(); @Override void dump(PrintStream p, String indent); @Override void setFieldNumber(int fieldNumber); @Override int getFieldNumber(); @Override void writeExternal(ObjectOutput out); @Override void readExternal(ObjectInput in); }### Answer: @Test public void testGetBytes() throws Throwable { ISOField iSOField = new ISOField(100); iSOField.setValue(""); byte[] result = iSOField.getBytes(); assertEquals(0, result.length, "result.length"); } @Test public void testGetBytes1() throws Throwable { byte[] result = new ISOField(100, "testISOFieldv").getBytes(); assertEquals(13, result.length, "result.length"); assertEquals((byte) 116, result[0], "result[0]"); } @Test public void testGetBytesThrowsNullPointerException() throws Throwable { byte[] bytes = new ISOField(100).getBytes(); assertArrayEquals(new byte[0], bytes); }
### Question: QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public String getKey (ISOMsg m) throws ISOException { if (out == null) throw new NullPointerException ("Misconfigured QMUX. Please verify out queue is not null."); StringBuilder sb = new StringBuilder (out); sb.append ('.'); sb.append (mapMTI(m.getMTI())); if (headerIsKey && m.getHeader()!=null) { sb.append ('.'); sb.append(ISOUtil.hexString(m.getHeader())); sb.append ('.'); } boolean hasFields = false; String[] k = mtiKey.getOrDefault(m.getMTI().substring(0,2), key); for (String f : k) { String v = m.getString(f); if (v != null) { if ("11".equals(f)) { String vt = v.trim(); int l = m.getMTI().charAt(0) == '2' ? 12 : 6; if (vt.length() < l) v = ISOUtil.zeropad(vt, l); } if ("41".equals(f)) { v = ISOUtil.zeropad(v.trim(), 16); } hasFields = true; sb.append(v); } } if (!hasFields) throw new ISOException ("Key fields not found - not sending " + sb.toString()); return sb.toString(); } 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 testGetKeyThrowsNullPointerException() throws Throwable { QMUX qMUX = new QMUX(); ISOMsg m = new ISOMsg(); try { qMUX.getKey(m); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { assertEquals("Misconfigured QMUX. Please verify out queue is not null.", ex.getMessage(), "ex.getMessage()"); assertEquals(0, m.getDirection(), "m.getDirection()"); } }
### Question: ISOField extends ISOComponent implements Cloneable, Externalizable { @Override public Object getKey() { return fieldNumber; } ISOField(); ISOField(int n); ISOField(int n, String v); @Override byte[] pack(); @Override int unpack(byte[] b); @Override void unpack(InputStream in); @Override Object getKey(); @Override Object getValue(); @Override void setValue(Object obj); @Override byte[] getBytes(); @Override void dump(PrintStream p, String indent); @Override void setFieldNumber(int fieldNumber); @Override int getFieldNumber(); @Override void writeExternal(ObjectOutput out); @Override void readExternal(ObjectInput in); }### Answer: @Test public void testGetKey() throws Throwable { Integer result = (Integer) new ISOField(100).getKey(); assertEquals(100, result.intValue(), "result"); } @Test public void testGetKey1() throws Throwable { Integer result = (Integer) new ISOField(0).getKey(); assertEquals(0, result.intValue(), "result"); }
### Question: ISOField extends ISOComponent implements Cloneable, Externalizable { @Override public Object getValue() { return value; } ISOField(); ISOField(int n); ISOField(int n, String v); @Override byte[] pack(); @Override int unpack(byte[] b); @Override void unpack(InputStream in); @Override Object getKey(); @Override Object getValue(); @Override void setValue(Object obj); @Override byte[] getBytes(); @Override void dump(PrintStream p, String indent); @Override void setFieldNumber(int fieldNumber); @Override int getFieldNumber(); @Override void writeExternal(ObjectOutput out); @Override void readExternal(ObjectInput in); }### Answer: @Test public void testGetValue() throws Throwable { String result = (String) new ISOField(100, "testISOFieldv").getValue(); assertEquals("testISOFieldv", result, "result"); } @Test public void testGetValue1() throws Throwable { Object result = new ISOField(100).getValue(); assertNull(result, "result"); }
### Question: ISOField extends ISOComponent implements Cloneable, Externalizable { @Override public byte[] pack() throws ISOException { throw new ISOException ("Not available on Leaf"); } ISOField(); ISOField(int n); ISOField(int n, String v); @Override byte[] pack(); @Override int unpack(byte[] b); @Override void unpack(InputStream in); @Override Object getKey(); @Override Object getValue(); @Override void setValue(Object obj); @Override byte[] getBytes(); @Override void dump(PrintStream p, String indent); @Override void setFieldNumber(int fieldNumber); @Override int getFieldNumber(); @Override void writeExternal(ObjectOutput out); @Override void readExternal(ObjectInput in); }### Answer: @Test public void testPackThrowsISOException() throws Throwable { try { new ISOField(100).pack(); fail("Expected ISOException to be thrown"); } catch (ISOException ex) { assertEquals("Not available on Leaf", ex.getMessage(), "ex.getMessage()"); assertNull(ex.nested, "ex.nested"); } }
### Question: ISOField extends ISOComponent implements Cloneable, Externalizable { @Override public void setFieldNumber (int fieldNumber) { this.fieldNumber = fieldNumber; } ISOField(); ISOField(int n); ISOField(int n, String v); @Override byte[] pack(); @Override int unpack(byte[] b); @Override void unpack(InputStream in); @Override Object getKey(); @Override Object getValue(); @Override void setValue(Object obj); @Override byte[] getBytes(); @Override void dump(PrintStream p, String indent); @Override void setFieldNumber(int fieldNumber); @Override int getFieldNumber(); @Override void writeExternal(ObjectOutput out); @Override void readExternal(ObjectInput in); }### Answer: @Test public void testSetFieldNumber() throws Throwable { ISOField iSOField = new ISOField(100); iSOField.setFieldNumber(1000); assertEquals(1000, iSOField.fieldNumber, "iSOField.fieldNumber"); }
### Question: ISOField extends ISOComponent implements Cloneable, Externalizable { @Override public void setValue(Object obj) throws ISOException { if (obj instanceof String) value = (String) obj; else value = obj.toString(); } ISOField(); ISOField(int n); ISOField(int n, String v); @Override byte[] pack(); @Override int unpack(byte[] b); @Override void unpack(InputStream in); @Override Object getKey(); @Override Object getValue(); @Override void setValue(Object obj); @Override byte[] getBytes(); @Override void dump(PrintStream p, String indent); @Override void setFieldNumber(int fieldNumber); @Override int getFieldNumber(); @Override void writeExternal(ObjectOutput out); @Override void readExternal(ObjectInput in); }### Answer: @Test public void testSetValue() throws Throwable { ISOField iSOField = new ISOField(100); iSOField.setValue(" W"); assertEquals(" W", iSOField.value, "iSOField.value"); } @Test public void testSetValue1() throws Throwable { ISOField iSOField = new ISOField(100); iSOField.setValue(200); assertThat("isoField setter", "200", equalTo(iSOField.value)); }
### Question: ISOField extends ISOComponent implements Cloneable, Externalizable { @Override public int unpack(byte[] b) throws ISOException { throw new ISOException ("Not available on Leaf"); } ISOField(); ISOField(int n); ISOField(int n, String v); @Override byte[] pack(); @Override int unpack(byte[] b); @Override void unpack(InputStream in); @Override Object getKey(); @Override Object getValue(); @Override void setValue(Object obj); @Override byte[] getBytes(); @Override void dump(PrintStream p, String indent); @Override void setFieldNumber(int fieldNumber); @Override int getFieldNumber(); @Override void writeExternal(ObjectOutput out); @Override void readExternal(ObjectInput in); }### Answer: @Test public void testUnpackThrowsISOException1() throws Throwable { byte[] b = new byte[2]; try { new ISOField(100, "testISOFieldv").unpack(b); fail("Expected ISOException to be thrown"); } catch (ISOException ex) { assertEquals("Not available on Leaf", ex.getMessage(), "ex.getMessage()"); assertNull(ex.nested, "ex.nested"); } }
### Question: ISOField extends ISOComponent implements Cloneable, Externalizable { @Override public void writeExternal (ObjectOutput out) throws IOException { out.writeShort (fieldNumber); out.writeUTF (value); } ISOField(); ISOField(int n); ISOField(int n, String v); @Override byte[] pack(); @Override int unpack(byte[] b); @Override void unpack(InputStream in); @Override Object getKey(); @Override Object getValue(); @Override void setValue(Object obj); @Override byte[] getBytes(); @Override void dump(PrintStream p, String indent); @Override void setFieldNumber(int fieldNumber); @Override int getFieldNumber(); @Override void writeExternal(ObjectOutput out); @Override void readExternal(ObjectInput in); }### Answer: @Test public void testWriteExternal() throws Throwable { ObjectOutput out = new ObjectOutputStream(new ByteArrayOutputStream()); new ISOVField(new ISOField(100, "testISOFieldv"), new ISOVError("testISOFieldDescription", "testISOFieldRejectCode")) .writeExternal(out); } @Test public void testWriteExternalThrowsNullPointerException() throws Throwable { ObjectOutput out = new ObjectOutputStream(new ByteArrayOutputStream()); try { new ISOField(100).writeExternal(out); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"String.length()\" because \"s\" is null", ex.getMessage(), "ex.getMessage()"); } } } @Test public void testWriteExternalThrowsNullPointerException1() throws Throwable { try { new ISOField(100).writeExternal(null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"java.io.ObjectOutput.writeShort(int)\" because \"out\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public static MUX getMUX (String name) throws NameRegistrar.NotFoundException { return (MUX) NameRegistrar.get ("mux."+name); } 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 testGetMUXThrowsNotFoundException() throws Throwable { try { QMUX.getMUX("testQMUXName"); fail("Expected NotFoundException to be thrown"); } catch (NameRegistrar.NotFoundException ex) { assertEquals("mux.testQMUXName", ex.getMessage(), "ex.getMessage()"); } }
### Question: NullPrefixer implements Prefixer { @Override public int decodeLength(byte[] b, int offset) { return -1; } private NullPrefixer(); @Override void encodeLength(int length, byte[] b); @Override int decodeLength(byte[] b, int offset); @Override int getPackedLength(); static final NullPrefixer INSTANCE; }### Answer: @Test public void testDecodeLength() throws Throwable { byte[] b = new byte[2]; int result = NullPrefixer.INSTANCE.decodeLength(b, 100); assertEquals(-1, result, "result"); }
### Question: NullPrefixer implements Prefixer { @Override public void encodeLength(int length, byte[] b) {} private NullPrefixer(); @Override void encodeLength(int length, byte[] b); @Override int decodeLength(byte[] b, int offset); @Override int getPackedLength(); static final NullPrefixer INSTANCE; }### Answer: @Test public void testEncodeLength() throws Throwable { NullPrefixer INSTANCE = NullPrefixer.INSTANCE; byte[] b = new byte[2]; INSTANCE.encodeLength(100, b); assertEquals(0, INSTANCE.getPackedLength(), "INSTANCE.getPackedLength()"); }
### Question: NullPrefixer implements Prefixer { @Override public int getPackedLength() { return 0; } private NullPrefixer(); @Override void encodeLength(int length, byte[] b); @Override int decodeLength(byte[] b, int offset); @Override int getPackedLength(); static final NullPrefixer INSTANCE; }### Answer: @Test public void testGetPackedLength() throws Throwable { int result = NullPrefixer.INSTANCE.getPackedLength(); assertEquals(0, result, "result"); }
### Question: Currency implements Serializable { public String getAlphaCode() { return alphacode; } Currency(String alphacode, int isocode, int numdecimals); int getDecimals(); int getIsoCode(); String getAlphaCode(); String formatAmountForISOMsg(double amount); double parseAmountFromISOMsg(String isoamount); @Override String toString(); }### Answer: @Test public void testGetAlphaCode() throws Throwable { String result = new Currency("testCurrencyAlphacode", 100, 1000).getAlphaCode(); assertEquals("testCurrencyAlphacode", result, "result"); }
### Question: Currency implements Serializable { public int getDecimals() { return numdecimals; } Currency(String alphacode, int isocode, int numdecimals); int getDecimals(); int getIsoCode(); String getAlphaCode(); String formatAmountForISOMsg(double amount); double parseAmountFromISOMsg(String isoamount); @Override String toString(); }### Answer: @Test public void testGetDecimals() throws Throwable { int result = new Currency("testCurrencyAlphacode", 100, 0).getDecimals(); assertEquals(0, result, "result"); } @Test public void testGetDecimals1() throws Throwable { int result = new Currency("testCurrencyAlphacode", 100, 1000).getDecimals(); assertEquals(1000, result, "result"); }
### Question: Currency implements Serializable { public int getIsoCode() { return isocode; } Currency(String alphacode, int isocode, int numdecimals); int getDecimals(); int getIsoCode(); String getAlphaCode(); String formatAmountForISOMsg(double amount); double parseAmountFromISOMsg(String isoamount); @Override String toString(); }### Answer: @Test public void testGetIsoCode() throws Throwable { int result = new Currency("testCurrencyAlphacode", 0, 100).getIsoCode(); assertEquals(0, result, "result"); } @Test public void testGetIsoCode1() throws Throwable { int result = new Currency("testCurrencyAlphacode", 100, 1000).getIsoCode(); assertEquals(100, result, "result"); }
### Question: QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public String getOutQueue () { return out; } 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 testGetOutQueue() throws Throwable { String result = new QMUX().getOutQueue(); assertNull(result, "result"); }
### 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 byte[] pack ( ISOComponent c ) throws ISOException { try { Map tab = c.getChildren(); StringBuilder sb = new StringBuilder(); for ( int i = 0; i < fld.length; i++ ) { ISOField f = (ISOField) tab.get (i); if ( f != null ) { sb.append ( new String( fld[i].pack( f ) ) ); } } return sb.toString().getBytes(); } catch ( Exception ex ) { throw new ISOException ( this.getRealm() + ": " + ex.getMessage(), ex ); } } CTCSubFieldPackager(); byte[] pack( ISOComponent c ); int unpack( ISOComponent m, byte[] b ); ISOComponent validate( ISOComponent c ); }### Answer: @Test public void testPack1() throws Throwable { CTCSubFieldPackager cTCSubFieldPackager = new CTCSubFieldPackager(); ISOFieldPackager[] fld = new ISOFieldPackager[1]; cTCSubFieldPackager.setFieldPackager(fld); byte[] result = cTCSubFieldPackager.pack(new ISOField()); assertEquals(0, result.length, "result.length"); } @Test public void testPackThrowsISOException() throws Throwable { try { new CTCSubFieldPackager().pack(null); fail("Expected ISOException to be thrown"); } catch (ISOException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertEquals("null: null", ex.getMessage(), "ex.getMessage()"); assertNull(ex.getNested().getMessage(), "ex.getNested().getMessage()"); } else { assertEquals("null: Cannot invoke \"org.jpos.iso.ISOComponent.getChildren()\" because \"c\" is null", ex.getMessage(), "ex.getMessage()"); assertEquals("Cannot invoke \"org.jpos.iso.ISOComponent.getChildren()\" because \"c\" is null", ex.getNested().getMessage(), "ex.getNested().getMessage()"); } } } @Test public void testPackThrowsISOException1() throws Throwable { try { new CTCSubFieldPackager().pack(new ISOBinaryField(100)); fail("Expected ISOException to be thrown"); } catch (ISOException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertEquals("null: null", ex.getMessage(), "ex.getMessage()"); assertNull(ex.getNested().getMessage(), "ex.getNested().getMessage()"); } else { assertEquals("null: Cannot read the array length because \"this.fld\" is null", ex.getMessage(), "ex.getMessage()"); assertEquals("Cannot read the array length because \"this.fld\" is null", ex.getNested().getMessage(), "ex.getNested().getMessage()"); } } } @Test public void testPackThrowsISOException2() throws Throwable { CTCSubFieldPackager cTCSubFieldPackager = new CTCSubFieldPackager(); ISOFieldPackager[] fld = new ISOFieldPackager[1]; cTCSubFieldPackager.setFieldPackager(fld); try { cTCSubFieldPackager.pack(new ISOMsg("testCTCSubFieldPackagerMti")); fail("Expected ISOException to be thrown"); } catch (ISOException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertEquals("null: null", ex.getMessage(), "ex.getMessage()"); assertNull(ex.getNested().getMessage(), "ex.getNested().getMessage()"); } else { assertEquals("null: Cannot invoke \"org.jpos.iso.ISOFieldPackager.pack(org.jpos.iso.ISOComponent)\" because \"this.fld[i]\" is null", ex.getMessage(), "ex.getMessage()"); assertEquals("Cannot invoke \"org.jpos.iso.ISOFieldPackager.pack(org.jpos.iso.ISOComponent)\" because \"this.fld[i]\" is null", ex.getNested().getMessage(), "ex.getNested().getMessage()"); } } }
### Question: CTCSubFieldPackager extends ISOBaseValidatingPackager { public int unpack ( ISOComponent m, byte[] b ) throws ISOException { LogEvent evt = new LogEvent ( this, "unpack" ); int consumed = 0; for ( int i=0; consumed < b.length ; i++ ) { ISOComponent c = fld[i].createComponent( i ); consumed += fld[i].unpack ( c, b, consumed ); if ( logger != null ) { evt.addMessage ("<unpack fld=\"" + i +"\" packager=\"" +fld[i].getClass().getName()+ "\">"); evt.addMessage (" <value>" +c.getValue().toString() + "</value>"); evt.addMessage ("</unpack>"); } m.set(c); } Logger.log (evt); return consumed; } CTCSubFieldPackager(); byte[] pack( ISOComponent c ); int unpack( ISOComponent m, byte[] b ); ISOComponent validate( ISOComponent c ); }### Answer: @Test public void testUnpack() throws Throwable { byte[] b = new byte[0]; int result = new CTCSubFieldPackager().unpack(new ISOField(), b); assertEquals(0, result, "result"); } @Test public void testUnpackThrowsISOException() throws Throwable { CTCSubFieldPackager cTCSubFieldPackager = new CTCSubFieldPackager(); ISOFieldPackager[] fld = new ISOFieldPackager[6]; fld[0] = new IFA_LLLLCHAR(100, "testCTCSubFieldPackagerDescription"); cTCSubFieldPackager.setFieldPackager(fld); byte[] b = new byte[4]; try { cTCSubFieldPackager.unpack(new ISOField(), b); fail("Expected ISOException to be thrown"); } catch (ISOException ex) { assertEquals("org.jpos.iso.IFA_LLLLCHAR: Problem unpacking field 0", ex.getMessage(), "ex.getMessage()"); assertEquals("Invalid character found. Expected digit.", ex.getNested().getMessage(), "ex.getNested().getMessage()"); } } @Test public void testUnpackThrowsNullPointerException() throws Throwable { assertThrows(NullPointerException.class, () -> { ISOFieldPackager[] fld = new ISOFieldPackager[4]; fld[0] = new IFE_CHAR(); CTCSubFieldPackager cTCSubFieldPackager = new CTCSubFieldPackager(); cTCSubFieldPackager.setFieldPackager(fld); byte[] b = new byte[2]; cTCSubFieldPackager.unpack(null, b); }); } @Test public void testUnpackThrowsNullPointerException2() throws Throwable { assertThrows(NullPointerException.class, () -> { new CTCSubFieldPackager().unpack(new ISOBinaryField(100), (byte[]) null); }); }
### 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 ISOFieldPackager getBitMapfieldPackager() { return fld[bitmapField]; } 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 testGetBitMapfieldPackager() throws Throwable { ISOFieldPackager iFA_AMOUNT = new IFA_AMOUNT(); ISOFieldPackager[] fld = new ISOFieldPackager[2]; fld[1] = iFA_AMOUNT; GenericPackager genericPackager = new GenericPackager(); genericPackager.setFieldPackager(fld); ISOFieldPackager result = genericPackager.getBitMapfieldPackager(); assertSame(iFA_AMOUNT, result, "result"); } @Test public void testGetBitMapfieldPackagerThrowsArrayIndexOutOfBoundsException() throws Throwable { ISOFieldPackager[] fld = new ISOFieldPackager[0]; GenericPackager genericPackager = new GenericPackager(); genericPackager.setFieldPackager(fld); try { genericPackager.getBitMapfieldPackager(); fail("Expected ArrayIndexOutOfBoundsException to be thrown"); } catch (ArrayIndexOutOfBoundsException ex) { if (isJavaVersionAtMost(JAVA_10)) { assertEquals("1", ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Index 1 out of bounds for length 0", ex.getMessage(), "ex.getMessage()"); } } } @Test public void testGetBitMapfieldPackagerThrowsNullPointerException() throws Throwable { GenericPackager genericPackager = new GenericPackager(); try { genericPackager.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: 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: GenericPackager extends ISOBasePackager implements Configurable { public void setConfiguration (Configuration cfg) throws ConfigurationException { filename = cfg.get("packager-config", null); if (filename == null) throw new ConfigurationException("packager-config property cannot be null"); try { String loggerName = cfg.get("packager-logger"); if (loggerName != null) setLogger(Logger.getLogger (loggerName), cfg.get ("packager-realm")); logFieldName= cfg.getBoolean("packager-log-fieldname", logFieldName); readFile(filename); } catch (ISOException e) { throw new ConfigurationException(e.getMessage(), e.fillInStackTrace()); } } 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: @Disabled("test failing") @Test public void testSetConfigurationThrowsConfigurationException() throws Throwable { GenericPackager genericPackager = new GenericPackager(); Configuration cfg = new SimpleConfiguration(); try { genericPackager.setConfiguration(cfg); fail("Expected ConfigurationException to be thrown"); } catch (ConfigurationException ex) { assertEquals( "org.jpos.iso.ISOException: java.lang.ClassNotFoundException: org.apache.crimson.parser.XMLReaderImpl (java.lang.ClassNotFoundException: org.apache.crimson.parser.XMLReaderImpl)", ex.getMessage(), "ex.getMessage()"); assertEquals("java.lang.ClassNotFoundException: org.apache.crimson.parser.XMLReaderImpl", ex.getNested().getMessage(), "ex.getNested().getMessage()"); assertEquals("", genericPackager.getLogger().getName(), "(GenericValidatingPackager) genericValidatingPackager.getLogger().getName()"); assertEquals("", genericPackager.getRealm(), "(GenericValidatingPackager) genericValidatingPackager.getRealm()"); } } @Test public void testSetConfigurationThrowsNullPointerException() throws Throwable { GenericPackager genericSubFieldPackager = new GenericSubFieldPackager(); Configuration cfg = new SubConfiguration(); try { genericSubFieldPackager.setConfiguration(cfg); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"org.jpos.core.Configuration.get(String, String)\" because \"this.cfg\" is null", ex.getMessage(), "ex.getMessage()"); } assertNull(genericSubFieldPackager.getLogger(), "(GenericSubFieldPackager) genericSubFieldPackager.getLogger()"); assertNull(genericSubFieldPackager.getRealm(), "(GenericSubFieldPackager) genericSubFieldPackager.getRealm()"); } }
### Question: GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override public byte[] pack(ISOComponent m) throws ISOException { LogEvent evt = new LogEvent (this, "pack"); try (ByteArrayOutputStream bout = new ByteArrayOutputStream(100)) { ISOComponent c; Map fields = m.getChildren(); if (emitBitMap()) { c = (ISOComponent) fields.get (-1); byte[] b = getBitMapfieldPackager().pack(c); bout.write(b); } for (int i=getFirstField(); i<=m.getMaxField(); i++) { c = (ISOComponent) fields.get (i); if (c == null && !emitBitMap()) c = new ISOField (i, ""); if (c != null) { try { byte[] b = fld[i].pack(c); bout.write(b); } catch (Exception e) { evt.addMessage ("error packing subfield "+i); evt.addMessage (c); evt.addMessage (e); throw e; } } } byte[] d = bout.toByteArray(); if (logger != null) evt.addMessage (ISOUtil.hexString (d)); return d; } catch (ISOException e) { evt.addMessage (e); throw e; } catch (Exception e) { evt.addMessage (e); throw new ISOException (e); } finally { Logger.log(evt); } } GenericSubFieldPackager(); @Override int getFieldNumber(); @Override int unpack(ISOComponent m, byte[] b); @Override byte[] pack(ISOComponent m); }### Answer: @Test public void testPackThrowsISOException() throws Throwable { try { new GenericSubFieldPackager().pack(new ISOMsg()); fail("Expected ISOException to be thrown"); } catch (ISOException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertEquals("java.lang.NullPointerException", ex.getMessage(), "ex.getMessage()"); assertNull(ex.getNested().getMessage(), "ex.getNested().getMessage()"); } else { assertEquals("java.lang.NullPointerException: Cannot load from object array because \"this.fld\" is null", ex.getMessage(), "ex.getMessage()"); assertEquals("Cannot load from object array because \"this.fld\" is null", ex.getNested().getMessage(), "ex.getNested().getMessage()"); } } } @Test public void testPackThrowsISOException1() throws Throwable { try { new GenericSubFieldPackager().pack(null); fail("Expected ISOException to be thrown"); } catch (ISOException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertEquals("java.lang.NullPointerException", ex.getMessage(), "ex.getMessage()"); assertNull(ex.getNested().getMessage(), "ex.getNested().getMessage()"); } else { assertEquals("java.lang.NullPointerException: Cannot invoke \"org.jpos.iso.ISOComponent.getChildren()\" because \"m\" is null", ex.getMessage(), "ex.getMessage()"); assertEquals("Cannot invoke \"org.jpos.iso.ISOComponent.getChildren()\" because \"m\" is null", ex.getNested().getMessage(), "ex.getNested().getMessage()"); } } } @Test public void testPackThrowsISOException2() throws Throwable { ISOFieldPackager[] fld = new ISOFieldPackager[3]; fld[1] = new IFA_LCHAR(0, "testGenericSubFieldPackagerDescription"); GenericSubFieldPackager genericSubFieldPackager = new GenericSubFieldPackager(); genericSubFieldPackager.setFieldPackager(fld); try { genericSubFieldPackager.pack(new ISOBinaryField(100)); fail("Expected ISOException to be thrown"); } catch (ISOException ex) { assertEquals("org.jpos.iso.IFA_LCHAR: Problem packing field unknown", ex.getMessage(), "ex.getMessage()"); if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getNested().getMessage(), "ex.getNested().getMessage()"); } else { assertEquals("Cannot invoke \"org.jpos.iso.ISOComponent.getValue()\" because \"c\" is null", ex.getNested().getMessage(), "ex.getNested().getMessage()"); } } }
### 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: ISOBaseValidatingPackager extends ISOBasePackager implements ISOValidator { public ISOComponent validate(ISOComponent m) throws ISOException { LogEvent evt = new LogEvent( this, "validate" ); try { ISOComponent c; Map fields = m.getChildren(); for (ISOValidator aFldVld : fldVld) { if (aFldVld != null && (c = (ISOComponent) fields.get(Integer.valueOf(((ISOFieldValidator) aFldVld).getFieldId()))) != null) { try { m.set(aFldVld.validate(c)); } catch (ISOVException e) { if (!e.treated()) { m.set(e.getErrComponent()); e.setTreated(true); } evt.addMessage("Component Validation Error."); throw e; } } } try { if ( msgVld != null ){ for (ISOBaseValidator aMsgVld : this.msgVld) { if (aMsgVld != null) m = aMsgVld.validate(m); } } } catch (ISOVException ex) { evt.addMessage( "Component Validation Error." ); throw ex; } return m; } finally { Logger.log( evt ); } } ISOBaseValidatingPackager(); ISOComponent validate(ISOComponent m); void setFieldValidator( ISOValidator[] fvlds ); void setMsgValidator( ISOBaseValidator[] msgVlds ); }### Answer: @Test public void testValidateThrowsNullPOinterException1() throws Throwable { try { new ISOBaseValidatingPackager().validate(new ISOField(100, "testISOBaseValidatingPackagerv")); fail("Expected ClassCastException to be thrown"); } catch (NullPointerException ex) { assertEquals(NullPointerException.class, ex.getClass(), "ex.getClass()"); } } @Test public void testValidateThrowsNullPointerException1() throws Throwable { try { new ISOBaseValidatingPackager().validate(new ISOMsg("testISOBaseValidatingPackagerMti")); 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: 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: CTCSubElementPackager extends ISOBaseValidatingPackager { public byte[] pack ( ISOComponent c ) throws ISOException { try { Map tab = c.getChildren(); StringBuilder sb = new StringBuilder(); for ( int i = 0; i < fld.length; i++ ) { ISOMsg f = (ISOMsg) tab.get (i); if ( f != null ) { sb.append ( ISOUtil.zeropad( f.getKey().toString(), 2 ) + new String( fld[i].pack( f ) ) ); } } return sb.toString().getBytes(); } catch ( Exception ex ) { throw new ISOException ( this.getRealm() + ":" + ex.getMessage(), ex ); } } CTCSubElementPackager(); byte[] pack( ISOComponent c ); int unpack( ISOComponent m, byte[] b ); ISOComponent validate( ISOComponent c ); }### Answer: @Test public void testPack() throws Throwable { CTCSubElementPackager cTCSubElementPackager = new CTCSubElementPackager(); ISOFieldPackager[] fld = new ISOFieldPackager[2]; cTCSubElementPackager.setFieldPackager(fld); byte[] result = cTCSubElementPackager.pack(new ISOBinaryField()); assertEquals(0, result.length, "result.length"); } @Test public void testPack1() throws Throwable { CTCSubElementPackager cTCSubElementPackager = new CTCSubElementPackager(); ISOFieldPackager[] fld = new ISOFieldPackager[0]; cTCSubElementPackager.setFieldPackager(fld); byte[] result = cTCSubElementPackager.pack(new ISOMsg()); assertEquals(0, result.length, "result.length"); } @Test public void testPackThrowsISOException() throws Throwable { CTCSubElementPackager cTCSubElementPackager = new CTCSubElementPackager(); ISOFieldPackager[] fld = new ISOFieldPackager[2]; cTCSubElementPackager.setFieldPackager(fld); try { cTCSubElementPackager.pack(new ISOMsg("testCTCSubElementPackagerMti")); fail("Expected ISOException to be thrown"); } catch (ISOException ex) { assertEquals(ClassCastException.class, ex.getNested().getClass(), "ex.getNested().getClass()"); } } @Test public void testPackThrowsISOException1() throws Throwable { try { new CTCSubElementPackager().pack(null); fail("Expected ISOException to be thrown"); } catch (ISOException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertEquals("null:null", ex.getMessage(), "ex.getMessage()"); assertNull(ex.getNested().getMessage(), "ex.getNested().getMessage()"); } else { assertEquals("null:Cannot invoke \"org.jpos.iso.ISOComponent.getChildren()\" because \"c\" is null", ex.getMessage(), "ex.getMessage()"); assertEquals("Cannot invoke \"org.jpos.iso.ISOComponent.getChildren()\" because \"c\" is null", ex.getNested().getMessage(), "ex.getNested().getMessage()"); } } } @Test public void testPackThrowsISOException2() throws Throwable { try { new CTCSubElementPackager().pack(new ISOBinaryField(100)); fail("Expected ISOException to be thrown"); } catch (ISOException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertEquals("null:null", ex.getMessage(), "ex.getMessage()"); assertNull(ex.getNested().getMessage(), "ex.getNested().getMessage()"); } else { assertEquals("null:Cannot read the array length because \"this.fld\" is null", ex.getMessage(), "ex.getMessage()"); assertEquals("Cannot read the array length because \"this.fld\" is null", ex.getNested().getMessage(), "ex.getNested().getMessage()"); } } }
### Question: QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { @Override public void notify (Object k, Object value) { Object obj = sp.inp (k); if (obj instanceof ISOMsg) { ISOMsg m = (ISOMsg) obj; try { if (isNotifyEligible(m)) { String key = getKey (m); String req = key + ".req"; Object r = isp.inp (req); if (r != null) { if (r instanceof AsyncRequest) { ((AsyncRequest) r).responseReceived (m); } else { isp.out (key, m); } return; } } } catch (ISOException e) { LogEvent evt = getLog().createLogEvent("notify"); evt.addMessage(e); evt.addMessage(obj); Logger.log(evt); } processUnhandled (m); } } 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 testNotifyThrowsNullPointerException() throws Throwable { QMUX qMUX = new QMUX(); try { qMUX.notify("", Integer.valueOf(2)); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"org.jpos.space.LocalSpace.inp(Object)\" because \"this.sp\" is null", ex.getMessage(), "ex.getMessage()"); } assertNull(qMUX.sp, "qMUX.sp"); assertEquals(0, qMUX.listeners.size(), "qMUX.listeners.size()"); } }
### 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 { protected void setGenericPackagerParams ( Attributes atts ) { String maxField = atts.getValue( "maxValidField" ); String emitBmap = atts.getValue( "emitBitmap" ); String bmapfield = atts.getValue( "bitmapField" ); if ( maxField != null ) maxValidField = Integer.parseInt( maxField ); if ( emitBmap != null ) emitBitmap = Boolean.valueOf(emitBmap); if ( bmapfield != null ) bitmapField = Integer.parseInt( bmapfield ); } 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 testSetGenericPackagerParams() throws Throwable { Attributes atts = new AttributesImpl(); GenericValidatingPackager genericValidatingPackager = new GenericValidatingPackager(); genericValidatingPackager.setGenericPackagerParams(atts); assertEquals(1, genericValidatingPackager.bitmapField, "genericValidatingPackager.bitmapField"); assertEquals(128, genericValidatingPackager.maxValidField, "genericValidatingPackager.maxValidField"); assertTrue(genericValidatingPackager.emitBitmap, "genericValidatingPackager.emitBitmap"); assertEquals(0, atts.getLength(), "(AttributesImpl) atts.getLength()"); } @Test public void testSetGenericPackagerParamsThrowsNullPointerException() throws Throwable { GenericValidatingPackager genericValidatingPackager = new GenericValidatingPackager(); try { genericValidatingPackager.setGenericPackagerParams(null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"org.xml.sax.Attributes.getValue(String)\" because \"atts\" is null", ex.getMessage(), "ex.getMessage()"); } assertEquals(1, genericValidatingPackager.bitmapField, "genericValidatingPackager.bitmapField"); assertEquals(128, genericValidatingPackager.maxValidField, "genericValidatingPackager.maxValidField"); assertTrue(genericValidatingPackager.emitBitmap, "genericValidatingPackager.emitBitmap"); } }
### 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: QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { protected void processUnhandled (ISOMsg m) { ISOSource source = m.getSource(); source = source != null ? source : this; Iterator iter = listeners.iterator(); if (iter.hasNext()) synchronized (this) { rxForwarded++; } while (iter.hasNext()) if (((ISORequestListener)iter.next()).process (source, m)) return; if (unhandled != null) { synchronized (this) { rxUnhandled++; } sp.out (unhandled, m, 120000); } } 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 testProcessUnhandled() throws Throwable { ISOMsg m = new ISOMsg("testQMUXMti"); m.setSource(new PADChannel(new EuroSubFieldPackager())); QMUX qMUX = new QMUX(); qMUX.processUnhandled(m); assertEquals(0, qMUX.listeners.size(), "qMUX.listeners.size()"); } @Test public void testProcessUnhandled1() throws Throwable { QMUX qMUX = new QMUX(); ISOMsg m = new ISOMsg("testQMUXMti"); qMUX.processUnhandled(m); assertNull(qMUX.sp, "qMUX.sp"); assertEquals(0, qMUX.listeners.size(), "qMUX.listeners.size()"); assertEquals(0, m.getDirection(), "m.getDirection()"); } @Test public void testProcessUnhandledThrowsNullPointerException() throws Throwable { QMUX qMUX = new QMUX(); try { qMUX.processUnhandled(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.ISOMsg.getSource()\" because \"m\" is null", ex.getMessage(), "ex.getMessage()"); } assertNull(qMUX.sp, "qMUX.sp"); assertEquals(0, qMUX.listeners.size(), "qMUX.listeners.size()"); } }
### Question: CharTagMap extends HashMap<String, CharTag> { public CharTag createTLV(String tagId, String value) throws IllegalArgumentException { validateTag(tagId); int maxValueLength = (int) Math.pow(BigDecimal.TEN.doubleValue(), lenLen) - 1; if (value != null && value.length() > maxValueLength) throw new IllegalArgumentException( String.format("The value size %d of the tag '%s' has" + " exceeded the maximum allowable value %d" , value.length(), tagId, maxValueLength ) ); CharTag tag = new CharTag(tagId, value); tag.setLengthSize(lenLen); tag.withTagLengthSwap(swapTagWithLength); return tag; } static CharTagMap getInstance(); void unpack(CharSequence data); String pack(); CharTagMap addTag(String tagId, String value); CharTag createTLV(String tagId, String value); String getTagValue(String tagId); boolean hasTag(String tagId); }### Answer: @Test public void testCreateTLV() { CharTag tag = instance.createTLV("X7", "test"); assertAll( () -> assertEquals("X7", tag.getTagId()), () -> assertEquals("test", tag.getValue()), () -> assertNull(instance.getTagValue("X7")), () -> assertNull(instance.get("X7")) ); } @Test public void testCreateTLVWithNullValue() { CharTag tag = instance.createTLV("X7", null); assertAll( () -> assertEquals("X7", tag.getTagId()), () -> assertNull(tag.getValue()), () -> assertNull(instance.get("X7")) ); } @Test public void testCreateTLVWithTagIdNull() { thrown = assertThrows(IllegalArgumentException.class, () -> instance.createTLV(null, "test") ); assertEquals("Tag identifier have to be specified", thrown.getMessage()); } @Test public void testCreateTLVWithTagIdInvalidSize() { thrown = assertThrows(IllegalArgumentException.class, () -> instance.createTLV("XYZ", "test") ); assertEquals("Invalid tag 'XYZ' size: expected 2, but got 3", thrown.getMessage()); } @Test public void testCreateTLVWithValueExceededMaxSize() { thrown = assertThrows(IllegalArgumentException.class, () -> instance.createTLV("XY", ISOUtil.zeropad("", 1000)) ); assertEquals( "The value size 1000 of the tag 'XY' has exceeded the maximum allowable value 999" , thrown.getMessage() ); }
### 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: Base1_BITMAP126 extends ISOBitMapPackager { public int unpack (ISOComponent c, byte[] b, int offset) throws ISOException { int len; BitSet bmap = ISOUtil.byte2BitSet (b, offset, false); c.setValue(bmap); len = (len=bmap.size()) > 128 ? 128 : len; return len >> 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 testUnpackThrowsArrayIndexOutOfBoundsException() throws Throwable { byte[] b = new byte[0]; ISOComponent c = new ISOMsg(); try { new Base1_BITMAP126().unpack(c, b, 100); fail("Expected ArrayIndexOutOfBoundsException to be thrown"); } catch (ArrayIndexOutOfBoundsException ex) { if (isJavaVersionAtMost(JAVA_10)) { assertEquals("100", ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Index 100 out of bounds for length 0", ex.getMessage(), "ex.getMessage()"); } assertEquals(0, ((ISOMsg) c).getDirection(), "(ISOMsg) c.getDirection()"); } } @Test public void testUnpackThrowsNullPointerException() throws Throwable { Base1_BITMAP126 base1_BITMAP126 = new Base1_BITMAP126(100, "testBase1_BITMAP126Description"); ISOComponent c = new ISOBinaryField(100); try { base1_BITMAP126.unpack(c, null, 100); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot load from byte/boolean array because \"b\" is null", ex.getMessage(), "ex.getMessage()"); } assertNull(((ISOBinaryField) c).getBytes(), "(ISOBinaryField) c.getBytes()"); } }
### 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 void characters (char ch[], int start, int length) { Object obj = stk.peek(); if (obj instanceof ISOField) { ISOField f = (ISOField) obj; String value = f.getValue() + new String(ch, start, length); try { f.setValue(value); } catch (ISOException e) { try { f.setValue (e.getMessage()); } catch (ISOException ignored) { } } } else if (obj instanceof BaseHeader) { BaseHeader bh = (BaseHeader) obj; String s = new String(ch,start,length); if (bh.isAsciiEncoding()) { bh.unpack (s.getBytes()); } else { bh.unpack (ISOUtil.hex2byte (s)); } } } 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 testCharactersThrowsEmptyStackException() throws Throwable { char[] ch = new char[0]; try { new XMLPackager().characters(ch, 100, 1000); fail("Expected EmptyStackException to be thrown"); } catch (EmptyStackException ex) { assertNull(ex.getMessage(), "ex.getMessage()"); } }
### 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 void endElement (String ns, String name, String qname) throws SAXException { if (name.equals (ISOMSG_TAG)) { ISOMsg m = (ISOMsg) stk.pop(); if (stk.empty()) stk.push (m); } else if (ISOFIELD_TAG.equals (name)) { stk.pop(); } else if (HEADER_TAG.equals (name)) { BaseHeader h = (BaseHeader) stk.pop(); ISOMsg m = (ISOMsg) stk.peek (); m.setHeader (h); } } 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 testEndElementThrowsEmptyStackException() throws Throwable { try { xMLPackager.endElement("testXMLPackagerNs", "header", "testXMLPackagerQname"); fail("Expected EmptyStackException to be thrown"); } catch (EmptyStackException ex) { assertNull(ex.getMessage(), "ex.getMessage()"); } } @Test public void testEndElementThrowsEmptyStackException1() throws Throwable { try { xMLPackager.endElement("testXMLPackagerNs", "isomsg", "testXMLPackagerQname"); fail("Expected EmptyStackException to be thrown"); } catch (EmptyStackException ex) { assertNull(ex.getMessage(), "ex.getMessage()"); } } @Test public void testEndElementThrowsNullPointerException() throws Throwable { try { xMLPackager.endElement("testXMLPackagerNs", null, "testXMLPackagerQname"); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"String.equals(Object)\" because \"name\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### 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 byte[] pack (ISOComponent c) throws ISOException { LogEvent evt = new LogEvent (this, "pack"); try { if (!(c instanceof ISOMsg)) throw new ISOException ("cannot pack "+c.getClass()); ISOMsg m = (ISOMsg) c; byte[] b; synchronized (this) { m.setDirection(0); m.dump (p, ""); b = out.toByteArray(); out.reset(); } if (logger != null) evt.addMessage (m); return b; } catch (ISOException e) { evt.addMessage (e); throw e; } finally { Logger.log(evt); } } 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 testPackException() { ISOField field = new ISOField(); try { xMLPackager.pack(field); fail("Exception Expected - not an isomsg"); } catch (ISOException e) { assertThat(e.getMessage(), is("cannot pack class org.jpos.iso.ISOField")); } } @Test public void testPack() throws IOException, ISOException, SAXException { isoMsg.setMTI("0800"); isoMsg.set(7, "7654321"); isoMsg.set(11, "12345678"); isoMsg.set(12, "20110224112759"); isoMsg.set(24, ""); byte[] data = isoMsg.pack(); String expected = "<isomsg><!-- org.jpos.iso.packager.XMLPackager --><field id=\"0\" value=\"0800\"/>" + "<field id=\"7\" value=\"7654321\"/><field id=\"11\" value=\"12345678\"/>" + "<field id=\"12\" value=\"20110224112759\"/><field id=\"24\" value=\"\"/></isomsg>"; XMLUnit.setIgnoreWhitespace(true); DetailedDiff myDiff = new DetailedDiff(XMLUnit.compareXML(expected, new String(data))); List allDifferences = myDiff.getAllDifferences(); assertEquals(0, allDifferences.size(), myDiff.toString()); }
### 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: EuroSubFieldPackager extends ISOBasePackager { @Override public byte[] pack (ISOComponent c) throws ISOException { LogEvent evt = new LogEvent (this, "pack"); try (ByteArrayOutputStream bout = new ByteArrayOutputStream(100)) { Map tab = c.getChildren(); for (Entry ent : (Set<Entry>) tab.entrySet()) { Integer i = (Integer) ent.getKey(); if (i < 0) continue; if (fld[i] == null) throw new ISOException ("Unsupported sub-field " + i + " packing field " + c.getKey()); if (ent.getValue() instanceof ISOComponent) try { ISOComponent f = (ISOComponent) ent.getValue(); byte[] b = fld[i].pack(f); bout.write(b); } catch (Exception e) { evt.addMessage ("error packing subfield "+i); evt.addMessage (c); evt.addMessage (e); throw e; } } byte[] d = bout.toByteArray(); if (logger != null) evt.addMessage (ISOUtil.hexString (d)); return d; } catch (Exception ex) { throw new ISOException (ex); } } @Override byte[] pack(ISOComponent c); @Override int unpack(ISOComponent m, byte[] b); }### Answer: @Test public void testPack() throws Throwable { EuroSubFieldPackager euroSubFieldPackager = new EuroSubFieldPackager(); ISOFieldPackager[] fld = new ISOFieldPackager[4]; euroSubFieldPackager.setFieldPackager(fld); byte[] result = euroSubFieldPackager.pack(new ISOMsg(100)); assertEquals(0, result.length, "result.length"); } @Test public void testPack3() throws Throwable { EuroSubFieldPackager euroSubFieldPackager = new EuroSubFieldPackager(); ISOFieldPackager[] fld = new ISOFieldPackager[1]; euroSubFieldPackager.setFieldPackager(fld); byte[] result = euroSubFieldPackager.pack(new ISOField()); assertEquals(0, result.length, "result.length"); } @Test public void testPackThrowsISOException1() throws Throwable { try { new EuroSubFieldPackager().pack(new ISOMsg("testEuroSubFieldPackagerMti")); fail("Expected ISOException to be thrown"); } catch (ISOException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertEquals("java.lang.NullPointerException", ex.getMessage(), "ex.getMessage()"); assertNull(ex.getNested().getMessage(), "ex.getNested().getMessage()"); } else { assertEquals("java.lang.NullPointerException: Cannot load from object array because \"this.fld\" is null", ex.getMessage(), "ex.getMessage()"); assertEquals("Cannot load from object array because \"this.fld\" is null", ex.getNested().getMessage(), "ex.getNested().getMessage()"); } } } @Test public void testPackThrowsISOException2() throws Throwable { try { new EuroSubFieldPackager().pack(null); fail("Expected ISOException to be thrown"); } catch (ISOException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertEquals("java.lang.NullPointerException", ex.getMessage(), "ex.getMessage()"); assertNull(ex.getNested().getMessage(), "ex.getNested().getMessage()"); } else { assertEquals("java.lang.NullPointerException: Cannot invoke \"org.jpos.iso.ISOComponent.getChildren()\" because \"c\" is null", ex.getMessage(), "ex.getMessage()"); assertEquals("Cannot invoke \"org.jpos.iso.ISOComponent.getChildren()\" because \"c\" is null", ex.getNested().getMessage(), "ex.getNested().getMessage()"); } } }
### Question: EuroSubFieldPackager extends ISOBasePackager { @Override public int unpack (ISOComponent m, byte[] b) throws ISOException { LogEvent evt = new LogEvent (this, "unpack"); int consumed = 0; ISOComponent c = null; while (consumed < b.length) { int i = c == null && fld[0] != null ? 0 : tagPrefixer.decodeLength(b, consumed); if (i >= fld.length \|\| fld[i] == null) throw new ISOException("Unsupported sub-field " + i + " unpacking field " + m.getKey()); c = fld[i].createComponent(i); consumed += fld[i].unpack (c, b, consumed); if (logger != null) { evt.addMessage ("<unpack fld=\"" + i +"\" packager=\"" +fld[i].getClass().getName()+ "\">"); evt.addMessage (" <value>" +c.getValue().toString() + "</value>"); evt.addMessage ("</unpack>"); } m.set(c); } Logger.log (evt); return consumed; } @Override byte[] pack(ISOComponent c); @Override int unpack(ISOComponent m, byte[] b); }### Answer: @Test public void testUnpackThrowsNullPointerException() throws Throwable { byte[] b = new byte[3]; try { new EuroSubFieldPackager().unpack(new ISOBinaryField(100), b); 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()"); } } } @Test public void testUnpackThrowsNullPointerException1() throws Throwable { EuroSubFieldPackager euroSubFieldPackager = new EuroSubFieldPackager(); ISOFieldPackager[] fld = new ISOFieldPackager[4]; fld[0] = new IFB_LLLCHAR(); euroSubFieldPackager.setFieldPackager(fld); byte[] b = new byte[3]; try { euroSubFieldPackager.unpack(null, b); 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.set(org.jpos.iso.ISOComponent)\" because \"m\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### 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: QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public ISOMsg request (ISOMsg m, long timeout) throws ISOException { String key = getKey (m); String req = key + ".req"; synchronized (isp) { if (isp.rdp (req) != null) throw new ISOException ("Duplicate key '" + req + "' detected"); isp.out (req, m); } m.setDirection(0); Chronometer c = new Chronometer(); if (timeout > 0) sp.out (out, m, timeout); else sp.out (out, m); ISOMsg resp; try { synchronized (this) { tx++; rxPending++; } for (;;) { resp = (ISOMsg) isp.in (key, timeout); if (!shouldIgnore (resp)) break; } if (resp == null && isp.inp (req) == null) { resp = (ISOMsg) isp.in (key, 10000); } synchronized (this) { if (resp != null) { rx++; lastTxn = System.currentTimeMillis(); }else { rxExpired++; if (m.getDirection() != ISOMsg.OUTGOING) txExpired++; } } } finally { synchronized (this) { rxPending--; } } long elapsed = c.elapsed(); metrics.record("all", elapsed); if (resp != null) metrics.record("ok", elapsed); return resp; } 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 testRequestThrowsNullPointerException() throws Throwable { QMUX qMUX = new QMUX(); ISOMsg m = new ISOMsg("testQMUXMti"); try { qMUX.request(m, 100L); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { assertEquals("Misconfigured QMUX. Please verify out queue is not null.", ex.getMessage(), "ex.getMessage()"); assertNull(qMUX.sp, "qMUX.sp"); assertEquals(0, m.getDirection(), "m.getDirection()"); } }
### 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 String guessAutNumber (String s) { StringBuilder buf = new StringBuilder(); for (int i=0; i<s.length(); i++) if (Character.isDigit(s.charAt(i))) buf.append (s.charAt(i)); if (buf.length() == 0) return null; while (buf.length() > 6) buf.deleteCharAt(0); while (buf.length() < 6) buf.insert(0, "0"); return buf.toString(); } 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 testGuessAutNumber() throws Throwable { int[] sequence = new int[0]; String result = new VISA1Packager(sequence, 100, "testVISA1PackagerBadResultCode", "testVISA1PackagerOkPattern") .guessAutNumber("testVISA1Packagers"); assertEquals("000001", result, "result"); } @Test public void testGuessAutNumber1() throws Throwable { int[] sequence = new int[2]; String result = new VISA1Packager(sequence, 100, "testVISA1PackagerBadResultCode", "testVISA1PackagerOkPattern") .guessAutNumber(" "); assertNull(result, "result"); } @Test public void testGuessAutNumber2() throws Throwable { int[] sequence = new int[2]; String result = new VISA1Packager(sequence, 100, "testVISA1PackagerBadResultCode", "testVISA1PackagerOkPattern") .guessAutNumber(""); assertNull(result, "result"); } @Test public void testGuessAutNumber3() throws Throwable { int[] sequence = new int[1]; String result = new VISA1Packager(sequence, 100, "testVISA1PackagerBadResultCode", "testVISA1PackagerOkPattern") .guessAutNumber("1"); assertEquals("000001", result, "result"); } @Test public void testGuessAutNumberThrowsNullPointerException() throws Throwable { int[] sequence = new int[2]; try { new VISA1Packager(sequence, 100, "testVISA1PackagerBadResultCode", "testVISA1PackagerOkPattern").guessAutNumber(null); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"String.length()\" because \"s\" is null", ex.getMessage(), "ex.getMessage()"); } } }
### Question: VISA1Packager extends SimpleLogSource implements ISOPackager, VISA1ResponseFilter { protected int handleSpecialField35 (ISOMsg m, ByteArrayOutputStream bout) throws ISOException, IOException { int len = 0; byte[] entryMode = new byte[1]; if (m.hasField (35)) { entryMode[0] = (byte) '\001'; byte[] value = m.getString(35).getBytes(); bout.write(entryMode); bout.write(value); bout.write(FS); len += value.length+2; } else if (m.hasField (2) && m.hasField (14)) { entryMode[0] = (byte) '\000'; String simulatedTrack2 = m.getString(2) + "=" + m.getString(14); bout.write(entryMode); bout.write(simulatedTrack2.getBytes()); bout.write(FS); len += simulatedTrack2.length()+2; } return len; } 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: @SuppressWarnings("unchecked") @Test public void testHandleSpecialField351() throws Throwable { int[] sequence = new int[0]; VISA1Packager vISA1Packager = new VISA1Packager(sequence, 100, "testVISA1PackagerBadResultCode", "testVISA1PackagerOkPattern"); ByteArrayOutputStream bout = new ByteArrayOutputStream(100); int result = vISA1Packager.handleSpecialField35(new ISOMsg(100), bout); assertEquals(0, result, "result"); } @SuppressWarnings("unchecked") @Test public void testHandleSpecialField35ThrowsNullPointerException() throws Throwable { int[] sequence = new int[0]; VISA1Packager vISA1Packager = new VISA1Packager(sequence, 100, "testVISA1PackagerBadResultCode", "testVISA1PackagerOkPattern"); ByteArrayOutputStream bout = new ByteArrayOutputStream(100); try { vISA1Packager.handleSpecialField35(null, bout); 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.ISOMsg.hasField(int)\" because \"m\" is null", ex.getMessage(), "ex.getMessage()"); } assertEquals(0, bout.toByteArray().length); } }
### 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: QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public synchronized void setInQueue (String in) { this.in = in; getPersist().getChild("in").setText (in); setModified (true); } 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 testSetInQueueThrowsNullPointerException() throws Throwable { QMUX qMUX = new QMUX(); try { qMUX.setInQueue("testQMUXIn"); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { assertEquals("testQMUXIn", qMUX.in, "qMUX.in"); if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"org.jdom2.Element.getChild(String)\" because the return value of \"org.jpos.q2.iso.QMUX.getPersist()\" is null", ex.getMessage(), "ex.getMessage()"); } assertFalse(qMUX.isModified(), "qMUX.isModified()"); } }
### 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: QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public synchronized void setOutQueue (String out) { this.out = out; getPersist().getChild("out").setText (out); setModified (true); } 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 testSetOutQueueThrowsNullPointerException() throws Throwable { QMUX qMUX = new QMUX(); try { qMUX.setOutQueue("testQMUXOut"); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { assertEquals("testQMUXOut", qMUX.out, "qMUX.out"); if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"org.jdom2.Element.getChild(String)\" because the return value of \"org.jpos.q2.iso.QMUX.getPersist()\" is null", ex.getMessage(), "ex.getMessage()"); } assertFalse(qMUX.isModified(), "qMUX.isModified()"); } }
### 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: QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public synchronized void setUnhandledQueue (String unhandled) { this.unhandled = unhandled; getPersist().getChild("unhandled").setText (unhandled); setModified (true); } 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 testSetUnhandledQueueThrowsNullPointerException() throws Throwable { QMUX qMUX = new QMUX(); try { qMUX.setUnhandledQueue("testQMUXUnhandled"); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { assertEquals("testQMUXUnhandled", qMUX.unhandled, "qMUX.unhandled"); if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertEquals("Cannot invoke \"org.jdom2.Element.getChild(String)\" because the return value of \"org.jpos.q2.iso.QMUX.getPersist()\" is null", ex.getMessage(), "ex.getMessage()"); } assertFalse(qMUX.isModified(), "qMUX.isModified()"); } }
### 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"); }

Subsets and Splits

No community queries yet

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