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);