public void CanReadWriteNull()
{
var sut = _fixture.Create <DbaseNumber>();
sut.Value = null;
using (var stream = new MemoryStream())
{
using (var writer = new BinaryWriter(stream, Encoding.ASCII, true))
{
sut.Write(writer);
writer.Flush();
}
stream.Position = 0;
using (var reader = new BinaryReader(stream, Encoding.ASCII, true))
{
var result = new DbaseNumber(sut.Field);
result.Read(reader);
Assert.Equal(sut.Field, result.Field);
Assert.Equal(sut.Value, result.Value);
}
}
}
public void AcceptsInt16ValueReturnsExpectedResult(int length, short value, bool accepted)
{
var sut = new DbaseNumber(
DbaseField.CreateNumberField(
_fixture.Create <DbaseFieldName>(),
new DbaseFieldLength(length),
new DbaseDecimalCount(0)
));
var result = sut.AcceptsValue(value);
Assert.Equal(accepted, result);
}
public void TrySetValueAsNullableInt16ReturnsExpectedResult(int length, short?value, bool expected)
{
var sut = new DbaseNumber(
DbaseField.CreateNumberField(
_fixture.Create <DbaseFieldName>(),
new DbaseFieldLength(length),
new DbaseDecimalCount(0)
));
var result = sut.TrySetValueAsNullableInt16(value);
Assert.Equal(expected, result);
}
public void TryGetValueAsInt32ReturnsExpectedResult(int length, double?value, bool gotten, int gottenValueAsInt32)
{
var sut = new DbaseNumber(
DbaseField.CreateNumberField(
_fixture.Create <DbaseFieldName>(),
new DbaseFieldLength(length),
new DbaseDecimalCount(0)
), value);
var result = sut.TryGetValueAsInt32(out var valueAsInt32);
Assert.Equal(gotten, result);
Assert.Equal(gottenValueAsInt32, valueAsInt32);
}
public void LengthOfNegativeValueBeingSetCanNotExceedFieldLength()
{
var length = DbaseNumber.MaximumLength;
var decimalCount = _fixture.GenerateDbaseDoubleDecimalCount(length);
var sut =
new DbaseNumber(
new DbaseField(
_fixture.Create <DbaseFieldName>(),
DbaseFieldType.Number,
_fixture.Create <ByteOffset>(),
length,
decimalCount
)
);
Assert.Throws <ArgumentException>(() => sut.Value = double.MinValue);
}
public void CanReadWriteWithMaxDecimalCount()
{
var length = DbaseNumber.MaximumLength;
var decimalCount = DbaseNumber.MaximumDecimalCount;
var sut =
new DbaseNumber(
new DbaseField(
_fixture.Create <DbaseFieldName>(),
DbaseFieldType.Number,
_fixture.Create <ByteOffset>(),
length,
decimalCount
)
);
using (var random = new PooledRandom())
{
sut.Value =
new DbaseFieldNumberGenerator(random)
.GenerateAcceptableValue(sut);
using (var stream = new MemoryStream())
{
using (var writer = new BinaryWriter(stream, Encoding.ASCII, true))
{
sut.Write(writer);
writer.Flush();
}
stream.Position = 0;
using (var reader = new BinaryReader(stream, Encoding.ASCII, true))
{
var result = new DbaseNumber(sut.Field);
result.Read(reader);
Assert.Equal(sut.Field, result.Field);
Assert.Equal(sut.Value, result.Value);
}
}
}
}
public void SetValueAsNullableInt16ReturnsExpectedResult(int length, short?value, bool expected)
{
var sut = new DbaseNumber(
DbaseField.CreateNumberField(
_fixture.Create <DbaseFieldName>(),
new DbaseFieldLength(length),
new DbaseDecimalCount(0)
));
if (!expected)
{
Assert.Throws <FormatException>(() =>
{
sut.ValueAsNullableInt16 = value;
});
}
else
{
sut.ValueAsNullableInt16 = value;
}
}
public void CanNotReadPastEndOfStream()
{
var sut = _fixture.Create <DbaseNumber>();
using (var stream = new MemoryStream())
{
using (var writer = new BinaryWriter(stream, Encoding.ASCII, true))
{
writer.Write(_fixture.CreateMany <byte>(new Random().Next(0, sut.Field.Length.ToInt32())).ToArray());
writer.Flush();
}
stream.Position = 0;
using (var reader = new BinaryReader(stream, Encoding.ASCII, true))
{
var result = new DbaseNumber(sut.Field);
Assert.Throws <EndOfStreamException>(() => result.Read(reader));
}
}
}
public void WritesExcessDecimalsAsZero()
{
var length = _fixture.GenerateDbaseDoubleLength();
var decimalCount = _fixture.GenerateDbaseDoubleDecimalCount(length);
var sut = new DbaseNumber(
new DbaseField(
_fixture.Create <DbaseFieldName>(),
DbaseFieldType.Number,
_fixture.Create <ByteOffset>(),
length,
decimalCount
), 0.0);
using (var stream = new MemoryStream())
{
using (var writer = new BinaryWriter(stream, Encoding.ASCII, true))
{
sut.Write(writer);
writer.Flush();
}
stream.Position = 0;
if (decimalCount.ToInt32() == 0)
{
Assert.Equal(
"0".PadLeft(length.ToInt32()),
Encoding.ASCII.GetString(stream.ToArray()));
}
else
{
Assert.Equal(
new string(' ', length.ToInt32() - decimalCount.ToInt32() - 2)
+ "0."
+ new string('0', decimalCount.ToInt32()),
Encoding.ASCII.GetString(stream.ToArray())
);
}
}
}
public void GetValueAsNullableInt16ReturnsExpectedResult(int length, double?value, bool gotten, short?gottenValueAsInt16)
{
var sut = new DbaseNumber(
DbaseField.CreateNumberField(
_fixture.Create <DbaseFieldName>(),
new DbaseFieldLength(length),
new DbaseDecimalCount(0)
), value);
if (!gotten)
{
Assert.Throws <FormatException>(() =>
{
var _ = sut.ValueAsNullableInt16;
});
}
else
{
var result = sut.ValueAsNullableInt16;
Assert.Equal(gottenValueAsInt16, result);
}
}
public double?GenerateAcceptableValue(DbaseNumber value)
{
double?result = default;
// null only
if (value.Field.Length < DbaseNumber.MinimumLength)
{
return(result);
}
// null or positive only
if (value.Field.Length < DbaseNumber.NegativeValueMinimumLength)
{
switch (_random.Next() % 2)
{
//case 0: null
case 1:
result = GeneratePositiveNullableDoubleValue(value.Field);
break;
}
return(result);
}
// null or positive or negative
switch (_random.Next() % 3)
{
//case 0: null
case 1:
result = GeneratePositiveNullableDoubleValue(value.Field);
break;
case 2:
result = GenerateNegativeNullableDoubleValue(value.Field);
break;
}
return(result);
}
public void CanReadWriteNegative()
{
using (var random = new PooledRandom())
{
var sut = new DbaseNumber(
new DbaseField(
_fixture.Create <DbaseFieldName>(),
DbaseFieldType.Number,
_fixture.Create <ByteOffset>(),
DbaseNumber.NegativeValueMinimumLength,
new DbaseDecimalCount(1)
)
);
sut.Value =
new DbaseFieldNumberGenerator(random)
.GenerateAcceptableValue(sut);
using (var stream = new MemoryStream())
{
using (var writer = new BinaryWriter(stream, Encoding.ASCII, true))
{
sut.Write(writer);
writer.Flush();
}
stream.Position = 0;
using (var reader = new BinaryReader(stream, Encoding.ASCII, true))
{
var result = new DbaseNumber(sut.Field);
result.Read(reader);
Assert.Equal(sut, result, new DbaseFieldValueEqualityComparer());
}
}
}
}
public void Visit(DbaseNumber value)
{
value.Value = _generator.GenerateAcceptableValue(value);
}
public FakeDbaseRecord()
{
Id = new DbaseNumber(Schema.Id);
Values = new DbaseFieldValue[] { Id };
}
public void Visit(DbaseNumber value)
{
HashCode = value.Value?.GetHashCode() ?? 0;
}
public void Visit(DbaseNumber value)
{
Comparer = new DelegatingDbaseFieldValueEqualityComparer <DbaseNumber>(
new DbaseNumberEqualityComparer(_precision));
}
