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 static DbaseFieldLength GenerateDbaseSingleLengthBetween(this IFixture fixture,
DbaseFieldLength minLength, DbaseFieldLength maxLength)
{
if (minLength < DbaseSingle.MinimumLength || minLength > DbaseSingle.MaximumLength)
{
throw new ArgumentOutOfRangeException(nameof(minLength),
$"The minimum length needs to be between {DbaseSingle.MinimumLength} and {DbaseSingle.MaximumLength}.");
}
if (maxLength < DbaseSingle.MinimumLength || maxLength > DbaseSingle.MaximumLength)
{
throw new ArgumentOutOfRangeException(nameof(maxLength),
$"The maximum length needs to be between {DbaseSingle.MinimumLength} and {DbaseSingle.MaximumLength}.");
}
if (minLength > maxLength)
{
throw new ArgumentOutOfRangeException(nameof(minLength),
$"The minimum length {minLength} needs to be less than or equal to the maximum length {maxLength}.");
}
using (var random = new PooledRandom())
{
return(new DbaseFieldLength(random.Next(minLength.ToInt32(), maxLength.ToInt32())));
}
}
public void LengthOfValueBeingSetCanNotExceedFieldLength()
{
var maxLength = new DbaseFieldLength(
int.MaxValue.ToString(CultureInfo.InvariantCulture).Length - 1
// because it's impossible to create a value longer than this (we need the test to generate a longer value)
);
var length = _fixture.GenerateDbaseInt32LengthLessThan(maxLength);
var sut =
new DbaseNullableInt32(
new DbaseField(
_fixture.Create <DbaseFieldName>(),
_fixture.GenerateDbaseInt32FieldType(),
_fixture.Create <ByteOffset>(),
length,
new DbaseDecimalCount(0)
)
);
var value = Enumerable
.Range(0, sut.Field.Length.ToInt32())
.Aggregate(1, (current, _) => current * 10);
Assert.Throws <FormatException>(() => sut.Value = value);
}
public static void CustomizeDbaseString(this IFixture fixture)
{
fixture.Customize <DbaseString>(
customization =>
customization
.FromFactory <int>(
value =>
{
using (var random = new PooledRandom(value))
{
var length = new DbaseFieldLength(random.Next(0, 255));
return(new DbaseString(
new DbaseField(
fixture.Create <DbaseFieldName>(),
DbaseFieldType.Character,
fixture.Create <ByteOffset>(),
length,
new DbaseDecimalCount(0)
),
new string('a', random.Next(0, length.ToInt32()))));
}
}
)
.OmitAutoProperties());
}
public static DbaseFieldLength GenerateDbaseInt32LengthLessThan(this IFixture fixture,
DbaseFieldLength maxLength)
{
using (var random = new PooledRandom())
{
return(new DbaseFieldLength(random.Next(maxLength.ToInt32())));
}
}
public static void CustomizeDbaseFieldLength(this IFixture fixture, DbaseFieldLength maxLength)
{
fixture.Customize <DbaseFieldLength>(
customization =>
customization.FromFactory <int>(
value => new DbaseFieldLength(value.AsDbaseFieldLengthValue(maxLength.ToInt32()))
));
}
public void ToByteReturnsExpectedValue()
{
var value = _fixture.Create <int>().AsDbaseFieldLengthValue();
var sut = new DbaseFieldLength(value);
var result = sut.ToByte();
Assert.Equal((byte)value, result);
}
public void LessThanOrEqualToDbaseFieldLengthOperatorReturnsExpectedValue(int left, int right, bool expected)
{
var sut = new DbaseFieldLength(left);
var other = new DbaseFieldLength(right);
var result = sut <= other;
Assert.Equal(expected, result);
}
public void CompareToDbaseFieldLengthReturnsExpectedResult(int left, int right, int expected)
{
var sut = new DbaseFieldLength(left);
var other = new DbaseFieldLength(right);
var result = sut.CompareTo(other);
Assert.Equal(expected, result);
}
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 void CreateFloatFieldFailsWhenLengthIsNotLessThanOrEqualTo20(int digits)
{
var length = new DbaseFieldLength(digits);
var decimalCount = _fixture.Create <DbaseDecimalCount>();
Assert.Throws <ArgumentException>(() =>
new DbaseField(
_fixture.Create <DbaseFieldName>(),
DbaseFieldType.Float,
_fixture.Create <ByteOffset>(),
length,
decimalCount));
}
public static DbaseFieldLength GenerateDbaseDoubleLengthLessThan(this IFixture fixture,
DbaseFieldLength maxLength)
{
if (maxLength < DbaseDouble.MinimumLength || maxLength > DbaseDouble.MaximumLength)
{
throw new ArgumentOutOfRangeException(nameof(maxLength),
$"The maximum length needs to be between {DbaseDouble.MinimumLength} and {DbaseDouble.MaximumLength}.");
}
using (var random = new PooledRandom())
{
return(new DbaseFieldLength(random.Next(DbaseDouble.MinimumLength.ToInt32(), maxLength.ToInt32() + 1)));
}
}
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 CreateLogicalFieldReturnsExpectedResultWhenLengthIs1AndDecimalCountIs0()
{
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.Logical,
offset,
length,
decimalCount);
Assert.Equal(name, result.Name);
Assert.Equal(DbaseFieldType.Logical, 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 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 DbaseRecordLength Plus(DbaseFieldLength other)
{
return(new DbaseRecordLength(_value + other.ToInt32()));
}
public static DbaseField CreateStringField(DbaseFieldName name, DbaseFieldLength length) => new DbaseField(name, DbaseFieldType.Character, ByteOffset.Initial, length, new DbaseDecimalCount(0));
public static DbaseDecimalCount GenerateDbaseSingleDecimalCount(this IFixture fixture, DbaseFieldLength length)
{
if (length < DbaseSingle.MinimumLength || length > DbaseSingle.MaximumLength)
{
throw new ArgumentOutOfRangeException(nameof(length),
$"The length needs to be between {DbaseSingle.MinimumLength} and {DbaseSingle.MaximumLength}.");
}
using (var random = new PooledRandom())
{
return(new DbaseDecimalCount(random.Next(1,
Math.Min(DbaseSingle.MaximumDecimalCount.ToInt32(), length.ToInt32()) - 2)));
}
}
public void MinReturnsExpectedResult(int left, int right, int expected)
{
var result = DbaseFieldLength.Min(new DbaseFieldLength(left), new DbaseFieldLength(right));
Assert.Equal(new DbaseFieldLength(expected), result);
}
public ByteOffset Plus(DbaseFieldLength other)
{
return(new ByteOffset(_value + other.ToInt32()));
}
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 DbaseIntegerDigits Plus(DbaseFieldLength other)
{
return(new DbaseIntegerDigits(_value + other.ToInt32()));
}
public static DbaseField CreateInt16Field(DbaseFieldName name, DbaseFieldLength length) => new DbaseField(name, DbaseFieldType.Number, ByteOffset.Initial, length, new DbaseDecimalCount(0));
// 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 static DbaseField CreateSingleField(DbaseFieldName name, DbaseFieldLength length, DbaseDecimalCount decimalCount) => new DbaseField(name, DbaseFieldType.Float, ByteOffset.Initial, length, decimalCount);
public DbaseIntegerDigits Minus(DbaseFieldLength other) => new DbaseIntegerDigits(_value - other.ToInt32());
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 static DbaseField CreateNumberField(DbaseFieldName name, DbaseFieldLength length, DbaseDecimalCount decimalCount) => new DbaseField(name, DbaseFieldType.Number, ByteOffset.Initial, length, decimalCount);
