private static void RunTest([NotNull] IFeatureClass polygonFeatureClass,
                                    [NotNull] IFeatureClass pointFeatureClass,
                                    int minimumPointCount, int maximumPointCount,
                                    [CanBeNull] string relevantPointCondition,
                                    bool countPointOnPolygonBorder,
                                    double tileSize,
                                    [CanBeNull] IEnvelope envelope, int expectedErrorCount)
        {
            var test = new QaContainedPointsCount(polygonFeatureClass, pointFeatureClass,
                                                  minimumPointCount, maximumPointCount,
                                                  relevantPointCondition,
                                                  countPointOnPolygonBorder);

            // run in container without envelope

            var containerRunner = new QaContainerTestRunner(tileSize, test);

            if (envelope == null)
            {
                containerRunner.Execute();
            }
            else
            {
                containerRunner.Execute(envelope);
            }

            Assert.AreEqual(expectedErrorCount, containerRunner.Errors.Count);
        }
        public void TestClosedLines()
        {
            var           ws = TestWorkspaceUtils.CreateInMemoryWorkspace("ClosedLines");
            IFeatureClass polylineFeatureClass;
            IFeatureClass pointFeatureClass;

            CreateTestFeatureClasses("polygons5", "points5",
                                     out polylineFeatureClass,
                                     out pointFeatureClass, ws, polygonAsClosedLines: true);

            IFeature emptyFeature = polylineFeatureClass.CreateFeature();

            emptyFeature.Shape =
                CurveConstruction.StartLine(100, 300)
                .LineTo(200, 300)
                .LineTo(200, 400)
                .LineTo(100, 400)
                .LineTo(100, 300)
                .Curve;
            emptyFeature.Store();

            IFeature counterClockwiseFeature = polylineFeatureClass.CreateFeature();

            counterClockwiseFeature.Shape =
                CurveConstruction.StartLine(100, 100)
                .LineTo(200, 100)
                .LineTo(200, 200)
                .LineTo(100, 200)
                .LineTo(100, 100)
                .Curve;
            counterClockwiseFeature.Store();

            IFeature clockwiseFeature = polylineFeatureClass.CreateFeature();

            clockwiseFeature.Shape =
                CurveConstruction.StartLine(100, 100)
                .LineTo(100, 200)
                .LineTo(200, 200)
                .LineTo(200, 100)
                .LineTo(100, 100)
                .Curve;
            clockwiseFeature.Store();

            IFeature notClosedFeature = polylineFeatureClass.CreateFeature();

            notClosedFeature.Shape =
                CurveConstruction.StartLine(300, 100)
                .LineTo(400, 100)
                .LineTo(400, 200)
                .Curve;
            notClosedFeature.Store();

            IFeature pointFeature1 = pointFeatureClass.CreateFeature();

            pointFeature1.Shape = GeometryFactory.CreatePoint(150, 150);
            pointFeature1.Store();

            IFeature pointFeature2 = pointFeatureClass.CreateFeature();

            pointFeature2.Shape = GeometryFactory.CreatePoint(350, 100);
            pointFeature2.Store();

            var test = new QaContainedPointsCount(polylineFeatureClass, pointFeatureClass, 1,
                                                  string.Empty)
            {
                PolylineUsage = PolylineUsage.AsIs
            };
            var containerRunner = new QaContainerTestRunner(1000, test);

            containerRunner.Execute();
            Assert.AreEqual(3, containerRunner.Errors.Count);

            test = new QaContainedPointsCount(polylineFeatureClass, pointFeatureClass, 1,
                                              string.Empty)
            {
                PolylineUsage = PolylineUsage.AsPolygonIfClosedElseReportIssue
            };
            containerRunner = new QaContainerTestRunner(1000, test);
            containerRunner.Execute();
            Assert.AreEqual(2, containerRunner.Errors.Count);

            test = new QaContainedPointsCount(polylineFeatureClass, pointFeatureClass, 1,
                                              string.Empty)
            {
                PolylineUsage = PolylineUsage.AsPolygonIfClosedElseIgnore
            };
            containerRunner = new QaContainerTestRunner(1000, test);
            containerRunner.Execute();
            Assert.AreEqual(1, containerRunner.Errors.Count);

            test = new QaContainedPointsCount(polylineFeatureClass, pointFeatureClass, 1,
                                              string.Empty)
            {
                PolylineUsage = PolylineUsage.AsPolygonIfClosedElseAsPolyline
            };
            containerRunner = new QaContainerTestRunner(1000, test);
            containerRunner.Execute();
            Assert.AreEqual(1, containerRunner.Errors.Count);
        }