public void MapByUnicodeAttribute()
{
var mapperFactory = new MapperFactoryConfig()
.UseOptionsDefault()
.DefaultDelimiter(null)
.DefaultTrim(true)
.DefaultTextPadding(Padding.Right)
.DefaultUnicodeFiller(' ')
.CreateMapByAttribute <UnicodeAttributeObject>()
.ToMapperFactory();
var mapper = mapperFactory.Create <UnicodeAttributeObject>();
var buffer = new byte[mapper.Size];
var obj = new UnicodeAttributeObject();
// Write
mapper.ToByte(buffer, 0, obj);
Assert.Equal(Encoding.Unicode.GetBytes(" __"), buffer);
// Read
mapper.FromByte(Encoding.Unicode.GetBytes("1 _A"), 0, obj);
Assert.Equal("1", obj.StringValue);
Assert.Equal("_A", obj.CustomStringValue);
}
public void MapByTextExpression()
{
var mapperFactory = new MapperFactoryConfig()
.DefaultDelimiter(null)
.DefaultEncoding(Encoding.ASCII)
.DefaultTrim(true)
.DefaultTextPadding(Padding.Right)
.DefaultTextFiller(0x20)
.CreateMapByExpression <TextExpressionObject>(8, config => config
.ForMember(x => x.StringValue, m => m.Text(4))
.ForMember(x => x.CustomStringValue, m => m.Text(4).Encoding(Encoding.ASCII).Trim(false).Padding(Padding.Left).Filler((byte)'_')))
.ToMapperFactory();
var mapper = mapperFactory.Create <TextExpressionObject>();
var buffer = new byte[mapper.Size];
var obj = new TextExpressionObject();
// Write
mapper.ToByte(buffer, 0, obj);
Assert.Equal(Encoding.ASCII.GetBytes(" ____"), buffer);
// Read
mapper.FromByte(Encoding.ASCII.GetBytes("12 __AB"), 0, obj);
Assert.Equal("12", obj.StringValue);
Assert.Equal("__AB", obj.CustomStringValue);
}
public void MapByByteAttribute()
{
var mapperFactory = new MapperFactoryConfig()
.DefaultDelimiter(null)
.CreateMapByAttribute <ByteAttributeObject>()
.ToMapperFactory();
var mapper = mapperFactory.Create <ByteAttributeObject>();
var buffer = new byte[mapper.Size];
var obj = new ByteAttributeObject
{
ByteValue = 1,
};
// Write
mapper.ToByte(buffer, 0, obj);
Assert.Equal(new byte[] { 0x01 }, buffer);
// Read
buffer[0] = 0x02;
mapper.FromByte(buffer, 0, obj);
Assert.Equal(2, obj.ByteValue);
}
public void MapByStringAttribute()
{
var mapperFactory = new MapperFactoryConfig()
.DefaultDelimiter(null)
.DefaultEncoding(Encoding.ASCII)
.DefaultTrim(true)
.DefaultTextPadding(Padding.Right)
.DefaultTextFiller(0x20)
.CreateMapByAttribute <TextAttributeObject>()
.ToMapperFactory();
var mapper = mapperFactory.Create <TextAttributeObject>();
var buffer = new byte[mapper.Size];
var obj = new TextAttributeObject();
// Write
mapper.ToByte(buffer, 0, obj);
Assert.Equal(Encoding.ASCII.GetBytes(" ______"), buffer);
// Read
mapper.FromByte(Encoding.ASCII.GetBytes("12 __AB*_"), 0, obj);
Assert.Equal("12", obj.StringValue);
Assert.Equal("__AB", obj.CustomStringValue);
Assert.Equal("*", obj.CustomStringValue2);
}
public void CoverageFix()
{
// Map
Assert.Throws <ArgumentOutOfRangeException>(() =>
new MapperFactoryConfig().CreateMapByExpression <DummyObject>(0, c => c.Constant(-1, Array.Empty <byte>())));
// ForMember
Assert.Throws <ArgumentOutOfRangeException>(() =>
new MapperFactoryConfig().CreateMapByExpression <DummyObject>(0, c => c.ForMember("x", -1, null)));
Assert.Throws <ArgumentNullException>(() =>
new MapperFactoryConfig().CreateMapByExpression <DummyObject>(0, c => c.ForMember("x", null)));
Assert.Throws <ArgumentException>(() =>
new MapperFactoryConfig().CreateMapByExpression <DummyObject>(0, c => c.ForMember("x", m => { })));
Assert.Throws <InvalidOperationException>(() =>
new MapperFactoryConfig().CreateMapByExpression <DummyObject>(0, c => c.ForMember(x => x.IntValue, m => { })));
Assert.Throws <ByteMapperException>(() =>
new MapperFactoryConfig().CreateMapByExpression <DummyObject>(0, c => c.ForMember(x => x.IntValue, m => m.Boolean())));
var mapperFactory = new MapperFactoryConfig()
.DefaultDelimiter(null)
.Also(config =>
{
config.CreateMapByExpression <DummyObject>(5, c => c
.ForMember(nameof(DummyObject.IntValue), 0, m => m.Binary())
.ForMember(nameof(DummyObject.BoolValue), m => m.Boolean()));
})
.ToMapperFactory();
Assert.NotNull(mapperFactory.Create <DummyObject>());
}
public void MapByByteExpression()
{
var mapperFactory = new MapperFactoryConfig()
.DefaultDelimiter(null)
.CreateMapByExpression <ByteExpressionObject>(1, config => config
.ForMember(x => x.ByteValue, m => m.Byte()))
.ToMapperFactory();
var mapper = mapperFactory.Create <ByteExpressionObject>();
var buffer = new byte[mapper.Size];
var obj = new ByteExpressionObject
{
ByteValue = 1,
};
// Write
mapper.ToByte(buffer, 0, obj);
Assert.Equal(new byte[] { 0x01 }, buffer);
// Read
buffer[0] = 0x02;
mapper.FromByte(buffer, 0, obj);
Assert.Equal(2, obj.ByteValue);
}
public void MapUseNullFiller()
{
var mapperFactory = new MapperFactoryConfig()
.DefaultDelimiter(null)
.DefaultFiller(0xCC)
.CreateMapByExpression <MapNullFillerObject>(2, c => c.NullFiller(0xFF))
.CreateMapByExpression <DefaultNullFillerObject>(2, c => { })
.ToMapperFactory();
var mapMapper = mapperFactory.Create <MapNullFillerObject>();
var defaultMapper = mapperFactory.Create <DefaultNullFillerObject>();
// Write
Assert.Equal(new byte[] { 0xFF, 0xFF }, mapMapper.ToByte(null));
Assert.Equal(new byte[] { 0xCC, 0xCC }, defaultMapper.ToByte(null));
}
public void MapByUnicodeExpression()
{
var mapperFactory = new MapperFactoryConfig()
.UseOptionsDefault()
.DefaultDelimiter(null)
.DefaultTrim(true)
.DefaultTextPadding(Padding.Right)
.DefaultUnicodeFiller(' ')
.CreateMapByExpression <UnicodeExpressionObject>(8, config => config
.ForMember(
x => x.StringValue,
m => m.Unicode(4))
.ForMember(
x => x.CustomStringValue,
m => m.Unicode(4).Trim(false).Padding(Padding.Left).Filler('_')))
.ToMapperFactory();
var mapper = mapperFactory.Create <UnicodeExpressionObject>();
var buffer = new byte[mapper.Size];
var obj = new UnicodeExpressionObject();
// Write
mapper.ToByte(buffer, 0, obj);
Assert.Equal(Encoding.Unicode.GetBytes(" __"), buffer);
// Read
mapper.FromByte(Encoding.Unicode.GetBytes("1 _A"), 0, obj);
Assert.Equal("1", obj.StringValue);
Assert.Equal("_A", obj.CustomStringValue);
}
public void MapByBooleanAttribute()
{
var mapperFactory = new MapperFactoryConfig()
.DefaultDelimiter(null)
.DefaultFiller(Filler)
.DefaultTrueValue(True)
.DefaultFalseValue(False)
.CreateMapByAttribute <BooleanAttributeObject>()
.ToMapperFactory();
var mapper = mapperFactory.Create <BooleanAttributeObject>();
var buffer = new byte[mapper.Size];
var obj = new BooleanAttributeObject();
// Write
mapper.ToByte(buffer, 0, obj);
Assert.Equal(new[] { False, Filler, No, Filler }, buffer);
// Read
mapper.FromByte(new[] { True, True, Yes, Yes }, 0, obj);
Assert.True(obj.BooleanValue);
Assert.True(obj.NullableBooleanValue);
Assert.True(obj.CustomBooleanValue);
Assert.True(obj.CustomNullableBooleanValue);
// Read default
mapper.FromByte(new[] { Filler, Filler, Filler, Filler }, 0, obj);
Assert.False(obj.BooleanValue);
Assert.Null(obj.NullableBooleanValue);
Assert.False(obj.CustomBooleanValue);
Assert.Null(obj.CustomNullableBooleanValue);
}
public void MapByBytesExpression()
{
var mapperFactory = new MapperFactoryConfig()
.DefaultDelimiter(null)
.DefaultFiller(0x30)
.CreateMapByExpression <BytesAttributeObject>(8, config => config
.ForMember(x => x.BytesValue, m => m.Bytes(4))
.ForMember(x => x.CustomBytesValue, m => m.Bytes(4).Filler(0x30)))
.ToMapperFactory();
var mapper = mapperFactory.Create <BytesAttributeObject>();
var buffer = new byte[mapper.Size];
var obj = new BytesAttributeObject
{
BytesValue = new byte[] { 0x01, 0x02, 0x03, 0x04 }
};
// Write
mapper.ToByte(buffer, 0, obj);
Assert.Equal(new byte[] { 0x01, 0x02, 0x03, 0x04, 0x30, 0x30, 0x30, 0x30 }, buffer);
// Read
for (var i = 0; i < buffer.Length; i++)
{
buffer[i] = 0xff;
}
mapper.FromByte(buffer, 0, obj);
Assert.Equal(new byte[] { 0xff, 0xff, 0xff, 0xff }, obj.BytesValue);
}
public void Setup()
{
var mapperFactory = new MapperFactoryConfig()
.CreateMapByAttribute <BinaryObject>()
.ToMapperFactory();
mapper = mapperFactory.Create <BinaryObject>();
}
public void MapByArrayExpression()
{
var mapperFactory = new MapperFactoryConfig()
.DefaultDelimiter(null)
.DefaultFiller(0x00)
.DefaultEndian(Endian.Big)
.CreateMapByExpression <ArrayExpressionObject>(19, config => config
.ForMember(x => x.ArrayValue, m => m.Array(3, e => e.Binary()))
.ForMember(x => x.ByteArrayValue, m => m.Array(7, e => e.Byte()).Filler(0xFF)))
.ToMapperFactory();
var mapper = mapperFactory.Create <ArrayExpressionObject>();
var buffer = new byte[mapper.Size];
var obj = new ArrayExpressionObject();
// Write
mapper.ToByte(buffer, 0, obj);
Assert.Equal(
new byte[]
{
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
},
buffer);
// Write
obj.ArrayValue = new[] { 1, 2, 3 };
obj.ByteArrayValue = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
mapper.ToByte(buffer, 0, obj);
Assert.Equal(
new byte[]
{
0x00, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x02,
0x00, 0x00, 0x00, 0x03,
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
},
buffer);
// Read
for (var i = 0; i < buffer.Length; i++)
{
if (buffer[i] > 0)
{
buffer[i]++;
}
}
mapper.FromByte(buffer, 0, obj);
Assert.Equal(new[] { 2, 3, 4 }, obj.ArrayValue);
Assert.Equal(new byte[] { 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }, obj.ByteArrayValue);
}
public void MapByDecimalAttribute()
{
var mapperFactory = new MapperFactoryConfig()
.UseOptionsDefault()
.DefaultDelimiter(null)
.DefaultZeroFill(false)
.DefaultNumberPadding(Padding.Left)
.DefaultNumberFiller(0x20)
.CreateMapByAttribute <DecimalAttributeObject>()
.ToMapperFactory();
var mapper = mapperFactory.Create <DecimalAttributeObject>();
var buffer = new byte[mapper.Size];
var obj = new DecimalAttributeObject
{
DecimalValue = 1234.5m,
PaddingRightDecimalValue = -1m,
ZeroFillDecimalValue = 1m
};
// Write
mapper.ToByte(buffer, 0, obj);
Assert.Equal(
Encoding.ASCII.GetBytes(
" 1,234.50" +
"______" +
"-1 " +
"000001"),
buffer);
// Read
mapper.FromByte(
Encoding.ASCII.GetBytes(
" 2,345.6" +
"_____2" +
"-2 " +
"000002"),
obj);
Assert.Equal(2345.60m, obj.DecimalValue);
Assert.Equal(2m, obj.NullableDecimalValue);
Assert.Equal(-2m, obj.PaddingRightDecimalValue);
Assert.Equal(2m, obj.ZeroFillDecimalValue);
mapper.FromByte(
Encoding.ASCII.GetBytes(
" " +
"______" +
" " +
"000000"),
obj);
Assert.Equal(0m, obj.DecimalValue);
Assert.Null(obj.NullableDecimalValue);
Assert.Equal(0m, obj.PaddingRightDecimalValue);
Assert.Equal(0m, obj.ZeroFillDecimalValue);
}
public void MapByDateTimeTextAttribute()
{
var mapperFactory = new MapperFactoryConfig()
.DefaultDelimiter(null)
.DefaultTrim(true)
.DefaultTextFiller(0x20)
.DefaultDateTimeTextEncoding(Encoding.ASCII)
.DefaultDateTimeTextProvider(CultureInfo.InvariantCulture)
.DefaultDateTimeTextStyle(DateTimeStyles.None)
.CreateMapByAttribute <DateTimeTextAttributeObject>()
.ToMapperFactory();
var mapper = mapperFactory.Create <DateTimeTextAttributeObject>();
var buffer = new byte[mapper.Size];
var obj = new DateTimeTextAttributeObject
{
DateTimeValue = new DateTime(2000, 12, 31, 0, 0, 0),
DateTimeOffsetValue = new DateTimeOffset(new DateTime(2000, 12, 31, 0, 0, 0))
};
// Write
mapper.ToByte(buffer, 0, obj);
Assert.Equal(
Encoding.ASCII.GetBytes(
"20001231" +
" " +
"______________" +
"20001231" +
" " +
"______________"),
buffer);
// Read
mapper.FromByte(buffer, obj);
mapper.FromByte(
Encoding.ASCII.GetBytes(
"20010101" +
"20010101" +
"20001231235959" +
"20010101" +
"20010101" +
"20001231235959"),
obj);
Assert.Equal(new DateTime(2001, 1, 1, 0, 0, 0), obj.DateTimeValue);
Assert.Equal(new DateTime(2001, 1, 1, 0, 0, 0), obj.NullableDateTimeValue);
Assert.Equal(new DateTime(2000, 12, 31, 23, 59, 59), obj.CustomDateTimeValue);
Assert.Equal(new DateTimeOffset(new DateTime(2001, 1, 1, 0, 0, 0)), obj.DateTimeOffsetValue);
Assert.Equal(new DateTimeOffset(new DateTime(2001, 1, 1, 0, 0, 0)), obj.NullableDateTimeOffsetValue);
Assert.Equal(new DateTimeOffset(new DateTime(2000, 12, 31, 23, 59, 59)), obj.CustomDateTimeOffsetValue);
}
public void MapByDateTimeAttribute()
{
var mapperFactory = new MapperFactoryConfig()
.UseOptionsDefault()
.DefaultDelimiter(null)
.DefaultTextFiller(0x20)
.DefaultDateTimeKind(DateTimeKind.Unspecified)
.CreateMapByAttribute <DateTimeAttributeObject>()
.ToMapperFactory();
var mapper = mapperFactory.Create <DateTimeAttributeObject>();
var buffer = new byte[mapper.Size];
var obj = new DateTimeAttributeObject
{
DateTimeValue = new DateTime(2000, 12, 31, 0, 0, 0),
DateTimeOffsetValue = new DateTimeOffset(new DateTime(2000, 12, 31, 0, 0, 0, DateTimeKind.Utc))
};
// Write
mapper.ToByte(buffer, 0, obj);
Assert.Equal(
Encoding.ASCII.GetBytes(
"20001231" +
" " +
"______________" +
"20001231" +
" " +
"______________"),
buffer);
// Read
mapper.FromByte(buffer, obj);
mapper.FromByte(
Encoding.ASCII.GetBytes(
"20010101" +
"20010101" +
"20001231235959" +
"20010101" +
"20010101" +
"20001231235959"),
obj);
Assert.Equal(new DateTime(2001, 1, 1, 0, 0, 0), obj.DateTimeValue);
Assert.Equal(new DateTime(2001, 1, 1, 0, 0, 0), obj.NullableDateTimeValue);
Assert.Equal(new DateTime(2000, 12, 31, 23, 59, 59), obj.CustomDateTimeValue);
Assert.Equal(new DateTimeOffset(new DateTime(2001, 1, 1, 0, 0, 0, DateTimeKind.Utc)), obj.DateTimeOffsetValue);
Assert.Equal(new DateTimeOffset(new DateTime(2001, 1, 1, 0, 0, 0, DateTimeKind.Utc)), obj.NullableDateTimeOffsetValue);
Assert.Equal(new DateTimeOffset(new DateTime(2000, 12, 31, 23, 59, 59, DateTimeKind.Utc)), obj.CustomDateTimeOffsetValue);
}
public void MapUseAutoFiller()
{
var mapperFactory = new MapperFactoryConfig()
.DefaultDelimiter(null)
.DefaultFiller(0xCC)
.CreateMapByAttribute <TypeFillerObject>()
.CreateMapByAttribute <DefaultFillerObject>()
.CreateMapByAttribute <NoFillerObject>()
.ToMapperFactory();
var typeMapper = mapperFactory.Create <TypeFillerObject>();
var defaultMapper = mapperFactory.Create <DefaultFillerObject>();
var noMapper = mapperFactory.Create <NoFillerObject>();
// Write
Assert.Equal(new byte[] { 0xFF, 0xFF }, typeMapper.ToByte(new TypeFillerObject()));
Assert.Equal(new byte[] { 0xCC, 0xCC }, defaultMapper.ToByte(new DefaultFillerObject()));
var buffer = new byte[noMapper.Size].Fill(0x11);
noMapper.ToByte(buffer, 0, new NoFillerObject());
Assert.Equal(new byte[] { 0x11, 0x11 }, buffer);
}
public void MapUseDelimiter()
{
var mapperFactory = new MapperFactoryConfig()
.DefaultFiller(0x00)
.DefaultDelimiter(0xCC)
.CreateMapByExpression <TypeDelimiterObject>(2, c => c.AutoFiller(false).UseDelimiter(0xFF))
.CreateMapByExpression <DefaultDelimiterObject>(2, c => c.AutoFiller(false).UseDelimiter(true))
.CreateMapByExpression <NoDelimiterObject>(2, c => c.AutoFiller(false).UseDelimiter(null))
.ToMapperFactory();
var typeMapper = mapperFactory.Create <TypeDelimiterObject>();
var defaultMapper = mapperFactory.Create <DefaultDelimiterObject>();
var noMapper = mapperFactory.Create <NoDelimiterObject>();
// Write
Assert.Equal(new byte[] { 0x00, 0xFF }, typeMapper.ToByte(new TypeDelimiterObject()));
Assert.Equal(new byte[] { 0x00, 0xCC }, defaultMapper.ToByte(new DefaultDelimiterObject()));
var buffer = new byte[noMapper.Size].Fill(0x11);
noMapper.ToByte(buffer, 0, new NoDelimiterObject());
Assert.Equal(new byte[] { 0x11, 0x11 }, buffer);
}
public void MapByConstantAttribute()
{
var mapperFactory = new MapperFactoryConfig()
.DefaultDelimiter(0x0D, 0x0A)
.CreateMapByAttribute <ConstAttributeObject>()
.ToMapperFactory();
var mapper = mapperFactory.Create <ConstAttributeObject>();
var buffer = new byte[mapper.Size];
var obj = new ConstAttributeObject();
// Write
mapper.ToByte(buffer, 0, obj);
Assert.Equal(Encoding.ASCII.GetBytes("12\r\n"), buffer);
}
public void MapByFillerAttribute()
{
var mapperFactory = new MapperFactoryConfig()
.DefaultDelimiter(null)
.DefaultFiller((byte)' ')
.CreateMapByAttribute <FillerAttributeObject>()
.ToMapperFactory();
var mapper = mapperFactory.Create <FillerAttributeObject>();
var buffer = new byte[mapper.Size];
var obj = new FillerAttributeObject();
// Write
mapper.ToByte(buffer, 0, obj);
Assert.Equal(Encoding.ASCII.GetBytes(" 00"), buffer);
}
public void Setup()
{
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
var mapperFactory = new MapperFactoryConfig()
.UseOptionsDefault()
.DefaultEncoding(SjisEncoding.Instance)
.CreateMapByExpression <ComplexData>(144, config => config
.ForMember(x => x.StringValue1, m => m.Text(20))
.ForMember(x => x.StringValue2, m => m.Text(20))
.ForMember(x => x.StringValue3, m => m.Text(20))
.ForMember(x => x.IntValue1, m => m.Integer(8))
.ForMember(x => x.IntValue2, m => m.Integer(8))
.ForMember(x => x.IntValue3, m => m.Integer(8))
.ForMember(x => x.IntValue4, m => m.Integer(8))
.ForMember(x => x.DecimalValue1, m => m.Decimal(10, 2))
.ForMember(x => x.DecimalValue2, m => m.Decimal(10, 2))
.ForMember(x => x.BoolValue1, m => m.Boolean())
.ForMember(x => x.BoolValue2, m => m.Boolean())
.ForMember(x => x.DateTimeValue1, m => m.DateTime("yyyyMMddHHmmss"))
.ForMember(x => x.DateTimeValue2, m => m.DateTime("yyyyMMddHHmmss")))
.ToMapperFactory();
mapper = mapperFactory.Create <ComplexData>();
allocatedBuffer = new byte[mapper.Size];
allocatedData = new ComplexData
{
StringValue1 = "XXXXXXXXXXXXXXXXXXXX",
StringValue2 = "あああああ",
StringValue3 = string.Empty,
IntValue1 = 1,
IntValue2 = 0,
IntValue3 = 1,
IntValue4 = null,
BoolValue1 = true,
BoolValue2 = null,
DecimalValue1 = 1.23m,
DecimalValue2 = null,
DateTimeValue1 = new DateTime(2000, 12, 31, 23, 59, 59, 999),
DateTimeValue2 = null
};
mapper.ToByte(allocatedBuffer, 0, allocatedData);
}
public void MapUseTypeDefaultAttribute()
{
var mapperFactory = new MapperFactoryConfig()
.DefaultDelimiter(null)
.DefaultEncoding(Encoding.UTF8)
.DefaultTrim(false)
.DefaultTextPadding(Padding.Right)
.DefaultFiller((byte)' ')
.DefaultTextFiller((byte)' ')
.DefaultEndian(Endian.Big)
.DefaultTrueValue((byte)'1')
.DefaultFalseValue((byte)'1')
.DefaultNumberTextEncoding(Encoding.UTF8)
.DefaultNumberTextProvider(CultureInfo.CurrentCulture)
.DefaultNumberTextNumberStyle(NumberStyles.Integer)
.DefaultNumberTextDecimalStyle(NumberStyles.Integer)
.DefaultNumberTextPadding(Padding.Left)
.DefaultNumberTextFiller((byte)' ')
.DefaultDateTimeTextEncoding(Encoding.UTF8)
.DefaultDateTimeTextProvider(CultureInfo.CurrentCulture)
.DefaultDateTimeTextStyle(DateTimeStyles.None)
.DefaultUnicodeFiller(' ')
.CreateMapByAttribute <TypeDefaultAttributeObject>()
.ToMapperFactory();
var mapper = mapperFactory.Create <TypeDefaultAttributeObject>();
var buffer = new byte[mapper.Size];
var obj = new TypeDefaultAttributeObject
{
IntValue = 1,
DecimalValue = 1,
BoolValue = true,
StringValue = "1"
};
// Write
mapper.ToByte(buffer, 0, obj);
Assert.Equal(Encoding.ASCII.GetBytes("1_1__1Y*\r\n"), buffer);
// Fix
Assert.Equal(Encoding.ASCII.CodePage, ((Encoding) new TypeEncodingAttribute(Encoding.ASCII.CodePage).Value).CodePage);
Assert.Equal(Encoding.ASCII.CodePage, ((Encoding) new TypeNumberTextEncodingAttribute(Encoding.ASCII.CodePage).Value).CodePage);
Assert.Equal(Encoding.ASCII.CodePage, ((Encoding) new TypeDateTimeTextEncodingAttribute(Encoding.ASCII.CodePage).Value).CodePage);
}
public void MapByConstantExpression()
{
var mapperFactory = new MapperFactoryConfig()
.DefaultDelimiter(0x0D, 0x0A)
.CreateMapByExpression <ConstExpressionObject>(6, config => config
.UseDelimiter(true)
.Constant(0, new byte[] { 0x31, 0x32 })
.Constant(new byte[] { 0x33, 0x34 }))
.ToMapperFactory();
var mapper = mapperFactory.Create <ConstExpressionObject>();
var buffer = new byte[mapper.Size];
var obj = new ConstExpressionObject();
// Write
mapper.ToByte(buffer, 0, obj);
Assert.Equal(Encoding.ASCII.GetBytes("1234\r\n"), buffer);
}
public void MapByBooleanExpression()
{
var mapperFactory = new MapperFactoryConfig()
.DefaultDelimiter(null)
.DefaultFiller(Filler)
.DefaultTrueValue(True)
.DefaultFalseValue(False)
.CreateMapByExpression <BooleanExpressionObject>(4, config => config
.ForMember(x => x.BooleanValue, m => m.Boolean())
.ForMember(x => x.NullableBooleanValue, m => m.Boolean())
.ForMember(x => x.CustomBooleanValue, m => m.Boolean(Yes, No))
.ForMember(x => x.CustomNullableBooleanValue, m => m.Boolean(Yes, No, Filler)))
.ToMapperFactory();
var mapper = mapperFactory.Create <BooleanExpressionObject>();
var buffer = new byte[mapper.Size];
var obj = new BooleanExpressionObject();
// Write
mapper.ToByte(buffer, 0, obj);
Assert.Equal(new[] { False, Filler, No, Filler }, buffer);
// Read
mapper.FromByte(new[] { True, True, Yes, Yes }, 0, obj);
Assert.True(obj.BooleanValue);
Assert.True(obj.NullableBooleanValue);
Assert.True(obj.CustomBooleanValue);
Assert.True(obj.CustomNullableBooleanValue);
// Read default
mapper.FromByte(new[] { Filler, Filler, Filler, Filler }, 0, obj);
Assert.False(obj.BooleanValue);
Assert.Null(obj.NullableBooleanValue);
Assert.False(obj.CustomBooleanValue);
Assert.Null(obj.CustomNullableBooleanValue);
}
public void MapByFillerExpression()
{
var mapperFactory = new MapperFactoryConfig()
.DefaultDelimiter(null)
.DefaultFiller((byte)' ')
.CreateMapByExpression <FillerExpressionObject>(4, config => config
.AutoFiller(true)
.Filler(0, 1)
.Filler(1, 1, (byte)'0')
.Filler(1)
.Filler(1, (byte)'_'))
.ToMapperFactory();
var mapper = mapperFactory.Create <FillerExpressionObject>();
var buffer = new byte[mapper.Size];
var obj = new FillerExpressionObject();
// Write
mapper.ToByte(buffer, 0, obj);
Assert.Equal(Encoding.ASCII.GetBytes(" 0 _"), buffer);
}
public void MapByNumberTextAttribute()
{
var mapperFactory = new MapperFactoryConfig()
.DefaultDelimiter(null)
.DefaultTrim(true)
.DefaultNumberTextEncoding(Encoding.ASCII)
.DefaultNumberTextProvider(CultureInfo.InvariantCulture)
.DefaultNumberTextNumberStyle(NumberStyles.Integer)
.DefaultNumberTextDecimalStyle(NumberStyles.Any)
.DefaultNumberTextPadding(Padding.Left)
.DefaultNumberTextFiller(0x20)
.CreateMapByAttribute <NumberTextAttributeObject>()
.ToMapperFactory();
var mapper = mapperFactory.Create <NumberTextAttributeObject>();
var buffer = new byte[mapper.Size];
var obj = new NumberTextAttributeObject
{
IntValue = 1,
CustomIntValue = -1,
LongValue = 1L,
CustomLongValue = -1L,
ShortValue = 1,
CustomShortValue = -1,
DecimalValue = 12.34m,
CustomDecimalValue = -1.2m
};
// Write
mapper.ToByte(buffer, 0, obj);
Assert.Equal(
Encoding.ASCII.GetBytes(
" 1" +
" " +
"-01_" +
" 1" +
" " +
"-01___" +
" 1" +
" " +
"-1" +
" 12.34" +
" " +
"-1.20_"),
buffer);
// Read
mapper.FromByte(
Encoding.ASCII.GetBytes(
" 2" +
" 2" +
"-2__" +
" 2" +
" 2" +
"-2____" +
" 2" +
" 2" +
"-2" +
" 23.4" +
" 23.4" +
" -23.4"),
obj);
Assert.Equal(2, obj.IntValue);
Assert.Equal(2, obj.NullableIntValue);
Assert.Equal(-2, obj.CustomIntValue);
Assert.Equal(2L, obj.LongValue);
Assert.Equal(2L, obj.NullableLongValue);
Assert.Equal(-2L, obj.CustomLongValue);
Assert.Equal((short)2, obj.ShortValue);
Assert.Equal((short)2, obj.NullableShortValue);
Assert.Equal((short)-2, obj.CustomShortValue);
Assert.Equal(23.4m, obj.DecimalValue);
Assert.Equal(23.4m, obj.NullableDecimalValue);
Assert.Equal(-23.4m, obj.CustomDecimalValue);
}
public void MapUseTypeDefaultExpression()
{
var mapperFactory = new MapperFactoryConfig()
.UseOptionsDefault()
.DefaultDelimiter(null)
.DefaultEncoding(Encoding.UTF8)
.DefaultTrim(false)
.DefaultTextPadding(Padding.Right)
.DefaultNumberPadding(Padding.Left)
.DefaultZeroFill(false)
.DefaultUseGrouping(false)
.DefaultFiller((byte)' ')
.DefaultTextFiller((byte)' ')
.DefaultNumberFiller((byte)' ')
.DefaultEndian(Endian.Big)
.DefaultTrueValue((byte)'1')
.DefaultFalseValue((byte)'1')
.DefaultNumberTextEncoding(Encoding.UTF8)
.DefaultNumberTextProvider(CultureInfo.CurrentCulture)
.DefaultNumberTextNumberStyle(NumberStyles.Integer)
.DefaultNumberTextDecimalStyle(NumberStyles.Integer)
.DefaultNumberTextPadding(Padding.Left)
.DefaultNumberTextFiller((byte)' ')
.DefaultDateTimeTextEncoding(Encoding.UTF8)
.DefaultDateTimeTextProvider(CultureInfo.CurrentCulture)
.DefaultDateTimeTextStyle(DateTimeStyles.None)
.CreateMapByExpression <TypeDefaultExpressionObject>(10, config => config
.TypeDelimiter(0x0D, 0x0A)
.TypeEncoding(Encoding.ASCII)
.TypeTrim(true)
.TypeTextPadding(Padding.Left)
.TypeNumberPadding(Padding.Right)
.TypeZeroFill(true)
.TypeUseGrouping(false)
.TypeFiller((byte)'*')
.TypeTextFiller((byte)'_')
.TypeNumberFiller((byte)'_')
.TypeDateTimeKind(DateTimeKind.Unspecified)
.TypeEndian(Endian.Little)
.TypeTrueValue((byte)'Y')
.TypeFalseValue((byte)'N')
.TypeNumberTextEncoding(Encoding.ASCII)
.TypeNumberTextProvider(CultureInfo.InvariantCulture)
.TypeNumberTextNumberStyle(NumberStyles.Any)
.TypeNumberTextDecimalStyle(NumberStyles.Any)
.TypeNumberTextPadding(Padding.Right)
.TypeNumberTextFiller((byte)'_')
.TypeDateTimeTextEncoding(Encoding.ASCII)
.TypeDateTimeTextProvider(CultureInfo.InvariantCulture)
.TypeDateTimeTextStyle(DateTimeStyles.None)
.ForMember(x => x.IntValue, 0, m => m.NumberText(2))
.ForMember(x => x.DecimalValue, 2, m => m.NumberText(2))
.ForMember(x => x.StringValue, 4, m => m.Text(2))
.ForMember(x => x.BoolValue, 6, m => m.Boolean()))
.ToMapperFactory();
var mapper = mapperFactory.Create <TypeDefaultExpressionObject>();
var buffer = new byte[mapper.Size];
var obj = new TypeDefaultExpressionObject
{
IntValue = 1,
DecimalValue = 1,
BoolValue = true,
StringValue = "1"
};
// Write
mapper.ToByte(buffer, 0, obj);
Assert.Equal(Encoding.ASCII.GetBytes("1_1__1Y*\r\n"), buffer);
}
public void MapByDateTimeTextExpression()
{
var mapperFactory = new MapperFactoryConfig()
.DefaultDelimiter(null)
.DefaultTrim(true)
.DefaultTextFiller(0x20)
.DefaultDateTimeTextEncoding(Encoding.ASCII)
.DefaultDateTimeTextProvider(CultureInfo.InvariantCulture)
.DefaultDateTimeTextStyle(DateTimeStyles.None)
.CreateMapByExpression <DateTimeTextExpressionObject>(60, config => config
.ForMember(
x => x.DateTimeValue,
m => m.DateTimeText(8, "yyyyMMdd"))
.ForMember(
x => x.NullableDateTimeValue,
m => m.DateTimeText(8, "yyyyMMdd"))
.ForMember(
x => x.CustomDateTimeValue,
m => m.DateTimeText(14, "yyyyMMddHHmmss").Encoding(Encoding.ASCII).Filler((byte)'_').Style(DateTimeStyles.None).Provider(CultureInfo.InvariantCulture))
.ForMember(
x => x.DateTimeOffsetValue,
m => m.DateTimeText(8, "yyyyMMdd"))
.ForMember(
x => x.NullableDateTimeOffsetValue,
m => m.DateTimeText(8, "yyyyMMdd"))
.ForMember(
x => x.CustomDateTimeOffsetValue,
m => m.DateTimeText(14, "yyyyMMddHHmmss").Encoding(Encoding.ASCII).Filler((byte)'_').Style(DateTimeStyles.None).Provider(CultureInfo.InvariantCulture)))
.ToMapperFactory();
var mapper = mapperFactory.Create <DateTimeTextExpressionObject>();
var buffer = new byte[mapper.Size];
var obj = new DateTimeTextExpressionObject
{
DateTimeValue = new DateTime(2000, 12, 31, 0, 0, 0),
DateTimeOffsetValue = new DateTimeOffset(new DateTime(2000, 12, 31, 0, 0, 0))
};
// Write
mapper.ToByte(buffer, 0, obj);
Assert.Equal(
Encoding.ASCII.GetBytes(
"20001231" +
" " +
"______________" +
"20001231" +
" " +
"______________"),
buffer);
// Read
mapper.FromByte(buffer, obj);
mapper.FromByte(
Encoding.ASCII.GetBytes(
"20010101" +
"20010101" +
"20001231235959" +
"20010101" +
"20010101" +
"20001231235959"),
obj);
Assert.Equal(new DateTime(2001, 1, 1, 0, 0, 0), obj.DateTimeValue);
Assert.Equal(new DateTime(2001, 1, 1, 0, 0, 0), obj.NullableDateTimeValue);
Assert.Equal(new DateTime(2000, 12, 31, 23, 59, 59), obj.CustomDateTimeValue);
Assert.Equal(new DateTimeOffset(new DateTime(2001, 1, 1, 0, 0, 0)), obj.DateTimeOffsetValue);
Assert.Equal(new DateTimeOffset(new DateTime(2001, 1, 1, 0, 0, 0)), obj.NullableDateTimeOffsetValue);
Assert.Equal(new DateTimeOffset(new DateTime(2000, 12, 31, 23, 59, 59)), obj.CustomDateTimeOffsetValue);
}
public void MapByIntegerAttribute()
{
var mapperFactory = new MapperFactoryConfig()
.UseOptionsDefault()
.DefaultDelimiter(null)
.DefaultZeroFill(false)
.DefaultNumberPadding(Padding.Left)
.DefaultNumberFiller(0x20)
.CreateMapByAttribute <IntegerAttributeObject>()
.ToMapperFactory();
var mapper = mapperFactory.Create <IntegerAttributeObject>();
var buffer = new byte[mapper.Size];
var obj = new IntegerAttributeObject
{
IntValue = 1,
PaddingRightIntValue = -1,
ZeroFillIntValue = 1,
LongValue = 1L,
PaddingRightLongValue = -1L,
ZeroFillLongValue = 1,
ShortValue = 1,
PaddingRightShortValue = -1,
ZeroFillShortValue = 1,
};
// Write
mapper.ToByte(buffer, 0, obj);
Assert.Equal(
Encoding.ASCII.GetBytes(
" 1" +
"____" +
"-1 " +
"0001" +
" 1" +
"______" +
"-1 " +
"000001" +
" 1" +
"__" +
"-1" +
"01"),
buffer);
// Read
mapper.FromByte(
Encoding.ASCII.GetBytes(
" 2" +
"___2" +
"-2 " +
"0002" +
" 2" +
"_____2" +
"-2 " +
"000002" +
" 2" +
"_2" +
"-2" +
"02"),
obj);
Assert.Equal(2, obj.IntValue);
Assert.Equal(2, obj.NullableIntValue);
Assert.Equal(-2, obj.PaddingRightIntValue);
Assert.Equal(2, obj.ZeroFillIntValue);
Assert.Equal(2L, obj.LongValue);
Assert.Equal(2L, obj.NullableLongValue);
Assert.Equal(-2L, obj.PaddingRightLongValue);
Assert.Equal(2L, obj.ZeroFillLongValue);
Assert.Equal((short)2, obj.ShortValue);
Assert.Equal((short)2, obj.NullableShortValue);
Assert.Equal(-2, obj.PaddingRightShortValue);
Assert.Equal((short)2, obj.ZeroFillShortValue);
mapper.FromByte(
Encoding.ASCII.GetBytes(
" " +
"____" +
" " +
"0000" +
" " +
"______" +
" " +
"000000" +
" " +
"__" +
" " +
"00"),
obj);
Assert.Equal(0, obj.IntValue);
Assert.Null(obj.NullableIntValue);
Assert.Equal(0, obj.PaddingRightIntValue);
Assert.Equal(0, obj.ZeroFillIntValue);
Assert.Equal(0L, obj.LongValue);
Assert.Null(obj.NullableLongValue);
Assert.Equal(0L, obj.PaddingRightLongValue);
Assert.Equal(0L, obj.ZeroFillLongValue);
Assert.Equal((short)0, obj.ShortValue);
Assert.Null(obj.NullableShortValue);
Assert.Equal(0, obj.PaddingRightShortValue);
Assert.Equal((short)0, obj.ZeroFillShortValue);
}
public void MapByNumberTextExpression()
{
var mapperFactory = new MapperFactoryConfig()
.DefaultDelimiter(null)
.DefaultTrim(true)
.DefaultNumberTextEncoding(Encoding.ASCII)
.DefaultNumberTextProvider(CultureInfo.InvariantCulture)
.DefaultNumberTextNumberStyle(NumberStyles.Integer)
.DefaultNumberTextDecimalStyle(NumberStyles.Any)
.DefaultNumberTextPadding(Padding.Left)
.DefaultNumberTextFiller(0x20)
.CreateMapByExpression <NumberTextExpressionObject>(54, config => config
.ForMember(x => x.IntValue, m => m.NumberText(4))
.ForMember(x => x.NullableIntValue, m => m.NumberText(4))
.ForMember(
x => x.CustomIntValue,
m => m.NumberText(4, "D2").Encoding(Encoding.ASCII).Trim(true).Padding(Padding.Right).Filler((byte)'_').Style(NumberStyles.Any).Provider(CultureInfo.InvariantCulture))
.ForMember(x => x.LongValue, m => m.NumberText(6))
.ForMember(x => x.NullableLongValue, m => m.NumberText(6))
.ForMember(
x => x.CustomLongValue,
m => m.NumberText(6, "D2").Encoding(Encoding.ASCII).Trim(true).Padding(Padding.Right).Filler((byte)'_').Style(NumberStyles.Any).Provider(CultureInfo.InvariantCulture))
.ForMember(x => x.ShortValue, m => m.NumberText(2))
.ForMember(x => x.NullableShortValue, m => m.NumberText(2))
.ForMember(
x => x.CustomShortValue,
m => m.NumberText(2, "D1").Encoding(Encoding.ASCII).Trim(true).Padding(Padding.Right).Filler((byte)'_').Style(NumberStyles.Any).Provider(CultureInfo.InvariantCulture))
.ForMember(x => x.DecimalValue, m => m.NumberText(6))
.ForMember(x => x.NullableDecimalValue, m => m.NumberText(6))
.ForMember(
x => x.CustomDecimalValue,
m => m.NumberText(6, "0.00").Encoding(Encoding.ASCII).Trim(true).Padding(Padding.Right).Filler((byte)'_').Style(NumberStyles.Any).Provider(CultureInfo.InvariantCulture)))
.ToMapperFactory();
var mapper = mapperFactory.Create <NumberTextExpressionObject>();
var buffer = new byte[mapper.Size];
var obj = new NumberTextExpressionObject
{
IntValue = 1,
CustomIntValue = -1,
LongValue = 1L,
CustomLongValue = -1L,
ShortValue = 1,
CustomShortValue = -1,
DecimalValue = 12.34m,
CustomDecimalValue = -1.2m
};
// Write
mapper.ToByte(buffer, 0, obj);
Assert.Equal(
Encoding.ASCII.GetBytes(
" 1" +
" " +
"-01_" +
" 1" +
" " +
"-01___" +
" 1" +
" " +
"-1" +
" 12.34" +
" " +
"-1.20_"),
buffer);
// Read
mapper.FromByte(
Encoding.ASCII.GetBytes(
" 2" +
" 2" +
"-2__" +
" 2" +
" 2" +
"-2____" +
" 2" +
" 2" +
"-2" +
" 23.4" +
" 23.4" +
" -23.4"),
obj);
Assert.Equal(2, obj.IntValue);
Assert.Equal(2, obj.NullableIntValue);
Assert.Equal(-2, obj.CustomIntValue);
Assert.Equal(2L, obj.LongValue);
Assert.Equal(2L, obj.NullableLongValue);
Assert.Equal(-2L, obj.CustomLongValue);
Assert.Equal((short)2, obj.ShortValue);
Assert.Equal((short)2, obj.NullableShortValue);
Assert.Equal((short)-2, obj.CustomShortValue);
Assert.Equal(23.4m, obj.DecimalValue);
Assert.Equal(23.4m, obj.NullableDecimalValue);
Assert.Equal(-23.4m, obj.CustomDecimalValue);
}
public void MapByDecimalExpression()
{
var mapperFactory = new MapperFactoryConfig()
.UseOptionsDefault()
.DefaultDelimiter(null)
.DefaultZeroFill(false)
.DefaultNumberPadding(Padding.Left)
.DefaultNumberFiller(0x20)
.CreateMapByExpression <DecimalExpressionObject>(28, config => config
.ForMember(x => x.DecimalValue, m => m.Decimal(10, 2).UseGrouping(true).GroupingSize(3))
.ForMember(x => x.NullableDecimalValue, m => m.Decimal(6).Filler((byte)'_'))
.ForMember(x => x.PaddingRightDecimalValue, m => m.Decimal(6).Padding(Padding.Right))
.ForMember(x => x.ZeroFillDecimalValue, m => m.Decimal(6).ZeroFill(true)))
.ToMapperFactory();
var mapper = mapperFactory.Create <DecimalExpressionObject>();
var buffer = new byte[mapper.Size];
var obj = new DecimalExpressionObject
{
DecimalValue = 1234.5m,
PaddingRightDecimalValue = -1m,
ZeroFillDecimalValue = 1m
};
// Write
mapper.ToByte(buffer, 0, obj);
Assert.Equal(
Encoding.ASCII.GetBytes(
" 1,234.50" +
"______" +
"-1 " +
"000001"),
buffer);
// Read
mapper.FromByte(
Encoding.ASCII.GetBytes(
" 2,345.6" +
"_____2" +
"-2 " +
"000002"),
obj);
Assert.Equal(2345.60m, obj.DecimalValue);
Assert.Equal(2m, obj.NullableDecimalValue);
Assert.Equal(-2m, obj.PaddingRightDecimalValue);
Assert.Equal(2m, obj.ZeroFillDecimalValue);
mapper.FromByte(
Encoding.ASCII.GetBytes(
" " +
"______" +
" " +
"000000"),
obj);
Assert.Equal(0m, obj.DecimalValue);
Assert.Null(obj.NullableDecimalValue);
Assert.Equal(0m, obj.PaddingRightDecimalValue);
Assert.Equal(0m, obj.ZeroFillDecimalValue);
}
