public void Format()
{
FormatterContext formatterContext = new FormatterContext(
FormatterContext.DefaultBufferSize);
Message value = new Message();
value.Formatter = GetFormatter(_fixedMessageFormatter);
value.Fields.Add(1, "HE");
value.Fields.Add(2, "LLO");
InnerMessageField field = new InnerMessageField(37, value);
InnerMessageFieldFormatter formatter;
string formattedData;
// Test fixed length formatting.
formatter = new InnerMessageFieldFormatter(37,
new FixedLengthManager(5), BinaryEncoder.GetInstance(),
GetFormatter(_fixedMessageFormatter));
formatter.Format(field, ref formatterContext);
formattedData = formatterContext.GetDataAsString();
Assert.IsTrue(formattedData.Equals("HELLO"));
formatterContext.Clear();
formatter = new InnerMessageFieldFormatter(37,
new FixedLengthManager(4), BinaryEncoder.GetInstance(),
GetFormatter(_fixedMessageFormatter));
try {
formatter.Format(field, ref formatterContext);
Assert.Fail();
}
catch (ArgumentOutOfRangeException e) {
Assert.IsTrue(e.ParamName.Equals("dataLength"));
}
// Test variable length formatting.
formatterContext.Clear();
formatter = new InnerMessageFieldFormatter(48, new VariableLengthManager(0,
999, StringLengthEncoder.GetInstance(999)),
BinaryEncoder.GetInstance(), GetFormatter(_fixedMessageFormatter));
formatter.Format(field, ref formatterContext);
formattedData = formatterContext.GetDataAsString();
Assert.IsTrue(formattedData.Equals("005HELLO"));
formatterContext.Clear();
formatter.Format(new InnerMessageField(35, null), ref formatterContext);
formattedData = formatterContext.GetDataAsString();
Assert.IsTrue(formattedData.Equals("000"));
}
public void Encode()
{
FormatterContext formatterContext =
new FormatterContext(FormatterContext.DefaultBufferSize);
_encoder.Encode(_data1, ref formatterContext);
Assert.IsTrue(formatterContext.DataLength == _encodedData1.Length);
byte[] encodedData = formatterContext.GetData();
for (int i = _encodedData1.Length - 1; i >= 0; i--)
{
Assert.IsTrue(_encodedData1[i] == encodedData[i]);
}
formatterContext.Clear();
_encoder.Encode(_data2, ref formatterContext);
Assert.IsTrue(formatterContext.DataLength == _encodedData2.Length);
encodedData = formatterContext.GetData();
for (int i = _encodedData2.Length - 1; i >= 0; i--)
{
Assert.IsTrue(_encodedData2[i] == encodedData[i]);
}
}
public void Encode()
{
FormatterContext formatterContext =
new FormatterContext(FormatterContext.DefaultBufferSize);
int[] sizes = { 3, 15, 999, 4510, 16384, 681115 };
StringLengthEncoder encoder;
string data;
for (int i = 0; i < sizes.Length; i++)
{
encoder = StringLengthEncoder.GetInstance(sizes[i]);
encoder.Encode(sizes[i], ref formatterContext);
data = formatterContext.GetDataAsString();
Assert.IsTrue(data.Length == (i + 1));
Assert.IsTrue(Convert.ToInt32(data) == sizes[i]);
formatterContext.Clear();
}
encoder = StringLengthEncoder.GetInstance(999);
try {
encoder.Encode(1000, ref formatterContext);
Assert.Fail();
} catch (ArgumentOutOfRangeException e) {
Assert.IsTrue(e.ParamName == "length");
}
}
public void Format()
{
FormatterContext formatterContext = new FormatterContext(
FormatterContext.DefaultBufferSize);
StringMessageHeader header = new StringMessageHeader("DATA");
StringMessageHeaderFormatter formatter;
string formattedData;
// Test fixed length formatting.
formatter = new StringMessageHeaderFormatter(
new FixedLengthManager(12), StringEncoder.GetInstance());
formatter.Format(header, ref formatterContext);
formattedData = formatterContext.GetDataAsString();
Assert.IsTrue(formattedData.Equals("DATA "));
formatterContext.Clear();
formatter.Format(null, ref formatterContext);
formattedData = formatterContext.GetDataAsString();
Assert.IsTrue(formattedData.Equals(" "));
// Test variable length formatting without padding.
formatterContext.Clear();
formatter = new StringMessageHeaderFormatter(new VariableLengthManager(0,
999, StringLengthEncoder.GetInstance(999)),
StringEncoder.GetInstance());
formatter.Format(header, ref formatterContext);
formattedData = formatterContext.GetDataAsString();
Assert.IsTrue(formattedData.Equals("004DATA"));
formatterContext.Clear();
formatter.Format(null, ref formatterContext);
formattedData = formatterContext.GetDataAsString();
Assert.IsTrue(formattedData.Equals("000"));
// Test variable length formatting with padding.
formatterContext.Clear();
formatter = new StringMessageHeaderFormatter(new VariableLengthManager(10,
10, StringLengthEncoder.GetInstance(10)),
StringEncoder.GetInstance(), SpacePaddingLeft.GetInstance(false));
formatter.Format(header, ref formatterContext);
formattedData = formatterContext.GetDataAsString();
Assert.IsTrue(formattedData.Equals("10 DATA"));
}
public void Encode()
{
FormatterContext formatterContext = new FormatterContext(
FormatterContext.DefaultBufferSize);
BcdStringEncoder encoder;
encoder = BcdStringEncoder.GetInstance(true, 0xF);
encoder.Encode("12D45", ref formatterContext);
Assert.IsTrue(formatterContext.GetDataAsString().Equals(
Encoding.UTF7.GetString(new byte[] { 0xF1, 0x2D, 0x45 })));
formatterContext.Clear();
encoder = BcdStringEncoder.GetInstance(false, 0xE);
encoder.Encode("12D45", ref formatterContext);
Assert.IsTrue(formatterContext.GetDataAsString().Equals(
Encoding.UTF7.GetString(new byte[] { 0x12, 0xD4, 0x5E })));
formatterContext.Clear();
encoder = BcdStringEncoder.GetInstance(true, 4);
encoder.Encode("12a45", ref formatterContext);
Assert.IsTrue(formatterContext.GetDataAsString().Equals(
Encoding.UTF7.GetString(new byte[] { 0x41, 0x2a, 0x45 })));
formatterContext.Clear();
encoder = BcdStringEncoder.GetInstance(true, 0);
encoder.Encode("1245", ref formatterContext);
Assert.IsTrue(formatterContext.GetDataAsString().Equals(
Encoding.UTF7.GetString(new byte[] { 0x12, 0x45 })));
formatterContext.Clear();
encoder = BcdStringEncoder.GetInstance(true, 0xf);
encoder.Encode("1245", ref formatterContext);
Assert.IsTrue(formatterContext.GetDataAsString().Equals(
Encoding.UTF7.GetString(new byte[] { 0x12, 0x45 })));
}
public void Format()
{
FormatterContext formatterContext = new FormatterContext(
FormatterContext.DefaultBufferSize);
BinaryField field = new BinaryField(1);
field.Value = "DATA";
BinaryFieldFormatter formatter;
string formattedData;
// Test fixed length formatting.
formatter = new BinaryFieldFormatter(37,
new FixedLengthManager(4), BinaryEncoder.GetInstance());
formatter.Format(field, ref formatterContext);
formattedData = formatterContext.GetDataAsString();
Assert.IsTrue(formattedData.Equals("DATA"));
formatterContext.Clear();
field.Value = "MORE DATA";
try {
formatter.Format(field, ref formatterContext);
Assert.Fail();
} catch (ArgumentOutOfRangeException e) {
Assert.IsTrue(e.ParamName.Equals("dataLength"));
}
// Test variable length formatting.
formatterContext.Clear();
formatter = new BinaryFieldFormatter(48, new VariableLengthManager(0,
999, StringLengthEncoder.GetInstance(999)),
BinaryEncoder.GetInstance());
formatter.Format(field, ref formatterContext);
formattedData = formatterContext.GetDataAsString();
Assert.IsTrue(formattedData.Equals("009MORE DATA"));
formatterContext.Clear();
formatter.Format(new BinaryField(5, null), ref formatterContext);
formattedData = formatterContext.GetDataAsString();
Assert.IsTrue(formattedData.Equals("000"));
}
public void WriteLength()
{
FormatterContext formatterContext = new FormatterContext(
FormatterContext.DefaultBufferSize);
VariableLengthManager lengthManager = new VariableLengthManager(8,
24, StringLengthEncoder.GetInstance(999));
lengthManager.WriteLength(null, 8, 8, ref formatterContext);
string length = formatterContext.GetDataAsString();
Assert.IsTrue(length.Equals("008"));
formatterContext.Clear();
lengthManager.WriteLength(null, 15, 15, ref formatterContext);
length = formatterContext.GetDataAsString();
Assert.IsTrue(length.Equals("015"));
formatterContext.Clear();
lengthManager.WriteLength(null, 24, 24, ref formatterContext);
length = formatterContext.GetDataAsString();
Assert.IsTrue(length.Equals("024"));
try {
lengthManager.WriteLength(null, 1, 1, ref formatterContext);
Assert.Fail();
} catch (ArgumentOutOfRangeException e) {
Assert.IsTrue(e.ParamName.Equals("dataLength"));
}
try {
lengthManager.WriteLength(null, 90, 90, ref formatterContext);
Assert.Fail();
} catch (ArgumentOutOfRangeException e) {
Assert.IsTrue(e.ParamName.Equals("dataLength"));
}
}
public void GetDataAsStringAndClear()
{
FormatterContext formatterContext = new FormatterContext(
FormatterContext.DefaultBufferSize);
formatterContext.Write(_data);
string availableData = formatterContext.GetDataAsString();
Assert.IsNotNull(availableData);
Assert.IsTrue(availableData.Length == _binaryData.Length);
Assert.IsTrue(_data.Equals(availableData));
formatterContext.Clear();
availableData = formatterContext.GetDataAsString();
Assert.IsNull(availableData);
}
public void Encode()
{
FormatterContext formatterContext =
new FormatterContext(FormatterContext.DefaultBufferSize);
int[] sizes = { 3, 15, 999, 4510, 16384, 681115 };
byte[][] expectedData =
{
new byte[] { 3 },
new byte[] { 0x15 },
new byte[] {9, 0x99 },
new byte[] {0x45, 0x10 },
new byte[] {1, 0x63, 0x84 },
new byte[] {0x68, 0x11, 0x15 }
};
BcdLengthEncoder encoder;
byte[] data;
for (int i = 0; i < sizes.Length; i++)
{
encoder = BcdLengthEncoder.GetInstance(sizes[i]);
encoder.Encode(sizes[i], ref formatterContext);
data = formatterContext.GetData();
Assert.IsTrue(data.Length == expectedData[i].Length);
for (int j = expectedData[i].Length - 1; j >= 0; j--)
{
Assert.IsTrue(data[j] == expectedData[i][j]);
}
formatterContext.Clear();
}
encoder = BcdLengthEncoder.GetInstance(99);
try {
encoder.Encode(100, ref formatterContext);
Assert.Fail();
} catch (ArgumentOutOfRangeException e) {
Assert.IsTrue(e.ParamName == "length");
}
}
public void Encode()
{
FormatterContext formatterContext =
new FormatterContext(FormatterContext.DefaultBufferSize);
int[] sizes = { 0, 115, 1999, 14510, 116384, 1681115 };
byte[][] expectedData =
{
new byte[] { 0 },
new byte[] { 0x73 },
new byte[] {7, 0xCF },
new byte[] {0x38, 0xAE },
new byte[] {1, 0xC6, 0xA0 },
new byte[] {0x19, 0xA6, 0xDB }
};
NboLengthEncoder encoder;
byte[] data;
for (int i = 0; i < sizes.Length; i++)
{
encoder = NboLengthEncoder.GetInstance(sizes[i]);
encoder.Encode(sizes[i], ref formatterContext);
data = formatterContext.GetData();
Assert.IsTrue(data.Length == expectedData[i].Length);
for (int j = expectedData[i].Length - 1; j >= 0; j--)
{
Assert.IsTrue(data[j] == expectedData[i][j]);
}
formatterContext.Clear();
}
encoder = NboLengthEncoder.GetInstance(65535);
try {
encoder.Encode(65536, ref formatterContext);
Assert.Fail();
} catch (ArgumentOutOfRangeException e) {
Assert.IsTrue(e.ParamName == "length");
}
}
public void Format()
{
FormatterContext formatterContext = new FormatterContext(
FormatterContext.DefaultBufferSize);
BitMapField bitmap = new BitMapField(0, 1, 64);
BitMapFieldFormatter bitmapFormatter = new BitMapFieldFormatter(
0, 1, 64, HexadecimalBinaryEncoder.GetInstance());
bitmapFormatter.Format(bitmap, ref formatterContext);
Assert.IsTrue(formatterContext.GetDataAsString().Equals(
"0000000000000000"));
formatterContext.Clear();
int[] fields = { 4, 7, 13, 19, 27, 36, 41, 42, 45, 47, 52, 56, 57, 63, 64 };
for (int i = 0; i < fields.Length; i++)
{
bitmap.Set(fields[i], true);
}
bitmapFormatter.Format(bitmap, ref formatterContext);
Assert.IsTrue(formatterContext.GetDataAsString().Equals(
"1208202010CA1183"));
}
public void ImplicitBufferResizing()
{
FormatterContext formatterContext = new FormatterContext(_data.Length);
Assert.IsTrue(formatterContext.BufferSize == _data.Length);
Assert.IsTrue(formatterContext.DataLength == 0);
formatterContext.Write(_data);
Assert.IsTrue(formatterContext.DataLength == _data.Length);
Assert.IsTrue(formatterContext.BufferSize == _data.Length);
formatterContext.Clear();
Assert.IsTrue(formatterContext.BufferSize == _data.Length);
Assert.IsTrue(formatterContext.DataLength == 0);
formatterContext.Write(_data);
Assert.IsTrue(formatterContext.DataLength == _data.Length);
Assert.IsTrue(formatterContext.BufferSize == _data.Length);
formatterContext.Write(_data);
Assert.IsTrue(formatterContext.DataLength == (_data.Length * 2));
Assert.IsTrue(formatterContext.BufferSize == (_data.Length +
FormatterContext.DefaultBufferSize));
}
public void DoTest(Iso8583MessageFormatter formatter, string[] fieldValues,
FieldFormatter[] fieldFormatters,
Iso8583MessageFormatterTestConfig[] tests, bool partialWriting)
{
FormatterContext formatterContext = new FormatterContext(
FormatterContext.DefaultBufferSize);
ParserContext parserContext = new ParserContext(
ParserContext.DefaultBufferSize);
Iso8583Message messageToFormat;
Iso8583Message parsedMessage;
string formattedData;
// Add field Formatters.
for (int i = 0; i < fieldFormatters.Length; i++)
{
if (fieldFormatters[i] != null)
{
formatter.FieldFormatters.Add(fieldFormatters[i]);
}
}
for (int i = 0; i < tests.Length; i++)
{
messageToFormat = new Iso8583Message(tests[i].MessageTypeIdentifier);
formatterContext.Clear();
parserContext.Clear();
parsedMessage = null;
formattedData = null;
// Set header formatter.
formatter.MessageHeaderFormatter = tests[i].HeaderFormatter;
// Set message type identifier formatter.
formatter.MessageTypeIdentifierFormatter = tests[i].MessageTypeIdentifierFormatter;
// Set header.
messageToFormat.Header = tests[i].Header;
// Set message fields.
for (int j = 0; j < tests[i].Fields.Length; j++)
{
messageToFormat.Fields.Add(tests[i].Fields[j],
fieldValues[tests[i].Fields[j] - 1]);
}
// Format message.
formatter.Format(messageToFormat, ref formatterContext);
formattedData = formatterContext.GetDataAsString();
//Console.WriteLine( "Data:[" + formattedData + "]");
// Check formatted data.
Assert.IsTrue(tests[i].ExpectedFormattedData.Equals(formattedData));
// Now parse to see if we get a copy of our message.
if (partialWriting)
{
for (int j = 0; j < formattedData.Length; j++)
{
parserContext.Write(formattedData.Substring(j, 1));
parsedMessage = ( Iso8583Message)formatter.Parse(ref parserContext);
// Message must be acquired only with the last char of formattedData.
if ((j + 1) == formattedData.Length)
{
Assert.IsNotNull(parsedMessage);
}
else
{
Assert.IsNull(parsedMessage);
}
}
}
else
{
parserContext.Write(formattedData);
parsedMessage = ( Iso8583Message)formatter.Parse(ref parserContext);
}
// Parser data must be exhausted.
Assert.IsTrue(parserContext.DataLength == 0);
// Check parsed message.
Assert.IsNotNull(parsedMessage);
// Check header.
if (tests[i].HeaderFormatter == null)
{
Assert.IsNull(parsedMessage.Header);
}
else
{
Assert.IsNotNull(parsedMessage.Header);
if (tests[i].Header == null)
{
Assert.IsTrue(string.Empty.Equals((( StringMessageHeader)
(parsedMessage.Header)).Value));
}
else
{
if ((( StringMessageHeader)(tests[i].Header)).Value == null)
{
Assert.IsTrue(string.Empty.Equals((( StringMessageHeader)
(parsedMessage.Header)).Value));
}
else
{
Assert.IsTrue((( StringMessageHeader)
(messageToFormat.Header)).Value.Equals((( StringMessageHeader)
(parsedMessage.Header)).Value));
}
}
}
// Check message type identifier.
Assert.IsTrue(messageToFormat.MessageTypeIdentifier ==
parsedMessage.MessageTypeIdentifier);
// Check fields.
Assert.IsTrue(messageToFormat.Fields.Count == parsedMessage.Fields.Count);
Assert.IsTrue(messageToFormat.Fields.MaximumFieldNumber ==
parsedMessage.Fields.MaximumFieldNumber);
for (int j = 0; j < tests[i].Fields.Length; j++)
{
Assert.IsTrue(fieldValues[tests[i].Fields[j] - 1].Equals(
(( StringField)(parsedMessage[tests[i].Fields[j]])).FieldValue));
}
}
}
public void Format()
{
FormatterContext formatterContext = new FormatterContext(
FormatterContext.DefaultBufferSize);
StringField field = new StringField(1, "DATA");
StringFieldFormatter formatter;
string formattedData;
// Test fixed length formatting.
formatter = new StringFieldFormatter(37,
new FixedLengthManager(12), StringEncoder.GetInstance());
formatter.Format(field, ref formatterContext);
formattedData = formatterContext.GetDataAsString();
Assert.IsTrue(formattedData.Equals("DATA "));
// Test variable length formatting without padding.
formatterContext.Clear();
formatter = new StringFieldFormatter(48, new VariableLengthManager(0,
999, StringLengthEncoder.GetInstance(999)),
StringEncoder.GetInstance());
formatter.Format(field, ref formatterContext);
formattedData = formatterContext.GetDataAsString();
Assert.IsTrue(formattedData.Equals("004DATA"));
formatterContext.Clear();
formatter.Format(new StringField(5, null), ref formatterContext);
formattedData = formatterContext.GetDataAsString();
Assert.IsTrue(formattedData.Equals("000"));
// Test variable length formatting with padding.
formatterContext.Clear();
formatter = new StringFieldFormatter(48, new VariableLengthManager(10,
10, StringLengthEncoder.GetInstance(10)),
StringEncoder.GetInstance(), SpacePaddingLeft.GetInstance(false),
string.Empty);
formatter.Format(field, ref formatterContext);
formattedData = formatterContext.GetDataAsString();
Assert.IsTrue(formattedData.Equals("10 DATA"));
// Test validator with fixed length formatting.
formatterContext.Clear();
formatter = new StringFieldFormatter(37,
new FixedLengthManager(12), StringEncoder.GetInstance(),
NumericValidator.GetInstance(), string.Empty);
field.FieldValue = "000000001500";
formatter.Format(field, ref formatterContext);
formattedData = formatterContext.GetDataAsString();
Assert.IsTrue(formattedData.Equals("000000001500"));
// Try with an invalid value.
formatterContext.Clear();
field.FieldValue = "D1500";
try {
formatter.Format(field, ref formatterContext);
Assert.Fail();
} catch (StringValidationException) {
}
// Test validator with fixed length formatting and numeric padding.
formatterContext.Clear();
formatter = new StringFieldFormatter(37,
new FixedLengthManager(12), StringEncoder.GetInstance(),
ZeroPaddingLeft.GetInstance(false, true), NumericValidator.GetInstance());
field.FieldValue = "56600";
formatter.Format(field, ref formatterContext);
formattedData = formatterContext.GetDataAsString();
Assert.IsTrue(formattedData.Equals("000000056600"));
// Try with an invalid value.
formatterContext.Clear();
field.FieldValue = "D1500";
try {
formatter.Format(field, ref formatterContext);
Assert.Fail();
} catch (StringValidationException) {
}
}
