public ForceMultiGeometryTrue()
{
_sut = new GeometryGeoJsonConverter(new GeoJsonSerializerSettings
{
ForceMultiGeometry = true
});
}
public void PolygonReturnsPolygon(GeometryGeoJsonConverter sut, ILine line, IPoint point, ISpatialReference spatialReference)
{
var polygon = (IGeometry) new PolygonClass();
polygon.SpatialReference = spatialReference;
var ring = (IPointCollection) new RingClass();
ring.AddPoint(line.FromPoint);
ring.AddPoint(line.ToPoint);
ring.AddPoint(point);
ring.AddPoint(line.FromPoint);
((IGeometryCollection)polygon).AddGeometry((IGeometry)ring);
var actual = JsonConvert.SerializeObject(polygon, Formatting.Indented, sut);
var expected = $@"{{
""type"": ""Polygon"",
""coordinates"": [
[{line.FromPoint.X.ToJsonString()}, {line.FromPoint.Y.ToJsonString()}],
[{line.ToPoint.X.ToJsonString()}, {line.ToPoint.Y.ToJsonString()}],
[{point.X.ToJsonString()}, {point.Y.ToJsonString()}],
[{line.FromPoint.X.ToJsonString()}, {line.FromPoint.Y.ToJsonString()}]
]
}}";
JsonAssert.Equal(expected, actual);
}
public void LineReturnsLineString(GeometryGeoJsonConverter sut, ILine line, ISpatialReference spatialReference)
{
var polyline = (IGeometry) new PolylineClass();
polyline.SpatialReference = spatialReference;
var path = (ISegmentCollection) new PathClass();
path.AddSegment((ISegment)line);
((IGeometryCollection)polyline).AddGeometry((IGeometry)path);
var actual = JsonConvert.SerializeObject(polyline, Formatting.Indented, sut);
var expected = $@"{{
""type"": ""LineString"",
""coordinates"": [
[
{line.FromPoint.X.ToJsonString()},
{line.FromPoint.Y.ToJsonString()}
],
[
{line.ToPoint.X.ToJsonString()},
{line.ToPoint.Y.ToJsonString()}
]
]
}}";
JsonAssert.Equal(expected, actual);
}
public void EmptyPointsAreRemoved(GeometryGeoJsonConverter sut, IMultipoint multiPoint, IPoint point1, IPoint point2, IPoint emptyPoint)
{
emptyPoint.SetEmpty();
multiPoint.SetEmpty();
((IPointCollection)multiPoint).AddPoint(emptyPoint);
((IPointCollection)multiPoint).AddPoint(point1);
((IPointCollection)multiPoint).AddPoint(emptyPoint);
((IPointCollection)multiPoint).AddPoint(point2);
((IPointCollection)multiPoint).AddPoint(emptyPoint);
var actual = JsonConvert.SerializeObject(multiPoint, sut);
var expected = $@"{{
""type"": ""MultiPoint"",
""coordinates"": [
[
{point1.X.ToJsonString()},
{point1.Y.ToJsonString()}
],
[
{point2.X.ToJsonString()},
{point2.Y.ToJsonString()}
]
]
}}";
JsonAssert.Equal(expected, actual);
}
public void LineString3DReturnsPolyline3D(Type type, GeoJsonSerializerSettings serializerSettings, double x1, double y1, double z1, double x2, double y2, double z2)
{
serializerSettings.Dimensions = DimensionHandling.XYZ;
var sut = new GeometryGeoJsonConverter(serializerSettings);
var geoJson = $@"{{
""type"": ""LineString"",
""coordinates"": [
[{x1.ToJsonString()}, {y1.ToJsonString()}, {z1.ToJsonString()}],
[{x2.ToJsonString()}, {y2.ToJsonString()}, {z2.ToJsonString()}]
]
}}";
var actual = (IPolyline)JsonConvert.DeserializeObject(geoJson, type, sut);
Assert.Equal(x1, actual.FromPoint.X);
Assert.Equal(y1, actual.FromPoint.Y);
Assert.Equal(z1, actual.FromPoint.Z);
Assert.Equal(x2, actual.ToPoint.X);
Assert.Equal(y2, actual.ToPoint.Y);
Assert.Equal(z2, actual.ToPoint.Z);
Assert.True(((IZAware)actual).ZAware);
}
public void OnlyCurvesAreGeneralized(GeometryGeoJsonConverter sut, IPolyline polyline, ILine line, ILine otherLine, IPoint extensionPoint, IBezierCurve bezier)
{
// Create {otherLine} that is an extension to {line}.
// This segment must not be simplified during the serialization.
line.QueryPoint(esriSegmentExtension.esriExtendAtTo, line.Length + line.Length / 2, false, extensionPoint);
otherLine.PutCoords(line.ToPoint, extensionPoint);
// Prepare the actual test value.
polyline.SetEmpty();
var segments1 = (ISegmentCollection) new PathClass();
segments1.AddSegment((ISegment)line);
segments1.AddSegment((ISegment)otherLine);
var segments2 = (ISegmentCollection) new PathClass();
segments2.AddSegment((ISegment)bezier);
((IGeometryCollection)polyline).AddGeometry((IGeometry)segments1);
((IGeometryCollection)polyline).AddGeometry((IGeometry)segments2);
var actual = JsonConvert.SerializeObject(polyline, Formatting.Indented, sut);
// It must contain the "mid" point between line.FromPoint and otherLine.ToPoint.
// If it is missing, the serialization merged the two segments even tho Simplify=false.
JsonAssert.Contains($@"
[
{otherLine.FromPoint.X.ToJsonString()},
{otherLine.FromPoint.Y.ToJsonString()}
]", actual);
}
public SimplifyTrue()
{
_sut = new GeometryGeoJsonConverter(new GeoJsonSerializerSettings
{
Simplify = true
});
}
public void EmptyReturnsNull(IPoint point, GeometryGeoJsonConverter sut)
{
point.SetEmpty();
var actual = JsonConvert.SerializeObject(point, sut);
Assert.Equal("null", actual);
}
public void NanYReturnsNull(IPoint point, GeometryGeoJsonConverter sut)
{
point.Y = double.NaN;
var actual = JsonConvert.SerializeObject(point, sut);
Assert.Equal("null", actual);
}
public void InvalidCoordinatesThrows(GeometryGeoJsonConverter sut)
{
var geoJson = @"{
""type"": ""Point"",
""coordinates"": ""wrong thing here""
}";
Assert.Throws <JsonReaderException>(() => JsonConvert.DeserializeObject <IPoint>(geoJson, sut));
}
public void EmptyReturnsNull(GeometryGeoJsonConverter sut)
{
var polyline = (IPolyline) new PolylineClass();
polyline.SetEmpty();
var actual = JsonConvert.SerializeObject(polyline, sut);
Assert.Equal("null", actual);
}
public void PathWithSinglePointReturnsNull(GeometryGeoJsonConverter sut, IPoint point)
{
var polylineWithoutToPoint = (IPolyline) new PolylineClass();
polylineWithoutToPoint.FromPoint = point;
var actual = JsonConvert.SerializeObject(polylineWithoutToPoint, Formatting.Indented, sut);
JsonAssert.Equal("null", actual);
}
public void InfinityCoordsReturnsNull(IPoint point)
{
var sut = new GeometryGeoJsonConverter();
point.Y = double.PositiveInfinity;
var actual = JsonConvert.SerializeObject(point, sut);
JsonAssert.Equal("null", actual);
}
public void BooleanCoordinatesValueReturns(string geoJson, GeometryGeoJsonConverter sut)
{
// Not sure what to do with boolean values.
// --
// The test is only there to document the current behavior.
// If it breaks in the futur, we'll think how to manage it, but
// it really is a dark and pretty limited edge case.
var point = JsonConvert.DeserializeObject <IPoint>(geoJson, sut);
Assert.Equal(1, point.X);
Assert.Equal(0, point.Y);
}
public void Throws(GeometryGeoJsonConverter sut)
{
var geoJson = @"{
""type"": ""LineString"",
""coordinates"": [
[100.0, 0.0],
[101.0, 1.0]
]
}";
Assert.Throws <JsonReaderException>(() => JsonConvert.DeserializeObject <IPoint>(geoJson, sut));
}
public void PointReturnsPoint(Type type, GeometryGeoJsonConverter sut, double x, double y)
{
var geoJson = $@"{{
""type"": ""Point"",
""coordinates"": [{x.ToJsonString()}, {y.ToJsonString()}]
}}";
var actual = (IPoint)JsonConvert.DeserializeObject(geoJson, type, sut);
Assert.Equal(x, actual.X);
Assert.Equal(y, actual.Y);
}
public void TouchingPathsReturnsMultiLineString(GeometryGeoJsonConverter sut, ILine line, IPoint point, ISpatialReference spatialReference)
{
var path1 = (ISegmentCollection) new PathClass();
path1.AddSegment((ISegment)line);
var otherLine = (ILine) new LineClass();
otherLine.FromPoint = line.ToPoint;
otherLine.ToPoint = point;
var path2 = (ISegmentCollection) new PathClass();
path2.AddSegment((ISegment)otherLine);
var polyline = (IGeometryCollection) new PolylineClass();
polyline.AddGeometry((IGeometry)path1);
polyline.AddGeometry((IGeometry)path2);
((IGeometry)polyline).SpatialReference = spatialReference;
var actual = JsonConvert.SerializeObject(polyline, Formatting.Indented, sut);
var expected = $@"{{
""type"": ""MultiLineString"",
""coordinates"": [
[
[
{line.FromPoint.X.ToJsonString()},
{line.FromPoint.Y.ToJsonString()}
],
[
{line.ToPoint.X.ToJsonString()},
{line.ToPoint.Y.ToJsonString()}
]
],
[
[
{otherLine.FromPoint.X.ToJsonString()},
{otherLine.FromPoint.Y.ToJsonString()}
],
[
{otherLine.ToPoint.X.ToJsonString()},
{otherLine.ToPoint.Y.ToJsonString()}
]
]
]
}}";
JsonAssert.Equal(expected, actual);
}
public void SinglePositionArrayReturnsIncompletePolyline(GeometryGeoJsonConverter sut, double x1, double y1)
{
var geoJson = $@"{{
""type"": ""LineString"",
""coordinates"": [
[{x1.ToJsonString()}, {y1.ToJsonString()}]
]
}}";
var actual = JsonConvert.DeserializeObject <IPolyline>(geoJson, sut);
Assert.False(actual.IsEmpty);
Assert.Equal(1, ((IPointCollection)actual).PointCount);
}
public void PointReturnsEmpty(GeoJsonSerializerSettings serializerSettings, double x, double y)
{
serializerSettings.Simplify = true;
var sut = new GeometryGeoJsonConverter(serializerSettings);
var geoJson = $@"{{
""type"": ""Point"",
""coordinates"": [{x.ToJsonString()}, {y.ToJsonString()}]
}}";
var actual = JsonConvert.DeserializeObject <IPolygon>(geoJson, sut);
Assert.True(actual.IsEmpty);
}
public void NullToPointReturnsNull(GeoJsonSerializerSettings serializerSettings, IPoint point)
{
serializerSettings.Simplify = true;
var sut = new GeometryGeoJsonConverter(serializerSettings);
var invalidPolyline = (IPolyline) new PolylineClass();
invalidPolyline.FromPoint = point;
var actual = JsonConvert.SerializeObject(invalidPolyline, Formatting.Indented, sut);
Assert.Equal("null", actual);
}
public void SinglePositionArrayReturnsEmpty(GeoJsonSerializerSettings serializerSettings, double x1, double y1)
{
serializerSettings.Simplify = true;
var sut = new GeometryGeoJsonConverter(serializerSettings);
var geoJson = $@"{{
""type"": ""LineString"",
""coordinates"": [
[{x1.ToJsonString()}, {y1.ToJsonString()}]
]
}}";
var actual = JsonConvert.DeserializeObject <IPolyline>(geoJson, sut);
Assert.True(actual.IsEmpty);
}
public void PointReturnsMultipoint(GeoJsonSerializerSettings serializerSettings, double x, double y)
{
serializerSettings.Simplify = true;
var sut = new GeometryGeoJsonConverter(serializerSettings);
var geoJson = $@"{{
""type"": ""Point"",
""coordinates"": [{x.ToJsonString()}, {y.ToJsonString()}]
}}";
var actual = (IPointCollection)JsonConvert.DeserializeObject <IMultipoint>(geoJson, sut);
Assert.Equal(1, actual.PointCount);
Assert.Equal(x, actual.Point[0].X);
Assert.Equal(y, actual.Point[0].Y);
}
public void SinglePointReturnsPoint(GeometryGeoJsonConverter sut, IMultipoint multiPoint, IPoint point)
{
multiPoint.SetEmpty();
((IPointCollection)multiPoint).AddPoint(point);
var actual = JsonConvert.SerializeObject(multiPoint, sut);
var expected = $@"{{
""type"": ""Point"",
""coordinates"": [
{point.X.ToJsonString()},
{point.Y.ToJsonString()}
]
}}";
JsonAssert.Equal(expected, actual);
}
public void OverlappedSegmentIsRemoved(GeoJsonSerializerSettings serializerSettings, ILine line,
IPoint midPoint, IPoint extensionPoint, ISpatialReference spatialReference)
{
serializerSettings.Simplify = true;
var sut = new GeometryGeoJsonConverter(serializerSettings);
// Find the midpoint to create the FromPoint of the overlapped segment.
line.QueryPoint(esriSegmentExtension.esriNoExtension, 0.5, true, midPoint);
// Extend pass the endpoint to create to ToPoint of the overlapped segment.
line.QueryPoint(esriSegmentExtension.esriExtendAtTo, line.Length + line.Length / 2, false,
extensionPoint);
var overlappedLine = (ILine) new LineClass();
overlappedLine.FromPoint = midPoint;
overlappedLine.ToPoint = extensionPoint;
var path = (ISegmentCollection) new PathClass();
path.AddSegment((ISegment)line);
path.AddSegment((ISegment)overlappedLine);
var polyline = (IGeometryCollection) new PolylineClass();
polyline.AddGeometry((IGeometry)path);
((IGeometry)polyline).SpatialReference = spatialReference;
var actual = JsonConvert.SerializeObject(polyline, Formatting.Indented, sut);
var expected = $@"{{
""type"": ""LineString"",
""coordinates"": [
[
{line.FromPoint.X.ToJsonString()},
{line.FromPoint.Y.ToJsonString()}
],
[
{extensionPoint.X.ToJsonString()},
{extensionPoint.Y.ToJsonString()}
]
]
}}";
JsonAssert.Equal(expected, actual);
}
public void Point2DReturnsJson(IPoint point)
{
((IZAware)point).ZAware = false;
var sut = new GeometryGeoJsonConverter();
var actual = JsonConvert.SerializeObject(point, Formatting.Indented, sut);
var expected = $@"{{
""type"": ""Point"",
""coordinates"": [
{point.X.ToJsonString()},
{point.Y.ToJsonString()}
]
}}";
JsonAssert.Equal(expected, actual);
}
public void OneCompletePathWithManyIncompletePathsReturnLinestring(GeometryGeoJsonConverter sut, IPolyline polyline, ILine line, IPoint fromPoint)
{
var emptyPath = (IPath) new PathClass();
var incompleteLine = (ILine) new LineClass();
incompleteLine.FromPoint = fromPoint;
var incompletePath = (IPath) new PathClass();
((ISegmentCollection)incompletePath).AddSegment((ISegment)incompleteLine);
// Add some incomplete lines.
polyline.SetEmpty();
var pathCol = (IGeometryCollection)polyline;
pathCol.AddGeometry(emptyPath);
pathCol.AddGeometry(incompletePath);
// Add a complete line.
var completePath = (IPath) new PathClass();
((ISegmentCollection)completePath).AddSegment((ISegment)line);
pathCol.AddGeometry(completePath);
// Add some more incomplete lines.
pathCol.AddGeometry((IGeometry)((IClone)emptyPath).Clone());
pathCol.AddGeometry((IGeometry)((IClone)incompletePath).Clone());
var actual = JsonConvert.SerializeObject(polyline, Formatting.Indented, sut);
var expected = $@"{{
""type"": ""LineString"",
""coordinates"": [
[
{line.FromPoint.X.ToJsonString()},
{line.FromPoint.Y.ToJsonString()}
],
[
{line.ToPoint.X.ToJsonString()},
{line.ToPoint.Y.ToJsonString()}
]
]
}}
";
JsonAssert.Equal(expected, actual);
}
public void LineStringReturnsPolyline(Type type, GeometryGeoJsonConverter sut, double x1, double y1, double x2, double y2)
{
var geoJson = $@"{{
""type"": ""LineString"",
""coordinates"": [
[{x1.ToJsonString()}, {y1.ToJsonString()}],
[{x2.ToJsonString()}, {y2.ToJsonString()}]
]
}}";
var actual = (IPolyline)JsonConvert.DeserializeObject(geoJson, type, sut);
Assert.Equal(x1, actual.FromPoint.X);
Assert.Equal(y1, actual.FromPoint.Y);
Assert.Equal(x2, actual.ToPoint.X);
Assert.Equal(y2, actual.ToPoint.Y);
}
public void ManyPathWithSinglePointsReturnsMultiPoint(GeometryGeoJsonConverter sut, IPolyline polyline, IPoint[] points)
{
polyline.SetEmpty();
var collection = (IGeometryCollection)polyline;
foreach (var point in points)
{
var path = (IPointCollection) new PathClass();
path.AddPoint(point);
collection.AddGeometry((IGeometry)path);
}
var actual = JsonConvert.SerializeObject(polyline, Formatting.Indented, sut);
var expected = "null";
JsonAssert.Equal(expected, actual);
}
public void Point3DReturnsMultipoint3D(Type type, GeoJsonSerializerSettings serializerSettings, double x, double y, double z)
{
serializerSettings.Dimensions = DimensionHandling.XYZ;
var sut = new GeometryGeoJsonConverter(serializerSettings);
var geoJson = $@"{{
""type"": ""Point"",
""coordinates"": [{x.ToJsonString()}, {y.ToJsonString()}, {z.ToJsonString()}]
}}";
var actual = (IPointCollection)JsonConvert.DeserializeObject(geoJson, type, sut);
Assert.Equal(1, actual.PointCount);
Assert.Equal(x, actual.Point[0].X);
Assert.Equal(y, actual.Point[0].Y);
Assert.Equal(z, actual.Point[0].Z);
Assert.True(((IZAware)actual).ZAware);
}
public void PointReturnsDefaultZValue(Type type, double x, double y, double defaultZValue)
{
var sut = new GeometryGeoJsonConverter(new GeoJsonSerializerSettings
{
DefaultZValue = defaultZValue,
Dimensions = DimensionHandling.XYZ
});
var geoJson = $@"{{
""type"": ""Point"",
""coordinates"": [{x.ToJsonString()}, {y.ToJsonString()}]
}}";
var actual = (IPoint)JsonConvert.DeserializeObject(geoJson, type, sut);
Assert.Equal(x, actual.X);
Assert.Equal(y, actual.Y);
Assert.Equal(defaultZValue, actual.Z);
Assert.True(((IZAware)actual).ZAware);
}
