public void ChangeViewSpatialFilterTriggersNotification()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
FeatureDataView view = new FeatureDataView(table);
Boolean resetNotificationOccured = false;
view.ListChanged += delegate(Object sender, ListChangedEventArgs e)
{
if (e.ListChangedType == ListChangedType.Reset)
{
resetNotificationOccured = true;
}
};
Assert.False(resetNotificationOccured);
IExtents queryExtents = _factories.GeoFactory.CreateExtents2D(0, 0, 10, 10);
SpatialBinaryExpression expression = SpatialBinaryExpression.Intersects(queryExtents);
view.SpatialFilter = expression;
Assert.True(resetNotificationOccured);
}
public void MovingRowTriggersViewListChangedItemMovedNotification()
{
// TODO: implement MovingRowTriggersViewListChangedItemMovedNotification
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
IExtents halfBounds = data.GetExtents();
halfBounds.Scale(0.5);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
FeatureDataView view = new FeatureDataView(table);
Boolean addNotificationOccured = false;
view.ListChanged += delegate(Object sender, ListChangedEventArgs e)
{
if (e.ListChangedType == ListChangedType.ItemMoved)
{
addNotificationOccured = true;
}
};
Assert.True(addNotificationOccured);
}
public void ChangeViewAttributeFilterTriggersNotification()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
FeatureDataView view = new FeatureDataView(table);
Boolean resetNotificationOccured = false;
view.ListChanged += delegate(Object sender, ListChangedEventArgs e)
{
if (e.ListChangedType == ListChangedType.Reset)
{
resetNotificationOccured = true;
}
};
Assert.False(resetNotificationOccured);
Assert.Throws <NotSupportedException>(delegate { view.RowFilter = "FeatureName LIKE 'A m*'"; });
Assert.True(resetNotificationOccured);
}
public void ChangeViewSpatialFilterReturnsOnlyFilteredRows()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader);
IGeometry queryExtents = _factories.GeoFactory.CreateExtents2D(0, 0, 10, 10).ToGeometry();
List <FeatureDataRow> expectedRows = new List <FeatureDataRow>();
foreach (FeatureDataRow row in table)
{
IGeometry g = row.Geometry;
if (queryExtents.Intersects(g))
{
expectedRows.Add(row);
}
}
FeatureDataView view = new FeatureDataView(table);
SpatialBinaryExpression expression = SpatialBinaryExpression.Intersects(queryExtents);
view.SpatialFilter = expression;
Assert.Equal(expectedRows.Count, view.Count);
}
public void SettingOidFilterAllowsOnlyFeaturesContainingFilteredOidsInView()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable <Guid> table = new FeatureDataTable <Guid>("Oid", _factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
Guid[] ids = new Guid[3];
ids[0] = (table.Rows[1] as FeatureDataRow <Guid>).Id;
ids[1] = (table.Rows[4] as FeatureDataRow <Guid>).Id;
ids[2] = (table.Rows[6] as FeatureDataRow <Guid>).Id;
FeatureDataView view = new FeatureDataView(table);
view.OidFilter = new OidCollectionExpression(ids);
Assert.Equal(3, view.Count);
Assert.True(view.Find(ids[0]) > -1);
Assert.True(view.Find(ids[1]) > -1);
Assert.True(view.Find(ids[2]) > -1);
Assert.Equal(-1, view.Find((table.Rows[0] as FeatureDataRow <Guid>).Id));
Assert.Equal(-1, view.Find((table.Rows[2] as FeatureDataRow <Guid>).Id));
Assert.Equal(-1, view.Find((table.Rows[3] as FeatureDataRow <Guid>).Id));
Assert.Equal(-1, view.Find((table.Rows[5] as FeatureDataRow <Guid>).Id));
}
public void AddingRowToTableTriggersViewListChangedItemAddedNotification()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
IExtents halfBounds = data.GetExtents();
halfBounds.Scale(0.5);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(halfBounds);
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
FeatureDataView view = new FeatureDataView(table);
Boolean addNotificationOccured = false;
view.ListChanged += delegate(Object sender, ListChangedEventArgs e)
{
if (e.ListChangedType == ListChangedType.ItemAdded)
{
addNotificationOccured = true;
}
};
FeatureDataRow row = table.NewRow();
row["Oid"] = Guid.NewGuid();
row["FeatureName"] = "New row";
row.Geometry = _factories.GeoFactory.CreatePoint2D(44, 44);
table.AddRow(row);
Assert.True(addNotificationOccured);
}
public void LoadingTableFromReader()
{
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureProvider provider = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(provider.GetExtents());
table.Load(provider.ExecuteFeatureQuery(query));
}
public void MergeSchemaToIdenticalTableShouldRemainIdentical()
{
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureProvider provider = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(provider.GetExtents());
IFeatureDataReader reader = provider.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
FeatureDataTable target = new FeatureDataTable(_factories.GeoFactory);
reader = provider.ExecuteFeatureQuery(query);
target.Load(reader, LoadOption.OverwriteChanges, null);
table.MergeSchemaTo(target);
DataTableHelper.AssertTableStructureIdentical(table, target);
}
public void DefaultViewReturnsAllRows()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader);
Assert.Equal(table.Rows.Count, table.DefaultView.Count);
}
public void NullSpatialFilterReturnsAllRows()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
table.Load(data.ExecuteFeatureQuery(query));
FeatureDataView view = new FeatureDataView(table);
Assert.Equal(table.Rows.Count, view.Count);
}
public void AddNewRowThrowsNotSupported()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
FeatureDataView view = new FeatureDataView(table);
Assert.Throws <NotSupportedException>(delegate { view.AddNew(); });
}
public void CreatingDataViewReturnsValidDataView()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
FeatureDataView view = new FeatureDataView(table);
Assert.IsType(typeof(FeatureDataTable), view.Table);
Assert.Same(table, view.Table);
}
public void SpatialQueryTypeIsWhatIsSpecifiedAtCreateTime()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
IGeometry filter = _factories.GeoFactory.CreateExtents2D(0, 0, 10, 10).ToGeometry();
FeatureDataView view = new FeatureDataView(table, filter, "", DataViewRowState.CurrentRows);
Assert.Equal(SpatialOperation.Intersects, view.SpatialFilter.Op);
}
public void ExecutingQueryOnTableTriggersViewListChangedResetNotification()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
IExtents dataExtents = data.GetExtents();
IExtents halfBounds = _factories.GeoFactory.CreateExtents(
dataExtents.Min, dataExtents.Max);
halfBounds.Scale(0.5);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(halfBounds);
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
FeatureDataView view = new FeatureDataView(table);
Boolean addNotificationOccured = false;
view.ListChanged += delegate(Object sender, ListChangedEventArgs e)
{
if (e.ListChangedType == ListChangedType.Reset)
{
addNotificationOccured = true;
}
};
IExtents otherHalfBounds = _factories.GeoFactory.CreateExtents(
dataExtents.Min, dataExtents.Max);
otherHalfBounds.TranslateRelativeToWidth(0.5, 0.5);
otherHalfBounds.Scale(0.5);
query = FeatureQueryExpression.Intersects(otherHalfBounds);
reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
Assert.True(addNotificationOccured);
}
public void CreatingDataViewWithEqualsSpatialExpressionSucceeds()
{
// This test is here so that when it is supported, the test breaks and is rewritten
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
Point <BufferedCoordinate> empty = _factories.GeoFactory.CreatePoint() as Point <BufferedCoordinate>;
new FeatureDataView(table, empty, SpatialOperation.Equals, "", DataViewRowState.CurrentRows);
}
private void createDataViewOnNewTable(out FeatureDataView view,
out FeatureDataTable <Guid> table,
Boolean includeGeometryCollections)
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory,
includeGeometryCollections);
table = new FeatureDataTable <Guid>("Oid", _factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
view = new FeatureDataView(table);
}
public void MergeSchemaToKeyedTableWithDifferentKeyNameButSameTypeShouldKeepKeyButAddOtherColumns()
{
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureProvider provider = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(provider.GetExtents());
IFeatureDataReader reader = provider.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
FeatureDataTable <Guid> target = new FeatureDataTable <Guid>("GID", _factories.GeoFactory);
table.MergeSchemaTo(target);
DataTableHelper.AssertTableStructureIdentical(table, target);
}
//[ExpectedException(typeof (NotImplementedException))]
public void DataViewManagerIsAFeatureDataViewManager()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
FeatureDataSet dataSet = new FeatureDataSet(_factories.GeoFactory);
dataSet.Tables.Add(table);
FeatureDataView view = dataSet.DefaultViewManager.CreateDataView(table);
Assert.NotNull(view.DataViewManager);
Assert.IsType(typeof(FeatureDataViewManager), view.DataViewManager);
}
public void CloneToCopiesTableStructureAndNoData()
{
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureProvider provider = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(provider.GetExtents());
IFeatureDataReader reader = provider.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
FeatureDataTable clone = new FeatureDataTable(_factories.GeoFactory);
table.CloneTo(clone);
DataTableHelper.AssertTableStructureIdentical(table, clone);
Assert.Equal(0, clone.Rows.Count);
}
public void SettingGeometryFilterToIdenticalGeometryDoesntChangeFilterObject()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
IGeometry filter = _factories.GeoFactory.CreateExtents2D(0, 0, 10, 10).ToGeometry();
FeatureDataView view = new FeatureDataView(table, filter, "", DataViewRowState.CurrentRows);
IGeometry filterCopy = filter.Clone();
Assert.NotSame(filter, filterCopy);
Assert.Equal(filter, filterCopy);
SpatialBinaryExpression expression = SpatialBinaryExpression.Intersects(filterCopy);
view.SpatialFilter = expression;
Assert.NotSame(expression, view.SpatialFilter);
}
public void RenderingPointsGeometriesWithGdiVectorRendererProducesCorrectGdiBitmaps()
{
using (GdiVectorRenderer vectorRenderer = new GdiVectorRenderer())
{
BasicGeometryRenderer2D <GdiRenderObject> geometryRenderer
= new BasicGeometryRenderer2D <GdiRenderObject>(vectorRenderer);
FeatureProvider provider = DataSourceHelper.CreateFeatureDatasource(_geoFactory);
FeatureQueryExpression query
= FeatureQueryExpression.Intersects(provider.GetExtents());
foreach (IFeatureDataRecord record in provider.ExecuteFeatureQuery(query))
{
IEnumerable <GdiRenderObject> renderedObjects = geometryRenderer.RenderFeature(record);
Int32 geoIndex = 0;
foreach (GdiRenderObject ro in renderedObjects)
{
IGeometry g = record.Geometry;
if (g is IMultiPoint)
{
IMultiPoint mp = g as IMultiPoint;
Assert.AreEqual(mp[geoIndex][Ordinates.X], ro.Bounds.Location.X, _e);
Assert.AreEqual(mp[geoIndex][Ordinates.Y], ro.Bounds.Location.Y, _e);
geoIndex++;
}
else if (g is IPoint)
{
IPoint p = g as IPoint;
Assert.AreEqual(p[Ordinates.X], ro.Bounds.Location.X, _e);
Assert.AreEqual(p[Ordinates.Y], ro.Bounds.Location.Y, _e);
}
}
}
}
}
public void ChangeViewAttributeFilterReturnsOnlyFilteredRows()
{
FeatureProvider data = DataSourceHelper.CreateFeatureDatasource(_factories.GeoFactory);
FeatureDataTable table = new FeatureDataTable(_factories.GeoFactory);
FeatureQueryExpression query = FeatureQueryExpression.Intersects(data.GetExtents());
IFeatureDataReader reader = data.ExecuteFeatureQuery(query);
table.Load(reader, LoadOption.OverwriteChanges, null);
FeatureDataView view = new FeatureDataView(table);
Int32 expectedRowCount = 0;
foreach (FeatureDataRow row in table.Rows)
{
if (row["FeatureName"].ToString().StartsWith("A m"))
{
expectedRowCount++;
}
}
Assert.Throws <NotSupportedException>(delegate { view.RowFilter = "FeatureName LIKE 'A m*'"; });
Assert.Equal(expectedRowCount, view.Count);
}
public void RenderingPolygonsWithGdiVectorRendererProducesCorrectGdiPaths()
{
using (GdiVectorRenderer vectorRenderer = new GdiVectorRenderer())
{
BasicGeometryRenderer2D <GdiRenderObject> geometryRenderer
= new BasicGeometryRenderer2D <GdiRenderObject>(vectorRenderer);
FeatureProvider provider = DataSourceHelper.CreateFeatureDatasource(_geoFactory);
FeatureQueryExpression query
= FeatureQueryExpression.Intersects(provider.GetExtents());
foreach (IFeatureDataRecord record in provider.ExecuteFeatureQuery(query))
{
IEnumerable <GdiRenderObject> renderedObjects
= geometryRenderer.RenderFeature(record);
foreach (GdiRenderObject ro in renderedObjects)
{
IGeometry g = record.Geometry;
if (g is IPolygon)
{
IPolygon p = g as IPolygon;
using (GraphicsPathIterator iter = new GraphicsPathIterator(ro.GdiPath))
{
Int32 start, end;
Boolean isClosed;
iter.NextSubpath(out start, out end, out isClosed);
Assert.IsTrue(isClosed);
Assert.AreEqual(p.ExteriorRing.Coordinates.Count, end - start + 1);
for (Int32 vertexIndex = 0;
vertexIndex < p.ExteriorRing.Coordinates.Count;
vertexIndex++)
{
ICoordinate v = (ICoordinate)p.ExteriorRing.Coordinates[vertexIndex];
PointF gdiPoint = ro.GdiPath.PathPoints[vertexIndex + start];
Assert.AreEqual(v[Ordinates.X], gdiPoint.X);
Assert.AreEqual(v[Ordinates.Y], gdiPoint.Y);
}
foreach (ILineString interiorRing in p.InteriorRings)
{
iter.NextSubpath(out start, out end, out isClosed);
Assert.IsTrue(isClosed);
Assert.AreEqual(interiorRing.PointCount, end - start + 1);
for (Int32 vertexIndex = 0;
vertexIndex < interiorRing.PointCount;
vertexIndex++)
{
ICoordinate v = interiorRing.Coordinates[vertexIndex];
PointF gdiPoint = ro.GdiPath.PathPoints[vertexIndex + start];
Assert.AreEqual(v[Ordinates.X], gdiPoint.X);
Assert.AreEqual(v[Ordinates.Y], gdiPoint.Y);
}
}
}
}
else if (g is IMultiPolygon)
{
IMultiPolygon mp = g as IMultiPolygon;
using (GraphicsPathIterator iter = new GraphicsPathIterator(ro.GdiPath))
{
foreach (IPolygon p in (IEnumerable <IPolygon>)mp)
{
Int32 start, end;
Boolean isClosed;
iter.NextSubpath(out start, out end, out isClosed);
Assert.IsTrue(isClosed);
Int32 exteriorPointCount = p.ExteriorRing.PointCount;
Assert.AreEqual(exteriorPointCount, end - start + 1);
for (Int32 vertexIndex = 0;
vertexIndex < exteriorPointCount;
vertexIndex++)
{
ICoordinate v = p.ExteriorRing.Coordinates[vertexIndex];
PointF gdiPoint = ro.GdiPath.PathPoints[vertexIndex + start];
Assert.AreEqual(v[Ordinates.X], gdiPoint.X);
Assert.AreEqual(v[Ordinates.Y], gdiPoint.Y);
}
foreach (ILineString interiorRing in p.InteriorRings)
{
iter.NextSubpath(out start, out end, out isClosed);
Assert.IsTrue(isClosed);
Assert.AreEqual(interiorRing.PointCount, end - start + 1);
for (Int32 vertexIndex = 0;
vertexIndex < interiorRing.PointCount;
vertexIndex++)
{
ICoordinate v = interiorRing.Coordinates[vertexIndex];
PointF gdiPoint = ro.GdiPath.PathPoints[vertexIndex + start];
Assert.AreEqual(v[Ordinates.X], gdiPoint.X);
Assert.AreEqual(v[Ordinates.Y], gdiPoint.Y);
}
}
}
}
}
}
}
}
}
public void RenderingLinesWithGdiVectorRendererProducesCorrectGdiPaths()
{
using (GdiVectorRenderer vectorRenderer = new GdiVectorRenderer())
{
BasicGeometryRenderer2D <GdiRenderObject> geometryRenderer
= new BasicGeometryRenderer2D <GdiRenderObject>(vectorRenderer);
FeatureProvider provider = DataSourceHelper.CreateFeatureDatasource(_geoFactory);
FeatureQueryExpression query
= FeatureQueryExpression.Intersects(provider.GetExtents());
foreach (IFeatureDataRecord record in provider.ExecuteFeatureQuery(query))
{
IEnumerable <GdiRenderObject> renderedObjects = geometryRenderer.RenderFeature(record);
Int32 geoIndex = 0;
IGeometry g = record.Geometry;
foreach (GdiRenderObject ro in renderedObjects)
{
using (GraphicsPathIterator iter = new GraphicsPathIterator(ro.GdiPath))
{
Int32 start, end;
Boolean isClosed;
iter.NextSubpath(out start, out end, out isClosed);
if (g is ILineString)
{
Assert.IsFalse(isClosed);
ILineString ls = g as ILineString;
Assert.AreEqual(1, iter.SubpathCount);
for (Int32 vertexIndex = 0; vertexIndex < ls.Coordinates.Count; vertexIndex++)
{
ICoordinate v = (ICoordinate)ls.Coordinates[vertexIndex];
PointF gdiPoint = ro.GdiPath.PathPoints[vertexIndex + start];
Assert.AreEqual(v[Ordinates.X], gdiPoint.X);
Assert.AreEqual(v[Ordinates.Y], gdiPoint.Y);
}
}
else if (g is IMultiLineString)
{
Assert.IsFalse(isClosed);
IMultiLineString mls = g as IMultiLineString;
Assert.AreEqual(mls.Count, iter.SubpathCount);
foreach (ILineString lineString in (IEnumerable <ILineString>)mls)
{
for (Int32 vertexIndex = 0; vertexIndex < lineString.Coordinates.Count; vertexIndex++)
{
ICoordinate v = (ICoordinate)lineString.Coordinates[vertexIndex];
PointF gdiPoint = ro.GdiPath.PathPoints[vertexIndex + start];
Assert.AreEqual(v[Ordinates.X], gdiPoint.X);
Assert.AreEqual(v[Ordinates.Y], gdiPoint.Y);
}
iter.NextSubpath(out start, out end, out isClosed);
}
}
}
}
}
}
}
