Esempi in C# (CSharp) per com.GetType

Linguaggio di programmazione: C# (CSharp)

Classe/tipologia: com

Metodo/funzione: GetType

Esempi su hotexamples.com: 2

com.GetType in C# (CSharp): 2 esempi trovati. Questi sono i migliori esempi reali in C# (CSharp) per com.GetType, estratti da progetti open source. Li puoi valutare, per aiutarci a migliorare la qualità dei nostri esempi.

Metodi utilizzati di frequente

Mostra Nascondi

GetChar(30)

GetString(30)

GetLong(28)

GetBoolean(27)

GetNullableString(14)

GetInt(14)

getValue(10)

GetDecimal(10)

GetNullableLong(10)

writeRaw(9)

getMask(8)

getAngle(8)

setAngle(8)

getY(7)

getX(7)

getId(7)

getScaleX(6)

hasParent(6)

getResult(6)

copyValuesTo(6)

getTimeline(6)

setY(6)

setX(6)

getScaleY(5)

setScaleY(5)

asQuotedUTF8(5)

SendBillingRequest(5)

setScaleX(5)

hasMoreBytes(4)

getData(4)

nextByte(4)

getParentId(4)

GetNullableInt(4)

GetNullableDate(4)

allocConcatBuffer(3)

getParent(3)

getAnimation(3)

asUnquotedUTF8(3)

asQuotedChars(3)

getMaxLineLength(3)

appendQuotedUTF8(3)

encodeBase64Partial(3)

GetNullableTime(3)

encodeBase64Chunk(3)

setParent(3)

getSchemaType(2)

hashSeed(2)

getPaddingChar(2)

getAlpha(2)

getObjectsToDraw(2)

Esempio n. 1

Mostra file

File: TestRelation.cs Progetto: davidraleigh/geometry-api-cs-tests

//		[NUnit.Framework.Test]
//		public virtual void TestPolylinePolylineCrosses()
//		{
//			com.esri.core.geometry.OperatorCrosses crosses = (com.esri.core.geometry.OperatorCrosses)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Crosses));
//			com.esri.core.geometry.SpatialReference sr = com.esri.core.geometry.SpatialReference.Create(102100);
//			double tolerance = sr.GetTolerance(com.esri.core.geometry.VertexDescription.Semantics.POSITION);
//			// Polyline1 and Polyline2 touch at a point
//			string str1 = "{\"paths\":[[[0,0],[0,5],[0,10],[10,10],[10,0]],[[1,1],[9,1],[9,9],[1,9],[1,1],[1,1]]]}";
//			string str2 = "{\"paths\":[[[10,10],[10,15],[15,15],[15,10]]]}";
//			com.esri.core.geometry.Polyline polyline1 = (com.esri.core.geometry.Polyline)(com.esri.core.geometry.TestCommonMethods.FromJson(str1).GetGeometry());
//			com.esri.core.geometry.Polyline polyline2 = (com.esri.core.geometry.Polyline)(com.esri.core.geometry.TestCommonMethods.FromJson(str2).GetGeometry());
//			bool res = crosses.Execute(polyline1, polyline2, sr, null);
//			NUnit.Framework.Assert.IsTrue(!res);
//			res = crosses.Execute(polyline2, polyline1, sr, null);
//			NUnit.Framework.Assert.IsTrue(!res);
//			// Polyline1 and Polyline2 intersect at interiors
//			str1 = "{\"paths\":[[[0,0],[0,5],[0,10],[10,10],[10,0],[0,0]],[[1,1],[9,1],[9,9],[1,9],[1,1],[1,1]]]}";
//			str2 = "{\"paths\":[[[15,5],[5,15],[15,15],[15,5]]]}";
//			polyline1 = (com.esri.core.geometry.Polyline)(com.esri.core.geometry.TestCommonMethods.FromJson(str1).GetGeometry());
//			polyline2 = (com.esri.core.geometry.Polyline)(com.esri.core.geometry.TestCommonMethods.FromJson(str2).GetGeometry());
//			res = crosses.Execute(polyline1, polyline2, sr, null);
//			NUnit.Framework.Assert.IsTrue(res);
//			res = crosses.Execute(polyline2, polyline1, sr, null);
//			NUnit.Framework.Assert.IsTrue(res);
//			// Polyline1 and Polyline2 touch at an endpoint of Polyline1 and
//			// interior of Polyline2 (but Polyline1 is closed)
//			str1 = "{\"paths\":[[[10,10],[10,0],[0,0],[0,10],[10,10]],[[1,1],[9,1],[9,9],[1,9],[1,1],[1,1]]]}";
//			str2 = "{\"paths\":[[[15,5],[5,15],[15,15]]]}";
//			polyline1 = (com.esri.core.geometry.Polyline)(com.esri.core.geometry.TestCommonMethods.FromJson(str1).GetGeometry());
//			polyline2 = (com.esri.core.geometry.Polyline)(com.esri.core.geometry.TestCommonMethods.FromJson(str2).GetGeometry());
//			res = crosses.Execute(polyline1, polyline2, sr, null);
//			NUnit.Framework.Assert.IsTrue(res);
//			res = crosses.Execute(polyline2, polyline1, sr, null);
//			NUnit.Framework.Assert.IsTrue(res);
//			// Polyline1 and Polyline2 touch at an endpoint of Polyline1 and
//			// interior of Polyline2 (same as previous case, but Polyline1 is not
//			// closed)
//			str1 = "{\"paths\":[[[10,10],[10,0],[0,0],[0,10]],[[1,1],[9,1],[9,9],[1,9],[1,1],[1,1]]]}";
//			str2 = "{\"paths\":[[[15,5],[5,15],[15,15]]]}";
//			polyline1 = (com.esri.core.geometry.Polyline)(com.esri.core.geometry.TestCommonMethods.FromJson(str1).GetGeometry());
//			polyline2 = (com.esri.core.geometry.Polyline)(com.esri.core.geometry.TestCommonMethods.FromJson(str2).GetGeometry());
//			res = crosses.Execute(polyline1, polyline2, sr, null);
//			NUnit.Framework.Assert.IsTrue(!res);
//			res = crosses.Execute(polyline2, polyline1, sr, null);
//			NUnit.Framework.Assert.IsTrue(!res);
//			str1 = "{\"paths\":[[[10,11],[10,0],[0,0],[0,10]],[[1,1],[9,1],[9,9],[1,9],[6, 9]]]}";
//			str2 = "{\"paths\":[[[15,5],[5,15],[15,15],[15,5]]]}";
//			polyline1 = (com.esri.core.geometry.Polyline)(com.esri.core.geometry.TestCommonMethods.FromJson(str1).GetGeometry());
//			polyline2 = (com.esri.core.geometry.Polyline)(com.esri.core.geometry.TestCommonMethods.FromJson(str2).GetGeometry());
//			res = crosses.Execute(polyline1, polyline2, sr, null);
//			NUnit.Framework.Assert.IsTrue(res);
//			res = crosses.Execute(polyline2, polyline1, sr, null);
//			NUnit.Framework.Assert.IsTrue(res);
//			polyline1.SetEmpty();
//			polyline2.SetEmpty();
//			polyline1.StartPath(-2, -2);
//			polyline1.LineTo(-1, -1);
//			polyline1.LineTo(1, 1);
//			polyline1.LineTo(2, 2);
//			polyline2.StartPath(-2, 2);
//			polyline2.LineTo(-1, 1);
//			polyline2.LineTo(1, -1);
//			polyline2.LineTo(2, -2);
//			res = crosses.Execute(polyline2, polyline1, sr, null);
//			NUnit.Framework.Assert.IsTrue(res);
//		}
//
//		[NUnit.Framework.Test]
//		public virtual void TestPolygonEnvelope()
//		{
//			com.esri.core.geometry.OperatorEquals equals = (com.esri.core.geometry.OperatorEquals)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Equals));
//			com.esri.core.geometry.OperatorContains contains = (com.esri.core.geometry.OperatorContains)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Contains));
//			com.esri.core.geometry.OperatorDisjoint disjoint = (com.esri.core.geometry.OperatorDisjoint)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Disjoint));
//			com.esri.core.geometry.OperatorCrosses crosses = (com.esri.core.geometry.OperatorCrosses)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Crosses));
//			com.esri.core.geometry.OperatorWithin within = (com.esri.core.geometry.OperatorWithin)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Within));
//			com.esri.core.geometry.OperatorOverlaps overlaps = (com.esri.core.geometry.OperatorOverlaps)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Overlaps));
//			com.esri.core.geometry.OperatorTouches touches = (com.esri.core.geometry.OperatorTouches)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Touches));
//			com.esri.core.geometry.OperatorDensifyByLength densify = (com.esri.core.geometry.OperatorDensifyByLength)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.DensifyByLength));
//			com.esri.core.geometry.SpatialReference sr = com.esri.core.geometry.SpatialReference.Create(4326);
//			{
//				com.esri.core.geometry.Polygon polygon = (com.esri.core.geometry.Polygon)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"rings\":[[[0,0],[0,5],[0,10],[10,10],[10,0],[0,0]]]}").GetGeometry());
//				com.esri.core.geometry.Polygon densified = (com.esri.core.geometry.Polygon)(densify.Execute(polygon, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(equals.Execute(envelope, densified, sr, null));
//				// they
//				// cover
//				// the
//				// same
//				// space
//				NUnit.Framework.Assert.IsTrue(contains.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polygon polygon = (com.esri.core.geometry.Polygon)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"rings\":[[[0,0],[0,5],[0,10],[10,10],[10,0],[0,0]]]}").GetGeometry());
//				com.esri.core.geometry.Polygon densified = (com.esri.core.geometry.Polygon)(densify.Execute(polygon, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":5,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				// the
//				// polygon
//				// contains
//				// the
//				// envelope,
//				// but
//				// they
//				// aren't
//				// equal
//				NUnit.Framework.Assert.IsTrue(contains.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polygon polygon = (com.esri.core.geometry.Polygon)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"rings\":[[[0,0],[0,5],[0,10],[10,10],[10,0],[0,0]]]}").GetGeometry());
//				com.esri.core.geometry.Polygon densified = (com.esri.core.geometry.Polygon)(densify.Execute(polygon, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":15,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				// the
//				// envelope
//				// sticks
//				// outside
//				// of
//				// the
//				// polygon
//				// but
//				// they
//				// intersect
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polygon polygon = (com.esri.core.geometry.Polygon)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"rings\":[[[0,0],[0,5],[0,10],[10,10],[10,0],[0,0]]]}").GetGeometry());
//				com.esri.core.geometry.Polygon densified = (com.esri.core.geometry.Polygon)(densify.Execute(polygon, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":5,\"ymin\":0,\"xmax\":15,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				// the
//				// envelope
//				// sticks
//				// outside
//				// of
//				// the
//				// polygon
//				// but
//				// they
//				// intersect
//				// and
//				// overlap
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polygon polygon = (com.esri.core.geometry.Polygon)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"rings\":[[[0,0],[0,5],[0,10],[10,10],[10,0],[0,0]]]}").GetGeometry());
//				com.esri.core.geometry.Polygon densified = (com.esri.core.geometry.Polygon)(densify.Execute(polygon, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":10,\"ymin\":0,\"xmax\":15,\"ymax\":5}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				// the
//				// envelope
//				// rides
//				// the
//				// side
//				// of
//				// the
//				// polygon
//				// (they
//				// touch)
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polygon polygon = (com.esri.core.geometry.Polygon)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"rings\":[[[0,0],[0,5],[0,10],[10,10],[10,0],[0,0]]]}").GetGeometry());
//				com.esri.core.geometry.Polygon densified = (com.esri.core.geometry.Polygon)(densify.Execute(polygon, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(contains.Execute(densified, envelope, sr, null));
//				// polygon
//				// and
//				// envelope
//				// cover
//				// the
//				// same
//				// space
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polygon polygon = (com.esri.core.geometry.Polygon)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"rings\":[[[0,0],[0,5],[0,10],[10,0],[0,0]]]}").GetGeometry());
//				com.esri.core.geometry.Polygon densified = (com.esri.core.geometry.Polygon)(densify.Execute(polygon, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(densified, envelope, sr, null));
//				// envelope
//				// sticks
//				// outside
//				// of
//				// polygon,
//				// but
//				// the
//				// envelopes
//				// are
//				// equal
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polygon polygon = (com.esri.core.geometry.Polygon)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"rings\":[[[0,0],[0,5],[0,10],[10,0],[0,0]]]}").GetGeometry());
//				com.esri.core.geometry.Polygon densified = (com.esri.core.geometry.Polygon)(densify.Execute(polygon, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":15,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(densified, envelope, sr, null));
//				// the
//				// polygon
//				// envelope
//				// doesn't
//				// contain
//				// the
//				// envelope,
//				// but
//				// they
//				// intersect
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polygon polygon = (com.esri.core.geometry.Polygon)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"rings\":[[[0,0],[0,5],[0,10],[10,10],[10,0],[0,0]]]}").GetGeometry());
//				com.esri.core.geometry.Polygon densified = (com.esri.core.geometry.Polygon)(densify.Execute(polygon, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":0,\"ymax\":0}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(densified, envelope, sr, null));
//				// envelope
//				// degenerate
//				// to
//				// a
//				// point
//				// and
//				// is
//				// on
//				// border
//				// (i.e.
//				// touches)
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polygon polygon = (com.esri.core.geometry.Polygon)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"rings\":[[[0,0],[0,5],[0,10],[10,10],[10,0],[0,0]]]}").GetGeometry());
//				com.esri.core.geometry.Polygon densified = (com.esri.core.geometry.Polygon)(densify.Execute(polygon, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":1,\"ymin\":1,\"xmax\":1,\"ymax\":1}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(contains.Execute(densified, envelope, sr, null));
//				// envelope
//				// degenerate
//				// to
//				// a
//				// point
//				// and
//				// is
//				// properly
//				// inside
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polygon polygon = (com.esri.core.geometry.Polygon)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"rings\":[[[0,0],[0,5],[0,10],[10,10],[10,0],[0,0]]]}").GetGeometry());
//				com.esri.core.geometry.Polygon densified = (com.esri.core.geometry.Polygon)(densify.Execute(polygon, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":-1,\"ymin\":-1,\"xmax\":-1,\"ymax\":-1}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(densified, envelope, sr, null));
//				// envelope
//				// degenerate
//				// to
//				// a
//				// point
//				// and
//				// is
//				// properly
//				// outside
//				NUnit.Framework.Assert.IsTrue(disjoint.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polygon polygon = (com.esri.core.geometry.Polygon)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"rings\":[[[0,0],[0,5],[0,10],[10,10],[10,0],[0,0]]]}").GetGeometry());
//				com.esri.core.geometry.Polygon densified = (com.esri.core.geometry.Polygon)(densify.Execute(polygon, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":1,\"ymax\":0}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(densified, envelope, sr, null));
//				// envelope
//				// degenerate
//				// to
//				// a
//				// line
//				// and
//				// rides
//				// the
//				// bottom
//				// of
//				// the
//				// polygon
//				// (no
//				// interior
//				// intersection)
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polygon polygon = (com.esri.core.geometry.Polygon)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"rings\":[[[0,0],[0,5],[0,10],[10,10],[10,0],[0,0]]]}").GetGeometry());
//				com.esri.core.geometry.Polygon densified = (com.esri.core.geometry.Polygon)(densify.Execute(polygon, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":1,\"xmax\":1,\"ymax\":1}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(contains.Execute(densified, envelope, sr, null));
//				// envelope
//				// degenerate
//				// to
//				// a
//				// line,
//				// touches
//				// the
//				// border
//				// on
//				// the
//				// inside
//				// yet
//				// has
//				// interior
//				// intersection
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polygon polygon = (com.esri.core.geometry.Polygon)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"rings\":[[[0,0],[0,5],[0,10],[10,0],[0,0]]]}").GetGeometry());
//				com.esri.core.geometry.Polygon densified = (com.esri.core.geometry.Polygon)(densify.Execute(polygon, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":5,\"ymin\":5,\"xmax\":6,\"ymax\":5}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(densified, envelope, sr, null));
//				// envelope
//				// degenerate
//				// to
//				// a
//				// line,
//				// touches
//				// the
//				// boundary,
//				// and
//				// is
//				// outside
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polygon polygon = (com.esri.core.geometry.Polygon)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"rings\":[[[0,0],[0,5],[0,10],[10,0],[0,0]]]}").GetGeometry());
//				com.esri.core.geometry.Polygon densified = (com.esri.core.geometry.Polygon)(densify.Execute(polygon, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":6,\"ymin\":5,\"xmax\":7,\"ymax\":5}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(densified, envelope, sr, null));
//				// envelope
//				// degenerate
//				// to
//				// a
//				// line,
//				// and
//				// is
//				// outside
//				NUnit.Framework.Assert.IsTrue(disjoint.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polygon polygon = (com.esri.core.geometry.Polygon)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"rings\":[[[0,0],[0,5],[0,10],[10,0],[0,0]]]}").GetGeometry());
//				com.esri.core.geometry.Polygon densified = (com.esri.core.geometry.Polygon)(densify.Execute(polygon, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":4,\"ymin\":5,\"xmax\":7,\"ymax\":5}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(densified, envelope, sr, null));
//				// envelope
//				// degenerate
//				// to
//				// a
//				// line,
//				// and
//				// crosses
//				// polygon
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(crosses.Execute(envelope, densified, sr, null));
//			}
//		}
//
//		[NUnit.Framework.Test]
//		public virtual void TestPolylineEnvelope()
//		{
//			com.esri.core.geometry.OperatorEquals equals = (com.esri.core.geometry.OperatorEquals)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Equals));
//			com.esri.core.geometry.OperatorContains contains = (com.esri.core.geometry.OperatorContains)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Contains));
//			com.esri.core.geometry.OperatorDisjoint disjoint = (com.esri.core.geometry.OperatorDisjoint)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Disjoint));
//			com.esri.core.geometry.OperatorCrosses crosses = (com.esri.core.geometry.OperatorCrosses)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Crosses));
//			com.esri.core.geometry.OperatorWithin within = (com.esri.core.geometry.OperatorWithin)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Within));
//			com.esri.core.geometry.OperatorOverlaps overlaps = (com.esri.core.geometry.OperatorOverlaps)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Overlaps));
//			com.esri.core.geometry.OperatorTouches touches = (com.esri.core.geometry.OperatorTouches)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Touches));
//			com.esri.core.geometry.OperatorDensifyByLength densify = (com.esri.core.geometry.OperatorDensifyByLength)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.DensifyByLength));
//			com.esri.core.geometry.SpatialReference sr = com.esri.core.geometry.SpatialReference.Create(4326);
//			{
//				com.esri.core.geometry.Polyline polyline = (com.esri.core.geometry.Polyline)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"paths\":[[[0,0],[0,5],[0,10],[10,10],[10,0]]]}").GetGeometry());
//				com.esri.core.geometry.Polyline densified = (com.esri.core.geometry.Polyline)(densify.Execute(polyline, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				// polyline
//				// straddles
//				// the
//				// envelope
//				// like
//				// a hat
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polyline polyline = (com.esri.core.geometry.Polyline)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"paths\":[[[-10,0],[0,10]]]}").GetGeometry());
//				com.esri.core.geometry.Polyline densified = (com.esri.core.geometry.Polyline)(densify.Execute(polyline, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polyline polyline = (com.esri.core.geometry.Polyline)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"paths\":[[[-11,0],[1,12]]]}").GetGeometry());
//				com.esri.core.geometry.Polyline densified = (com.esri.core.geometry.Polyline)(densify.Execute(polyline, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(disjoint.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polyline polyline = (com.esri.core.geometry.Polyline)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"paths\":[[[5,5],[6,6]]]}").GetGeometry());
//				com.esri.core.geometry.Polyline densified = (com.esri.core.geometry.Polyline)(densify.Execute(polyline, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				// polyline
//				// properly
//				// inside
//				NUnit.Framework.Assert.IsTrue(contains.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polyline polyline = (com.esri.core.geometry.Polyline)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"paths\":[[[5,5],[10,10]]]}").GetGeometry());
//				com.esri.core.geometry.Polyline densified = (com.esri.core.geometry.Polyline)(densify.Execute(polyline, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(contains.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polyline polyline = (com.esri.core.geometry.Polyline)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"paths\":[[[-5,5],[15,5]]]}").GetGeometry());
//				com.esri.core.geometry.Polyline densified = (com.esri.core.geometry.Polyline)(densify.Execute(polyline, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(crosses.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(crosses.Execute(densified, envelope, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polyline polyline = (com.esri.core.geometry.Polyline)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"paths\":[[[5,5],[5,15]]]}").GetGeometry());
//				com.esri.core.geometry.Polyline densified = (com.esri.core.geometry.Polyline)(densify.Execute(polyline, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				// polyline
//				// slices
//				// through
//				// the
//				// envelope
//				// (interior
//				// and
//				// exterior
//				// intersection)
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polyline polyline = (com.esri.core.geometry.Polyline)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"paths\":[[[5,11],[5,15]]]}").GetGeometry());
//				com.esri.core.geometry.Polyline densified = (com.esri.core.geometry.Polyline)(densify.Execute(polyline, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				// polyline
//				// outside
//				// of
//				// envelope
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(disjoint.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polyline polyline = (com.esri.core.geometry.Polyline)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"paths\":[[[0,0],[0,5],[0,10],[10,10],[10,0]]]}").GetGeometry());
//				com.esri.core.geometry.Polyline densified = (com.esri.core.geometry.Polyline)(densify.Execute(polyline, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":10,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				// polyline
//				// straddles
//				// the
//				// degenerate
//				// envelope
//				// like
//				// a hat
//				NUnit.Framework.Assert.IsTrue(contains.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polyline polyline = (com.esri.core.geometry.Polyline)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"paths\":[[[0,0],[0,5],[0,10],[10,10],[10,0]]]}").GetGeometry());
//				com.esri.core.geometry.Polyline densified = (com.esri.core.geometry.Polyline)(densify.Execute(polyline, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":-5,\"xmax\":0,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polyline polyline = (com.esri.core.geometry.Polyline)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"paths\":[[[0,0],[0,5],[0,10],[10,10],[10,0]]]}").GetGeometry());
//				com.esri.core.geometry.Polyline densified = (com.esri.core.geometry.Polyline)(densify.Execute(polyline, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":0,\"ymax\":0}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 511);
//				WiggleGeometry(envelope, 0.00000001, 1982);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				// degenerate
//				// envelope
//				// is at
//				// the
//				// end
//				// point
//				// of
//				// polyline
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polyline polyline = (com.esri.core.geometry.Polyline)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"paths\":[[[0,0],[0,5],[0,10],[10,10],[10,0]]]}").GetGeometry());
//				com.esri.core.geometry.Polyline densified = (com.esri.core.geometry.Polyline)(densify.Execute(polyline, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":5,\"xmax\":0,\"ymax\":5}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				// degenerate
//				// envelope
//				// is at
//				// the
//				// interior
//				// of
//				// polyline
//				NUnit.Framework.Assert.IsTrue(contains.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polyline polyline = (com.esri.core.geometry.Polyline)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"paths\":[[[2,-2],[2,2]]]}").GetGeometry());
//				com.esri.core.geometry.Polyline densified = (com.esri.core.geometry.Polyline)(densify.Execute(polyline, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":5,\"ymax\":0}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				// degenerate
//				// envelope
//				// crosses
//				// polyline
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polyline polyline = (com.esri.core.geometry.Polyline)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"paths\":[[[2,0],[2,2]]]}").GetGeometry());
//				com.esri.core.geometry.Polyline densified = (com.esri.core.geometry.Polyline)(densify.Execute(polyline, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":5,\"ymax\":0}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				// degenerate
//				// envelope
//				// crosses
//				// polyline
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polyline polyline = (com.esri.core.geometry.Polyline)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"paths\":[[[2,0],[2,2]]]}").GetGeometry());
//				com.esri.core.geometry.Polyline densified = (com.esri.core.geometry.Polyline)(densify.Execute(polyline, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":2,\"ymin\":0,\"xmax\":2,\"ymax\":3}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				// degenerate
//				// envelope
//				// contains
//				// polyline
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(densified, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(contains.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polyline polyline = (com.esri.core.geometry.Polyline)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"paths\":[[[5,5],[6,6]]]}").GetGeometry());
//				com.esri.core.geometry.Polyline densified = (com.esri.core.geometry.Polyline)(densify.Execute(polyline, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":5,\"ymax\":5}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, densified, sr, null));
//				// polyline
//				// properly
//				// inside
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//			{
//				com.esri.core.geometry.Polyline polyline = (com.esri.core.geometry.Polyline)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"paths\":[[[5,5],[5,10]]]}").GetGeometry());
//				com.esri.core.geometry.Polyline densified = (com.esri.core.geometry.Polyline)(densify.Execute(polyline, 1.0, null));
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":5,\"ymin\":5,\"xmax\":5,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(densified, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(equals.Execute(envelope, densified, sr, null));
//				// polyline
//				// properly
//				// inside
//				NUnit.Framework.Assert.IsTrue(contains.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, densified, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, densified, sr, null));
//			}
//		}
//
//		[NUnit.Framework.Test]
//		public virtual void TestMultiPointEnvelope()
//		{
//			com.esri.core.geometry.OperatorEquals equals = (com.esri.core.geometry.OperatorEquals)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Equals));
//			com.esri.core.geometry.OperatorContains contains = (com.esri.core.geometry.OperatorContains)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Contains));
//			com.esri.core.geometry.OperatorDisjoint disjoint = (com.esri.core.geometry.OperatorDisjoint)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Disjoint));
//			com.esri.core.geometry.OperatorCrosses crosses = (com.esri.core.geometry.OperatorCrosses)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Crosses));
//			com.esri.core.geometry.OperatorWithin within = (com.esri.core.geometry.OperatorWithin)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Within));
//			com.esri.core.geometry.OperatorOverlaps overlaps = (com.esri.core.geometry.OperatorOverlaps)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Overlaps));
//			com.esri.core.geometry.OperatorTouches touches = (com.esri.core.geometry.OperatorTouches)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Touches));
//			com.esri.core.geometry.OperatorDensifyByLength densify = (com.esri.core.geometry.OperatorDensifyByLength)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.DensifyByLength));
//			com.esri.core.geometry.SpatialReference sr = com.esri.core.geometry.SpatialReference.Create(4326);
//			{
//				com.esri.core.geometry.MultiPoint multi_point = (com.esri.core.geometry.MultiPoint)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"points\":[[0,0],[0,10],[10,10],[10,0]]}").GetGeometry());
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(multi_point, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, multi_point, sr, null));
//				// all
//				// points
//				// on
//				// boundary
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, multi_point, sr, null));
//			}
//			{
//				com.esri.core.geometry.MultiPoint multi_point = (com.esri.core.geometry.MultiPoint)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"points\":[[0,0],[0,10],[10,10],[5,5]]}").GetGeometry());
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(multi_point, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, multi_point, sr, null));
//				// points
//				// on
//				// boundary
//				// and
//				// one
//				// point
//				// in
//				// interior
//				NUnit.Framework.Assert.IsTrue(contains.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, multi_point, sr, null));
//			}
//			{
//				com.esri.core.geometry.MultiPoint multi_point = (com.esri.core.geometry.MultiPoint)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"points\":[[0,0],[0,10],[10,10],[5,5],[15,15]]}").GetGeometry());
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(multi_point, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, multi_point, sr, null));
//				// points
//				// on
//				// boundary,
//				// one
//				// interior,
//				// one
//				// exterior
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(crosses.Execute(envelope, multi_point, sr, null));
//			}
//			{
//				com.esri.core.geometry.MultiPoint multi_point = (com.esri.core.geometry.MultiPoint)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"points\":[[0,0],[0,10],[10,10],[15,15]]}").GetGeometry());
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(multi_point, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, multi_point, sr, null));
//				// points
//				// on
//				// boundary,
//				// one
//				// exterior
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, multi_point, sr, null));
//			}
//			{
//				com.esri.core.geometry.MultiPoint multi_point = (com.esri.core.geometry.MultiPoint)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"points\":[[0,-1],[0,11],[11,11],[15,15]]}").GetGeometry());
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(multi_point, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, multi_point, sr, null));
//				// all
//				// points
//				// exterior
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(disjoint.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, multi_point, sr, null));
//			}
//			{
//				com.esri.core.geometry.MultiPoint multi_point = (com.esri.core.geometry.MultiPoint)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"points\":[[0,0],[0,10],[10,10],[10,0]]}").GetGeometry());
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":10,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(multi_point, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, multi_point, sr, null));
//				// degenerate
//				// envelope
//				// slices
//				// through
//				// some
//				// points,
//				// but
//				// some
//				// points
//				// are
//				// off
//				// the
//				// line
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, multi_point, sr, null));
//			}
//			{
//				com.esri.core.geometry.MultiPoint multi_point = (com.esri.core.geometry.MultiPoint)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"points\":[[0,0],[1,10],[10,10],[10,0]]}").GetGeometry());
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":10,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(multi_point, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, multi_point, sr, null));
//				// degenerate
//				// envelope
//				// slices
//				// through
//				// some
//				// points,
//				// but
//				// some
//				// points
//				// are
//				// off
//				// the
//				// line
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(crosses.Execute(envelope, multi_point, sr, null));
//			}
//			{
//				com.esri.core.geometry.MultiPoint multi_point = (com.esri.core.geometry.MultiPoint)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"points\":[[0,10],[10,10]]}").GetGeometry());
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":10,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(multi_point, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, multi_point, sr, null));
//				// degenerate
//				// envelopes
//				// slices
//				// through
//				// all
//				// the
//				// points,
//				// and
//				// they
//				// are
//				// at
//				// the
//				// end
//				// points
//				// of
//				// the
//				// line
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, multi_point, sr, null));
//			}
//			{
//				com.esri.core.geometry.MultiPoint multi_point = (com.esri.core.geometry.MultiPoint)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"points\":[[1,10],[9,10]]}").GetGeometry());
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":10,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(multi_point, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, multi_point, sr, null));
//				// degenerate
//				// envelopes
//				// slices
//				// through
//				// all
//				// the
//				// points,
//				// and
//				// they
//				// are
//				// in
//				// the
//				// interior
//				// of
//				// the
//				// line
//				NUnit.Framework.Assert.IsTrue(contains.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, multi_point, sr, null));
//			}
//			{
//				com.esri.core.geometry.MultiPoint multi_point = (com.esri.core.geometry.MultiPoint)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"points\":[[0,-1],[0,11],[11,11],[15,15]]}").GetGeometry());
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":10,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(multi_point, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, multi_point, sr, null));
//				// all
//				// points
//				// exterior
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(disjoint.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, multi_point, sr, null));
//			}
//			{
//				com.esri.core.geometry.MultiPoint multi_point = (com.esri.core.geometry.MultiPoint)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"points\":[[0,-1],[0,11],[11,11],[15,15]]}").GetGeometry());
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":10,\"ymin\":10,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(multi_point, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, multi_point, sr, null));
//				// all
//				// points
//				// exterior
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(disjoint.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, multi_point, sr, null));
//			}
//			{
//				com.esri.core.geometry.MultiPoint multi_point = (com.esri.core.geometry.MultiPoint)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"points\":[[0,-1],[0,11],[11,11],[15,15]]}").GetGeometry());
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":11,\"ymax\":11}").GetGeometry());
//				WiggleGeometry(multi_point, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, multi_point, sr, null));
//				// all
//				// points
//				// exterior
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(multi_point, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, multi_point, sr, null));
//			}
//			{
//				com.esri.core.geometry.MultiPoint multi_point = (com.esri.core.geometry.MultiPoint)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"points\":[[0,-1],[0,-1]]}").GetGeometry());
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":-1,\"xmax\":0,\"ymax\":-1}").GetGeometry());
//				WiggleGeometry(multi_point, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(equals.Execute(envelope, multi_point, sr, null));
//				// all
//				// points
//				// exterior
//				NUnit.Framework.Assert.IsTrue(contains.Execute(multi_point, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(contains.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, multi_point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, multi_point, sr, null));
//			}
//		}
//
//		[NUnit.Framework.Test]
//		public virtual void TestPointEnvelope()
//		{
//			com.esri.core.geometry.OperatorEquals equals = (com.esri.core.geometry.OperatorEquals)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Equals));
//			com.esri.core.geometry.OperatorContains contains = (com.esri.core.geometry.OperatorContains)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Contains));
//			com.esri.core.geometry.OperatorDisjoint disjoint = (com.esri.core.geometry.OperatorDisjoint)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Disjoint));
//			com.esri.core.geometry.OperatorCrosses crosses = (com.esri.core.geometry.OperatorCrosses)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Crosses));
//			com.esri.core.geometry.OperatorWithin within = (com.esri.core.geometry.OperatorWithin)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Within));
//			com.esri.core.geometry.OperatorOverlaps overlaps = (com.esri.core.geometry.OperatorOverlaps)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Overlaps));
//			com.esri.core.geometry.OperatorTouches touches = (com.esri.core.geometry.OperatorTouches)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Touches));
//			com.esri.core.geometry.SpatialReference sr = com.esri.core.geometry.SpatialReference.Create(4326);
//			{
//				com.esri.core.geometry.Point point = (com.esri.core.geometry.Point)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"x\":5,\"y\":6}").GetGeometry());
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(point, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(contains.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(point, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, point, sr, null));
//			}
//			{
//				com.esri.core.geometry.Point point = (com.esri.core.geometry.Point)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"x\":0,\"y\":10}").GetGeometry());
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(point, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(point, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, point, sr, null));
//			}
//			{
//				com.esri.core.geometry.Point point = (com.esri.core.geometry.Point)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"x\":0,\"y\":11}").GetGeometry());
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(point, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(point, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(disjoint.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, point, sr, null));
//			}
//			{
//				com.esri.core.geometry.Point point = (com.esri.core.geometry.Point)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"x\":0,\"y\":0}").GetGeometry());
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":0}").GetGeometry());
//				WiggleGeometry(point, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(point, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, point, sr, null));
//			}
//			{
//				com.esri.core.geometry.Point point = (com.esri.core.geometry.Point)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"x\":5,\"y\":0}").GetGeometry());
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":0}").GetGeometry());
//				WiggleGeometry(point, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(contains.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(point, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, point, sr, null));
//			}
//			{
//				com.esri.core.geometry.Point point = (com.esri.core.geometry.Point)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"x\":11,\"y\":0}").GetGeometry());
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":0}").GetGeometry());
//				WiggleGeometry(point, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(point, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(disjoint.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, point, sr, null));
//			}
//			{
//				com.esri.core.geometry.Point point = (com.esri.core.geometry.Point)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"x\":0,\"y\":0}").GetGeometry());
//				com.esri.core.geometry.Envelope envelope = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":0,\"ymax\":0}").GetGeometry());
//				WiggleGeometry(point, 0.00000001, 1982);
//				WiggleGeometry(envelope, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(equals.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(contains.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(contains.Execute(point, envelope, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(envelope, point, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(envelope, point, sr, null));
//			}
//		}
//
//		[NUnit.Framework.Test]
//		public virtual void TestEnvelopeEnvelope()
//		{
//			com.esri.core.geometry.OperatorEquals equals = (com.esri.core.geometry.OperatorEquals)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Equals));
//			com.esri.core.geometry.OperatorContains contains = (com.esri.core.geometry.OperatorContains)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Contains));
//			com.esri.core.geometry.OperatorDisjoint disjoint = (com.esri.core.geometry.OperatorDisjoint)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Disjoint));
//			com.esri.core.geometry.OperatorCrosses crosses = (com.esri.core.geometry.OperatorCrosses)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Crosses));
//			com.esri.core.geometry.OperatorWithin within = (com.esri.core.geometry.OperatorWithin)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Within));
//			com.esri.core.geometry.OperatorOverlaps overlaps = (com.esri.core.geometry.OperatorOverlaps)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Overlaps));
//			com.esri.core.geometry.OperatorTouches touches = (com.esri.core.geometry.OperatorTouches)(com.esri.core.geometry.OperatorFactoryLocal.GetInstance().GetOperator(com.esri.core.geometry.Operator.Type.Touches));
//			com.esri.core.geometry.SpatialReference sr = com.esri.core.geometry.SpatialReference.Create(4326);
//			{
//				com.esri.core.geometry.Envelope env1 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				com.esri.core.geometry.Envelope env2 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(env1, 0.00000001, 1982);
//				WiggleGeometry(env2, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(equals.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(contains.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(contains.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env2, env1, sr, null));
//			}
//			{
//				com.esri.core.geometry.Envelope env1 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":5,\"ymin\":5,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				com.esri.core.geometry.Envelope env2 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(env1, 0.00000001, 1982);
//				WiggleGeometry(env2, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(contains.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env2, env1, sr, null));
//			}
//			{
//				com.esri.core.geometry.Envelope env1 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":5,\"ymin\":5,\"xmax\":15,\"ymax\":15}").GetGeometry());
//				com.esri.core.geometry.Envelope env2 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(env1, 0.00000001, 1982);
//				WiggleGeometry(env2, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(overlaps.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(overlaps.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env2, env1, sr, null));
//			}
//			{
//				com.esri.core.geometry.Envelope env1 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":10,\"ymin\":0,\"xmax\":20,\"ymax\":10}").GetGeometry());
//				com.esri.core.geometry.Envelope env2 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(env1, 0.00000001, 1982);
//				WiggleGeometry(env2, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env2, env1, sr, null));
//			}
//			{
//				com.esri.core.geometry.Envelope env1 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":10,\"ymin\":0,\"xmax\":20,\"ymax\":10}").GetGeometry());
//				com.esri.core.geometry.Envelope env2 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(env1, 0.00000001, 1982);
//				WiggleGeometry(env2, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env2, env1, sr, null));
//			}
//			{
//				com.esri.core.geometry.Envelope env1 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":10,\"ymin\":0,\"xmax\":20,\"ymax\":10}").GetGeometry());
//				com.esri.core.geometry.Envelope env2 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":10,\"xmax\":10,\"ymax\":20}").GetGeometry());
//				WiggleGeometry(env1, 0.00000001, 1982);
//				WiggleGeometry(env2, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env2, env1, sr, null));
//			}
//			{
//				com.esri.core.geometry.Envelope env1 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				com.esri.core.geometry.Envelope env2 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":0}").GetGeometry());
//				WiggleGeometry(env1, 0.00000001, 1982);
//				WiggleGeometry(env2, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env2, env1, sr, null));
//			}
//			{
//				com.esri.core.geometry.Envelope env1 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				com.esri.core.geometry.Envelope env2 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":15,\"ymax\":0}").GetGeometry());
//				WiggleGeometry(env1, 0.00000001, 1982);
//				WiggleGeometry(env2, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env2, env1, sr, null));
//			}
//			{
//				com.esri.core.geometry.Envelope env1 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				com.esri.core.geometry.Envelope env2 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":-5,\"ymin\":5,\"xmax\":0,\"ymax\":5}").GetGeometry());
//				WiggleGeometry(env1, 0.00000001, 1982);
//				WiggleGeometry(env2, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env2, env1, sr, null));
//			}
//			{
//				com.esri.core.geometry.Envelope env1 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				com.esri.core.geometry.Envelope env2 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":-5,\"ymin\":5,\"xmax\":5,\"ymax\":5}").GetGeometry());
//				WiggleGeometry(env1, 0.00000001, 1982);
//				WiggleGeometry(env2, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(crosses.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(crosses.Execute(env2, env1, sr, null));
//			}
//			{
//				com.esri.core.geometry.Envelope env1 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				com.esri.core.geometry.Envelope env2 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":3,\"ymin\":5,\"xmax\":5,\"ymax\":5}").GetGeometry());
//				WiggleGeometry(env1, 0.00000001, 1982);
//				WiggleGeometry(env2, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(contains.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env2, env1, sr, null));
//			}
//			{
//				com.esri.core.geometry.Envelope env1 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				com.esri.core.geometry.Envelope env2 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":3,\"ymin\":5,\"xmax\":10,\"ymax\":5}").GetGeometry());
//				WiggleGeometry(env1, 0.00000001, 1982);
//				WiggleGeometry(env2, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(contains.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env2, env1, sr, null));
//			}
//			{
//				com.esri.core.geometry.Envelope env1 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				com.esri.core.geometry.Envelope env2 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":-5,\"ymin\":0,\"xmax\":0,\"ymax\":0}").GetGeometry());
//				WiggleGeometry(env1, 0.00000001, 1982);
//				WiggleGeometry(env2, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env2, env1, sr, null));
//			}
//			{
//				com.esri.core.geometry.Envelope env1 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":0}").GetGeometry());
//				com.esri.core.geometry.Envelope env2 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":0}").GetGeometry());
//				WiggleGeometry(env1, 0.00000001, 1982);
//				WiggleGeometry(env2, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(equals.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(contains.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(contains.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env2, env1, sr, null));
//			}
//			{
//				com.esri.core.geometry.Envelope env1 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":15,\"ymax\":0}").GetGeometry());
//				com.esri.core.geometry.Envelope env2 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":0}").GetGeometry());
//				WiggleGeometry(env1, 0.00000001, 1982);
//				WiggleGeometry(env2, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(contains.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env2, env1, sr, null));
//			}
//			{
//				com.esri.core.geometry.Envelope env1 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":15,\"ymax\":0}").GetGeometry());
//				com.esri.core.geometry.Envelope env2 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":-5,\"ymin\":0,\"xmax\":10,\"ymax\":0}").GetGeometry());
//				WiggleGeometry(env1, 0.00000001, 1982);
//				WiggleGeometry(env2, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(overlaps.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(overlaps.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env2, env1, sr, null));
//			}
//			{
//				com.esri.core.geometry.Envelope env1 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":5,\"ymax\":0}").GetGeometry());
//				com.esri.core.geometry.Envelope env2 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":-5,\"ymin\":0,\"xmax\":0,\"ymax\":0}").GetGeometry());
//				WiggleGeometry(env1, 0.00000001, 1982);
//				WiggleGeometry(env2, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env2, env1, sr, null));
//			}
//			{
//				com.esri.core.geometry.Envelope env1 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":0}").GetGeometry());
//				com.esri.core.geometry.Envelope env2 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":5,\"ymin\":-5,\"xmax\":5,\"ymax\":5}").GetGeometry());
//				WiggleGeometry(env1, 0.00000001, 1982);
//				WiggleGeometry(env2, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(crosses.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(crosses.Execute(env2, env1, sr, null));
//			}
//			{
//				com.esri.core.geometry.Envelope env1 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":0}").GetGeometry());
//				com.esri.core.geometry.Envelope env2 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":10,\"ymin\":0,\"xmax\":20,\"ymax\":0}").GetGeometry());
//				WiggleGeometry(env1, 0.00000001, 1982);
//				WiggleGeometry(env2, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env2, env1, sr, null));
//			}
//			{
//				com.esri.core.geometry.Envelope env1 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":0}").GetGeometry());
//				com.esri.core.geometry.Envelope env2 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":5,\"ymin\":0,\"xmax\":5,\"ymax\":5}").GetGeometry());
//				WiggleGeometry(env1, 0.00000001, 1982);
//				WiggleGeometry(env2, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env2, env1, sr, null));
//			}
//			{
//				com.esri.core.geometry.Envelope env1 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":0,\"ymax\":0}").GetGeometry());
//				com.esri.core.geometry.Envelope env2 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(env1, 0.00000001, 1982);
//				WiggleGeometry(env2, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env2, env1, sr, null));
//			}
//			{
//				com.esri.core.geometry.Envelope env1 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":5,\"ymin\":0,\"xmax\":5,\"ymax\":0}").GetGeometry());
//				com.esri.core.geometry.Envelope env2 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(env1, 0.00000001, 1982);
//				WiggleGeometry(env2, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env2, env1, sr, null));
//			}
//			{
//				com.esri.core.geometry.Envelope env1 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":5,\"ymin\":5,\"xmax\":5,\"ymax\":5}").GetGeometry());
//				com.esri.core.geometry.Envelope env2 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":10}").GetGeometry());
//				WiggleGeometry(env1, 0.00000001, 1982);
//				WiggleGeometry(env2, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(contains.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env2, env1, sr, null));
//			}
//			{
//				com.esri.core.geometry.Envelope env1 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":0,\"ymax\":0}").GetGeometry());
//				com.esri.core.geometry.Envelope env2 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":0}").GetGeometry());
//				WiggleGeometry(env1, 0.00000001, 1982);
//				WiggleGeometry(env2, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(touches.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env2, env1, sr, null));
//			}
//			{
//				com.esri.core.geometry.Envelope env1 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":5,\"ymin\":0,\"xmax\":5,\"ymax\":0}").GetGeometry());
//				com.esri.core.geometry.Envelope env2 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":0,\"ymin\":0,\"xmax\":10,\"ymax\":0}").GetGeometry());
//				WiggleGeometry(env1, 0.00000001, 1982);
//				WiggleGeometry(env2, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(!equals.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!contains.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(contains.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env2, env1, sr, null));
//			}
//			{
//				com.esri.core.geometry.Envelope env1 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":5,\"ymin\":0,\"xmax\":5,\"ymax\":0}").GetGeometry());
//				com.esri.core.geometry.Envelope env2 = (com.esri.core.geometry.Envelope)(com.esri.core.geometry.TestCommonMethods.FromJson("{\"xmin\":5,\"ymin\":0,\"xmax\":5,\"ymax\":0}").GetGeometry());
//				WiggleGeometry(env1, 0.00000001, 1982);
//				WiggleGeometry(env2, 0.00000001, 511);
//				NUnit.Framework.Assert.IsTrue(equals.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(contains.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(contains.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!disjoint.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!touches.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!overlaps.Execute(env2, env1, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env1, env2, sr, null));
//				NUnit.Framework.Assert.IsTrue(!crosses.Execute(env2, env1, sr, null));
//			}
//		}

		internal static void WiggleGeometry(com.esri.core.geometry.Geometry geometry, double tolerance, int rand)
		{
			int type = geometry.GetType().Value();
			if (type == com.esri.core.geometry.Geometry.GeometryType.Polygon || type == com.esri.core.geometry.Geometry.GeometryType.Polyline || type == com.esri.core.geometry.Geometry.GeometryType.MultiPoint)
			{
				com.esri.core.geometry.MultiVertexGeometry mvGeom = (com.esri.core.geometry.MultiVertexGeometry)geometry;
				for (int i = 0; i < mvGeom.GetPointCount(); i++)
				{
					com.esri.core.geometry.Point2D pt = mvGeom.GetXY(i);
					// create random vector and normalize it to 0.49 * tolerance
					com.esri.core.geometry.Point2D randomV = new com.esri.core.geometry.Point2D();
					rand = com.esri.core.geometry.NumberUtils.NextRand(rand);
					randomV.x = 1.0 * rand / com.esri.core.geometry.NumberUtils.IntMax() - 0.5;
					rand = com.esri.core.geometry.NumberUtils.NextRand(rand);
					randomV.y = 1.0 * rand / com.esri.core.geometry.NumberUtils.IntMax() - 0.5;
					randomV.Normalize();
					randomV.Scale(0.45 * tolerance);
					pt.Add(randomV);
					mvGeom.SetXY(i, pt);
				}
			}
			else
			{
				if (type == com.esri.core.geometry.Geometry.GeometryType.Point)
				{
					com.esri.core.geometry.Point ptGeom = (com.esri.core.geometry.Point)(geometry);
					com.esri.core.geometry.Point2D pt = ptGeom.GetXY();
					// create random vector and normalize it to 0.49 * tolerance
					com.esri.core.geometry.Point2D randomV = new com.esri.core.geometry.Point2D();
					rand = com.esri.core.geometry.NumberUtils.NextRand(rand);
					randomV.x = 1.0 * rand / com.esri.core.geometry.NumberUtils.IntMax() - 0.5;
					rand = com.esri.core.geometry.NumberUtils.NextRand(rand);
					randomV.y = 1.0 * rand / com.esri.core.geometry.NumberUtils.IntMax() - 0.5;
					randomV.Normalize();
					randomV.Scale(0.45 * tolerance);
					pt.Add(randomV);
					ptGeom.SetXY(pt);
				}
				else
				{
					if (type == com.esri.core.geometry.Geometry.GeometryType.Envelope)
					{
						com.esri.core.geometry.Envelope envGeom = (com.esri.core.geometry.Envelope)(geometry);
						com.esri.core.geometry.Envelope2D env = new com.esri.core.geometry.Envelope2D();
						envGeom.QueryEnvelope2D(env);
						double xmin;
						double xmax;
						double ymin;
						double ymax;
						com.esri.core.geometry.Point2D pt = new com.esri.core.geometry.Point2D();
						env.QueryLowerLeft(pt);
						// create random vector and normalize it to 0.49 * tolerance
						com.esri.core.geometry.Point2D randomV = new com.esri.core.geometry.Point2D();
						rand = com.esri.core.geometry.NumberUtils.NextRand(rand);
						randomV.x = 1.0 * rand / com.esri.core.geometry.NumberUtils.IntMax() - 0.5;
						rand = com.esri.core.geometry.NumberUtils.NextRand(rand);
						randomV.y = 1.0 * rand / com.esri.core.geometry.NumberUtils.IntMax() - 0.5;
						randomV.Normalize();
						randomV.Scale(0.45 * tolerance);
						xmin = (pt.x + randomV.x);
						ymin = (pt.y + randomV.y);
						env.QueryUpperRight(pt);
						// create random vector and normalize it to 0.49 * tolerance
						rand = com.esri.core.geometry.NumberUtils.NextRand(rand);
						randomV.x = 1.0 * rand / com.esri.core.geometry.NumberUtils.IntMax() - 0.5;
						rand = com.esri.core.geometry.NumberUtils.NextRand(rand);
						randomV.y = 1.0 * rand / com.esri.core.geometry.NumberUtils.IntMax() - 0.5;
						randomV.Normalize();
						randomV.Scale(0.45 * tolerance);
						xmax = (pt.x + randomV.x);
						ymax = (pt.y + randomV.y);
						if (xmin > xmax)
						{
							double swap = xmin;
							xmin = xmax;
							xmax = swap;
						}
						if (ymin > ymax)
						{
							double swap = ymin;
							ymin = ymax;
							ymax = swap;
						}
						envGeom.SetCoords(xmin, ymin, xmax, ymax);
					}
				}
			}
		}

Esempio n. 2

Mostra file

File: TestRasterizedGeometry2D.cs Progetto: davidraleigh/geometry-api-cs-tests

		internal virtual bool RgHelper(com.esri.core.geometry.RasterizedGeometry2D rg, com.esri.core.geometry.MultiPath mp)
		{
			com.esri.core.geometry.SegmentIterator iter = mp.QuerySegmentIterator();
			while (iter.NextPath())
			{
				while (iter.HasNextSegment())
				{
					com.esri.core.geometry.Segment seg = iter.NextSegment();
					int count = 20;
					for (int i = 0; i < count; i++)
					{
						double t = (1.0 * i / count);
						com.esri.core.geometry.Point2D pt = seg.GetCoord2D(t);
						com.esri.core.geometry.RasterizedGeometry2D.HitType hit = rg.QueryPointInGeometry(pt.x, pt.y);
						if (hit != com.esri.core.geometry.RasterizedGeometry2D.HitType.Border)
						{
							return false;
						}
					}
				}
			}
			if (mp.GetType() != com.esri.core.geometry.Geometry.Type.Polygon)
			{
				return true;
			}
			com.esri.core.geometry.Polygon poly = (com.esri.core.geometry.Polygon)mp;
			com.esri.core.geometry.Envelope2D env = new com.esri.core.geometry.Envelope2D();
			poly.QueryEnvelope2D(env);
			int count_1 = 100;
			for (int iy = 0; iy < count_1; iy++)
			{
				double ty = 1.0 * iy / count_1;
				double y = env.ymin * (1.0 - ty) + ty * env.ymax;
				for (int ix = 0; ix < count_1; ix++)
				{
					double tx = 1.0 * ix / count_1;
					double x = env.xmin * (1.0 - tx) + tx * env.xmax;
					com.esri.core.geometry.RasterizedGeometry2D.HitType hit = rg.QueryPointInGeometry(x, y);
					com.esri.core.geometry.PolygonUtils.PiPResult res = com.esri.core.geometry.PolygonUtils.IsPointInPolygon2D(poly, new com.esri.core.geometry.Point2D(x, y), 0);
					if (res == com.esri.core.geometry.PolygonUtils.PiPResult.PiPInside)
					{
						bool bgood = (hit == com.esri.core.geometry.RasterizedGeometry2D.HitType.Border || hit == com.esri.core.geometry.RasterizedGeometry2D.HitType.Inside);
						if (!bgood)
						{
							return false;
						}
					}
					else
					{
						if (res == com.esri.core.geometry.PolygonUtils.PiPResult.PiPOutside)
						{
							bool bgood = (hit == com.esri.core.geometry.RasterizedGeometry2D.HitType.Border || hit == com.esri.core.geometry.RasterizedGeometry2D.HitType.Outside);
							if (!bgood)
							{
								return false;
							}
						}
						else
						{
							bool bgood = (hit == com.esri.core.geometry.RasterizedGeometry2D.HitType.Border);
							if (!bgood)
							{
								return false;
							}
						}
					}
				}
			}
			return true;
		}