target stringlengths 20 113k | src_fm stringlengths 11 86.3k | src_fm_fc stringlengths 21 86.4k | src_fm_fc_co stringlengths 30 86.4k | src_fm_fc_ms stringlengths 42 86.8k | src_fm_fc_ms_ff stringlengths 43 86.8k |
|---|---|---|---|---|---|
@Test public void testUnpadAllPadding() throws Exception { assertEquals("", padder.unpad("000")); } | 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 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 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); } | 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... | 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... |
@Test public void testPad() throws Throwable { String result = new RightTPadder(' ').pad("10Characte", 10); assertEquals("10Characte", result, "result"); } | 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 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 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); } | 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); } | 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 R... |
@Test public void testPad1() throws Throwable { String result = RightTPadder.SPACE_PADDER.pad("", 100); assertEquals(" ", result, "result"); } | 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 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 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); } | 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); } | 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 R... |
@Test public void testPad2() throws Throwable { String result = new RightTPadder(' ').pad("testRightTPadderData", 0); assertEquals("", result, "result"); } | 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 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 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); } | 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); } | 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 R... |
@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 i... | 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 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 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); } | 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); } | 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 R... |
@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 o... | 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 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 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); } | 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); } | 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 R... |
@Test public void testGetInQueue() throws Throwable { String result = new QMUX().getInQueue(); assertNull(result, "result"); } | public String getInQueue () { return in; } | QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public String getInQueue () { return in; } } | QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public String getInQueue () { return in; } QMUX(); } | 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(ISO... | 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(ISO... |
@Test public void testBuild() { CharTagMap tm = instance.withTagSize(3) .withLengthSize(2) .build(); tm.unpack("XYZ19The quick brown foxKV107Foo Bar"); assertEquals("The quick brown fox", tm.getTagValue("XYZ")); assertEquals("Foo Bar", tm.getTagValue("KV1")); String result = tm.pack(); tm.clear(); tm.unpack(result); as... | public CharTagMap build() throws IllegalArgumentException { CharTagMap tm = CharTagMap.getInstance(); if (tagSize != null) tm.setTagSize(tagSize); if (lengthSize != null) tm.setLengthSize(lengthSize); tm.withTagLengthSwap(swapTagWithLength); return tm; } | CharTagMapBuilder { public CharTagMap build() throws IllegalArgumentException { CharTagMap tm = CharTagMap.getInstance(); if (tagSize != null) tm.setTagSize(tagSize); if (lengthSize != null) tm.setLengthSize(lengthSize); tm.withTagLengthSwap(swapTagWithLength); return tm; } } | CharTagMapBuilder { public CharTagMap build() throws IllegalArgumentException { CharTagMap tm = CharTagMap.getInstance(); if (tagSize != null) tm.setTagSize(tagSize); if (lengthSize != null) tm.setLengthSize(lengthSize); tm.withTagLengthSwap(swapTagWithLength); return tm; } CharTagMapBuilder(); } | CharTagMapBuilder { public CharTagMap build() throws IllegalArgumentException { CharTagMap tm = CharTagMap.getInstance(); if (tagSize != null) tm.setTagSize(tagSize); if (lengthSize != null) tm.setLengthSize(lengthSize); tm.withTagLengthSwap(swapTagWithLength); return tm; } CharTagMapBuilder(); CharTagMapBuilder withLe... | CharTagMapBuilder { public CharTagMap build() throws IllegalArgumentException { CharTagMap tm = CharTagMap.getInstance(); if (tagSize != null) tm.setTagSize(tagSize); if (lengthSize != null) tm.setLengthSize(lengthSize); tm.withTagLengthSwap(swapTagWithLength); return tm; } CharTagMapBuilder(); CharTagMapBuilder withLe... |
@Test public void testEncode() throws Exception { byte[] b = new byte[2]; AsciiPrefixer.LL.encodeLength(21, b); TestUtils.assertEquals(new byte[]{0x32, 0x31}, b); } | @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 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 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); } } AsciiP... | 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); } } AsciiP... | 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); } } AsciiP... |
@Test public void testEncodeShortLength() throws Exception { byte[] b = new byte[2]; AsciiPrefixer.LL.encodeLength(3, b); TestUtils.assertEquals(new byte[]{0x30, 0x33}, b); } | @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 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 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); } } AsciiP... | 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); } } AsciiP... | 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); } } AsciiP... |
@Test public void testDecode() throws Exception { byte[] b = new byte[]{0x32, 0x35}; assertEquals(25, AsciiPrefixer.LL.decodeLength(b, 0)); } | @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 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'; } retu... | 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'; } retu... | 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'; } retu... | 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'; } retu... |
@Test public void testInterpret() throws Exception { byte[] b = new byte[3]; inter.interpret("123", b, 0); TestUtils.assertEquals(new byte[] {49, 50, 51}, b); } | @Override public void interpret(String data, byte[] b, int offset) { System.arraycopy(data.getBytes(ISOUtil.CHARSET), 0, b, offset, data.length()); } | AsciiInterpreter implements Interpreter { @Override public void interpret(String data, byte[] b, int offset) { System.arraycopy(data.getBytes(ISOUtil.CHARSET), 0, b, offset, data.length()); } } | AsciiInterpreter implements Interpreter { @Override public void interpret(String data, byte[] b, int offset) { System.arraycopy(data.getBytes(ISOUtil.CHARSET), 0, b, offset, data.length()); } } | 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 lengt... | 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 lengt... |
@Test public void testUninterpret() throws Exception { byte[] b = new byte[] {49, 50, 51}; assertEquals("123", inter.uninterpret(b, 0, 3)); } | @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 b... | 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( St... | 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( St... | 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( St... | 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( St... |
@Test public void testGetPackedLength() throws Exception { assertEquals(3, inter.getPackedLength(3)); } | @Override public int getPackedLength(int nDataUnits) { return nDataUnits; } | AsciiInterpreter implements Interpreter { @Override public int getPackedLength(int nDataUnits) { return nDataUnits; } } | AsciiInterpreter implements Interpreter { @Override public int getPackedLength(int nDataUnits) { return nDataUnits; } } | 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); } | 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 AsciiInter... |
@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"); } | @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.start... | 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.prin... | 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.prin... | 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.prin... | 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.prin... |
@Test public void testGetBytes() throws Throwable { ISOField iSOField = new ISOField(100); iSOField.setValue(""); byte[] result = iSOField.getBytes(); assertEquals(0, result.length, "result.length"); } | @Override public byte[] getBytes() { return value != null ? value.getBytes(ISOUtil.CHARSET) : new byte[] {}; } | ISOField extends ISOComponent implements Cloneable, Externalizable { @Override public byte[] getBytes() { return value != null ? value.getBytes(ISOUtil.CHARSET) : new byte[] {}; } } | 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); } | 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(Inp... | 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(Inp... |
@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]"); } | @Override public byte[] getBytes() { return value != null ? value.getBytes(ISOUtil.CHARSET) : new byte[] {}; } | ISOField extends ISOComponent implements Cloneable, Externalizable { @Override public byte[] getBytes() { return value != null ? value.getBytes(ISOUtil.CHARSET) : new byte[] {}; } } | 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); } | 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(Inp... | 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(Inp... |
@Test public void testGetBytesThrowsNullPointerException() throws Throwable { byte[] bytes = new ISOField(100).getBytes(); assertArrayEquals(new byte[0], bytes); } | @Override public byte[] getBytes() { return value != null ? value.getBytes(ISOUtil.CHARSET) : new byte[] {}; } | ISOField extends ISOComponent implements Cloneable, Externalizable { @Override public byte[] getBytes() { return value != null ? value.getBytes(ISOUtil.CHARSET) : new byte[] {}; } } | 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); } | 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(Inp... | 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(Inp... |
@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.getMessag... | 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.a... | 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 ('.')... | 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 ('.')... | 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 ('.')... | 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 ('.')... |
@Test public void testGetKey() throws Throwable { Integer result = (Integer) new ISOField(100).getKey(); assertEquals(100, result.intValue(), "result"); } | @Override public Object getKey() { return fieldNumber; } | ISOField extends ISOComponent implements Cloneable, Externalizable { @Override public Object getKey() { return fieldNumber; } } | ISOField extends ISOComponent implements Cloneable, Externalizable { @Override public Object getKey() { return fieldNumber; } ISOField(); ISOField(int n); ISOField(int n, String v); } | 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 Obj... | 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 Obj... |
@Test public void testGetKey1() throws Throwable { Integer result = (Integer) new ISOField(0).getKey(); assertEquals(0, result.intValue(), "result"); } | @Override public Object getKey() { return fieldNumber; } | ISOField extends ISOComponent implements Cloneable, Externalizable { @Override public Object getKey() { return fieldNumber; } } | ISOField extends ISOComponent implements Cloneable, Externalizable { @Override public Object getKey() { return fieldNumber; } ISOField(); ISOField(int n); ISOField(int n, String v); } | 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 Obj... | 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 Obj... |
@Test public void testGetValue() throws Throwable { String result = (String) new ISOField(100, "testISOFieldv").getValue(); assertEquals("testISOFieldv", result, "result"); } | @Override public Object getValue() { return value; } | ISOField extends ISOComponent implements Cloneable, Externalizable { @Override public Object getValue() { return value; } } | ISOField extends ISOComponent implements Cloneable, Externalizable { @Override public Object getValue() { return value; } ISOField(); ISOField(int n); ISOField(int n, String v); } | 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 ... | 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 ... |
@Test public void testGetValue1() throws Throwable { Object result = new ISOField(100).getValue(); assertNull(result, "result"); } | @Override public Object getValue() { return value; } | ISOField extends ISOComponent implements Cloneable, Externalizable { @Override public Object getValue() { return value; } } | ISOField extends ISOComponent implements Cloneable, Externalizable { @Override public Object getValue() { return value; } ISOField(); ISOField(int n); ISOField(int n, String v); } | 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 ... | 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 ... |
@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"); } } | @Override public byte[] pack() throws ISOException { throw new ISOException ("Not available on Leaf"); } | ISOField extends ISOComponent implements Cloneable, Externalizable { @Override public byte[] pack() throws ISOException { throw new ISOException ("Not available on Leaf"); } } | 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); } | 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(InputStre... | 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(InputStre... |
@Test public void testSetFieldNumber() throws Throwable { ISOField iSOField = new ISOField(100); iSOField.setFieldNumber(1000); assertEquals(1000, iSOField.fieldNumber, "iSOField.fieldNumber"); } | @Override public void setFieldNumber (int fieldNumber) { this.fieldNumber = fieldNumber; } | ISOField extends ISOComponent implements Cloneable, Externalizable { @Override public void setFieldNumber (int fieldNumber) { this.fieldNumber = fieldNumber; } } | ISOField extends ISOComponent implements Cloneable, Externalizable { @Override public void setFieldNumber (int fieldNumber) { this.fieldNumber = fieldNumber; } ISOField(); ISOField(int n); ISOField(int n, String v); } | 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); @Overr... | 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); @Overr... |
@Test public void testSetValue() throws Throwable { ISOField iSOField = new ISOField(100); iSOField.setValue(" W"); assertEquals(" W", iSOField.value, "iSOField.value"); } | @Override public void setValue(Object obj) throws ISOException { if (obj instanceof String) value = (String) obj; else value = obj.toString(); } | 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 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); } | 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(by... | 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(by... |
@Test public void testSetValue1() throws Throwable { ISOField iSOField = new ISOField(100); iSOField.setValue(200); assertThat("isoField setter", "200", equalTo(iSOField.value)); } | @Override public void setValue(Object obj) throws ISOException { if (obj instanceof String) value = (String) obj; else value = obj.toString(); } | 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 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); } | 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(by... | 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(by... |
@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.ne... | @Override public int unpack(byte[] b) throws ISOException { throw new ISOException ("Not available on Leaf"); } | ISOField extends ISOComponent implements Cloneable, Externalizable { @Override public int unpack(byte[] b) throws ISOException { throw new ISOException ("Not available on Leaf"); } } | 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); } | 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(In... | 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(In... |
@Test public void testWriteExternal() throws Throwable { ObjectOutput out = new ObjectOutputStream(new ByteArrayOutputStream()); new ISOVField(new ISOField(100, "testISOFieldv"), new ISOVError("testISOFieldDescription", "testISOFieldRejectCode")) .writeExternal(out); } | @Override public void writeExternal (ObjectOutput out) throws IOException { out.writeShort (fieldNumber); out.writeUTF (value); } | ISOField extends ISOComponent implements Cloneable, Externalizable { @Override public void writeExternal (ObjectOutput out) throws IOException { out.writeShort (fieldNumber); out.writeUTF (value); } } | 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); } | 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); @Overr... | 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); @Overr... |
@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()"); } } | public static MUX getMUX (String name) throws NameRegistrar.NotFoundException { return (MUX) NameRegistrar.get ("mux."+name); } | 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 extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public static MUX getMUX (String name) throws NameRegistrar.NotFoundException { return (MUX) NameRegistrar.get ("mux."+name); } QMUX(); } | 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(); sta... | 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(); sta... |
@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))... | @Override public void writeExternal (ObjectOutput out) throws IOException { out.writeShort (fieldNumber); out.writeUTF (value); } | ISOField extends ISOComponent implements Cloneable, Externalizable { @Override public void writeExternal (ObjectOutput out) throws IOException { out.writeShort (fieldNumber); out.writeUTF (value); } } | 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); } | 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); @Overr... | 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); @Overr... |
@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 { assertEqua... | @Override public void writeExternal (ObjectOutput out) throws IOException { out.writeShort (fieldNumber); out.writeUTF (value); } | ISOField extends ISOComponent implements Cloneable, Externalizable { @Override public void writeExternal (ObjectOutput out) throws IOException { out.writeShort (fieldNumber); out.writeUTF (value); } } | 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); } | 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); @Overr... | 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); @Overr... |
@Test public void testDecodeLength() throws Throwable { byte[] b = new byte[2]; int result = NullPrefixer.INSTANCE.decodeLength(b, 100); assertEquals(-1, result, "result"); } | @Override public int decodeLength(byte[] b, int offset) { return -1; } | NullPrefixer implements Prefixer { @Override public int decodeLength(byte[] b, int offset) { return -1; } } | NullPrefixer implements Prefixer { @Override public int decodeLength(byte[] b, int offset) { return -1; } private NullPrefixer(); } | 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(); } | 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; } |
@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()"); } | @Override public void encodeLength(int length, byte[] b) {} | NullPrefixer implements Prefixer { @Override public void encodeLength(int length, byte[] b) {} } | NullPrefixer implements Prefixer { @Override public void encodeLength(int length, byte[] b) {} private NullPrefixer(); } | 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(); } | 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; } |
@Test public void testGetPackedLength() throws Throwable { int result = NullPrefixer.INSTANCE.getPackedLength(); assertEquals(0, result, "result"); } | @Override public int getPackedLength() { return 0; } | NullPrefixer implements Prefixer { @Override public int getPackedLength() { return 0; } } | NullPrefixer implements Prefixer { @Override public int getPackedLength() { return 0; } private NullPrefixer(); } | 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(); } | 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; } |
@Test public void testGetAlphaCode() throws Throwable { String result = new Currency("testCurrencyAlphacode", 100, 1000).getAlphaCode(); assertEquals("testCurrencyAlphacode", result, "result"); } | public String getAlphaCode() { return alphacode; } | Currency implements Serializable { public String getAlphaCode() { return alphacode; } } | Currency implements Serializable { public String getAlphaCode() { return alphacode; } Currency(String alphacode, int isocode, int numdecimals); } | 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 toStri... | 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 toStri... |
@Test public void testGetDecimals() throws Throwable { int result = new Currency("testCurrencyAlphacode", 100, 0).getDecimals(); assertEquals(0, result, "result"); } | public int getDecimals() { return numdecimals; } | Currency implements Serializable { public int getDecimals() { return numdecimals; } } | Currency implements Serializable { public int getDecimals() { return numdecimals; } Currency(String alphacode, int isocode, int numdecimals); } | 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... | 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... |
@Test public void testGetDecimals1() throws Throwable { int result = new Currency("testCurrencyAlphacode", 100, 1000).getDecimals(); assertEquals(1000, result, "result"); } | public int getDecimals() { return numdecimals; } | Currency implements Serializable { public int getDecimals() { return numdecimals; } } | Currency implements Serializable { public int getDecimals() { return numdecimals; } Currency(String alphacode, int isocode, int numdecimals); } | 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... | 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... |
@Test public void testGetIsoCode() throws Throwable { int result = new Currency("testCurrencyAlphacode", 0, 100).getIsoCode(); assertEquals(0, result, "result"); } | public int getIsoCode() { return isocode; } | Currency implements Serializable { public int getIsoCode() { return isocode; } } | Currency implements Serializable { public int getIsoCode() { return isocode; } Currency(String alphacode, int isocode, int numdecimals); } | 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(); } | 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(); ... |
@Test public void testGetIsoCode1() throws Throwable { int result = new Currency("testCurrencyAlphacode", 100, 1000).getIsoCode(); assertEquals(100, result, "result"); } | public int getIsoCode() { return isocode; } | Currency implements Serializable { public int getIsoCode() { return isocode; } } | Currency implements Serializable { public int getIsoCode() { return isocode; } Currency(String alphacode, int isocode, int numdecimals); } | 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(); } | 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(); ... |
@Test public void testGetOutQueue() throws Throwable { String result = new QMUX().getOutQueue(); assertNull(result, "result"); } | public String getOutQueue () { return out; } | QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public String getOutQueue () { return out; } } | QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public String getOutQueue () { return out; } QMUX(); } | 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(I... | 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(I... |
@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"); } | protected boolean emitBitMap() { return fld[0] instanceof ISOBitMapPackager; } | Base1SubFieldPackager extends ISOBasePackager { protected boolean emitBitMap() { return fld[0] instanceof ISOBitMapPackager; } } | Base1SubFieldPackager extends ISOBasePackager { protected boolean emitBitMap() { return fld[0] instanceof ISOBitMapPackager; } } | Base1SubFieldPackager extends ISOBasePackager { protected boolean emitBitMap() { return fld[0] instanceof ISOBitMapPackager; } int unpack(ISOComponent m, byte[] b); @Override byte[] pack(ISOComponent m); } | Base1SubFieldPackager extends ISOBasePackager { protected boolean emitBitMap() { return fld[0] instanceof ISOBitMapPackager; } int unpack(ISOComponent m, byte[] b); @Override byte[] pack(ISOComponent m); } |
@Test public void testEmitBitMapThrowsArrayIndexOutOfBoundsException() throws Throwable { Base1SubFieldPackager f126Packager = new Base1Packager.F126Packager(); ISOFieldPackager[] fld = new ISOFieldPackager[0]; f126Packager.setFieldPackager(fld); try { f126Packager.emitBitMap(); fail("Expected ArrayIndexOutOfBoundsExce... | protected boolean emitBitMap() { return fld[0] instanceof ISOBitMapPackager; } | Base1SubFieldPackager extends ISOBasePackager { protected boolean emitBitMap() { return fld[0] instanceof ISOBitMapPackager; } } | Base1SubFieldPackager extends ISOBasePackager { protected boolean emitBitMap() { return fld[0] instanceof ISOBitMapPackager; } } | Base1SubFieldPackager extends ISOBasePackager { protected boolean emitBitMap() { return fld[0] instanceof ISOBitMapPackager; } int unpack(ISOComponent m, byte[] b); @Override byte[] pack(ISOComponent m); } | Base1SubFieldPackager extends ISOBasePackager { protected boolean emitBitMap() { return fld[0] instanceof ISOBitMapPackager; } int unpack(ISOComponent m, byte[] b); @Override byte[] pack(ISOComponent m); } |
@Test public void testGetBitMapfieldPackager() throws Throwable { Base1SubFieldPackager f126Packager = new Base1Packager.F126Packager(); Base1_BITMAP126 result = (Base1_BITMAP126) f126Packager.getBitMapfieldPackager(); assertEquals(2, result.getMaxPackedLength(), "result.getMaxPackedLength()"); } | protected ISOFieldPackager getBitMapfieldPackager() { return fld[0]; } | Base1SubFieldPackager extends ISOBasePackager { protected ISOFieldPackager getBitMapfieldPackager() { return fld[0]; } } | Base1SubFieldPackager extends ISOBasePackager { protected ISOFieldPackager getBitMapfieldPackager() { return fld[0]; } } | Base1SubFieldPackager extends ISOBasePackager { protected ISOFieldPackager getBitMapfieldPackager() { return fld[0]; } int unpack(ISOComponent m, byte[] b); @Override byte[] pack(ISOComponent m); } | Base1SubFieldPackager extends ISOBasePackager { protected ISOFieldPackager getBitMapfieldPackager() { return fld[0]; } int unpack(ISOComponent m, byte[] b); @Override byte[] pack(ISOComponent m); } |
@Test public void testGetBitMapfieldPackagerThrowsNullPointerException() throws Throwable { Base1SubFieldPackager base1SubFieldPackager = new Base1SubFieldPackager(); try { base1SubFieldPackager.getBitMapfieldPackager(); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaV... | protected ISOFieldPackager getBitMapfieldPackager() { return fld[0]; } | Base1SubFieldPackager extends ISOBasePackager { protected ISOFieldPackager getBitMapfieldPackager() { return fld[0]; } } | Base1SubFieldPackager extends ISOBasePackager { protected ISOFieldPackager getBitMapfieldPackager() { return fld[0]; } } | Base1SubFieldPackager extends ISOBasePackager { protected ISOFieldPackager getBitMapfieldPackager() { return fld[0]; } int unpack(ISOComponent m, byte[] b); @Override byte[] pack(ISOComponent m); } | Base1SubFieldPackager extends ISOBasePackager { protected ISOFieldPackager getBitMapfieldPackager() { return fld[0]; } int unpack(ISOComponent m, byte[] b); @Override byte[] pack(ISOComponent m); } |
@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 = base1SubFi... | protected int getFirstField() { return fld[0] instanceof ISOBitMapPackager ? 1 : 0; } | Base1SubFieldPackager extends ISOBasePackager { protected int getFirstField() { return fld[0] instanceof ISOBitMapPackager ? 1 : 0; } } | Base1SubFieldPackager extends ISOBasePackager { protected int getFirstField() { return fld[0] instanceof ISOBitMapPackager ? 1 : 0; } } | Base1SubFieldPackager extends ISOBasePackager { protected int getFirstField() { return fld[0] instanceof ISOBitMapPackager ? 1 : 0; } int unpack(ISOComponent m, byte[] b); @Override byte[] pack(ISOComponent m); } | Base1SubFieldPackager extends ISOBasePackager { protected int getFirstField() { return fld[0] instanceof ISOBitMapPackager ? 1 : 0; } int unpack(ISOComponent m, byte[] b); @Override byte[] pack(ISOComponent m); } |
@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"); } | protected int getFirstField() { return fld[0] instanceof ISOBitMapPackager ? 1 : 0; } | Base1SubFieldPackager extends ISOBasePackager { protected int getFirstField() { return fld[0] instanceof ISOBitMapPackager ? 1 : 0; } } | Base1SubFieldPackager extends ISOBasePackager { protected int getFirstField() { return fld[0] instanceof ISOBitMapPackager ? 1 : 0; } } | Base1SubFieldPackager extends ISOBasePackager { protected int getFirstField() { return fld[0] instanceof ISOBitMapPackager ? 1 : 0; } int unpack(ISOComponent m, byte[] b); @Override byte[] pack(ISOComponent m); } | Base1SubFieldPackager extends ISOBasePackager { protected int getFirstField() { return fld[0] instanceof ISOBitMapPackager ? 1 : 0; } int unpack(ISOComponent m, byte[] b); @Override byte[] pack(ISOComponent m); } |
@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_... | protected int getFirstField() { return fld[0] instanceof ISOBitMapPackager ? 1 : 0; } | Base1SubFieldPackager extends ISOBasePackager { protected int getFirstField() { return fld[0] instanceof ISOBitMapPackager ? 1 : 0; } } | Base1SubFieldPackager extends ISOBasePackager { protected int getFirstField() { return fld[0] instanceof ISOBitMapPackager ? 1 : 0; } } | Base1SubFieldPackager extends ISOBasePackager { protected int getFirstField() { return fld[0] instanceof ISOBitMapPackager ? 1 : 0; } int unpack(ISOComponent m, byte[] b); @Override byte[] pack(ISOComponent m); } | Base1SubFieldPackager extends ISOBasePackager { protected int getFirstField() { return fld[0] instanceof ISOBitMapPackager ? 1 : 0; } int unpack(ISOComponent m, byte[] b); @Override byte[] pack(ISOComponent m); } |
@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... | 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 ... | 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)); i... | 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)); i... | 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)); i... | 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)); i... |
@Test public void testEmitBitMap() throws Throwable { X92GenericPackager x92GenericPackager = new X92GenericPackager(); boolean result = x92GenericPackager.emitBitMap(); assertTrue(result, "result"); } | protected boolean emitBitMap () { return true; } | X92GenericPackager extends GenericPackager { protected boolean emitBitMap () { return true; } } | X92GenericPackager extends GenericPackager { protected boolean emitBitMap () { return true; } X92GenericPackager(); X92GenericPackager(String filename); X92GenericPackager(InputStream stream); } | X92GenericPackager extends GenericPackager { protected boolean emitBitMap () { return true; } X92GenericPackager(); X92GenericPackager(String filename); X92GenericPackager(InputStream stream); } | X92GenericPackager extends GenericPackager { protected boolean emitBitMap () { return true; } X92GenericPackager(); X92GenericPackager(String filename); X92GenericPackager(InputStream stream); } |
@Test public void testGetBitMapfieldPackager() throws Throwable { X92GenericPackager x92GenericPackager = new X92GenericPackager(); X92_BITMAP result = (X92_BITMAP) x92GenericPackager.getBitMapfieldPackager(); assertEquals(4, result.getMaxPackedLength(), "result.getMaxPackedLength()"); } | protected ISOFieldPackager getBitMapfieldPackager() { return bitMapPackager; } | X92GenericPackager extends GenericPackager { protected ISOFieldPackager getBitMapfieldPackager() { return bitMapPackager; } } | X92GenericPackager extends GenericPackager { protected ISOFieldPackager getBitMapfieldPackager() { return bitMapPackager; } X92GenericPackager(); X92GenericPackager(String filename); X92GenericPackager(InputStream stream); } | X92GenericPackager extends GenericPackager { protected ISOFieldPackager getBitMapfieldPackager() { return bitMapPackager; } X92GenericPackager(); X92GenericPackager(String filename); X92GenericPackager(InputStream stream); } | X92GenericPackager extends GenericPackager { protected ISOFieldPackager getBitMapfieldPackager() { return bitMapPackager; } X92GenericPackager(); X92GenericPackager(String filename); X92GenericPackager(InputStream stream); } |
@Test public void testGetUnhandledQueue() throws Throwable { String result = new QMUX().getUnhandledQueue(); assertNull(result, "result"); } | public String getUnhandledQueue () { return unhandled; } | QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public String getUnhandledQueue () { return unhandled; } } | QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public String getUnhandledQueue () { return unhandled; } QMUX(); } | 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); vo... | 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); vo... |
@Test public void testGetMaxValidField() throws Throwable { X92GenericPackager x92GenericPackager = new X92GenericPackager(); int result = x92GenericPackager.getMaxValidField(); assertEquals(64, result, "result"); } | protected int getMaxValidField() { return 64; } | X92GenericPackager extends GenericPackager { protected int getMaxValidField() { return 64; } } | X92GenericPackager extends GenericPackager { protected int getMaxValidField() { return 64; } X92GenericPackager(); X92GenericPackager(String filename); X92GenericPackager(InputStream stream); } | X92GenericPackager extends GenericPackager { protected int getMaxValidField() { return 64; } X92GenericPackager(); X92GenericPackager(String filename); X92GenericPackager(InputStream stream); } | X92GenericPackager extends GenericPackager { protected int getMaxValidField() { return 64; } X92GenericPackager(); X92GenericPackager(String filename); X92GenericPackager(InputStream stream); } |
@Test public void testEmitBitMap() throws Throwable { CTCSubFieldPackager cTCSubFieldPackager = new CTCSubFieldPackager(); boolean result = cTCSubFieldPackager.emitBitMap(); assertFalse(result, "result"); } | protected boolean emitBitMap() { return false; } | CTCSubFieldPackager extends ISOBaseValidatingPackager { protected boolean emitBitMap() { return false; } } | CTCSubFieldPackager extends ISOBaseValidatingPackager { protected boolean emitBitMap() { return false; } CTCSubFieldPackager(); } | CTCSubFieldPackager extends ISOBaseValidatingPackager { protected boolean emitBitMap() { return false; } CTCSubFieldPackager(); byte[] pack( ISOComponent c ); int unpack( ISOComponent m, byte[] b ); ISOComponent validate( ISOComponent c ); } | CTCSubFieldPackager extends ISOBaseValidatingPackager { protected boolean emitBitMap() { return false; } CTCSubFieldPackager(); byte[] pack( ISOComponent c ); int unpack( ISOComponent m, byte[] b ); ISOComponent validate( ISOComponent c ); } |
@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"); } | 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... | 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].pac... | 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].pac... | 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].pac... | 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].pac... |
@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()... | 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... | 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].pac... | 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].pac... | 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].pac... | 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].pac... |
@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.getN... | 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... | 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].pac... | 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].pac... | 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].pac... | 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].pac... |
@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 IS... | 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... | 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].pac... | 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].pac... | 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].pac... | 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].pac... |
@Test public void testUnpack() throws Throwable { byte[] b = new byte[0]; int result = new CTCSubFieldPackager().unpack(new ISOField(), b); assertEquals(0, result, "result"); } | 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... | 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, cons... | 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, cons... | 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, cons... | 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, cons... |
@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[... | 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... | 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, cons... | 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, cons... | 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, cons... | 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, cons... |
@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... | 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... | 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, cons... | 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, cons... | 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, cons... | 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, cons... |
@Test public void testUnpackThrowsNullPointerException2() throws Throwable { assertThrows(NullPointerException.class, () -> { new CTCSubFieldPackager().unpack(new ISOBinaryField(100), (byte[]) null); }); } | 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... | 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, cons... | 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, cons... | 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, cons... | 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, cons... |
@Test public void testInitServiceWithoutListeners() throws Throwable { QMUX mux = new QMUX(); Configuration cfg = new SimpleConfiguration(); mux.setConfiguration(cfg); Element persist = new Element("testQMUXName"); persist.addContent(new Element("in").addContent("queue-in")); persist.addContent(new Element("out").addCo... | public void initService () throws ConfigurationException { Element e = getPersist (); sp = grabSpace (e.getChild ("space")); isp = cfg.getBoolean("reuse-space", false) ? sp : new TSpace(); in = Environment.get(e.getChildTextTrim ("in")); out = Environment.get(e.getChildTextTrim ("out")); if (in == null || out == null) ... | QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public void initService () throws ConfigurationException { Element e = getPersist (); sp = grabSpace (e.getChild ("space")); isp = cfg.getBoolean("reuse-space", false) ? sp : new TSpace(); in = Environment.get(e.getChildTex... | QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public void initService () throws ConfigurationException { Element e = getPersist (); sp = grabSpace (e.getChild ("space")); isp = cfg.getBoolean("reuse-space", false) ? sp : new TSpace(); in = Environment.get(e.getChildTex... | QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public void initService () throws ConfigurationException { Element e = getPersist (); sp = grabSpace (e.getChild ("space")); isp = cfg.getBoolean("reuse-space", false) ? sp : new TSpace(); in = Environment.get(e.getChildTex... | QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public void initService () throws ConfigurationException { Element e = getPersist (); sp = grabSpace (e.getChild ("space")); isp = cfg.getBoolean("reuse-space", false) ? sp : new TSpace(); in = Environment.get(e.getChildTex... |
@Test public void testValidateThrowsNullPointerException1() throws Throwable { assertThrows(NullPointerException.class, () -> { new CTCSubFieldPackager().validate(null); }); } | 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 ( IS... | 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.... | 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.... | 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.... | 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.... |
@Test public void testValidateThrowsNullPointerException2() throws Throwable { assertThrows(NullPointerException.class, () -> { new CTCSubFieldPackager().validate(new ISOMsg()); }); } | 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 ( IS... | 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.... | 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.... | 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.... | 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.... |
@Test public void testValidateThrowsNullPointerException3() throws Throwable { assertThrows(NullPointerException.class, () -> { CTCSubFieldPackager cTCSubFieldPackager = new CTCSubFieldPackager(); cTCSubFieldPackager.setLogger(Logger.getLogger(""), "testCTCSubFieldPackagerRealm"); ISOValidator[] fvlds = new ISOValidato... | 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 ( IS... | 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.... | 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.... | 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.... | 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.... |
@Test public void testEmitBitMap() throws Throwable { GenericPackager genericPackager = new GenericPackager(); boolean result = genericPackager.emitBitMap(); assertTrue(result, "result"); } | @Override protected boolean emitBitMap() { return emitBitmap; } | GenericPackager extends ISOBasePackager implements Configurable { @Override protected boolean emitBitMap() { return emitBitmap; } } | GenericPackager extends ISOBasePackager implements Configurable { @Override protected boolean emitBitMap() { return emitBitmap; } GenericPackager(); GenericPackager(String filename); GenericPackager(InputStream input); } | 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... | 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... |
@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 = genericPackag... | @Override protected ISOFieldPackager getBitMapfieldPackager() { return fld[bitmapField]; } | GenericPackager extends ISOBasePackager implements Configurable { @Override protected ISOFieldPackager getBitMapfieldPackager() { return fld[bitmapField]; } } | GenericPackager extends ISOBasePackager implements Configurable { @Override protected ISOFieldPackager getBitMapfieldPackager() { return fld[bitmapField]; } GenericPackager(); GenericPackager(String filename); GenericPackager(InputStream input); } | 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)... | 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)... |
@Test public void testGetBitMapfieldPackagerThrowsArrayIndexOutOfBoundsException() throws Throwable { ISOFieldPackager[] fld = new ISOFieldPackager[0]; GenericPackager genericPackager = new GenericPackager(); genericPackager.setFieldPackager(fld); try { genericPackager.getBitMapfieldPackager(); fail("Expected ArrayInde... | @Override protected ISOFieldPackager getBitMapfieldPackager() { return fld[bitmapField]; } | GenericPackager extends ISOBasePackager implements Configurable { @Override protected ISOFieldPackager getBitMapfieldPackager() { return fld[bitmapField]; } } | GenericPackager extends ISOBasePackager implements Configurable { @Override protected ISOFieldPackager getBitMapfieldPackager() { return fld[bitmapField]; } GenericPackager(); GenericPackager(String filename); GenericPackager(InputStream input); } | 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)... | 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)... |
@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)) {... | @Override protected ISOFieldPackager getBitMapfieldPackager() { return fld[bitmapField]; } | GenericPackager extends ISOBasePackager implements Configurable { @Override protected ISOFieldPackager getBitMapfieldPackager() { return fld[bitmapField]; } } | GenericPackager extends ISOBasePackager implements Configurable { @Override protected ISOFieldPackager getBitMapfieldPackager() { return fld[bitmapField]; } GenericPackager(); GenericPackager(String filename); GenericPackager(InputStream input); } | 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)... | 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)... |
@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(); asse... | @Override protected int getFirstField() { if (firstField != null) return Integer.parseInt (firstField); else return super.getFirstField(); } | GenericPackager extends ISOBasePackager implements Configurable { @Override protected int getFirstField() { if (firstField != null) return Integer.parseInt (firstField); else return super.getFirstField(); } } | 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); } | 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(... | 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(... |
@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"); } | @Override protected int getFirstField() { if (firstField != null) return Integer.parseInt (firstField); else return super.getFirstField(); } | GenericPackager extends ISOBasePackager implements Configurable { @Override protected int getFirstField() { if (firstField != null) return Integer.parseInt (firstField); else return super.getFirstField(); } } | 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); } | 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(... | 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(... |
@Test public void testGetFirstFieldThrowsArrayIndexOutOfBoundsException() throws Throwable { GenericPackager genericValidatingPackager = new GenericValidatingPackager(); ISOFieldPackager[] fld = new ISOFieldPackager[1]; genericValidatingPackager.setFieldPackager(fld); assertEquals(0, genericValidatingPackager.getFirstF... | @Override protected int getFirstField() { if (firstField != null) return Integer.parseInt (firstField); else return super.getFirstField(); } | GenericPackager extends ISOBasePackager implements Configurable { @Override protected int getFirstField() { if (firstField != null) return Integer.parseInt (firstField); else return super.getFirstField(); } } | 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); } | 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(... | 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(... |
@Test public void testInitServiceThrowsNullPointerException() throws Throwable { assertThrows(NullPointerException.class, () -> { QMUX qMUX = new QMUX(); qMUX.setPersist(new Element("testQMUXName", "testQMUXUri")); qMUX.initService(); }); } | public void initService () throws ConfigurationException { Element e = getPersist (); sp = grabSpace (e.getChild ("space")); isp = cfg.getBoolean("reuse-space", false) ? sp : new TSpace(); in = Environment.get(e.getChildTextTrim ("in")); out = Environment.get(e.getChildTextTrim ("out")); if (in == null || out == null) ... | QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public void initService () throws ConfigurationException { Element e = getPersist (); sp = grabSpace (e.getChild ("space")); isp = cfg.getBoolean("reuse-space", false) ? sp : new TSpace(); in = Environment.get(e.getChildTex... | QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public void initService () throws ConfigurationException { Element e = getPersist (); sp = grabSpace (e.getChild ("space")); isp = cfg.getBoolean("reuse-space", false) ? sp : new TSpace(); in = Environment.get(e.getChildTex... | QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public void initService () throws ConfigurationException { Element e = getPersist (); sp = grabSpace (e.getChild ("space")); isp = cfg.getBoolean("reuse-space", false) ? sp : new TSpace(); in = Environment.get(e.getChildTex... | QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public void initService () throws ConfigurationException { Element e = getPersist (); sp = grabSpace (e.getChild ("space")); isp = cfg.getBoolean("reuse-space", false) ? sp : new TSpace(); in = Environment.get(e.getChildTex... |
@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.get... | @Override protected int getFirstField() { if (firstField != null) return Integer.parseInt (firstField); else return super.getFirstField(); } | GenericPackager extends ISOBasePackager implements Configurable { @Override protected int getFirstField() { if (firstField != null) return Integer.parseInt (firstField); else return super.getFirstField(); } } | 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); } | 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(... | 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(... |
@Test public void testGetMaxValidField() throws Throwable { GenericPackager genericPackager = new GenericPackager(); int result = genericPackager.getMaxValidField(); assertEquals(128, result, "result"); } | @Override protected int getMaxValidField() { return maxValidField; } | GenericPackager extends ISOBasePackager implements Configurable { @Override protected int getMaxValidField() { return maxValidField; } } | GenericPackager extends ISOBasePackager implements Configurable { @Override protected int getMaxValidField() { return maxValidField; } GenericPackager(); GenericPackager(String filename); GenericPackager(InputStream input); } | 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(InputS... | 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(InputS... |
@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()... | 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) { th... | 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... | 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... | 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... | 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... |
@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()"); } } | 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) { th... | 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... | 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... | 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... | 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... |
@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"); } c... | 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.... | 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... | 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... | 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... | 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... |
@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 (Nul... | 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.... | 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... | 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... | 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... | 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... |
@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()"); assert... | @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().pac... | 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... | 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... | 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... | 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... |
@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... | @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().pac... | 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... | 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... | 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... | 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... |
@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 { ... | @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().pac... | 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... | 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... | 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... | 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... |
@Test public void testUnpackThrowsISOException() throws Throwable { ISOFieldPackager[] fld = new ISOFieldPackager[0]; GenericSubFieldPackager genericSubFieldPackager = new GenericSubFieldPackager(); genericSubFieldPackager.setFieldPackager(fld); byte[] b = new byte[2]; try { genericSubFieldPackager.unpack(new ISOMsg(),... | @Override 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 (b.length == 0) return 0; if (logger != null) evt.addMessage (ISOUtil.hexString (b)); int consum... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... |
@Test public void testInitServiceThrowsNullPointerException2() throws Throwable { QMUX qMUX = new QMUX(); try { qMUX.initService(); fail("Expected NullPointerException to be thrown"); } catch (NullPointerException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertNull(ex.getMessage(), "ex.getMessage()"); } else { assertE... | public void initService () throws ConfigurationException { Element e = getPersist (); sp = grabSpace (e.getChild ("space")); isp = cfg.getBoolean("reuse-space", false) ? sp : new TSpace(); in = Environment.get(e.getChildTextTrim ("in")); out = Environment.get(e.getChildTextTrim ("out")); if (in == null || out == null) ... | QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public void initService () throws ConfigurationException { Element e = getPersist (); sp = grabSpace (e.getChild ("space")); isp = cfg.getBoolean("reuse-space", false) ? sp : new TSpace(); in = Environment.get(e.getChildTex... | QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public void initService () throws ConfigurationException { Element e = getPersist (); sp = grabSpace (e.getChild ("space")); isp = cfg.getBoolean("reuse-space", false) ? sp : new TSpace(); in = Environment.get(e.getChildTex... | QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public void initService () throws ConfigurationException { Element e = getPersist (); sp = grabSpace (e.getChild ("space")); isp = cfg.getBoolean("reuse-space", false) ? sp : new TSpace(); in = Environment.get(e.getChildTex... | QMUX extends QBeanSupport implements SpaceListener, MUX, QMUXMBean, Loggeable, MetricsProvider { public void initService () throws ConfigurationException { Element e = getPersist (); sp = grabSpace (e.getChild ("space")); isp = cfg.getBoolean("reuse-space", false) ? sp : new TSpace(); in = Environment.get(e.getChildTex... |
@Test public void testUnpackThrowsISOException1() throws Throwable { byte[] b = new byte[2]; try { new GenericSubFieldPackager().unpack(new ISOMsg(), b); fail("Expected ISOException to be thrown"); } catch (ISOException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertEquals("java.lang.NullPointerException", ex.getMessa... | @Override 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 (b.length == 0) return 0; if (logger != null) evt.addMessage (ISOUtil.hexString (b)); int consum... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... |
@Test public void testUnpackThrowsISOException2() throws Throwable { ISOFieldPackager[] fld = new ISOFieldPackager[2]; fld[1] = new IFA_LCHAR(0, "testGenericSubFieldPackagerDescription"); GenericSubFieldPackager genericSubFieldPackager = new GenericSubFieldPackager(); genericSubFieldPackager.setFieldPackager(fld); byte... | @Override 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 (b.length == 0) return 0; if (logger != null) evt.addMessage (ISOUtil.hexString (b)); int consum... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... |
@Test public void testUnpackThrowsISOException3() throws Throwable { GenericSubFieldPackager genericSubFieldPackager = new GenericSubFieldPackager(); genericSubFieldPackager.setLogger(new Logger(), "testGenericSubFieldPackagerRealm"); try { genericSubFieldPackager.unpack(new ISOMsg(), (byte[]) null); fail("Expected ISO... | @Override 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 (b.length == 0) return 0; if (logger != null) evt.addMessage (ISOUtil.hexString (b)); int consum... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... |
@Test public void testUnpackThrowsISOException4() throws Throwable { byte[] b = new byte[0]; try { new GenericSubFieldPackager().unpack(null, b); fail("Expected ISOException to be thrown"); } catch (ISOException ex) { if (isJavaVersionAtMost(JAVA_14)) { assertEquals("java.lang.NullPointerException", ex.getMessage(), "e... | @Override 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 (b.length == 0) return 0; if (logger != null) evt.addMessage (ISOUtil.hexString (b)); int consum... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... |
@Test public void testUnpackThrowsISOException5() throws Throwable { byte[] b = new byte[2]; try { new GenericSubFieldPackager().unpack(new ISOBinaryField(), b); fail("Expected ISOException to be thrown"); } catch (ISOException ex) { assertEquals("Can't call packager on non Composite", ex.getMessage(), "ex.getMessage()... | @Override 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 (b.length == 0) return 0; if (logger != null) evt.addMessage (ISOUtil.hexString (b)); int consum... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... |
@Test public void testReturnsZero() throws Throwable { byte[] b = new byte[0]; GenericSubFieldPackager genericSubFieldPackager = new GenericSubFieldPackager(); genericSubFieldPackager.setLogger(new Logger(), "testGenericSubFieldPackagerRealm"); int l = genericSubFieldPackager.unpack(new ISOMsg("testGenericSubFieldPacka... | @Override 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 (b.length == 0) return 0; if (logger != null) evt.addMessage (ISOUtil.hexString (b)); int consum... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... |
@Test public void testUnpackReturnsZero1() throws Throwable { byte[] b = new byte[0]; ISOFieldPackager[] fld = new ISOFieldPackager[0]; GenericSubFieldPackager genericSubFieldPackager = new GenericSubFieldPackager(); genericSubFieldPackager.setFieldPackager(fld); genericSubFieldPackager.setLogger(new Logger(), "testGen... | @Override 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 (b.length == 0) return 0; if (logger != null) evt.addMessage (ISOUtil.hexString (b)); int consum... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... |
@Test public void testUnpackThrowsISOException8() throws Throwable { ISOFieldPackager[] fld = new ISOFieldPackager[2]; fld[1] = new IFA_LLLLCHAR(); GenericSubFieldPackager genericSubFieldPackager = new GenericSubFieldPackager(); genericSubFieldPackager.setFieldPackager(fld); genericSubFieldPackager.setLogger(new Logger... | @Override 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 (b.length == 0) return 0; if (logger != null) evt.addMessage (ISOUtil.hexString (b)); int consum... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... | GenericSubFieldPackager extends GenericPackager implements ISOSubFieldPackager { @Override 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 (b.length == 0)... |
@Test public void testSetFieldValidator() throws Throwable { ISOValidator[] fvlds = new ISOValidator[1]; ISOBaseValidatingPackager cTCSubElementPackager = new CTCSubElementPackager(); cTCSubElementPackager.setFieldValidator(fvlds); assertSame(fvlds, ((CTCSubElementPackager) cTCSubElementPackager).fldVld, "(CTCSubElemen... | public void setFieldValidator( ISOValidator[] fvlds ){ this.fldVld = fvlds; } | ISOBaseValidatingPackager extends ISOBasePackager implements ISOValidator { public void setFieldValidator( ISOValidator[] fvlds ){ this.fldVld = fvlds; } } | ISOBaseValidatingPackager extends ISOBasePackager implements ISOValidator { public void setFieldValidator( ISOValidator[] fvlds ){ this.fldVld = fvlds; } ISOBaseValidatingPackager(); } | 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 )... | 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 )... |
@Test public void testSetMsgValidator() throws Throwable { ISOBaseValidator[] msgVlds = new ISOBaseValidator[0]; ISOBaseValidatingPackager cTCSubElementPackager = new CTCSubElementPackager(); cTCSubElementPackager.setMsgValidator(msgVlds); assertSame(msgVlds, ((CTCSubElementPackager) cTCSubElementPackager).msgVld, "(CT... | public void setMsgValidator( ISOBaseValidator[] msgVlds ){ this.msgVld = msgVlds; } | ISOBaseValidatingPackager extends ISOBasePackager implements ISOValidator { public void setMsgValidator( ISOBaseValidator[] msgVlds ){ this.msgVld = msgVlds; } } | ISOBaseValidatingPackager extends ISOBasePackager implements ISOValidator { public void setMsgValidator( ISOBaseValidator[] msgVlds ){ this.msgVld = msgVlds; } ISOBaseValidatingPackager(); } | 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[] msg... | 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[] msg... |
@Test public void testIsConnected() throws Throwable { assertFalse(new QMUX().isConnected(), "result"); } | 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 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 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(); } | 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 ... | 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 ... |
@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()... | 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()))... | 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 = (ISOCompon... | 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 = (ISOCompon... | 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 = (ISOCompon... | 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 = (ISOCompon... |
@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.getMess... | 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()))... | 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 = (ISOCompon... | 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 = (ISOCompon... | 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 = (ISOCompon... | 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 = (ISOCompon... |
@Test public void testEmitBitMap() throws Throwable { CTCSubElementPackager cTCSubElementPackager = new CTCSubElementPackager(); boolean result = cTCSubElementPackager.emitBitMap(); assertFalse(result, "result"); } | protected boolean emitBitMap() { return false; } | CTCSubElementPackager extends ISOBaseValidatingPackager { protected boolean emitBitMap() { return false; } } | CTCSubElementPackager extends ISOBaseValidatingPackager { protected boolean emitBitMap() { return false; } CTCSubElementPackager(); } | CTCSubElementPackager extends ISOBaseValidatingPackager { protected boolean emitBitMap() { return false; } CTCSubElementPackager(); byte[] pack( ISOComponent c ); int unpack( ISOComponent m, byte[] b ); ISOComponent validate( ISOComponent c ); } | CTCSubElementPackager extends ISOBaseValidatingPackager { protected boolean emitBitMap() { return false; } CTCSubElementPackager(); byte[] pack( ISOComponent c ); int unpack( ISOComponent m, byte[] b ); ISOComponent validate( ISOComponent c ); } |
@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, "resu... | 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 ) ) ); } ... | 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.getKe... | 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.getKe... | 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.getKe... | 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.getKe... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.