From 70757b919c6647798bc2a1836f4ce16a97930826 Mon Sep 17 00:00:00 2001 From: Murtuza Chhil Date: Thu, 23 Jan 2025 08:47:02 +0530 Subject: [PATCH] Bugfixes + cleanup + test cases --- .../main/java/com/sample/hsm/HSMMessage.java | 6 +- .../jpos/fsdpackager/AFSDFieldPackager.java | 17 +- .../jpos/fsdpackager/BranchFieldPackager.java | 67 +- .../java/org/jpos/fsdpackager/FSDMsgX.java | 19 +- .../jpos/fsdpackager/FixedFieldPackager.java | 53 +- .../jpos/fsdpackager/OptionalPackager.java | 11 +- .../fsdpackager/VariableFieldPackager.java | 88 ++- .../fsdpackager/BranchFieldPackagerTest.java | 324 ++++++++- .../fsdpackager/FixedFieldPackagerTest.java | 287 +++++++- .../fsdpackager/LookAheadPackagerTest.java | 312 ++++++++- .../fsdpackager/OptionalPackagerTest.java | 156 +++++ .../VariableFieldPackagerTest.java | 633 ++++++++++++------ 12 files changed, 1646 insertions(+), 327 deletions(-) mode change 100644 => 100755 modules/fsdmsgx/src/main/java/org/jpos/fsdpackager/BranchFieldPackager.java mode change 100644 => 100755 modules/fsdmsgx/src/main/java/org/jpos/fsdpackager/FSDMsgX.java mode change 100644 => 100755 modules/fsdmsgx/src/main/java/org/jpos/fsdpackager/FixedFieldPackager.java mode change 100644 => 100755 modules/fsdmsgx/src/test/java/org/jpos/fsdpackager/BranchFieldPackagerTest.java mode change 100644 => 100755 modules/fsdmsgx/src/test/java/org/jpos/fsdpackager/LookAheadPackagerTest.java create mode 100644 modules/fsdmsgx/src/test/java/org/jpos/fsdpackager/OptionalPackagerTest.java mode change 100644 => 100755 modules/fsdmsgx/src/test/java/org/jpos/fsdpackager/VariableFieldPackagerTest.java diff --git a/modules/fsdmsgx/src/main/java/com/sample/hsm/HSMMessage.java b/modules/fsdmsgx/src/main/java/com/sample/hsm/HSMMessage.java index c710d7cbe2..7854dc2122 100644 --- a/modules/fsdmsgx/src/main/java/com/sample/hsm/HSMMessage.java +++ b/modules/fsdmsgx/src/main/java/com/sample/hsm/HSMMessage.java @@ -25,7 +25,7 @@ public FSDMsgX getFSDMessage() { FixedFieldPackager command = new FixedFieldPackager("command", 2, AsciiInterpreter.INSTANCE); message.add(command); - Map commandCases = new HashMap(); + Map commandCases = new HashMap<>(); commandCases.put("A0", getA0Packager()); commandCases.put("A1", getA1Packager()); commandCases.put("A6", getA6Packager()); @@ -56,7 +56,7 @@ private static AFSDFieldPackager getFAPackager() { optionalGrp1.add(reserved1); optionalGrp1.add(keySchemeLMK); optionalGrp1.add(keyCheckValue); - LookAheadPackager determineGrp1 = new LookAheadPackager("LAGRP1", 0, new Byte((byte)';') ,optionalGrp1, null, new String[]{"key-scheme-lmk","key-check-value-len"}, null); + LookAheadPackager determineGrp1 = new LookAheadPackager("LAGRP1", 0, Byte.valueOf((byte)';') ,optionalGrp1, null, new String[]{"key-scheme-lmk","key-check-value-len"}, null); FSDMsgX optionalGrp2 = new FSDMsgX("OptionalGroup2"); @@ -64,7 +64,7 @@ private static AFSDFieldPackager getFAPackager() { AFSDFieldPackager percent = new FixedFieldPackager("delimiter-2","%",AsciiInterpreter.INSTANCE); optionalGrp2.add(percent); optionalGrp2.add(lmkid); - LookAheadPackager determineGrp2 = new LookAheadPackager("LAGRP2", 0, new Byte((byte)'%') ,optionalGrp2, null, new String[]{"LMK-ID"}, null); + LookAheadPackager determineGrp2 = new LookAheadPackager("LAGRP2", 0, Byte.valueOf((byte)'%') ,optionalGrp2, null, new String[]{"LMK-ID"}, null); FSDMsgX container = new FSDMsgX("TranslateZPKReq-FA"); diff --git a/modules/fsdmsgx/src/main/java/org/jpos/fsdpackager/AFSDFieldPackager.java b/modules/fsdmsgx/src/main/java/org/jpos/fsdpackager/AFSDFieldPackager.java index be511b4dbc..f30245d617 100644 --- a/modules/fsdmsgx/src/main/java/org/jpos/fsdpackager/AFSDFieldPackager.java +++ b/modules/fsdmsgx/src/main/java/org/jpos/fsdpackager/AFSDFieldPackager.java @@ -26,27 +26,23 @@ public class AFSDFieldPackager implements IFSDFieldPackager { private String name; - - /* (non-Javadoc) - * @see org.jpos.fsdpackager.IFSDFieldPackager#pack(java.util.Map) - */ + @Override public byte[] pack(Map setfields) throws ISOException { - // TODO Auto-generated method stub return null; } + @Override public String getValue() { - // TODO Auto-generated method stub return null; } + @Override public void setValue(String value) { - // TODO Auto-generated method stub } + @Override public int unpack(byte[] inStream, int offset, Map fields) throws ISOException { - // TODO Auto-generated method stub return 0; } @@ -58,19 +54,20 @@ public void setName(String fieldName) { this.name = fieldName; } + @Override public String dump(String prefix, Map setfields) { return ""; } + @Override public byte[] hexDump(String prefix,Map setfields) { - // TODO Auto-generated method stub return null; } + @Override public String getParserTree(String prefix) { - // TODO Auto-generated method stub return null; } diff --git a/modules/fsdmsgx/src/main/java/org/jpos/fsdpackager/BranchFieldPackager.java b/modules/fsdmsgx/src/main/java/org/jpos/fsdpackager/BranchFieldPackager.java old mode 100644 new mode 100755 index a123a4abf0..8951eaf26e --- a/modules/fsdmsgx/src/main/java/org/jpos/fsdpackager/BranchFieldPackager.java +++ b/modules/fsdmsgx/src/main/java/org/jpos/fsdpackager/BranchFieldPackager.java @@ -134,22 +134,21 @@ public void setValue(String value) { public String dump(String prefix, Map setfields) { String fieldValue = setfields.get(switchField); - if (fieldValue == null) { - if (defaultCase != null) { - - return defaultCase.dump(prefix, setfields); - } - } else { + if ((fieldValue != null)) { AFSDFieldPackager temp = switchCases.get(fieldValue); - if (temp == null) { - if (defaultCase != null) { - return defaultCase.dump(prefix, setfields); - } - } else { + if (temp != null) { return temp.dump(prefix, setfields); } + if (defaultCase != null) { + + return defaultCase.dump(prefix, setfields); + } } + if (defaultCase != null) { + + return defaultCase.dump(prefix, setfields); + } return ""; } @@ -172,24 +171,58 @@ public String dump(String prefix, Map setfields) { @Override public String getParserTree(String prefix) { - String cases = ""; + StringBuilder cases = new StringBuilder(); if (switchCases == null) { - cases += "[Not Set]" + System.lineSeparator(); + cases.append("[Not Set]") + .append(System.lineSeparator()); } else { for (Map.Entry entry : switchCases.entrySet()) { AFSDFieldPackager fPkgr = entry.getValue(); - cases += "\t\t" + entry.getKey() + ":" + System.lineSeparator() + fPkgr.getParserTree("\t\t\t"); + cases.append("\t\t") + .append(entry.getKey()) + .append(":") + .append(System.lineSeparator()) + .append(fPkgr.getParserTree("\t\t\t")); } } - cases += "\t\tdefault:" + System.lineSeparator() + ((defaultCase != null) - ? System.lineSeparator() + defaultCase.getParserTree("\t\t\t") : "\t\t\t[Not Set]"); + cases.append("\t\tdefault:") + .append(System.lineSeparator()) + .append((defaultCase != null) + ? System.lineSeparator() + defaultCase.getParserTree("\t\t\t") : "\t\t\t[Not Set]"); return String.format("%sField [%s] : [Branch]%n" + "\tswitch (%s)%n" + "%s", prefix, getName(), switchField, - cases); + cases.toString()); } + @Override + public byte[] hexDump(String prefix, Map fields) { + + String value = fields.get(switchField); + + if (value == null) { + if (defaultCase != null) { + defaultCase.setValue(fields.get(defaultCase.getName())); + return defaultCase.hexDump(prefix, fields); + } + return null; + } + AFSDFieldPackager selectedPackager = switchCases.get(value); + if (selectedPackager == null) { + + if (defaultCase != null) { + defaultCase.setValue(fields.get(defaultCase.getName())); + return defaultCase.hexDump(prefix, fields); + } + return null; + + } + selectedPackager.setValue(fields.get(selectedPackager.getName())); + return selectedPackager.hexDump(prefix, fields); + + } + } diff --git a/modules/fsdmsgx/src/main/java/org/jpos/fsdpackager/FSDMsgX.java b/modules/fsdmsgx/src/main/java/org/jpos/fsdpackager/FSDMsgX.java old mode 100644 new mode 100755 index 7e0916c81f..f3bc79567c --- a/modules/fsdmsgx/src/main/java/org/jpos/fsdpackager/FSDMsgX.java +++ b/modules/fsdmsgx/src/main/java/org/jpos/fsdpackager/FSDMsgX.java @@ -26,20 +26,21 @@ public class FSDMsgX extends AFSDFieldPackager { - public String dump(String prefix, Map setfields) { + @Override + public String dump(String prefix, Map setfields) { // TODO Auto-generated method stub return dump(prefix); } - private Map fieldPackagers = new LinkedHashMap(); - private Map setfields = new LinkedHashMap(); + private Map fieldPackagers = new LinkedHashMap<>(); + private Map setfields = new LinkedHashMap<>(); public FSDMsgX(String name) { setName(name); } private FSDMsgX() { - }; + } public void add(String name, AFSDFieldPackager fsdFieldPackager) { @@ -80,8 +81,9 @@ public void set(String fieldName, String value) { IFSDFieldPackager p = getFields().get(fieldName); getSetfields().put(fieldName, value); - if (p != null) - p.setValue(value); + if (p != null) { + p.setValue(value); + } } @@ -221,9 +223,12 @@ public void setSetfields(Map setfields) { public byte[] hexDump(String prefix, Map setfields) { byte[] outStream = null; + this.setfields = setfields; for (Map.Entry entry : fieldPackagers.entrySet()) { - byte[] temp = entry.getValue().hexDump(prefix, getSetfields()); + byte[] temp = entry.getValue() + .hexDump(prefix, setfields); + if (temp != null) { if (outStream == null) { outStream = temp; diff --git a/modules/fsdmsgx/src/main/java/org/jpos/fsdpackager/FixedFieldPackager.java b/modules/fsdmsgx/src/main/java/org/jpos/fsdpackager/FixedFieldPackager.java old mode 100644 new mode 100755 index d4c835d736..bcd1c9fe54 --- a/modules/fsdmsgx/src/main/java/org/jpos/fsdpackager/FixedFieldPackager.java +++ b/modules/fsdmsgx/src/main/java/org/jpos/fsdpackager/FixedFieldPackager.java @@ -22,6 +22,7 @@ import org.jpos.fsdpackager.compliance.APCICompliance; import org.jpos.fsdpackager.compliance.NoCompliance; +import org.jpos.iso.AsciiInterpreter; import org.jpos.iso.ISOException; import org.jpos.iso.ISOUtil; import org.jpos.iso.Interpreter; @@ -32,10 +33,14 @@ public class FixedFieldPackager extends AFSDFieldPackager { Interpreter interpretter; private int size; private boolean padLeft = true; - private boolean padright = false; - private Byte padCharacter = new Byte((byte) 0x20); //space + private Byte padCharacter = Byte.valueOf((byte) 0x20); //space private APCICompliance compliance = new NoCompliance(); + public FixedFieldPackager(String name, int size) { + this.interpretter = new AsciiInterpreter(); + this.size = size; + this.setName(name); + } public FixedFieldPackager(String name,int size,Interpreter interpretter) { this.interpretter = interpretter; this.size = size; @@ -62,11 +67,9 @@ public int unpack(byte[] inStream, int offset, Map fields) throw throw new ISOException(String.format("Field [%s] at offset [%d]:Expecting %d bytes found %d", getName(),offset,packedSize, inStream.length - offset)); } String interprettedvalue = interpretter.uninterpret(inStream, offset, size); - if (getValue() != null) { - if (!getValue().equals(interprettedvalue)) { - throw new ISOException(String.format("Field [%s] at offset [%d]:Expected %s but found %s", getName(),offset,getValue(), interprettedvalue)); - } - } + if ((getValue() != null) && !getValue().equals(interprettedvalue)) { + throw new ISOException(String.format("Field [%s] at offset [%d]:Expected %s but found %s", getName(),offset,getValue(), interprettedvalue)); + } fields.put(getName(),interprettedvalue); value = interprettedvalue; @@ -87,17 +90,15 @@ public byte[] pack(Map fields) throws ISOException { if (value==null){ throw new ISOException(String.format("Field [%s]: Unable to pack as field is not set",getName())); } - if (value.length() <= size) { - if (padLeft){ - ISOUtil.padleft(getValue(), size,(char) padCharacter.byteValue() ); - } - else { - ISOUtil.padright(getValue(), size,(char) padCharacter.byteValue() ); - } - } - else { + if (value.length() > size) { throw new ISOException(String.format("Field [%s]:Cannot pack as data has size %d and size needs to be %d",getName(), value.length(),size)); } + if (padLeft){ + value = ISOUtil.padleft(getValue(), size, (char) padCharacter.byteValue()); + } + else { + value = ISOUtil.padright(getValue(), size, (char) padCharacter.byteValue()); + } byte[] packedbyte = new byte[interpretter.getPackedLength(size)]; interpretter.interpret(getValue(), packedbyte, 0); @@ -119,7 +120,6 @@ public void setValue(String value) { public void setPad(boolean padLeft) { this.padLeft = padLeft; - this.padright = !padLeft; } public Byte getPadCharacter() { @@ -132,13 +132,26 @@ public void setPadCharacter(Byte padCharacter) { @Override public String dump(String prefix,Map setfields) { - if (getValue()!=null) - return String.format("%s%n", prefix,getName(),compliance.makeCompliant(getValue())); + if (value == null) { + value = setfields.get(getName()); + + } + if (getValue()!=null) { + return String.format("%s%n", prefix,getName(),compliance.makeCompliant(getValue())); + } return ""; } @Override public byte[] hexDump(String prefix,Map setfields) { - + + if (value == null) {// if the hardcoded value is in the constructor , + // use it. + value = setfields.get(getName()); + return null; + + } + setfields.put(getName(), value); + int numberOfPackedBytes = interpretter.getPackedLength(getValue().length()); String compliant = compliance.makeCompliant(getValue()); byte[] temp = new byte[numberOfPackedBytes]; diff --git a/modules/fsdmsgx/src/main/java/org/jpos/fsdpackager/OptionalPackager.java b/modules/fsdmsgx/src/main/java/org/jpos/fsdpackager/OptionalPackager.java index 196c755f34..db485c8ff9 100644 --- a/modules/fsdmsgx/src/main/java/org/jpos/fsdpackager/OptionalPackager.java +++ b/modules/fsdmsgx/src/main/java/org/jpos/fsdpackager/OptionalPackager.java @@ -40,7 +40,7 @@ public byte[] pack(Map setfields) throws ISOException { return fieldPackager.pack(setfields); } catch (Exception e) { - ;// If optional was absent, pack would have thrown an exception as field was not set + // If optional was absent, pack would have thrown an exception as field was not set } return null; } @@ -51,14 +51,13 @@ public int unpack(byte[] inStream, int offset, Map fields) throw return fieldPackager.unpack(inStream, offset, fields); } catch (Exception ex){ - ;//Do nothing, means optional field not present + //Do nothing, means optional field not present } return offset; // return original offset passed in } @Override public String getParserTree(String prefix) { - // TODO Auto-generated method stub return String.format("%sField [%s] : [OPTIONAL]%n",prefix,getName()) +fieldPackager.getParserTree(prefix+"\t"); } @@ -69,11 +68,15 @@ public String dump(String prefix, Map setfields) { try { return fieldPackager.dump(prefix, setfields); } catch (Exception e) { - // TODO: handle exception } return ""; } + @Override + public byte[] hexDump(String prefix, Map setfields) { + + return fieldPackager.hexDump(prefix, setfields); + } diff --git a/modules/fsdmsgx/src/main/java/org/jpos/fsdpackager/VariableFieldPackager.java b/modules/fsdmsgx/src/main/java/org/jpos/fsdpackager/VariableFieldPackager.java index eee8a9842e..b8cdfefa87 100644 --- a/modules/fsdmsgx/src/main/java/org/jpos/fsdpackager/VariableFieldPackager.java +++ b/modules/fsdmsgx/src/main/java/org/jpos/fsdpackager/VariableFieldPackager.java @@ -9,11 +9,11 @@ * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Affero General Public License for more details. * * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . + * along with this program. If not, see . */ package org.jpos.fsdpackager; @@ -42,11 +42,13 @@ public int unpack(byte[] inStream, int offset, Map fields) throw boolean delimiterFound = false; int i = offset; int lengthTotraverse; - if (maxSize <= inStream.length - offset) // length-offset = remaining - // bytes + if (maxSize <= inStream.length - offset) { // length-offset = remaining + // bytes lengthTotraverse = maxSize + offset + 1;// to include th delimiter - else + } + else { // length-offset = remaining lengthTotraverse = inStream.length; + } while (i < lengthTotraverse) { // there is no point traversing to the // end, if we can we should traverse to // the maxsize @@ -57,24 +59,24 @@ public int unpack(byte[] inStream, int offset, Map fields) throw i++; } - if (delimiterFound || i == inStream.length) { - - byte[] dest = new byte[i - offset]; - if ((i - offset) == 0) { - // Means there is no data and its terminated by delimiter - value = ""; - } else if ((i - offset) <= maxSize) { - System.arraycopy(inStream, offset, dest, 0, i - offset); - value = interpreter.uninterpret(dest, 0, i - offset); - - } else - throw new ISOException( - String.format("Field size [%d] is greater than max size [%d] of field ", i - offset, maxSize)); - - } else { + if (!delimiterFound && (i != inStream.length)) { throw new ISOException(String.format("Field [%s]: Delimiter %x not present after max size %d", getName(), delimiter.byteValue(), maxSize)); } + byte[] dest = new byte[i - offset]; + if ((i - offset) == 0) { + // Means there is no data and its terminated by delimiter + value = ""; + } + else if ((i - offset) <= maxSize) { + System.arraycopy(inStream, offset, dest, 0, i - offset); + value = interpreter.uninterpret(dest, 0, i - offset); + + } + else { + throw new ISOException(String.format("Field size [%d] is greater than max size [%d] of field ", i - offset, + maxSize)); + } setValue(value); return i + 1; } @@ -85,8 +87,13 @@ public byte[] pack(Map fields) throws ISOException { if (value == null || value.equals("")) { // if field is not set, make sure to send the delimiter to indicate // its presence. - return new byte[] { delimiter.byteValue() }; + value = fields.get(getName()); + if (value == null || value.equals("")) { + setValue(""); // set this as the hexdump method throws NPE + return new byte[] { delimiter.byteValue() }; + } } + if (value.length() <= maxSize) { byte[] b = new byte[interpreter.getPackedLength(value.length() + 1)]; interpreter.interpret(value, b, 0); @@ -142,28 +149,52 @@ public String getValue() { @Override public void setValue(String value) { this.value = value; + // TODO Auto-generated method stub } @Override public String dump(String prefix, Map setfields) { - if (getValue()!=null) - return String.format("%s%n", prefix, getName(), - compliance.makeCompliant(getValue())); + if (value == null) {// if the hardcoded value is in the constructor , + // use it. + value = setfields.get(getName()); + + } + if (getValue() != null) { + return String.format("%s%n", prefix, getName(), + compliance.makeCompliant(getValue())); + } return ""; } @Override public byte[] hexDump(String prefix, Map setfields) { + if (value == null || value.equals("")) { + // if field is not set, make sure to send the delimiter to indicate + // its presence. + value = setfields.get(getName()); + if (value == null || value.equals("")) { + setValue(""); // set this as the hexdump method throws NPE + // return new byte[] { delimiter.byteValue() }; + } + } + else { + setfields.put(getName(), value); + } + int numberOfPackedBytes = interpreter.getPackedLength(getValue().length()); String compliant = compliance.makeCompliant(getValue()); - byte[] temp = new byte[numberOfPackedBytes+1];// +1 for the delimiter + byte[] temp = new byte[numberOfPackedBytes + 1]; // +1 + // for + // the + // delimiter try { interpreter.interpret(compliant, temp, 0); - temp[temp.length-1]= delimiter.byteValue(); - } catch (ISOException e) { + temp[temp.length - 1] = delimiter.byteValue(); + } + catch (ISOException e) { return null; } return temp; @@ -173,7 +204,8 @@ public byte[] hexDump(String prefix, Map setfields) { @Override public String getParserTree(String prefix) { - return String.format("%sField [%s] : VAR[0..%d] delimiter[0x%X] or EOM %s%n", prefix, getName(),maxSize, delimiter.byteValue(), getValue()==null?"":": "+getValue()); + return String.format("%sField [%s] : VAR[0..%d] delimiter[0x%X] or EOM %s%n", prefix, getName(), maxSize, + delimiter.byteValue(), getValue() == null ? "" : ": " + getValue()); } diff --git a/modules/fsdmsgx/src/test/java/org/jpos/fsdpackager/BranchFieldPackagerTest.java b/modules/fsdmsgx/src/test/java/org/jpos/fsdpackager/BranchFieldPackagerTest.java old mode 100644 new mode 100755 index e4f188ecf5..fc9efb8569 --- a/modules/fsdmsgx/src/test/java/org/jpos/fsdpackager/BranchFieldPackagerTest.java +++ b/modules/fsdmsgx/src/test/java/org/jpos/fsdpackager/BranchFieldPackagerTest.java @@ -18,6 +18,8 @@ package org.jpos.fsdpackager; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; import static org.junit.jupiter.api.Assertions.assertArrayEquals; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -31,6 +33,308 @@ public class BranchFieldPackagerTest { + /** + * Test case to verify the BranchFieldPackager with a switch field, switch + * cases and a default case. + * + * @throws ISOException + * if an error occurs during packing or unpacking + */ + @Test + public void testBranchFieldPackagerWithCasesAndDefault() throws ISOException { + // 1. Setup: Create the packagers. + + // Create packagers for each field. + FixedFieldPackager field1Packager = new FixedFieldPackager("F1", 5); + FixedFieldPackager field2Packager = new FixedFieldPackager("F2", 2); + FixedFieldPackager field4Packager = new FixedFieldPackager("F4", 3); + FixedFieldPackager field5Packager = new FixedFieldPackager("F5", 4); + FixedFieldPackager defaultPackager = new FixedFieldPackager("FDefault", 3); + + // Create switch cases + Map switchCases = new HashMap<>(); + switchCases.put("01", field4Packager); + switchCases.put("02", field5Packager); + + // Create the branch packager + BranchFieldPackager branchPackager = new BranchFieldPackager("F3", "F2", switchCases, defaultPackager); + + // 2. Test pack operation + // Case 1: Switch field exists in the switch case + Map fields1 = new HashMap<>(); + fields1.put("F1", "ABCDE"); + fields1.put("F2", "02"); + fields1.put("F5", "4444"); + byte[] packed1 = branchPackager.pack(fields1); + assertNotNull(packed1); + assertEquals("34343434", bytesToHex(packed1)); + + // Case 2: Switch field exists in the switch case + Map fields2 = new HashMap<>(); + fields2.put("F1", "ABCDE"); + fields2.put("F2", "01"); + fields2.put("F4", "123"); + + byte[] packed2 = branchPackager.pack(fields2); + assertNotNull(packed2); + assertEquals("313233", bytesToHex(packed2)); + + // Case 3: Switch field does not exist, should use default + Map fields3 = new HashMap<>(); + fields3.put("F1", "ABCDE"); + fields3.put("FDefault", "XYZ"); + + byte[] packed3 = branchPackager.pack(fields3); + assertNotNull(packed3); + assertEquals("58595a", bytesToHex(packed3)); + + // Case 4: Switch field is null and there is no default case. Should + // return null. + BranchFieldPackager branchPackagerNoDefault = new BranchFieldPackager("F3", "F2", switchCases, null); + Map fields4 = new HashMap<>(); + fields4.put("F1", "ABCDE"); + + byte[] packed4 = branchPackagerNoDefault.pack(fields4); + assertNull(packed4); + + // Case 5: Switch field does not exist and no default case should return + // null. + Map fields5 = new HashMap<>(); + fields5.put("F1", "ABCDE"); + fields5.put("F4", "123"); + + byte[] packed5 = branchPackagerNoDefault.pack(fields5); + assertNull(packed5); + + // 3. Test Unpack operation. + // Case 1: Switch field exists in the switch case. + byte[] inStream1 = hexToBytes("34343434"); + Map unpackedFields1 = new HashMap<>(); + unpackedFields1.put("F2", "02"); + int offset1 = branchPackager.unpack(inStream1, 0, unpackedFields1); + assertEquals(4, offset1); + assertEquals("4444", unpackedFields1.get("F5")); + + // Case 2: Switch field exists in the switch case + byte[] inStream2 = hexToBytes("313233"); + Map unpackedFields2 = new HashMap<>(); + unpackedFields2.put("F2", "01"); + int offset2 = branchPackager.unpack(inStream2, 0, unpackedFields2); + assertEquals(3, offset2); + assertEquals("123", unpackedFields2.get("F4")); + + // Case 3: Switch field does not exist, should use default + byte[] inStream3 = hexToBytes("58595a"); + Map unpackedFields3 = new HashMap<>(); + int offset3 = branchPackager.unpack(inStream3, 0, unpackedFields3); + assertEquals(3, offset3); + assertEquals("XYZ", unpackedFields3.get("FDefault")); + + // Case 4: Switch field is null and no default case, no changes + BranchFieldPackager branchPackagerNoDefaultUnpack = new BranchFieldPackager("F3", "F2", switchCases, null); + byte[] inStream4 = hexToBytes("313233"); + Map unpackedFields4 = new HashMap<>(); + int offset4 = branchPackagerNoDefaultUnpack.unpack(inStream4, 0, + unpackedFields4); + assertEquals(0, offset4); + assertNull(unpackedFields4.get("F4")); + assertNull(unpackedFields4.get("F5")); + + // Case 5: Switch field doesn't exist and no default + byte[] inStream5 = hexToBytes("313233"); + Map unpackedFields5 = new HashMap<>(); + unpackedFields5.put("F2", "10"); + int offset5 = branchPackagerNoDefaultUnpack.unpack(inStream5, 0, unpackedFields5); + assertEquals(0, offset5); + assertNull(unpackedFields5.get("F4")); + assertNull(unpackedFields5.get("F5")); + + // 4. Test dump operation + // Case 1: Switch field exists in the switch case + Map dumpFields1 = new HashMap<>(); + dumpFields1.put("F2", "02"); + String dump1 = branchPackager.dump("", dumpFields1); + assertEquals("", dump1.trim()); + + // Case 2: Switch field exists in the switch case + Map dumpFields2 = new HashMap<>(); + dumpFields2.put("F2", "01"); + String dump2 = branchPackager.dump("", dumpFields2); + assertEquals("", dump2.trim()); + + // Case 3: Switch field does not exist, should use default + Map dumpFields3 = new HashMap<>(); + dumpFields3.put("FDefault", "XYZ"); + String dump3 = branchPackager.dump("", dumpFields3); + assertEquals("", dump3.trim()); + +// // Case 4: Switch field is null, use default. + switchCases = new HashMap<>(); + switchCases.put("01", field4Packager); + switchCases.put("02", field5Packager); + defaultPackager = new FixedFieldPackager("FDefault", 3); + // Create the branch packager + + branchPackager = new BranchFieldPackager("F3", "F2", switchCases, defaultPackager); + Map dumpFields4 = new HashMap<>(); + + dumpFields4.put("FDefault", "ABC"); + String dump4 = branchPackager.dump("", dumpFields4); + assertEquals("", dump4.trim()); + System.out.println(branchPackager.getParserTree("case4")); + System.out.println(dump4); + // Case 5: Switch field does not exist, use default. + + defaultPackager = new FixedFieldPackager("FDefault", 3); + + // Create switch cases + switchCases = new HashMap<>(); + switchCases.put("01", field4Packager); + switchCases.put("02", field5Packager); + + // Create the branch packager + + branchPackager = new BranchFieldPackager("F3", "F2", switchCases, defaultPackager); + Map dumpFields5 = new HashMap<>(); + dumpFields5.put("F2", "03"); + dumpFields5.put("FDefault", "ABC"); + String dump5 = branchPackager.dump("", dumpFields5); + assertEquals("", dump5.trim()); + System.out.println(branchPackager.getParserTree("case5")); + System.out.println(dump5); + + } + + /** + * Test case to verify the getParserTree method with a branch packager. + */ + @Test + public void testGetParserTree() { + // 1. Setup + FixedFieldPackager field1Packager = new FixedFieldPackager("F1", 5); + FixedFieldPackager field2Packager = new FixedFieldPackager("F2", 2); + FixedFieldPackager field4Packager = new FixedFieldPackager("F4", 3); + FixedFieldPackager field5Packager = new FixedFieldPackager("F5", 4); + FixedFieldPackager defaultPackager = new FixedFieldPackager("FDefault", 3); + + // Create switch cases + Map switchCases = new HashMap<>(); + switchCases.put("01", field4Packager); + switchCases.put("02", field5Packager); + + // Create the branch packager + BranchFieldPackager branchPackager = new BranchFieldPackager("F3", "F2", switchCases, defaultPackager); + + // 2. Execute and assert + + String expectedTree = "Field [F3] : [Branch]" + System.lineSeparator() + "\tswitch (F2)" + + System.lineSeparator() + "\t\t01:" + System.lineSeparator() + "\t\t\tField [F4] : Fixed [3] " + + System.lineSeparator() + "\t\t02:" + System.lineSeparator() + + "\t\t\tField [F5] : Fixed [4] " + System.lineSeparator() + "\t\tdefault:" + System.lineSeparator() + + "" + + System.lineSeparator() + "\t\t\tField [FDefault] : Fixed [3] " + System.lineSeparator(); + + assertEquals(expectedTree, branchPackager.getParserTree("")); + + } + + /** + * Test case to verify hexDump operation with various scenarios. + * + * @throws ISOException + * if an error occurs during packing + */ + @Test + public void testHexDump() throws ISOException { + // 1. Setup + FixedFieldPackager field1Packager = new FixedFieldPackager("F1", 5); + FixedFieldPackager field2Packager = new FixedFieldPackager("F2", 2); + FixedFieldPackager field4Packager = new FixedFieldPackager("F4", 3); + FixedFieldPackager field5Packager = new FixedFieldPackager("F5", 4); + FixedFieldPackager defaultPackager = new FixedFieldPackager("FDefault", 3); + + // Create switch cases + Map switchCases = new HashMap<>(); + switchCases.put("01", field4Packager); + switchCases.put("02", field5Packager); + + // Create the branch packager + BranchFieldPackager branchPackager = new BranchFieldPackager("F3", "F2", switchCases, defaultPackager); + + // 2. Test hexDump operation + + // Case 1: Switch field exists in the switch case + Map fields1 = new HashMap<>(); + fields1.put("F2", "02"); + fields1.put("F5", "4444"); + + byte[] hexDump1 = branchPackager.hexDump("", fields1); + assertNotNull(hexDump1); + assertEquals("34343434", bytesToHex(hexDump1)); + + // Case 2: Switch field exists in the switch case + Map fields2 = new HashMap<>(); + fields2.put("F2", "01"); + fields2.put("F4", "123"); + + byte[] hexDump2 = branchPackager.hexDump("", fields2); + assertNotNull(hexDump2); + assertEquals("313233", bytesToHex(hexDump2)); + + // Case 3: Switch field does not exist, should use default + Map fields3 = new HashMap<>(); + fields3.put("FDefault", "XYZ"); + + byte[] hexDump3 = branchPackager.hexDump("", fields3); + assertNotNull(hexDump3); + assertEquals("58595a", bytesToHex(hexDump3)); + + // Case 4: Switch field is null and no default case. Should return null. + BranchFieldPackager branchPackagerNoDefault = new BranchFieldPackager("F3", "F2", switchCases, null); + Map fields4 = new HashMap<>(); + byte[] hexDump4 = branchPackagerNoDefault.hexDump("", fields4); + assertNull(hexDump4); + + // Case 5: Switch field does not exist, and there is no default. Should + // return null. + Map fields5 = new HashMap<>(); + fields5.put("F2", "10"); + fields5.put("F4", "123"); + + byte[] hexDump5 = branchPackagerNoDefault.hexDump("", fields5); + assertNull(hexDump5); + } + + /** + * Helper method to convert byte array to hex string. + * + * @param bytes + * The byte array to convert + * @return Hex string representation of the byte array + */ + private static String bytesToHex(byte[] bytes) { + StringBuilder sb = new StringBuilder(); + for (byte b : bytes) { + sb.append(String.format("%02x", b)); + } + return sb.toString(); + } + + /** + * Helper method to convert hex string to byte array + * + * @param hex + * The hex string to convert + * @return Byte array represented by the hex string + */ + private static byte[] hexToBytes(String hex) { + int len = hex.length(); + byte[] data = new byte[len / 2]; + for (int i = 0; i < len; i += 2) { + data[i / 2] = (byte) ((Character.digit(hex.charAt(i), 16) << 4) + Character.digit(hex.charAt(i + 1), 16)); + } + return data; + } @Test public void unpackTest06() throws ISOException{ @@ -52,7 +356,7 @@ public void unpackTest06() throws ISOException{ innerFSDCase02.add("F8",f8); innerFSDCase02.add("F9",f9); - Map caseMap = new HashMap(); + Map caseMap = new HashMap<>(); caseMap.put("01", innerFSDCase01); caseMap.put("02", innerFSDCase02); AFSDFieldPackager f3 = new BranchFieldPackager("F3", "F2", caseMap, null); @@ -85,7 +389,7 @@ public void packTest03() throws ISOException{ AFSDFieldPackager f4 = new FixedFieldPackager("F4", 3, AsciiInterpreter.INSTANCE); innerFSDCase01.add("Inner",f4); - Map caseMap = new HashMap(); + Map caseMap = new HashMap<>(); caseMap.put("01", innerFSDCase01); caseMap.put("02", case02); AFSDFieldPackager f3 = new BranchFieldPackager("F3", "F2", caseMap, null); @@ -119,7 +423,7 @@ public void packTest04() throws ISOException{ AFSDFieldPackager case01 = new FixedFieldPackager("F4", 3, AsciiInterpreter.INSTANCE); AFSDFieldPackager case02 = new FixedFieldPackager("F5", 4, AsciiInterpreter.INSTANCE); - Map caseMap = new HashMap(); + Map caseMap = new HashMap<>(); caseMap.put("01", case01); caseMap.put("02", case02); AFSDFieldPackager f3 = new BranchFieldPackager("F3", "F2", caseMap, null); @@ -153,7 +457,7 @@ public void packTest05() throws ISOException{ AFSDFieldPackager case01 = new FixedFieldPackager("F4", 3, AsciiInterpreter.INSTANCE); AFSDFieldPackager case02 = new FixedFieldPackager("F5", 4, AsciiInterpreter.INSTANCE); - Map caseMap = new HashMap(); + Map caseMap = new HashMap<>(); caseMap.put("01", case01); caseMap.put("02", case02); AFSDFieldPackager f3 = new BranchFieldPackager("F3", "F2", caseMap, null); @@ -188,7 +492,7 @@ public void packTest08() throws ISOException{ AFSDFieldPackager case01 = new FixedFieldPackager("F4", 3, AsciiInterpreter.INSTANCE); AFSDFieldPackager case02 = new FixedFieldPackager("F5", 4, AsciiInterpreter.INSTANCE); - Map caseMap = new HashMap(); + Map caseMap = new HashMap<>(); caseMap.put("01", case01); caseMap.put("02", case02); AFSDFieldPackager f3 = new BranchFieldPackager("F3", "F2", caseMap, null); @@ -204,12 +508,12 @@ public void packTest08() throws ISOException{ msg.set("F2", "01"); msg.set("F4", "333"); msg.set("F5", "4444"); - msg.set("F6", String.valueOf((char)0x02)); + msg.set("F6", String.valueOf(0x02)); byte[] outStream = msg.pack(); - assertArrayEquals(("ABCDE01333"+(char)0x02).getBytes(), outStream); + assertArrayEquals(("ABCDE013332").getBytes(), outStream); //System.out.println(ISOUtil.hexdump(outStream)); } @@ -223,7 +527,7 @@ public void packTest07() throws ISOException{ AFSDFieldPackager case01 = new FixedFieldPackager("F4", 3, AsciiInterpreter.INSTANCE); AFSDFieldPackager case02 = new FixedFieldPackager("F5", 4, AsciiInterpreter.INSTANCE); - Map caseMap = new HashMap(); + Map caseMap = new HashMap<>(); caseMap.put("01", case01); caseMap.put("02", case02); AFSDFieldPackager f3 = new BranchFieldPackager("F3", "F2", caseMap, null); @@ -258,7 +562,7 @@ public void packTest06() throws ISOException{ AFSDFieldPackager case01 = new FixedFieldPackager("F4", 3, AsciiInterpreter.INSTANCE); AFSDFieldPackager case02 = new FixedFieldPackager("F5", 4, AsciiInterpreter.INSTANCE); - Map caseMap = new HashMap(); + Map caseMap = new HashMap<>(); caseMap.put("01", case01); caseMap.put("02", case02); AFSDFieldPackager f3 = new BranchFieldPackager("F3", "F2", caseMap, null); @@ -289,7 +593,7 @@ public void unpacktest07() throws ISOException{ AFSDFieldPackager case01 = new FixedFieldPackager("F4", 3, AsciiInterpreter.INSTANCE); AFSDFieldPackager case02 = new FixedFieldPackager("F5", 4, AsciiInterpreter.INSTANCE); - Map caseMap = new HashMap(); + Map caseMap = new HashMap<>(); caseMap.put("01", case01); caseMap.put("02", case02); AFSDFieldPackager f3 = new BranchFieldPackager("F3", "F2", caseMap, null); diff --git a/modules/fsdmsgx/src/test/java/org/jpos/fsdpackager/FixedFieldPackagerTest.java b/modules/fsdmsgx/src/test/java/org/jpos/fsdpackager/FixedFieldPackagerTest.java index 5f0495cadb..bae979c465 100644 --- a/modules/fsdmsgx/src/test/java/org/jpos/fsdpackager/FixedFieldPackagerTest.java +++ b/modules/fsdmsgx/src/test/java/org/jpos/fsdpackager/FixedFieldPackagerTest.java @@ -18,24 +18,280 @@ package org.jpos.fsdpackager; -import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import java.util.HashMap; +import java.util.Map; + +import org.jpos.fsdpackager.compliance.NoCompliance; import org.jpos.fsdpackager.compliance.TrackDataCompliance; import org.jpos.iso.AsciiInterpreter; import org.jpos.iso.BCDInterpreter; import org.jpos.iso.EbcdicInterpreter; import org.jpos.iso.ISOException; import org.jpos.iso.ISOUtil; -import org.junit.jupiter.api.Test; +import org.jpos.iso.Interpreter; +import org.junit.Before; +import org.junit.Test; public class FixedFieldPackagerTest { + private FixedFieldPackager packager; + + @Before + public void setUp() { + + } + + @Test + public void testConstructorWithNameSizeAndInterpreter() { + packager = new FixedFieldPackager("testField", 10, new AsciiInterpreter()); + assertEquals("testField", packager.getName()); + } + + @Test + public void testConstructorWithNameSizeInterpreterAndCompliance() { + packager = new FixedFieldPackager("testField", 10, new AsciiInterpreter(), new NoCompliance()); + assertEquals("testField", packager.getName()); + } + + @Test + public void testConstructorWithNameValueAndInterpreter() { + packager = new FixedFieldPackager("testField", "testValue", new AsciiInterpreter()); + assertEquals("testField", packager.getName()); + assertEquals("testValue", packager.getValue()); + } + + @Test + public void testConstructorWithNameValueAndInterpreter2() throws ISOException { + packager = new FixedFieldPackager("testField", "testValue", new AsciiInterpreter()); + assertEquals("testField", packager.getName()); + assertEquals("testValue", packager.getValue()); + Map fields = new HashMap<>(); + byte[] inStream1 = "testValue".getBytes(); + packager.unpack(inStream1, 0, fields); + assertEquals("testValue", fields.get("testField")); + assertEquals("testValue", packager.getValue()); + + } + + @Test(expected = ISOException.class) + public void testConstructorWithNameValueAndInterpreter3() throws ISOException { + packager = new FixedFieldPackager("testField", "testValue", new AsciiInterpreter()); + assertEquals("testField", packager.getName()); + assertEquals("testValue", packager.getValue()); + Map fields = new HashMap<>(); + byte[] inStream1 = "TestValue".getBytes(); // does + // not + // match + // constant + // expected, + // will + // throw + // exception + packager.unpack(inStream1, 0, fields); + + } + + public void testPackWithConstant() throws ISOException { + packager = new FixedFieldPackager("testField", "testValue", new AsciiInterpreter()); + assertEquals("testField", packager.getName()); + assertEquals("testValue", packager.getValue()); + Map fields = new HashMap<>(); + + byte[] packed = packager.pack(fields); + assertArrayEquals("testValue".getBytes(), packed); + + } + + @Test + public void testUnpack() throws ISOException { + packager = new FixedFieldPackager("testField", 5, new AsciiInterpreter()); + + byte[] inStream = "abcde".getBytes(); + Map fields = new HashMap<>(); + int newOffset = packager.unpack(inStream, 0, fields); + + assertEquals(5, newOffset); + assertEquals("abcde", fields.get("testField")); + assertEquals("abcde", packager.getValue()); + + byte[] inStream1 = "abcdefghij".getBytes(); + packager = new FixedFieldPackager("testField1", 10, new AsciiInterpreter()); + fields = new HashMap<>(); + newOffset = packager.unpack(inStream1, 0, fields); + assertEquals(10, newOffset); + assertEquals("abcdefghij", fields.get("testField1")); + assertEquals("abcdefghij", packager.getValue()); + + } + + @Test(expected = ISOException.class) + public void testUnpackShortInput() throws ISOException { + + packager = new FixedFieldPackager("testField", 5, new AsciiInterpreter()); + byte[] inStream = "abcd".getBytes(); + Map fields = new HashMap<>(); + packager.unpack(inStream, 0, fields); + } + + @Test(expected = ISOException.class) + public void testUnpackValueMismatch() throws ISOException { + + packager = new FixedFieldPackager("testField", "abcde", new AsciiInterpreter()); + + byte[] inStream = "abcxy".getBytes(); + Map fields = new HashMap<>(); + packager.unpack(inStream, 0, fields); + } + + @Test + public void testPackWithValueFromFields() throws ISOException { + + packager = new FixedFieldPackager("testField", 5, new AsciiInterpreter()); + + Map fields = new HashMap<>(); + fields.put("testField", "abcde"); + byte[] packed = packager.pack(fields); + assertArrayEquals("abcde".getBytes(), packed); + assertEquals("abcde", fields.get("testField")); + } + + @Test + public void testPackWithValueFromConstructor() throws ISOException { + + packager = new FixedFieldPackager("testField", "abcde", new AsciiInterpreter()); + Map fields = new HashMap<>(); + byte[] packed = packager.pack(fields); + assertArrayEquals("abcde".getBytes(), packed); + assertEquals("abcde", fields.get("testField")); + } + + @Test + public void testPackWithPadding() throws ISOException { + + packager = new FixedFieldPackager("testField", 5, new AsciiInterpreter()); + packager.setPad(true); + Map fields = new HashMap<>(); + fields.put("testField", "abc"); + byte[] packed = packager.pack(fields); + assertArrayEquals(" abc".getBytes(), packed); + + packager.setPad(false); + packed = packager.pack(fields); + assertArrayEquals("abc ".getBytes(), packed); + assertEquals(" abc", fields.get("testField")); + } + + @Test(expected = ISOException.class) + public void testPackNoValue() throws ISOException { + packager = new FixedFieldPackager("testField", 5, new AsciiInterpreter()); + Map fields = new HashMap<>(); + packager.pack(fields); + } + + @Test(expected = ISOException.class) + public void testPackValueTooLong() throws ISOException { + packager = new FixedFieldPackager("testField", 5, new AsciiInterpreter()); + Map fields = new HashMap<>(); + fields.put("testField", "abcdef"); + packager.pack(fields); + } + + @Test + public void testGetValueAndSetValue() { + packager = new FixedFieldPackager("testField", 5, new AsciiInterpreter()); + packager.setValue("test"); + assertEquals("test", packager.getValue()); + } + + @Test + public void testSetPad() { + packager = new FixedFieldPackager("testField", 5, new AsciiInterpreter()); + packager.setPad(false); + packager.setPad(true); + } + + @Test + public void testGetAndSetPadCharacter() { + packager = new FixedFieldPackager("testField", 5, new AsciiInterpreter()); + Byte padChar = (byte) '0'; + packager.setPadCharacter(padChar); + assertEquals(padChar, packager.getPadCharacter()); + } + + @Test + public void testDumpWithValue() { + + packager = new FixedFieldPackager("testField", 5, new AsciiInterpreter(), new NoCompliance()); + packager.setValue("test"); + String expectedDump = "" + System.lineSeparator(); + assertEquals(expectedDump, packager.dump("", new HashMap<>())); + } + + @Test + public void testDumpWithoutValue() { + packager = new FixedFieldPackager("testField", 5, new AsciiInterpreter(), new NoCompliance()); + String expectedDump = ""; + assertEquals(expectedDump, packager.dump("", new HashMap<>())); + } + + @Test + public void testHexDumpWithValue() throws ISOException { + + packager = new FixedFieldPackager("testField", 4, new AsciiInterpreter(), new NoCompliance()); + packager.setValue("ABCD"); + + Map fields = new HashMap<>(); + byte[] hexDump = packager.hexDump("", fields); + assertArrayEquals(new byte[] { 0x41, 0x42, 0x43, 0x44 }, hexDump); + assertEquals("ABCD", fields.get("testField")); + + } + + @Test + public void testHexDumpWithoutValue() throws ISOException { + + packager = new FixedFieldPackager("testField", 5, new AsciiInterpreter(), new NoCompliance()); + Map fields = new HashMap<>(); + byte[] hexDump = packager.hexDump("", fields); + assertNull(hexDump); + } + + @Test + public void testGetParserTreeWithValue() { + packager = new FixedFieldPackager("testField", 5, new AsciiInterpreter()); + packager.setValue("test"); + String expectedTree = "Field [testField] : Fixed [5] : test" + System.lineSeparator(); + assertEquals(expectedTree, packager.getParserTree("")); + } + + @Test + public void testGetParserTreeWithoutValue() { + packager = new FixedFieldPackager("testField", 5, new AsciiInterpreter()); + String expectedTree = "Field [testField] : Fixed [5] " + System.lineSeparator(); + assertEquals(expectedTree, packager.getParserTree("")); + } + + @Test + public void testAsciiInterpreter() throws ISOException { + Interpreter interpreter = new AsciiInterpreter(); + byte[] out = new byte[5]; + interpreter.interpret("abcde", out, 0); + assertArrayEquals("abcde".getBytes(), out); + assertEquals("abcde", interpreter.uninterpret("abcde".getBytes(), 0, 5)); + assertEquals(5, interpreter.getPackedLength(5)); + } + @Test public void unpackTest01() throws ISOException { int size = 5; FixedFieldPackager p = new FixedFieldPackager("F1", size, AsciiInterpreter.INSTANCE); FSDMsgX msg = new FSDMsgX("Test"); - ; + msg.add("F1", p); String s = "12ABCDEFH"; @@ -55,7 +311,7 @@ public void unpackTest02() throws ISOException { int size = 5; FixedFieldPackager p = new FixedFieldPackager("F1", size, BCDInterpreter.RIGHT_PADDED); FSDMsgX msg = new FSDMsgX("Test"); - ; + msg.add("F1", p); byte[] b = { 0x12, 0x34, 0x56, 0x78 }; @@ -73,7 +329,7 @@ public void unpackTest03() throws ISOException { FixedFieldPackager p = new FixedFieldPackager("F1", size, AsciiInterpreter.INSTANCE); String s = "12AB"; FSDMsgX msg = new FSDMsgX("Test"); - ; + msg.add("F1", p); int offset = msg.unpack(s.getBytes()); @@ -90,7 +346,7 @@ public void unpackTest04() throws ISOException { FixedFieldPackager p = new FixedFieldPackager("F1", "12345", AsciiInterpreter.INSTANCE); String s = "12345"; FSDMsgX msg = new FSDMsgX("Test"); - ; + msg.add("F1", p); int offset = msg.unpack(s.getBytes()); @@ -106,7 +362,7 @@ public void unpackTest05() throws ISOException { FixedFieldPackager p = new FixedFieldPackager("F1", "12345", AsciiInterpreter.INSTANCE); String s = "12346"; FSDMsgX msg = new FSDMsgX("Test"); - ; + msg.add("F1", p); int offset = msg.unpack(s.getBytes()); @@ -125,7 +381,7 @@ public void unpackTest06() throws ISOException { FixedFieldPackager p = new FixedFieldPackager("F1", "12345", AsciiInterpreter.INSTANCE); String s = "ABC"; FSDMsgX msg = new FSDMsgX("Test"); - ; + msg.add("F1", p); int offset = msg.unpack(s.getBytes()); @@ -143,7 +399,7 @@ public void packTest01() throws ISOException { FixedFieldPackager p = new FixedFieldPackager("F1", 5, AsciiInterpreter.INSTANCE); String s = "ABC1234"; FSDMsgX msg = new FSDMsgX("Test"); - ; + msg.add("F1", p); msg.set("F1", s); byte[] b = msg.pack(); @@ -159,7 +415,7 @@ public void packTest02() throws ISOException { FixedFieldPackager p = new FixedFieldPackager("F1", 5, AsciiInterpreter.INSTANCE); String s = "ABC12"; FSDMsgX msg = new FSDMsgX("Test"); - ; + msg.add("F1", p); msg.set("F1", s); byte[] stream = msg.pack(); @@ -174,7 +430,7 @@ public void packTest03() throws ISOException { FixedFieldPackager p = new FixedFieldPackager("F1", size, BCDInterpreter.RIGHT_PADDED); FSDMsgX msg = new FSDMsgX("Test"); - ; + msg.add("F1", p); msg.set("F1", "12345"); @@ -188,9 +444,10 @@ public void packTest03() throws ISOException { public void packTest09() throws ISOException { int size = 16; - FixedFieldPackager p = new FixedFieldPackager("F1", size, AsciiInterpreter.INSTANCE, new TrackDataCompliance()); + FixedFieldPackager p = new FixedFieldPackager("F1", size, AsciiInterpreter.INSTANCE, + new TrackDataCompliance()); FSDMsgX msg = new FSDMsgX("Test"); - ; + msg.add("F1", p); String s = "1234567890123456"; @@ -212,7 +469,7 @@ public void packTest10() throws ISOException { FixedFieldPackager p = new FixedFieldPackager("F1", size, EbcdicInterpreter.INSTANCE, new TrackDataCompliance()); FSDMsgX msg = new FSDMsgX("Test"); - ; + msg.add("F1", p); String s = "1234567890123456"; @@ -227,4 +484,4 @@ public void packTest10() throws ISOException { } -} +} \ No newline at end of file diff --git a/modules/fsdmsgx/src/test/java/org/jpos/fsdpackager/LookAheadPackagerTest.java b/modules/fsdmsgx/src/test/java/org/jpos/fsdpackager/LookAheadPackagerTest.java old mode 100644 new mode 100755 index ce203d9f61..bf447663b3 --- a/modules/fsdmsgx/src/test/java/org/jpos/fsdpackager/LookAheadPackagerTest.java +++ b/modules/fsdmsgx/src/test/java/org/jpos/fsdpackager/LookAheadPackagerTest.java @@ -18,11 +18,17 @@ package org.jpos.fsdpackager; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; + +import java.util.HashMap; +import java.util.Map; + import org.jpos.iso.AsciiInterpreter; import org.jpos.iso.ISOException; import org.junit.jupiter.api.Test; -import static org.junit.jupiter.api.Assertions.assertArrayEquals; -import static org.junit.jupiter.api.Assertions.assertEquals; public class LookAheadPackagerTest { @@ -36,7 +42,7 @@ public class LookAheadPackagerTest { public void unpacktest01() throws ISOException { - String s = "ABCD1234XYZ"; + String s = "ABCD1234;XYZ"; FSDMsgX ifSet = new FSDMsgX("ifSet"); AFSDFieldPackager f0_a = new FixedFieldPackager("F0", new String(new byte[] { (byte) ';' }), AsciiInterpreter.INSTANCE); @@ -191,5 +197,305 @@ public void packtest01() throws ISOException { System.out.println(main.hexDump("")); } + + @Test + void testPack_useIfSet_fieldsSet() throws ISOException { + AFSDFieldPackager useIfSetPackager = new MockAFSDFieldPackager("useIfSet", "testValueIfSet"); + AFSDFieldPackager useIfNotSetPackager = new MockAFSDFieldPackager("useIfNotSet", "testValueIfNotSet"); + String[] fieldNamesSet = { "field1" }; + String[] fieldNamesnotSet = { "field2" }; + LookAheadPackager packager = new LookAheadPackager("lookAhead", 1, (byte) 0x01, useIfSetPackager, + useIfNotSetPackager, fieldNamesSet, + fieldNamesnotSet); + + Map fields = new HashMap<>(); + fields.put("field1", "value1"); + + byte[] packed = packager.pack(fields); + + assertNotNull(packed); + assertEquals("testValueIfSet".length(), packed.length); + assertArrayEquals("testValueIfSet".getBytes(), packed); + assertEquals("testValueIfSet", useIfSetPackager.getValue()); + } + + @Test + void testPack_useIfNotSet_fieldsNotSet() throws ISOException { + AFSDFieldPackager useIfSetPackager = new MockAFSDFieldPackager("useIfSet", "testValueIfSet"); + AFSDFieldPackager useIfNotSetPackager = new MockAFSDFieldPackager("useIfNotSet", "testValueIfNotSet"); + String[] fieldNamesSet = { "field1" }; + String[] fieldNamesnotSet = { "field2" }; + LookAheadPackager packager = new LookAheadPackager("lookAhead", 1, (byte) 0x01, useIfSetPackager, + useIfNotSetPackager, fieldNamesSet, + fieldNamesnotSet); + + Map fields = new HashMap<>(); + + byte[] packed = packager.pack(fields); + + assertNotNull(packed); + assertEquals("testValueIfNotSet".length(), packed.length); + assertArrayEquals("testValueIfNotSet".getBytes(), packed); + assertEquals("testValueIfNotSet", useIfNotSetPackager.getValue()); + } + + @Test + void testPack_noMatch() throws ISOException { + AFSDFieldPackager useIfSetPackager = new MockAFSDFieldPackager("useIfSet", "testValueIfSet"); + AFSDFieldPackager useIfNotSetPackager = new MockAFSDFieldPackager("useIfNotSet", "testValueIfNotSet"); + String[] fieldNamesSet = { "field1" }; + String[] fieldNamesnotSet = { "field2" }; + LookAheadPackager packager = new LookAheadPackager("lookAhead", 1, (byte) 0x01, null, null, + fieldNamesSet, fieldNamesnotSet); + + Map fields = new HashMap<>(); + + byte[] packed = packager.pack(fields); + + assertNull(packed); + } + + @Test + void testUnpack_useIfSet_match() throws ISOException { + AFSDFieldPackager useIfSetPackager = new MockAFSDFieldPackager("useIfSet", "testValue"); + AFSDFieldPackager useIfNotSetPackager = new MockAFSDFieldPackager("useIfNotSet", "testValue"); + String[] fieldNamesSet = { "field1" }; + String[] fieldNamesnotSet = { "field2" }; + LookAheadPackager packager = new LookAheadPackager("lookAhead", 1, (byte) 0x01, useIfSetPackager, + useIfNotSetPackager, fieldNamesSet, + fieldNamesnotSet); + + byte[] inStream = { 0x00, 0x01, 0x02, 0x03 }; + Map fields = new HashMap<>(); + + int newOffset = packager.unpack(inStream, 0, fields); + + assertEquals("testValue", useIfSetPackager.getValue()); + assertEquals("testValue", fields.get("useIfSet")); + + assertEquals("testValue", useIfSetPackager.getValue()); + assertEquals(9, newOffset); + + } + + @Test + void testUnpack_useIfNotSet_noMatch() throws ISOException { + AFSDFieldPackager useIfSetPackager = new MockAFSDFieldPackager("useIfSet", "testValue"); + AFSDFieldPackager useIfNotSetPackager = new MockAFSDFieldPackager("useIfNotSet", "testValue2"); + String[] fieldNamesSet = { "field1" }; + String[] fieldNamesnotSet = { "field2" }; + LookAheadPackager packager = new LookAheadPackager("lookAhead", 1, (byte) 0x01, useIfSetPackager, + useIfNotSetPackager, fieldNamesSet, + fieldNamesnotSet); + + byte[] inStream = { 0x00, 0x02, 0x02, 0x03 }; + Map fields = new HashMap<>(); + + int newOffset = packager.unpack(inStream, 0, fields); + + assertEquals("testValue2", useIfNotSetPackager.getValue()); + assertEquals("testValue2", fields.get("useIfNotSet")); + assertEquals(9, newOffset); + } + + @Test + void testUnpack_noMatch() throws ISOException { + AFSDFieldPackager useIfSetPackager = new MockAFSDFieldPackager("useIfSet", "testValue"); + AFSDFieldPackager useIfNotSetPackager = new MockAFSDFieldPackager("useIfNotSet", "testValue"); + String[] fieldNamesSet = { "field1" }; + String[] fieldNamesnotSet = { "field2" }; + LookAheadPackager packager = new LookAheadPackager("lookAhead", 1, (byte) 0x01, null, null, + fieldNamesSet, fieldNamesnotSet); + + byte[] inStream = { 0x00, 0x02, 0x02, 0x03 }; + Map fields = new HashMap<>(); + + int newOffset = packager.unpack(inStream, 0, fields); + + assertEquals(0, newOffset); + } + + @Test + void testUnpack_offsetOutOfBounds() throws ISOException { + AFSDFieldPackager useIfSetPackager = new MockAFSDFieldPackager("useIfSet", "testValue"); + AFSDFieldPackager useIfNotSetPackager = new MockAFSDFieldPackager("useIfNotSet", "testValue"); + String[] fieldNamesSet = { "field1" }; + String[] fieldNamesnotSet = { "field2" }; + LookAheadPackager packager = new LookAheadPackager("lookAhead", 2, (byte) 0x01, useIfSetPackager, + useIfNotSetPackager, fieldNamesSet, + fieldNamesnotSet); + + byte[] inStream = { 0x00, 0x01 }; + Map fields = new HashMap<>(); + + int newOffset = packager.unpack(inStream, 0, fields); + + assertEquals(0, newOffset); + } + + @Test + void testDump_useIfSet_fieldsSet() { + AFSDFieldPackager useIfSetPackager = new MockAFSDFieldPackager("useIfSet", "testValue"); + AFSDFieldPackager useIfNotSetPackager = new MockAFSDFieldPackager("useIfNotSet", "testValue"); + String[] fieldNamesSet = { "field1" }; + String[] fieldNamesnotSet = { "field2" }; + LookAheadPackager packager = new LookAheadPackager("lookAhead", 1, (byte) 0x01, useIfSetPackager, + useIfNotSetPackager, fieldNamesSet, + fieldNamesnotSet); + + Map fields = new HashMap<>(); + fields.put("field1", "value1"); + + String dump = packager.dump("", fields); + + assertEquals("Mock Field [useIfSet] : value=testValue", dump); + } + + @Test + void testDump_useIfNotSet_fieldsNotSet() { + AFSDFieldPackager useIfSetPackager = new MockAFSDFieldPackager("useIfSet", "testValue"); + AFSDFieldPackager useIfNotSetPackager = new MockAFSDFieldPackager("useIfNotSet", "testValue2"); + String[] fieldNamesSet = { "field1" }; + String[] fieldNamesnotSet = { "field2" }; + LookAheadPackager packager = new LookAheadPackager("lookAhead", 1, (byte) 0x01, useIfSetPackager, + useIfNotSetPackager, fieldNamesSet, + fieldNamesnotSet); + Map fields = new HashMap<>(); + String dump = packager.dump("", fields); + assertEquals("Mock Field [useIfNotSet] : value=testValue2", dump); + } + + @Test + void testDump_noMatch() { + String[] fieldNamesSet = { "field1" }; + String[] fieldNamesnotSet = { "field2" }; + LookAheadPackager packager = new LookAheadPackager("lookAhead", 1, (byte) 0x01, null, null, + fieldNamesSet, fieldNamesnotSet); + Map fields = new HashMap<>(); + String dump = packager.dump("", fields); + assertEquals("", dump); + } + + @Test + void testHexDump_useIfSet_fieldsSet() { + AFSDFieldPackager useIfSetPackager = new MockAFSDFieldPackager("useIfSet", "testValue"); + AFSDFieldPackager useIfNotSetPackager = new MockAFSDFieldPackager("useIfNotSet", "testValue2"); + String[] fieldNamesSet = { "field1" }; + String[] fieldNamesnotSet = { "field2" }; + LookAheadPackager packager = new LookAheadPackager("lookAhead", 1, (byte) 0x01, useIfSetPackager, + useIfNotSetPackager, fieldNamesSet, + fieldNamesnotSet); + + Map fields = new HashMap<>(); + fields.put("field1", "value1"); + + byte[] hexDump = packager.hexDump("", fields); + assertArrayEquals("testValue".getBytes(), hexDump); + // assertEquals("Mock Field [useIfSet] : value=testValue", hexDump); + } + + @Test + void testHexDump_useIfNotSet_fieldsNotSet() { + AFSDFieldPackager useIfSetPackager = new MockAFSDFieldPackager("useIfSet", "testValue"); + AFSDFieldPackager useIfNotSetPackager = new MockAFSDFieldPackager("useIfNotSet", "testValue2"); + String[] fieldNamesSet = { "field1" }; + String[] fieldNamesnotSet = { "field2" }; + LookAheadPackager packager = new LookAheadPackager("lookAhead", 1, (byte) 0x01, useIfSetPackager, + useIfNotSetPackager, fieldNamesSet, + fieldNamesnotSet); + Map fields = new HashMap<>(); + byte[] hexDump = packager.hexDump("", fields); + assertArrayEquals("testValue2".getBytes(), hexDump); + + // assertEquals("Mock Field [useIfNotSet] : value=testValue2", hexDump); + } + + @Test + void testHexDump_noMatch() { + String[] fieldNamesSet = { "field1" }; + String[] fieldNamesnotSet = { "field2" }; + LookAheadPackager packager = new LookAheadPackager("lookAhead", 1, (byte) 0x01, null, null, + fieldNamesSet, fieldNamesnotSet); + Map fields = new HashMap<>(); + + byte[] hexDump = packager.hexDump("", fields); + assertNull(hexDump); + + } + + @Test + void testGetParserTree() { + AFSDFieldPackager useIfSetPackager = new MockAFSDFieldPackager("useIfSet", "testValue"); + AFSDFieldPackager useIfNotSetPackager = new MockAFSDFieldPackager("useIfNotSet", "testValue2"); + String[] fieldNamesSet = { "field1", "field2" }; + String[] fieldNamesnotSet = { "field3" }; + + LookAheadPackager packager = new LookAheadPackager("lookAhead", 1, (byte) 0x01, useIfSetPackager, + useIfNotSetPackager, fieldNamesSet, fieldNamesnotSet); + String tree = packager.getParserTree(""); + String expected = String.format("Field [lookAhead] : [LookAhead]%n" + "\t\t\toffset[1] find[0x1]%n" + + "\t\t\t\t[if found]%n" + "\t\t\t\t\tMock Field [useIfSet] : value=testValue%n" + + "\t\t\t\t[if not found]%n" + "\t\t\t\t\tMock Field [useIfNotSet] : value=testValue2%n" + + "\t\t\tCheck Field[field1,field2,]%n"); + assertEquals(expected, tree); + + LookAheadPackager packagerNulls = new LookAheadPackager("lookAhead", 1, (byte) 0x01, null, null, fieldNamesSet, + fieldNamesnotSet); + String treeNulls = packagerNulls.getParserTree(""); + String expectedNulls = String.format("Field [lookAhead] : [LookAhead]%n" + + "\t\t\toffset[1] find[0x1]%n" + "\t\t\t\t[if found]%n" + "\t\t\t\t\t[Not Set]" + + System.lineSeparator() + "\t\t\t\t[if not found]%n" + "\t\t\t\t\t[Not Set]" + System.lineSeparator() + + "\t\t\tCheck Field[field1,field2,]%n"); + assertEquals(expectedNulls, treeNulls); + } + + // Mock class for AFSDFieldPackager to isolate LookAheadPackager logic. + static class MockAFSDFieldPackager extends AFSDFieldPackager { + private String value; + private String name; + + public MockAFSDFieldPackager(String name, String value) { + this.value = value; + this.name = name; + } + + @Override + public byte[] pack(Map setfields) throws ISOException { + return value.getBytes(); + } + + @Override + public int unpack(byte[] inStream, int offset, Map fields) throws ISOException { + fields.put(name, value); + return 9; + + } + + @Override + public String dump(String prefix, Map setfields) { + return prefix + "Mock Field [" + name + "] : value=" + value; + } + + @Override + public byte[] hexDump(String prefix, Map setfields) { + return value.getBytes(); + } + + @Override + public String getParserTree(String prefix) { + return prefix + "Mock Field [" + name + "] : value=" + value + System.lineSeparator(); + } + + @Override + public String getValue() { + return value; + } + + @Override + public String getName() { + return name; + } + } + } diff --git a/modules/fsdmsgx/src/test/java/org/jpos/fsdpackager/OptionalPackagerTest.java b/modules/fsdmsgx/src/test/java/org/jpos/fsdpackager/OptionalPackagerTest.java new file mode 100644 index 0000000000..26e8d2087e --- /dev/null +++ b/modules/fsdmsgx/src/test/java/org/jpos/fsdpackager/OptionalPackagerTest.java @@ -0,0 +1,156 @@ +package org.jpos.fsdpackager; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; + +import java.util.HashMap; +import java.util.Map; + +import org.jpos.iso.ISOException; +import org.junit.jupiter.api.Test; + +public class OptionalPackagerTest { + + @Test + void testPack_fieldPresent() throws ISOException { + AFSDFieldPackager mockPackager = new MockAFSDFieldPackager("testField", "testValue"); + OptionalPackager optionalPackager = new OptionalPackager("optional", mockPackager); + Map fields = new HashMap<>(); + fields.put("testField", "value"); + + byte[] packed = optionalPackager.pack(fields); + assertNotNull(packed); + assertArrayEquals("testValue".getBytes(), packed); + } + + @Test + void testPack_fieldAbsent() throws ISOException { + AFSDFieldPackager mockPackager = new MockAFSDFieldPackager("testField", "testValue"); + OptionalPackager optionalPackager = new OptionalPackager("optional", mockPackager); + Map fields = new HashMap<>(); + + byte[] packed = optionalPackager.pack(fields); + assertNull(packed); + } + + @Test + void testUnpack_fieldPresent() throws ISOException { + AFSDFieldPackager mockPackager = new MockAFSDFieldPackager("testField", "testValue"); + OptionalPackager optionalPackager = new OptionalPackager("optional", mockPackager); + byte[] inStream = "testValue".getBytes(); + Map fields = new HashMap<>(); + int offset = optionalPackager.unpack(inStream, 0, fields); + + assertEquals(9, offset); + assertEquals("testValue", fields.get("testField")); + } + + @Test + void testUnpack_fieldAbsent() throws ISOException { + AFSDFieldPackager mockPackager = new FixedFieldPackager("testField", 9); + OptionalPackager optionalPackager = new OptionalPackager("optional", mockPackager); + byte[] inStream = {}; + Map fields = new HashMap<>(); + int offset = optionalPackager.unpack(inStream, 0, fields); + + assertEquals(0, offset); + assertNull(fields.get("testField")); + } + + @Test + void testGetParserTree() { + AFSDFieldPackager mockPackager = new MockAFSDFieldPackager("testField", "testValue"); + OptionalPackager optionalPackager = new OptionalPackager("optional", mockPackager); + String tree = optionalPackager.getParserTree(""); + String expected = String.format("Field [optional] : [OPTIONAL]%n" + + "\tMock Field [testField] : value=testValue%n"); + assertEquals(expected, tree); + } + + @Test + void testDump_fieldPresent() { + AFSDFieldPackager mockPackager = new MockAFSDFieldPackager("testField", "testValue"); + OptionalPackager optionalPackager = new OptionalPackager("optional", mockPackager); + Map fields = new HashMap<>(); + fields.put("testField", "value"); + String dump = optionalPackager.dump("", fields); + assertEquals("Mock Field [testField] : value=testValue", dump); + } + + @Test + void testDump_fieldAbsent() { + AFSDFieldPackager mockPackager = new FixedFieldPackager("testField", 9); + OptionalPackager optionalPackager = new OptionalPackager("optional", mockPackager); + Map fields = new HashMap<>(); + String dump = optionalPackager.dump("", fields); + assertEquals("", dump); + } + + @Test + void testHexDump_fieldPresent() { + AFSDFieldPackager mockPackager = new MockAFSDFieldPackager("testField", "testValue"); + OptionalPackager optionalPackager = new OptionalPackager("optional", mockPackager); + Map fields = new HashMap<>(); + fields.put("testField", "value"); + byte[] hexDump = optionalPackager.hexDump("", fields); + assertArrayEquals("testValue".getBytes(), hexDump); + + } + + @Test + void testHexDump_fieldAbsent() { + AFSDFieldPackager mockPackager = new MockAFSDFieldPackager("testField", "testValue"); + OptionalPackager optionalPackager = new OptionalPackager("optional", mockPackager); + Map fields = new HashMap<>(); + byte[] hexDump = optionalPackager.hexDump("", fields); + assertArrayEquals("testValue".getBytes(), hexDump); + + } + + // Mock class for AFSDFieldPackager to isolate OptionalPackager logic. + static class MockAFSDFieldPackager extends AFSDFieldPackager { + private String value; + private String name; + + public MockAFSDFieldPackager(String name, String value) { + this.value = value; + this.name = name; + } + + @Override + public byte[] pack(Map setfields) throws ISOException { + if (setfields.get(name) == null) { + throw new ISOException("field not set"); + } + return value.getBytes(); + } + + @Override + public int unpack(byte[] inStream, int offset, Map fields) throws ISOException { + fields.put(name, value); + return 9; + } + + @Override + public String dump(String prefix, Map setfields) { + return prefix + "Mock Field [" + name + "] : value=" + value; + } + + @Override + public String getParserTree(String prefix) { + return prefix + "Mock Field [" + name + "] : value=" + value + System.lineSeparator(); + } + + @Override + public byte[] hexDump(String prefix, Map setfields) { + return value.getBytes(); + } + + @Override + public String getName() { + return name; + } + } +} \ No newline at end of file diff --git a/modules/fsdmsgx/src/test/java/org/jpos/fsdpackager/VariableFieldPackagerTest.java b/modules/fsdmsgx/src/test/java/org/jpos/fsdpackager/VariableFieldPackagerTest.java old mode 100644 new mode 100755 index 5236a258d0..fbf2ff0b56 --- a/modules/fsdmsgx/src/test/java/org/jpos/fsdpackager/VariableFieldPackagerTest.java +++ b/modules/fsdmsgx/src/test/java/org/jpos/fsdpackager/VariableFieldPackagerTest.java @@ -1,236 +1,449 @@ -/* - * jPOS Project [http://jpos.org] - * Copyright (C) 2000-2024 jPOS Software SRL - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Affero General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Affero General Public License for more details. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - */ - package org.jpos.fsdpackager; -import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import java.util.HashMap; +import java.util.Map; +import org.jpos.fsdpackager.compliance.APCICompliance; +import org.jpos.fsdpackager.compliance.NoCompliance; import org.jpos.iso.AsciiInterpreter; import org.jpos.iso.ISOException; import org.jpos.iso.ISOUtil; -import org.junit.jupiter.api.Test; +import org.jpos.iso.Interpreter; +import org.junit.Before; +import org.junit.Test; public class VariableFieldPackagerTest { - /** - * Happy day scenario where a variable field within the max size with a - * field separator is received. The field should be available for use - * without the delimiter. - * - * @throws ISOException - */ - @Test - public void unpackTest01() throws ISOException { - - VariableFieldPackager p = new VariableFieldPackager("F1", 20, new Byte((byte) 0x1c), AsciiInterpreter.INSTANCE); - FSDMsgX msg = new FSDMsgX("Test");; - msg.add("F1", p); - String inStream = "123456" + (char) 0x1c; - msg.unpack(inStream.getBytes()); - - assertEquals("123456", msg.get("F1")); - - } - - /** - * Happy day scenario where a variable field is set without using a - * delimiter. The resulting byte array will have the data and the delimiter - * in it. - * - * @throws ISOException - */ - @Test - public void packTest01() throws ISOException { - - VariableFieldPackager f1 = new VariableFieldPackager("F1", 20, new Byte((byte) 0x1c), - AsciiInterpreter.INSTANCE); - FSDMsgX msg = new FSDMsgX("Test");; - msg.add("F1", f1); - msg.set("F1", "123456"); - - byte[] outStream = msg.pack(); - - assertArrayEquals(("123456" + (char) 0x1c).getBytes(), outStream); - - } - - /** - * Happy day scenario where a 2 variable field within the max size with - * their respective delimiters is received. The field should be available - * for use without the delimiter. - * - * @throws ISOException - */ - @Test - public void unpackTest02() throws ISOException { - - VariableFieldPackager f1 = new VariableFieldPackager("F1", 20, new Byte((byte) 0x1c), - AsciiInterpreter.INSTANCE); - VariableFieldPackager f2 = new VariableFieldPackager("F2", 5, new Byte((byte) 0x1d), AsciiInterpreter.INSTANCE); - - FSDMsgX msg = new FSDMsgX("Test");; - msg.add("F1", f1); - msg.add("F2", f2); - - String inStream = "123456" + (char) 0x1c + "ABC" + (char) 0x1d; - msg.unpack(inStream.getBytes()); - - assertEquals("123456", msg.get("F1")); - assertEquals("ABC", msg.get("F2")); - - } - - /** - * Happy day scenario where a multiple variable fields are set without using - * a delimiter. The resulting byte array will have the data of the fields - * with their respective delimiters in it. - * - * @throws ISOException - */ - - @Test - public void packTest02() throws ISOException { - - VariableFieldPackager f1 = new VariableFieldPackager("F1", 20, new Byte((byte) 0x1c), - AsciiInterpreter.INSTANCE); - VariableFieldPackager f2 = new VariableFieldPackager("F2", 5, new Byte((byte) 0x1d), AsciiInterpreter.INSTANCE); - - FSDMsgX msg = new FSDMsgX("Test");; - msg.add("F1", f1); - msg.add("F2", f2); - - msg.set("F1", "123456"); - msg.set("F2", "ABC"); - - byte[] outStream = msg.pack(); - - assertArrayEquals(("123456" + (char) 0x1c + "ABC" + (char) 0x1d).getBytes(), outStream); - - } - - /** - * The order of the packed fields is dependent on the FSDMsg2's add. Setting - * of fields can be in any order. - * - * @throws ISOException - */ - @Test - public void packTest03() throws ISOException { - - VariableFieldPackager f1 = new VariableFieldPackager("F1", 20, new Byte((byte) 0x1c), - AsciiInterpreter.INSTANCE); - VariableFieldPackager f2 = new VariableFieldPackager("F2", 5, new Byte((byte) 0x1d), AsciiInterpreter.INSTANCE); - - FSDMsgX msg = new FSDMsgX("Test");; - msg.add("F1", f1); - msg.add("F2", f2); - - msg.set("F2", "ABC"); - msg.set("F1", "123456"); - - byte[] outStream = msg.pack(); - - assertArrayEquals(("123456" + (char) 0x1c + "ABC" + (char) 0x1d).getBytes(), outStream); - - } - - /** - * Field size can be upto 20 followed by delimiter. The data available is 25 - * wide and no delimiter. An exception should be thrown indicating a - * delimiter wasnt found after the max of 20 allowed. - * - * @throws ISOException - */ - @Test - public void unpackTest03() throws ISOException { - - Throwable exception = assertThrows(ISOException.class, () -> { - - VariableFieldPackager p = new VariableFieldPackager("F1", 20, new Byte((byte) 0x1c), AsciiInterpreter.INSTANCE); - FSDMsgX msg = new FSDMsgX("Test");; - msg.add("F1", p); - - String inStream = ISOUtil.padleft("", 25, '1') + (char) 0x1c; - msg.unpack(inStream.getBytes()); - }); - assertEquals("Field [F1]: Delimiter 1c not present after max size 20", exception.getMessage()); + private VariableFieldPackager packager; + private Map fields; + private byte delimiter; + private Interpreter interpreter; + + @Before + public void setUp() { + delimiter = 0x1C; // Example delimiter + interpreter = AsciiInterpreter.INSTANCE; + fields = new HashMap<>(); + } + + @Test + public void testUnpack_validData() throws ISOException { + packager = new VariableFieldPackager("field1", 10, delimiter, interpreter); + byte[] inStream = "test".getBytes(); + byte[] withDelimiter = new byte[inStream.length + 1]; + System.arraycopy(inStream, 0, withDelimiter, 0, inStream.length); + withDelimiter[withDelimiter.length - 1] = delimiter; + + int offset = 0; + int bytesRead = packager.unpack(withDelimiter, offset, fields); + assertEquals(5, bytesRead); + assertEquals("test", packager.getValue()); + } + + @Test + public void testUnpack_emptyData() throws ISOException { + packager = new VariableFieldPackager("field1", 10, delimiter, interpreter); + byte[] inStream = { delimiter }; + int offset = 0; + int bytesRead = packager.unpack(inStream, offset, fields); + assertEquals(1, bytesRead); + assertEquals("", packager.getValue()); + } + + @Test + public void testUnpack_noDelimiter() throws ISOException { + // No exception as its delimiter or end of message + packager = new VariableFieldPackager("field1", 10, delimiter, interpreter); + byte[] inStream = "test".getBytes(); + int offset = 0; + packager.unpack(inStream, offset, fields); + } + + @Test(expected = ISOException.class) + public void testUnpack_exceedsMaxSize() throws ISOException { + packager = new VariableFieldPackager("field1", 2, delimiter, interpreter); + byte[] inStream = "test".getBytes(); + byte[] withDelimiter = new byte[inStream.length + 1]; + System.arraycopy(inStream, 0, withDelimiter, 0, inStream.length); + withDelimiter[withDelimiter.length - 1] = delimiter; + int offset = 0; + packager.unpack(withDelimiter, offset, fields); + + } + + @Test + public void testUnpack_maxSizeEqualToData() throws ISOException { + packager = new VariableFieldPackager("field1", 4, delimiter, interpreter); + byte[] inStream = "test".getBytes(); + byte[] withDelimiter = new byte[inStream.length + 1]; + System.arraycopy(inStream, 0, withDelimiter, 0, inStream.length); + withDelimiter[withDelimiter.length - 1] = delimiter; + int offset = 0; + int bytesRead = packager.unpack(withDelimiter, offset, fields); + assertEquals(5, bytesRead); + assertEquals("test", packager.getValue()); + } + + @Test + public void testPack_validData() throws ISOException { + packager = new VariableFieldPackager("field1", 10, delimiter, interpreter); + fields.put("field1", "test"); + byte[] packed = packager.pack(fields); + byte[] expected = "test".getBytes(); + byte[] expectedWithDelimiter = new byte[expected.length + 1]; + System.arraycopy(expected, 0, expectedWithDelimiter, 0, expected.length); + expectedWithDelimiter[expectedWithDelimiter.length - 1] = delimiter; + assertArrayEquals(expectedWithDelimiter, packed); + assertEquals("test", packager.getValue()); + } + + @Test + public void testPack_fieldValueNotNull() throws ISOException { + packager = new VariableFieldPackager("field1", 10, delimiter, interpreter); + packager.setValue("test"); + byte[] packed = packager.pack(fields); + byte[] expected = "test".getBytes(); + byte[] expectedWithDelimiter = new byte[expected.length + 1]; + System.arraycopy(expected, 0, expectedWithDelimiter, 0, expected.length); + expectedWithDelimiter[expectedWithDelimiter.length - 1] = delimiter; + assertArrayEquals(expectedWithDelimiter, packed); + assertEquals("test", packager.getValue()); + + } + + @Test + public void testPack_emptyData() throws ISOException { + packager = new VariableFieldPackager("field1", 10, delimiter, interpreter); + fields.put("field1", ""); + byte[] packed = packager.pack(fields); + assertEquals("", packager.getValue()); + assertArrayEquals(new byte[] { delimiter }, packed); + } + + @Test + public void testPack_nullData() throws ISOException { + packager = new VariableFieldPackager("field1", 10, delimiter, interpreter); + byte[] packed = packager.pack(fields); + assertEquals("", packager.getValue()); + assertArrayEquals(new byte[] { delimiter }, packed); + } + + @Test(expected = ISOException.class) + public void testPack_exceedsMaxSize() throws ISOException { + packager = new VariableFieldPackager("field1", 2, delimiter, interpreter); + fields.put("field1", "test"); + packager.pack(fields); + } + + @Test + public void testPack_maxSizeEqualToValueLength() throws ISOException { + packager = new VariableFieldPackager("field1", 4, delimiter, interpreter); + fields.put("field1", "test"); + byte[] packed = packager.pack(fields); + byte[] expected = "test".getBytes(); + byte[] expectedWithDelimiter = new byte[expected.length + 1]; + System.arraycopy(expected, 0, expectedWithDelimiter, 0, expected.length); + expectedWithDelimiter[expectedWithDelimiter.length - 1] = delimiter; + assertArrayEquals(expectedWithDelimiter, packed); + assertEquals("test", packager.getValue()); + } + + @Test + public void testConstructorWithCompliance() { + APCICompliance compliance = new NoCompliance(); + packager = new VariableFieldPackager("field1", 10, delimiter, interpreter, compliance); + assertNotNull(packager); + } + + @Test + public void testConstructorWithoutMaxSize() { + packager = new VariableFieldPackager("field1", delimiter, interpreter); + assertNotNull(packager); + } + + @Test + public void testConstructorWithoutMaxSizeWithCompliance() { + APCICompliance compliance = new NoCompliance(); + packager = new VariableFieldPackager("field1", delimiter, interpreter, compliance); + assertNotNull(packager); + } + + @Test + public void testConstructorWithMandatory() { + packager = new VariableFieldPackager("field1", 10, delimiter, interpreter, true); + assertNotNull(packager); + } + + @Test + public void testDump() { + packager = new VariableFieldPackager("field1", 10, delimiter, interpreter); + packager.setValue("test"); + String dump = packager.dump("", fields); + assertEquals("\n", dump); + } + + @Test + public void testDump_NullValue() { + packager = new VariableFieldPackager("field1", 10, delimiter, interpreter); + String dump = packager.dump("", fields); + assertEquals("", dump); + } + + @Test + public void testHexDump_withValue() { + packager = new VariableFieldPackager("field1", 10, delimiter, interpreter); + packager.setValue("test"); + byte[] hexDump = packager.hexDump("", fields); + byte[] expected = "test".getBytes(); + byte[] expectedWithDelimiter = new byte[expected.length + 1]; + System.arraycopy(expected, 0, expectedWithDelimiter, 0, expected.length); + expectedWithDelimiter[expectedWithDelimiter.length - 1] = delimiter; + assertArrayEquals(expectedWithDelimiter, hexDump); + } + + @Test + public void testHexDump_NullValue() { + packager = new VariableFieldPackager("field1", 10, delimiter, interpreter); + byte[] hexDump = packager.hexDump("", fields); + byte[] expected = { 0x1c }; + assertArrayEquals(hexDump, expected); + + } + + @Test + public void testGetParserTree() { + packager = new VariableFieldPackager("field1", 10, delimiter, interpreter); + packager.setValue("test"); + String parserTree = packager.getParserTree(""); + assertEquals("Field [field1] : VAR[0..10] delimiter[0x1C] or EOM : test\n", parserTree); + + } + + @Test + public void testGetParserTree_NullValue() { + packager = new VariableFieldPackager("field1", 10, delimiter, interpreter); + String parserTree = packager.getParserTree(""); + assertEquals("Field [field1] : VAR[0..10] delimiter[0x1C] or EOM \n", parserTree); + + } + + /** + * Happy day scenario where a variable field within the max size with a + * field separator is received. The field should be available for use + * without the delimiter. + * + * @throws ISOException + */ + @Test + public void unpackTest01() throws ISOException { + + VariableFieldPackager p = new VariableFieldPackager("F1", 20, Byte.valueOf((byte) 0x1c), + AsciiInterpreter.INSTANCE); + FSDMsgX msg = new FSDMsgX("Test"); + msg.add("F1", p); + String inStream = "123456" + (char) 0x1c; + msg.unpack(inStream.getBytes()); + + assertEquals("123456", msg.get("F1")); + + } + + /** + * Happy day scenario where a variable field is set without using a + * delimiter. The resulting byte array will have the data and the delimiter + * in it. + * + * @throws ISOException + */ + @Test + public void packTest01() throws ISOException { + + VariableFieldPackager f1 = new VariableFieldPackager("F1", 20, Byte.valueOf((byte) 0x1c), + AsciiInterpreter.INSTANCE); + FSDMsgX msg = new FSDMsgX("Test"); + msg.add("F1", f1); + msg.set("F1", "123456"); + + byte[] outStream = msg.pack(); + + assertArrayEquals(("123456" + (char) 0x1c).getBytes(), outStream); + + } + + /** + * Happy day scenario where a 2 variable field within the max size with + * their respective delimiters is received. The field should be available + * for use without the delimiter. + * + * @throws ISOException + */ + @Test + public void unpackTest02() throws ISOException { + + VariableFieldPackager f1 = new VariableFieldPackager("F1", 20, Byte.valueOf((byte) 0x1c), + AsciiInterpreter.INSTANCE); + VariableFieldPackager f2 = new VariableFieldPackager("F2", 5, Byte.valueOf((byte) 0x1d), + AsciiInterpreter.INSTANCE); + + FSDMsgX msg = new FSDMsgX("Test"); + msg.add("F1", f1); + msg.add("F2", f2); + + String inStream = "123456" + (char) 0x1c + "ABC" + (char) 0x1d; + msg.unpack(inStream.getBytes()); + + assertEquals("123456", msg.get("F1")); + assertEquals("ABC", msg.get("F2")); + + } + + /** + * Happy day scenario where a multiple variable fields are set without using + * a delimiter. The resulting byte array will have the data of the fields + * with their respective delimiters in it. + * + * @throws ISOException + */ + + @Test + public void packTest02() throws ISOException { + + VariableFieldPackager f1 = new VariableFieldPackager("F1", 20, Byte.valueOf((byte) 0x1c), + AsciiInterpreter.INSTANCE); + VariableFieldPackager f2 = new VariableFieldPackager("F2", 5, Byte.valueOf((byte) 0x1d), + AsciiInterpreter.INSTANCE); + + FSDMsgX msg = new FSDMsgX("Test"); + msg.add("F1", f1); + msg.add("F2", f2); + + msg.set("F1", "123456"); + msg.set("F2", "ABC"); + + byte[] outStream = msg.pack(); + + assertArrayEquals(("123456" + (char) 0x1c + "ABC" + (char) 0x1d).getBytes(), outStream); + + } + + /** + * The order of the packed fields is dependent on the FSDMsg2's add. Setting + * of fields can be in any order. + * + * @throws ISOException + */ + @Test + public void packTest03() throws ISOException { + + VariableFieldPackager f1 = new VariableFieldPackager("F1", 20, Byte.valueOf((byte) 0x1c), + AsciiInterpreter.INSTANCE); + VariableFieldPackager f2 = new VariableFieldPackager("F2", 5, Byte.valueOf((byte) 0x1d), + AsciiInterpreter.INSTANCE); + + FSDMsgX msg = new FSDMsgX("Test"); + msg.add("F1", f1); + msg.add("F2", f2); - } + msg.set("F2", "ABC"); + msg.set("F1", "123456"); + + byte[] outStream = msg.pack(); + + assertArrayEquals(("123456" + (char) 0x1c + "ABC" + (char) 0x1d).getBytes(), outStream); + + } + + /** + * Field size can be upto 20 followed by delimiter. The data available is 25 + * wide and no delimiter. An exception should be thrown indicating a + * delimiter wasnt found after the max of 20 allowed. + * + * @throws ISOException + */ + @Test + public void unpackTest03() throws ISOException { - /** - * If a variable stream comes in with data that reaches end of stream and - * does not contain a delimitter its valid. There is no point to have a - * delimiter at the end of a field if its the last field. - * - * @throws ISOException - */ - @Test - public void unpackTest04() throws ISOException { + Throwable exception = assertThrows(ISOException.class, () -> { - VariableFieldPackager p = new VariableFieldPackager("F1", 20, new Byte((byte) 0x1c), AsciiInterpreter.INSTANCE); - FSDMsgX msg = new FSDMsgX("Test");; - msg.add("F1", p); + VariableFieldPackager p = new VariableFieldPackager("F1", 20, Byte.valueOf((byte) 0x1c), + AsciiInterpreter.INSTANCE); + FSDMsgX msg = new FSDMsgX("Test"); + msg.add("F1", p); + + String inStream = ISOUtil.padleft("", 25, '1') + (char) 0x1c; + msg.unpack(inStream.getBytes()); + }); + assertEquals("Field [F1]: Delimiter 1c not present after max size 20", exception.getMessage()); + + } - String inStream = ISOUtil.padleft("", 10, '1'); - msg.unpack(inStream.getBytes()); + /** + * If a variable stream comes in with data that reaches end of stream and + * does not contain a delimitter its valid. There is no point to have a + * delimiter at the end of a field if its the last field. + * + * @throws ISOException + */ + @Test + public void unpackTest04() throws ISOException { - assertEquals(inStream, msg.get("F1")); + VariableFieldPackager p = new VariableFieldPackager("F1", 20, Byte.valueOf((byte) 0x1c), + AsciiInterpreter.INSTANCE); + FSDMsgX msg = new FSDMsgX("Test"); + msg.add("F1", p); - } + String inStream = ISOUtil.padleft("", 10, '1'); + msg.unpack(inStream.getBytes()); - /** - * variable fields indicate their presence with the delimiter. If there is - * no data a delimiter needs to be sent indicating the presence of the field - * with no data. The field will be set with an empty string. - * - * @throws ISOException - */ - @Test - public void unpackTest05() throws ISOException { + assertEquals(inStream, msg.get("F1")); - VariableFieldPackager p = new VariableFieldPackager("F1", 20, new Byte((byte) 0x1c), AsciiInterpreter.INSTANCE); - FSDMsgX msg = new FSDMsgX("Test");; - msg.add("F1", p); + } + + /** + * variable fields indicate their presence with the delimiter. If there is + * no data a delimiter needs to be sent indicating the presence of the field + * with no data. The field will be set with an empty string. + * + * @throws ISOException + */ + @Test + public void unpackTest05() throws ISOException { - String inStream = new String(new byte[] { 0x1c }); - msg.unpack(inStream.getBytes()); + VariableFieldPackager p = new VariableFieldPackager("F1", 20, Byte.valueOf((byte) 0x1c), + AsciiInterpreter.INSTANCE); + FSDMsgX msg = new FSDMsgX("Test"); + msg.add("F1", p); - assertEquals("", msg.get("F1")); + String inStream = new String(new byte[] { 0x1c }); + msg.unpack(inStream.getBytes()); - } + assertEquals("", msg.get("F1")); - /** - * At time of packing if the field is not set, make sure that the delimiter - * is still available. - * - * @throws ISOException - */ - @Test - public void packTest04() throws ISOException { + } - VariableFieldPackager p = new VariableFieldPackager("F1", 20, new Byte((byte) 0x1c), AsciiInterpreter.INSTANCE); - FSDMsgX msg = new FSDMsgX("Test");; - msg.add("F1", p); + /** + * At time of packing if the field is not set, make sure that the delimiter + * is still available. + * + * @throws ISOException + */ + @Test + public void packTest04() throws ISOException { + + VariableFieldPackager p = new VariableFieldPackager("F1", 20, Byte.valueOf((byte) 0x1c), + AsciiInterpreter.INSTANCE); + FSDMsgX msg = new FSDMsgX("Test"); + msg.add("F1", p); - byte[] outStream = msg.pack(); + byte[] outStream = msg.pack(); - assertArrayEquals(new byte[] { 0x1c }, outStream); + assertArrayEquals(new byte[] { 0x1c }, outStream); - } + } -} +} \ No newline at end of file