public static DbaseField Read(BinaryReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
var name = new DbaseFieldName(reader.ReadRightPaddedString(11, char.MinValue));
var typeOfField = reader.ReadByte();
if (!Enum.IsDefined(typeof(DbaseFieldType), typeOfField))
{
var values = Enum.GetValues(typeof(DbaseFieldType));
var supportedValues = string.Join(
",",
Enumerable
.Range(0, values.Length)
.Select(index =>
values.GetValue(index).ToString() + "[" + ((byte)values.GetValue(index)).ToString() + "]")
);
throw new DbaseFileHeaderException(
$"The field type {typeOfField} of field {name} is not supported ({supportedValues}).");
}
var fieldType = (DbaseFieldType)typeOfField;
var offset = new ByteOffset(reader.ReadInt32());
var length = new DbaseFieldLength(reader.ReadByte());
var decimalCount = new DbaseDecimalCount(reader.ReadByte());
reader.ReadBytes(14);
return(new DbaseField(name, fieldType, offset, length, decimalCount));
}
public DbaseSingle(DbaseField field, float?value = null) : base(field)
{
if (field == null)
{
throw new ArgumentNullException(nameof(field));
}
if (field.FieldType != DbaseFieldType.Float)
{
throw new ArgumentException(
$"The field {field.Name} 's type must be float to use it as a single field.", nameof(field));
}
if (field.Length < MinimumLength || field.Length > MaximumLength)
{
throw new ArgumentException(
$"The field {field.Name} 's length ({field.Length}) must be between {MinimumLength} and {MaximumLength}.",
nameof(field));
}
Provider = new NumberFormatInfo
{
NumberDecimalDigits = DbaseDecimalCount.Min(MaximumDecimalCount, field.DecimalCount).ToInt32(),
NumberDecimalSeparator = "."
};
Value = value;
}
public static void CustomizeDbaseDecimalCount(this IFixture fixture, DbaseDecimalCount maximum)
{
fixture.Customize <DbaseDecimalCount>(
customization =>
customization.FromFactory <int>(
value => new DbaseDecimalCount(value.AsDbaseDecimalCountValue(maximum.ToInt32()))
));
}
public void ToInt32ReturnsExpectedValue()
{
var value = _fixture.Create <int>().AsDbaseDecimalCountValue();
var sut = new DbaseDecimalCount(value);
var result = sut.ToInt32();
Assert.Equal(value, result);
}
public void LessThanOrEqualToDbaseDecimalCountOperatorReturnsExpectedValue(int left, int right, bool expected)
{
var sut = new DbaseDecimalCount(left);
var other = new DbaseDecimalCount(right);
var result = sut <= other;
Assert.Equal(expected, result);
}
public void InequalityOperatorReturnsExpectedValue(int left, int right, bool expected)
{
var sut = new DbaseDecimalCount(left);
var other = new DbaseDecimalCount(right);
var result = sut != other;
Assert.Equal(expected, result);
}
public void CompareToDbaseDecimalCountReturnsExpectedResult(int left, int right, int expected)
{
var sut = new DbaseDecimalCount(left);
var other = new DbaseDecimalCount(right);
var result = sut.CompareTo(other);
Assert.Equal(expected, result);
}
public void CreateSingleFieldThrowsWhenDecimalCountGreaterThanOrEqualToLength(int plus)
{
var name = _fixture.Create <DbaseFieldName>();
var length = _fixture.GenerateDbaseSingleLength();
var decimalCount = new DbaseDecimalCount(length.ToInt32()).Plus(new DbaseDecimalCount(plus));
Assert.Throws <ArgumentException>(() => DbaseField.CreateSingleField(
name,
length,
decimalCount));
}
public void CreateSingleFieldThrowsWhenDecimalCountGreaterThanZeroAndLengthSmallerThan3(int smallerThan3)
{
var name = _fixture.Create <DbaseFieldName>();
var length = new DbaseFieldLength(smallerThan3);
var decimalCount = new DbaseDecimalCount(1);
Assert.Throws <ArgumentException>(() => DbaseField.CreateSingleField(
name,
length,
decimalCount));
}
public bool AcceptsValue(float value)
{
if (Field.DecimalCount.ToInt32() == 0)
{
return(((float)Math.Truncate(value)).ToString("F", Provider).Length <= Field.Length.ToInt32());
}
var digits = DbaseDecimalCount.Min(MaximumDecimalCount, Field.DecimalCount).ToInt32();
var rounded = (float)Math.Round(value, digits);
return(rounded.ToString("F", Provider).Length <= Field.Length.ToInt32());
}
public void CreateNumberFieldFailsWhenDecimalCountIsNotZeroAndNotLessThanLengthMinus2(int minus)
{
var length = _fixture.GenerateDbaseDoubleLength();
var decimalCount = new DbaseDecimalCount(length.ToInt32()).Minus(new DbaseDecimalCount(minus));
Assert.Throws <ArgumentException>(() =>
new DbaseField(
_fixture.Create <DbaseFieldName>(),
DbaseFieldType.Number,
_fixture.Create <ByteOffset>(),
length,
decimalCount));
}
public void CreateFloatFieldFailsWhenDecimalCountIsNotZeroAndNotLessThanOrEqualTo7(int decimals)
{
var length = _fixture.Create <DbaseFieldLength>();
var decimalCount = new DbaseDecimalCount(decimals);
Assert.Throws <ArgumentException>(() =>
new DbaseField(
_fixture.Create <DbaseFieldName>(),
DbaseFieldType.Float,
_fixture.Create <ByteOffset>(),
length,
decimalCount));
}
private char[] GeneratePositiveNumber(DbaseIntegerDigits digits, DbaseDecimalCount decimals)
{
var data = new char[digits.ToInt32() + 1 + decimals.ToInt32()];
for (var index = 0; index < digits.ToInt32(); index++)
{
data[index] = _random.Next(0, 10).ToString()[0];
}
data[digits.ToInt32()] = '.';
for (var index = 0; index < decimals.ToInt32(); index++)
{
data[digits.ToInt32() + 1 + index] = _random.Next(0, 10).ToString()[0];
}
return(data);
}
public static DbaseDecimalCount GenerateDbaseDoubleDecimalCount(this IFixture fixture,
DbaseDecimalCount minimum, DbaseFieldLength length)
{
if (length > DbaseDouble.MaximumLength)
{
throw new ArgumentOutOfRangeException(nameof(length),
$"The length ({length}) can not exceed the maximum length ({DbaseDouble.MaximumLength}).");
}
using (var random = new PooledRandom())
{
return(new DbaseDecimalCount(random.Next(minimum.ToInt32(),
Math.Min(DbaseDouble.MaximumDecimalCount.ToInt32() + 1, length.ToInt32()) - 2)));
}
}
public bool AcceptsValue(double?value)
{
if (!value.HasValue)
{
return(true);
}
if (Field.DecimalCount.ToInt32() == 0)
{
return(Math.Truncate(value.Value).ToString("F", Provider).Length <= Field.Length.ToInt32());
}
var digits = DbaseDecimalCount.Min(MaximumDecimalCount, Field.DecimalCount).ToInt32();
var rounded = Math.Round(value.Value, digits);
return(rounded.ToString("F", Provider).Length <= Field.Length.ToInt32());
}
public void CreateFailsIfFieldLengthIsOutOfRange(int outOfRange)
{
var length = new DbaseFieldLength(outOfRange);
var decimalCount = new DbaseDecimalCount(0);
Assert.Throws <ArgumentException>(
() =>
new DbaseNumber(
new DbaseField(
_fixture.Create <DbaseFieldName>(),
DbaseFieldType.Number,
_fixture.Create <ByteOffset>(),
length,
decimalCount
)
)
);
}
public void CanReadWriteWithMaxDecimalCount()
{
var length = DbaseSingle.MaximumLength;
var decimalCount = DbaseDecimalCount.Min(DbaseSingle.MaximumDecimalCount,
new DbaseDecimalCount(length.ToInt32() - 2));
var sut =
new DbaseSingle(
new DbaseField(
_fixture.Create <DbaseFieldName>(),
DbaseFieldType.Float,
_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 DbaseSingle(sut.Field);
result.Read(reader);
Assert.Equal(sut, result, new DbaseFieldValueEqualityComparer());
}
}
}
}
public void CreateNumberFieldReturnsExpectedResultWhenDecimalCountIsZeroAndNotLessThanLengthMinus2()
{
var name = _fixture.Create <DbaseFieldName>();
var offset = _fixture.Create <ByteOffset>();
var length = new DbaseFieldLength(1);
var decimalCount = new DbaseDecimalCount(0);
var result =
new DbaseField(
name,
DbaseFieldType.Number,
offset,
length,
decimalCount);
Assert.Equal(name, result.Name);
Assert.Equal(DbaseFieldType.Number, result.FieldType);
Assert.Equal(offset, result.Offset);
Assert.Equal(length, result.Length);
Assert.Equal(decimalCount, result.DecimalCount);
Assert.Equal(new DbaseIntegerDigits(1), result.PositiveIntegerDigits);
Assert.Equal(new DbaseIntegerDigits(0), result.NegativeIntegerDigits);
}
public void CreateCharacterFieldReturnsExpectedWhenDecimalCountIs0()
{
var name = _fixture.Create <DbaseFieldName>();
var offset = _fixture.Create <ByteOffset>();
var length = _fixture.Create <DbaseFieldLength>();
var decimalCount = new DbaseDecimalCount(0);
var result =
new DbaseField(
name,
DbaseFieldType.Character,
offset,
length,
decimalCount);
Assert.Equal(name, result.Name);
Assert.Equal(DbaseFieldType.Character, result.FieldType);
Assert.Equal(offset, result.Offset);
Assert.Equal(length, result.Length);
Assert.Equal(decimalCount, result.DecimalCount);
Assert.Equal(new DbaseIntegerDigits(0), result.PositiveIntegerDigits);
Assert.Equal(new DbaseIntegerDigits(0), result.NegativeIntegerDigits);
}
public DbaseDecimalEqualityComparer(DbaseDecimalCount precision)
{
_precision = precision;
}
public static DbaseField CreateNumberField(DbaseFieldName name, DbaseFieldLength length, DbaseDecimalCount decimalCount) => new DbaseField(name, DbaseFieldType.Number, ByteOffset.Initial, length, decimalCount);
public DbaseNullableDoubleEqualityComparer(DbaseDecimalCount precision)
{
_precision = precision;
}
// public static DbaseField CreateDecimalField(DbaseFieldName name, DbaseFieldLength length,
// DbaseDecimalCount decimalCount)
// {
// return new DbaseField(name, DbaseFieldType.Number, ByteOffset.Initial, length, decimalCount);
// }
public static DbaseField CreateDoubleField(DbaseFieldName name, DbaseFieldLength length,
DbaseDecimalCount decimalCount)
{
return(new DbaseField(name, DbaseFieldType.Number, ByteOffset.Initial, length, decimalCount));
}
public void MinReturnsExpectedResult(int left, int right, int expected)
{
var result = DbaseDecimalCount.Min(new DbaseDecimalCount(left), new DbaseDecimalCount(right));
Assert.Equal(new DbaseDecimalCount(expected), result);
}
bool IEqualityComparer <object> .Equals(object left, object right)
{
if (left == null && right == null)
{
return(true);
}
if (left == null || right == null)
{
return(false);
}
if (left is double leftDouble && right is double rightDouble)
{
var doubleDigits = DbaseDecimalCount.Min(_digits, DbaseDouble.MaximumDecimalCount).ToInt32();
var leftRounded = Math.Round(leftDouble, doubleDigits);
var rightRounded = Math.Round(rightDouble, doubleDigits);
return(Math.Abs(leftRounded - rightRounded) <= Math.Pow(10, -doubleDigits));
}
if (left is double? && right is double?)
{
var nullableLeft = (double?)left;
var nullableRight = (double?)right;
if (!nullableLeft.HasValue && !nullableRight.HasValue)
{
return(true);
}
if (nullableLeft.HasValue || nullableRight.HasValue)
{
return(false);
}
var doubleDigits = DbaseDecimalCount.Min(_digits, DbaseDouble.MaximumDecimalCount).ToInt32();
var leftRounded = Math.Round((double)nullableLeft.Value, doubleDigits);
var rightRounded = Math.Round((double)nullableRight.Value, doubleDigits);
return(Math.Abs(leftRounded - rightRounded) <= Math.Pow(10, -doubleDigits));
}
if (left is float leftSingle && right is float rightSingle)
{
var singleDigits = DbaseDecimalCount.Min(_digits, DbaseSingle.MaximumDecimalCount).ToInt32();
var leftRounded = Math.Round(leftSingle, singleDigits);
var rightRounded = Math.Round(rightSingle, singleDigits);
return(Math.Abs(leftRounded - rightRounded) <= Math.Pow(10, -singleDigits));
}
if (left is float? && right is float?)
{
var nullableLeft = (float?)left;
var nullableRight = (float?)right;
if (!nullableLeft.HasValue && !nullableRight.HasValue)
{
return(true);
}
if (nullableLeft.HasValue || nullableRight.HasValue)
{
return(false);
}
var singleDigits = DbaseDecimalCount.Min(_digits, DbaseSingle.MaximumDecimalCount).ToInt32();
var leftRounded = Math.Round((float)nullableLeft.Value, singleDigits);
var rightRounded = Math.Round((float)nullableRight.Value, singleDigits);
return(Math.Abs(leftRounded - rightRounded) <= Math.Pow(10, -singleDigits));
}
return(Equals(left, right));
}
public static DbaseField CreateSingleField(DbaseFieldName name, DbaseFieldLength length, DbaseDecimalCount decimalCount) => new DbaseField(name, DbaseFieldType.Float, ByteOffset.Initial, length, decimalCount);
public ComparerSelectingInspector(DbaseDecimalCount precision)
{
_precision = precision;
}
public DbaseField(DbaseFieldName name, DbaseFieldType fieldType, ByteOffset offset, DbaseFieldLength length,
DbaseDecimalCount decimalCount)
{
if (!Enum.IsDefined(typeof(DbaseFieldType), fieldType))
{
throw new ArgumentException(
$"The field type {fieldType} of field {name} is not supported.",
nameof(fieldType));
}
switch (fieldType)
{
case DbaseFieldType.Character:
if (decimalCount.ToInt32() != 0)
{
throw new ArgumentException(
$"The character field {name} decimal count ({decimalCount}) must be set to 0.",
nameof(decimalCount));
}
break;
case DbaseFieldType.DateTime:
if (length.ToInt32() != 15)
{
throw new ArgumentException($"The datetime field {name} length ({length}) must be set to 15.",
nameof(length));
}
if (decimalCount.ToInt32() != 0)
{
throw new ArgumentException(
$"The datetime field {name} decimal count ({decimalCount}) must be set to 0.",
nameof(decimalCount));
}
break;
case DbaseFieldType.Number:
if (length > DbaseDouble.MaximumLength)
{
throw new ArgumentException(
$"The number field {name} length ({length}) must be less than or equal to {DbaseDouble.MaximumLength}.",
nameof(length));
}
if (decimalCount.ToInt32() != 0)
{
if (length < DbaseDouble.MinimumLength)
{
throw new ArgumentException(
$"The number field {name} length ({length}) must be at least {DbaseDouble.MinimumLength}.",
nameof(length));
}
if (decimalCount > DbaseDouble.MaximumDecimalCount)
{
throw new ArgumentException(
$"The number field {name} decimal count ({decimalCount}) must be less than or equal to {DbaseDouble.MaximumDecimalCount}.",
nameof(decimalCount));
}
if (decimalCount.ToInt32() > length.ToInt32() - 2)
{
throw new ArgumentException(
$"The number field {name} decimal count ({decimalCount}) must be 2 less than its length ({length}).",
nameof(decimalCount));
}
}
break;
case DbaseFieldType.Float:
if (length > DbaseSingle.MaximumLength)
{
throw new ArgumentException(
$"The float field {name} length ({length}) must be less than or equal to {DbaseSingle.MaximumLength}.",
nameof(length));
}
if (decimalCount.ToInt32() != 0)
{
if (length < DbaseSingle.MinimumLength)
{
throw new ArgumentException(
$"The number field {name} length ({length}) must be at least {DbaseSingle.MinimumLength}.",
nameof(length));
}
if (decimalCount > DbaseSingle.MaximumDecimalCount)
{
throw new ArgumentException(
$"The float field {name} decimal count ({decimalCount}) must be less than or equal to {DbaseSingle.MaximumDecimalCount}.",
nameof(decimalCount));
}
if (decimalCount.ToInt32() > length.ToInt32() - 2)
{
throw new ArgumentException(
$"The float field {name} decimal count ({decimalCount}) must be 2 less than its length ({length}).",
nameof(decimalCount));
}
}
break;
case DbaseFieldType.Logical:
if (decimalCount.ToInt32() != 0)
{
throw new ArgumentException(
$"The logical field {name} decimal count ({decimalCount}) must be set to 0.",
nameof(decimalCount));
}
if (length.ToInt32() != 1)
{
throw new ArgumentException(
$"The logical field {name} length ({length}) must be set to 1.",
nameof(length));
}
break;
}
Name = name;
FieldType = fieldType;
Offset = offset;
Length = length;
DecimalCount = decimalCount;
if (FieldType == DbaseFieldType.Number || FieldType == DbaseFieldType.Float)
{
PositiveIntegerDigits =
DecimalCount.ToInt32() != 0
? new DbaseIntegerDigits(
Length
.Minus(DecimalCount.ToLength())
.Minus(DecimalSeparatorLength)
.ToInt32()
)
: new DbaseIntegerDigits(Length.ToInt32());
NegativeIntegerDigits =
PositiveIntegerDigits != new DbaseIntegerDigits(0)
? PositiveIntegerDigits
.Minus(SignLength)
: new DbaseIntegerDigits(0);
}
else
{
PositiveIntegerDigits = new DbaseIntegerDigits(0);
NegativeIntegerDigits = new DbaseIntegerDigits(0);
}
}
public ObjectEqualityComparer(DbaseDecimalCount digits)
{
_digits = digits;
}
