private ShapeRecord[] GenerateManyRecords(ShapeType typeOfShape, ShapeRecordCount count)
{
var records = new ShapeRecord[count.ToInt32()];
var number = RecordNumber.Initial;
for (var index = 0; index < records.Length; index++)
{
ShapeContent content = null;
switch (typeOfShape)
{
case ShapeType.Point:
content = new PointShapeContent(_fixture.Create <Point>());
break;
case ShapeType.PolyLineM:
content = new PolyLineMShapeContent(_fixture.Create <PolyLineM>());
break;
case ShapeType.Polygon:
content = new PolygonShapeContent(_fixture.Create <Polygon>());
break;
//case ShapeType.NullShape:
default:
content = NullShapeContent.Instance;
break;
}
records[index] = content.RecordAs(number);
number = number.Next();
}
return(records);
}
public void ShapeReturnsExpectedValue()
{
var shape = _fixture.Create <Polygon>();
var sut = new PolygonShapeContent(shape);
Assert.Same(shape, sut.Shape);
}
private ShapeRecord GenerateOneRecord(ShapeType typeOfShape)
{
ShapeContent content = null;
switch (typeOfShape)
{
case ShapeType.Point:
content = new PointShapeContent(_fixture.Create <Point>());
break;
case ShapeType.PolyLineM:
content = new PolyLineMShapeContent(_fixture.Create <PolyLineM>());
break;
case ShapeType.Polygon:
content = new PolygonShapeContent(_fixture.Create <Polygon>());
break;
//case ShapeType.NullShape:
default:
content = NullShapeContent.Instance;
break;
}
return(content.RecordAs(RecordNumber.Initial));
}
public void ReadPolygonCanReadWrittenPolygonShape()
{
var shape = _fixture.Create <Polygon>();
var sut = new PolygonShapeContent(shape);
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 = (PolygonShapeContent)PolygonShapeContent.ReadPolygon(reader);
Assert.Equal(sut.Shape, result.Shape);
Assert.Equal(sut.ShapeType, result.ShapeType);
Assert.Equal(sut.ContentLength, result.ContentLength);
}
}
}
internal static ShapeContent ReadFromRecord(BinaryReader reader, ShapeRecordHeader header)
{
var shapeType = reader.ReadInt32LittleEndian();
if (!Enum.IsDefined(typeof(ShapeType), shapeType))
{
throw new ShapeRecordContentException("The Shape Type field does not contain a known type of shape.");
}
var content = NullShapeContent.Instance;
switch ((ShapeType)shapeType)
{
case ShapeType.NullShape:
break;
case ShapeType.Point:
content = PointShapeContent.ReadPointFromRecord(reader, header);
break;
case ShapeType.PolyLineM:
content = PolyLineMShapeContent.ReadPolyLineMFromRecord(reader, header);
break;
case ShapeType.Polygon:
content = PolygonShapeContent.ReadPolygonFromRecord(reader, header);
break;
default:
throw new ShapeRecordContentException($"The Shape Type {shapeType} is currently not suppported.");
}
return(content);
}
private bool Equals(PolygonShapeContent left, PolygonShapeContent right)
{
var sameContentLength = left.ContentLength.Equals(right.ContentLength);
var sameShapeType = left.ShapeType.Equals(right.ShapeType);
var sameShape = left.Shape.Equals(right.Shape);
return(sameContentLength && sameShapeType && sameShape);
}
public void ContentLengthReturnsExpectedValue()
{
var shape = _fixture.Create <Polygon>();
var sut = new PolygonShapeContent(shape);
var numberOfParts = shape.NumberOfParts;
var numberOfPoints = shape.NumberOfPoints;
var contentLength = new WordLength(
2 + 2 + 2 // shape type, number of parts, number of points,
+ 4 * 4 // bounding box,
+ 2 * numberOfParts // parts
+ 4 * 2 * numberOfPoints // points
);
Assert.Equal(contentLength, sut.ContentLength);
}
public void ReadPolygonCanReadWrittenNullShape()
{
using (var stream = new MemoryStream())
{
using (var writer = new BinaryWriter(stream, Encoding.ASCII, true))
{
NullShapeContent.Instance.Write(writer);
writer.Flush();
}
stream.Position = 0;
using (var reader = new BinaryReader(stream, Encoding.ASCII, true))
{
var result = PolygonShapeContent.ReadPolygon(reader);
Assert.Equal(NullShapeContent.Instance, result);
}
}
}
public void ReadPolygonCanNotReadOtherShapeType(ShapeType other)
{
using (var stream = new MemoryStream())
{
using (var writer = new BinaryWriter(stream, Encoding.ASCII, true))
{
writer.WriteInt32LittleEndian((int)other);
writer.Flush();
}
stream.Position = 0;
using (var reader = new BinaryReader(stream, Encoding.ASCII, true))
{
Assert.Throws <ShapeRecordContentException>(
() => PolygonShapeContent.ReadPolygon(reader)
);
}
}
}
public static ShapeContent Read(BinaryReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
var shapeType = reader.ReadInt32LittleEndian();
if (!Enum.IsDefined(typeof(ShapeType), shapeType))
{
throw new ShapeRecordContentException("The Shape Type field does not contain a known type of shape.");
}
var content = NullShapeContent.Instance;
switch ((ShapeType)shapeType)
{
case ShapeType.NullShape:
break;
case ShapeType.Point:
content = PointShapeContent.ReadPointGeometry(reader);
break;
case ShapeType.PolyLineM:
content = PolyLineMShapeContent.ReadPolyLineMGeometry(reader);
break;
case ShapeType.Polygon:
content = PolygonShapeContent.ReadPolygonGeometry(reader);
break;
default:
throw new ShapeRecordContentException($"The Shape Type {shapeType} is currently not suppported.");
}
return(content);
}
public ShapeRecordTests()
{
_fixture = new Fixture();
_fixture.CustomizeRecordNumber();
_fixture.CustomizeWordLength();
_fixture.CustomizeWordOffset();
_fixture.CustomizePoint();
_fixture.CustomizePolygon();
_fixture.CustomizePolyLineM();
_fixture.Customize <ShapeContent>(customization =>
customization.FromFactory <int>(value =>
{
ShapeContent content = null;
switch (value % 4)
{
case 0:
content = NullShapeContent.Instance;
break;
case 1:
content = new PointShapeContent(_fixture.Create <Point>());
break;
case 2:
content = new PolyLineMShapeContent(_fixture.Create <PolyLineM>());
break;
case 3:
content = new PolygonShapeContent(_fixture.Create <Polygon>());
break;
}
return(content);
}));
_fixture.Register(() => new BinaryReader(new MemoryStream()));
_fixture.Register(() => new BinaryWriter(new MemoryStream()));
}
public ShapeBinaryWriterTests()
{
_fixture = new Fixture();
_fixture.CustomizeShapeRecordCount(100);
_fixture.CustomizeRecordNumber();
_fixture.CustomizeWordLength();
_fixture.CustomizeWordOffset();
_fixture.Customize <ShapeType>(customization =>
customization.FromFactory(generator =>
{
var result = ShapeType.NullShape;
switch (generator.Next() % 4)
{
//case 0:
case 1:
result = ShapeType.Point;
break;
case 2:
result = ShapeType.PolyLineM;
break;
case 3:
result = ShapeType.Polygon;
break;
}
return(result);
}
).OmitAutoProperties()
);
_fixture.CustomizePoint();
_fixture.CustomizePolygon();
_fixture.CustomizePolyLineM();
_fixture.Customize <ShapeContent>(customization =>
customization.FromFactory(generator =>
{
ShapeContent content = null;
switch (generator.Next() % 4)
{
case 0:
content = NullShapeContent.Instance;
break;
case 1:
content = new PointShapeContent(_fixture.Create <Point>());
break;
case 2:
content = new PolyLineMShapeContent(_fixture.Create <PolyLineM>());
break;
case 3:
content = new PolygonShapeContent(_fixture.Create <Polygon>());
break;
}
return(content);
}));
_fixture.Register <Stream>(() => new MemoryStream());
}
public void ShapeTypeReturnsExpectedValue()
{
var sut = new PolygonShapeContent(_fixture.Create <Polygon>());
Assert.Equal(ShapeType.Polygon, sut.ShapeType);
}
public void ReadPolygonReaderCanNotBeNull()
{
new GuardClauseAssertion(_fixture)
.Verify(Methods.Select(() => PolygonShapeContent.ReadPolygon(null)));
}
