public void FindPathTest()
        {
            int[] nodeIDs = new int[] { 2, 3 };
            string networkDatasetName = "RoadNet@Changchun";
            TransportationAnalystParameter parameter = new TransportationAnalystParameter();
            parameter.ResultSetting = new TransportationAnalystResultSetting();
            parameter.ResultSetting.ReturnEdgeIDs = true;
            parameter.ResultSetting.ReturnNodeIDs = true;
            parameter.ResultSetting.ReturnPathGuides = true;
            parameter.ResultSetting.ReturnRoutes = true;
            parameter.ResultSetting.ReturnEdgeFeatures = true;
            parameter.ResultSetting.ReturnEdgeGeometry = true;
            parameter.ResultSetting.ReturnNodeFeatures = true;
            parameter.ResultSetting.ReturnNodeGeometry = true;
            parameter.WeightFieldName = "length";
            parameter.TurnWeightField = "TurnCost";

            NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");
            List<Path> paths = networkAnalyst.FindPath(networkDatasetName, nodeIDs, true, parameter);
            Assert.IsNotNull(paths);
            Assert.IsNotNull(paths[0]);
            Assert.IsNotNull(paths[0].EdgeFeatures[0]);
            Assert.IsNotNull(paths[0].EdgeIDs[0]);
            Assert.IsNotNull(paths[0].NodeFeatures[0]);
            Assert.IsNotNull(paths[0].NodeIDs[0]);
            Assert.IsNotNull(paths[0].PathGuideItems[0]);
            Assert.IsNotNull(paths[0].Route);
            Assert.IsNotNull(paths[0].Route.Length);
            Assert.IsNotNull(paths[0].Route.Points[0]);
            Assert.AreEqual(paths[0].Route.Points[1].Measure, 42.273803871316005);
            Assert.IsNotNull(paths[0].Route.Type);
            Assert.AreEqual(paths[0].Route.MaxM, 53);
            Assert.AreEqual(paths[0].Route.MinM, 0.0);
            Assert.AreEqual(paths[0].Route.Type, GeometryType.LINEM);
        }
                    public static NetworkAnalyst FromBaseObject(BaseObject baseObj)
                    {
                        if (baseObj == null || baseObj.NativeObject == IntPtr.Zero)
                        {
                            return(null);
                        }
                        NetworkAnalyst obj = baseObj as  NetworkAnalyst;

                        if (object.Equals(obj, null))
                        {
                            obj = new NetworkAnalyst(CreatedWhenConstruct.CWC_NotToCreate);
                            obj.BindNativeObject(baseObj.NativeObject, "CNetworkAnalyst");
                            obj.IncreaseCast();
                        }

                        return(obj);
                    }
        public void FindClosestFacilityTest_ID_Geometry()
        {
            string networkDatasetName = "RoadNet@Changchun";
            int[] facilityIDs = new int[] { 1, 6, 52 };
            int eventID = 2;
            int expectFacilityCount = 2;
            bool fromEvent = false;
            double maxWeight = 0;
            TransportationAnalystParameter parameter = new TransportationAnalystParameter();
            parameter.WeightFieldName = "length";
            parameter.TurnWeightField = "TurnCost";
            parameter.ResultSetting = new TransportationAnalystResultSetting();
            parameter.ResultSetting.ReturnEdgeFeatures = false;
            parameter.ResultSetting.ReturnEdgeGeometry = true;
            parameter.ResultSetting.ReturnEdgeIDs = true;
            parameter.ResultSetting.ReturnNodeFeatures = false;
            parameter.ResultSetting.ReturnNodeGeometry = true;
            parameter.ResultSetting.ReturnNodeIDs = true;
            parameter.ResultSetting.ReturnPathGuides = true;
            parameter.ResultSetting.ReturnRoutes = true;

            NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");
            List<ClosestFacilityPath<int>> pathResult = networkAnalyst.FindClosestFacility(networkDatasetName, facilityIDs,
                eventID, expectFacilityCount, fromEvent, maxWeight, parameter);
            Assert.IsNotNull(pathResult);
            Assert.AreEqual(pathResult.Count, 2);
            Assert.AreEqual(pathResult[0].FacilityIndex, 0);
            Assert.AreEqual(pathResult[0].Facility, 1);
            Assert.AreEqual(pathResult[1].FacilityIndex, 1);
            Assert.AreEqual(pathResult[1].Facility, 6);
            Assert.AreEqual(pathResult[0].Weight, 125);
            Assert.AreEqual(pathResult[1].Weight, 484);
            Assert.IsNotNull(pathResult[0].StopWeights);
            Assert.IsNotNull(pathResult[0].Route);
            Assert.IsNotNull(pathResult[0].PathGuideItems);
            Assert.IsNotNull(pathResult[0].NodeIDs);
            Assert.IsNotNull(pathResult[0].EdgeIDs);
        }
                    public BaseObject Create()
                    {
                        NetworkAnalyst emptyInstance = new NetworkAnalyst(CreatedWhenConstruct.CWC_NotToCreate);

                        return(emptyInstance);
                    }
        public void ComputeWeightMatrix_Points()
        {
            NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");
            Point2D[] points = new Point2D[2];
            points[0] = new Point2D() { X = 32.754, Y = 23.205 };
            points[1] = new Point2D() { X = 415.55, Y = 87.66 };

            double[][] weightMatrix = networkAnalyst.ComputeWeightMatrix("RoadNet@Changchun", points);

            Assert.IsNotNull(weightMatrix);
            Assert.IsTrue(weightMatrix.Length == 2);
            Assert.IsTrue(weightMatrix[0].Length == 2);
            Assert.IsTrue(weightMatrix[1][0] == 446.26723858569954);
        }
        public void TSPPathTest_PointDatasetNull()
        {
            NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");
            Point2D[] points = new Point2D[4];
            points[0] = new Point2D(119.6100397551, -122.6278394459);
            points[1] = new Point2D(171.9035599945, -113.2491141857);
            points[2] = new Point2D(181.9035599945, -123.2491141857);
            points[3] = new Point2D(161.9035599945, -123.2491141857);
            TransportationAnalystParameter parameter = new TransportationAnalystParameter();
            parameter.WeightFieldName = "length";
            parameter.TurnWeightField = "TurnCost";
            try
            {
                List<TSPPath> paths = networkAnalyst.FindTSPPath(string.Empty, points, false, parameter);
            }
            catch (ArgumentNullException e)
            {
                Assert.AreEqual(e.Message, "参数不能为空。\r\n参数名: networkDatasetName");
            }

        }
        public void TSPPathTest_PointParameterNull()
        {
            NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");
            Point2D[] points = new Point2D[4];
            points[0] = new Point2D(119.6100397551, -122.6278394459);
            points[1] = new Point2D(171.9035599945, -113.2491141857);
            points[2] = new Point2D(181.9035599945, -123.2491141857);
            points[3] = new Point2D(161.9035599945, -123.2491141857);

            List<TSPPath> paths = networkAnalyst.FindTSPPath("RoadNet@Changchun", points, false, null);

            Assert.IsNotNull(paths);
            Assert.IsNotNull(paths[0]);
            Assert.IsNull(paths[0].EdgeFeatures);
            Assert.IsNotNull(paths[0].EdgeIDs[0]);
            Assert.IsNull(paths[0].NodeFeatures);
            Assert.IsNotNull(paths[0].NodeIDs[0]);
            Assert.IsNull(paths[0].PathGuideItems);
            Assert.IsNotNull(paths[0].Route);
            Assert.IsNotNull(paths[0].Route.Length);
            Assert.IsNotNull(paths[0].Route.Points[0]);
            Assert.AreEqual(paths[0].Route.Points[1].Measure, 40.7164345497407);
            Assert.IsNotNull(paths[0].Route.Type);
            Assert.AreEqual(paths[0].Route.MaxM, 66);
            Assert.AreEqual(paths[0].Route.MinM, 0.0);
            Assert.AreEqual(paths[0].StopIndexes[0], 0);
            Assert.AreEqual(paths[0].StopIndexes[1], 3);
            Assert.AreEqual(paths[0].Route.Type, GeometryType.LINEM);
        }
        public void ComputeWeightMatrix_IDError()
        {
            NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");

            TransportationAnalystParameter parameter = new TransportationAnalystParameter();
            parameter.WeightFieldName = "length";
            parameter.TurnWeightField = "TurnCost";
            List<int> nodes = new List<int>() { -2, 6, 9 };
            try
            {
                double[][] weightMatrix = networkAnalyst.ComputeWeightMatrix("RoadNet@Changchun", nodes.ToArray());
            }
            catch (ServiceException exception)
            {
                //Assert.IsTrue("执行 findWeightMatrix 操作时出错,原因是:网络数据集中节点ID数组错误" == exception.Message);
                Assert.IsTrue(exception.Code == 400);
            }
        }
        public void TSPPathTest_ParameterNUll()
        {
            NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");
            int[] nodeIDs = new int[] { 2, 3 };
            TransportationAnalystParameter parameter = new TransportationAnalystParameter();
            parameter.WeightFieldName = "length";
            parameter.TurnWeightField = "TurnCost";
            List<TSPPath> paths = networkAnalyst.FindTSPPath("RoadNet@Changchun", nodeIDs, false, null);

            Assert.IsNotNull(paths);
            Assert.IsNotNull(paths[0]);
            Assert.IsNotNull(paths[0].EdgeIDs[0]);
            Assert.IsNotNull(paths[0].NodeIDs[0]);
            Assert.IsNotNull(paths[0].Route);
            Assert.IsNotNull(paths[0].Route.Length);
            Assert.IsNotNull(paths[0].Route.Points[0]);
            Assert.AreEqual(paths[0].Route.Points[1].Measure, 42.273803871316005);
            Assert.IsNotNull(paths[0].Route.Type);
            Assert.AreEqual(paths[0].Route.MaxM, 53);
            Assert.AreEqual(paths[0].Route.MinM, 0.0);
            Assert.AreEqual(paths[0].StopWeights[0], 53);
            Assert.AreEqual(paths[0].Weight, 53);
            Assert.AreEqual(paths[0].StopIndexes[0], 0);
            Assert.AreEqual(paths[0].StopIndexes[1], 1);
        }
        public void FindPathTest_networkDatasetName()
        {
            int[] nodeIDs = new int[] { 2, 3 };
            //string networkDatasetName = "RoadNet@Changchun";
            TransportationAnalystParameter parameter = new TransportationAnalystParameter();
            parameter.ResultSetting = new TransportationAnalystResultSetting();
            parameter.WeightFieldName = "length";
            parameter.TurnWeightField = "TurnCost";

            NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");
            try
            {
                List<Path> paths = networkAnalyst.FindPath(string.Empty, nodeIDs, true, parameter);
            }
            catch (ArgumentException e)
            {
                Assert.AreEqual(e.Message, "参数不能为空。\r\n参数名: networkDatasetName");
            }
        }
        public void FindClosestFacilityTest_Point_TAParameterNULL()
        {
            string networkDatasetName = "RoadNet@Changchun";
            Point2D[] facilities = new Point2D[3];
            facilities[0] = new Point2D(70.1515638201, -54.7406354454);
            facilities[1] = new Point2D(550.6770595320, -56.1050211383);
            facilities[2] = new Point2D(445.6471889264, -229.2074549041);
            Point2D eventPoint = new Point2D(119.6100397551, -122.6278394459);
            int expectFacilityCount = 2;
            bool fromEvent = false;
            double maxWeight = 0;

            NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");
            List<ClosestFacilityPath<Point2D>> pathResult = networkAnalyst.FindClosestFacility(networkDatasetName, facilities,
                eventPoint, expectFacilityCount, fromEvent, maxWeight, null);
            Assert.IsNotNull(pathResult);
            Assert.AreEqual(pathResult.Count, 2);
            Assert.AreEqual(pathResult[0].FacilityIndex, 0);
            Assert.AreEqual(pathResult[0].Facility.X, 70.1515638201);
            Assert.AreEqual(pathResult[0].Facility.Y, -54.7406354454);
            Assert.AreEqual(pathResult[1].FacilityIndex, 1);
            Assert.AreEqual(pathResult[1].Facility.X, 550.677059532);
            Assert.AreEqual(pathResult[1].Facility.Y, -56.1050211383);
            Assert.AreEqual(pathResult[0].Weight, 125);
            Assert.AreEqual(pathResult[1].Weight, 454);
            Assert.IsNotNull(pathResult[0].Route);
            Assert.IsNull(pathResult[0].PathGuideItems);
            Assert.IsNotNull(pathResult[0].NodeIDs);
            Assert.IsNull(pathResult[0].NodeFeatures);
            Assert.IsNull(pathResult[0].EdgeFeatures);
            Assert.IsNotNull(pathResult[0].EdgeIDs);
        }
        public void FindServiceArea_CenterPoints()
        {
            NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");

            Point2D[] centerPoints = new Point2D[1];
            centerPoints[0] = new Point2D() { X = 4978.55537676716, Y = -2574.77869765731 };
            double[] weights = new double[] { 300 };
            TransportationAnalystParameter parameter = new TransportationAnalystParameter();
            parameter.WeightFieldName = "length";
            parameter.TurnWeightField = "TurnCost";
            List<ServiceAreaResult> result = networkAnalyst.FindServiceArea("RoadNet@Changchun", centerPoints, weights, true, false, parameter);
            Assert.IsNotNull(result);
            Assert.IsTrue(result.Count == 1);
            Assert.IsNotNull(result[0]);
            Assert.IsTrue(result[0].NodeIDs.Count == 19);
            Assert.IsTrue(result[0].EdgeIDs.Count == 38);
            Assert.IsTrue(result[0].Routes.Count == 40);
        }
        public void FindServiceArea_IsFromCenterFalse()
        {
            NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");

            Point2D[] centerPoints = new Point2D[1];
            centerPoints[0] = new Point2D() { X = 4978.55537676716, Y = -2574.77869765731 };
            double[] weights = new double[] { 300 };
            TransportationAnalystParameter parameter = new TransportationAnalystParameter();
            parameter.ResultSetting = new TransportationAnalystResultSetting();

            parameter.WeightFieldName = "length";
            parameter.TurnWeightField = "TurnCost";
            try
            {
                List<ServiceAreaResult> result = networkAnalyst.FindServiceArea("RoadNet@Changchun", centerPoints, weights, false, false, parameter);
                Assert.IsNotNull(result);
                Assert.IsTrue(result.Count == 1);
                Assert.IsTrue(result[0] != null);
                Assert.IsTrue(result[0].NodeIDs.Count == 19);
            }
            catch (ServiceException e)
            {
                Assert.IsTrue(e.Code == 400);
            }
        }
        public void FindServiceArea_NodeIDs()
        {
            NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");

            int[] centerIDs = new int[] { 2, 4, 6 };
            double[] weights = new double[] { 500, 1000, 500 };
            TransportationAnalystParameter parameter = new TransportationAnalystParameter();
            parameter.WeightFieldName = "length";
            parameter.TurnWeightField = "TurnCost";
            List<ServiceAreaResult> result = networkAnalyst.FindServiceArea("RoadNet@Changchun", centerIDs, weights, true, false, parameter);
            Assert.IsNotNull(result);
            Assert.IsTrue(result.Count == 3);
            Assert.IsNotNull(result[0]);
            Assert.IsTrue(result[0].NodeIDs.Count == 16);
            Assert.IsTrue(result[0].EdgeIDs.Count == 19);
            Assert.IsTrue(result[0].Routes.Count == 19);
        }
 public void FindLocation_CountSet()
 {
     NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");
     LocationAnalystParameter parameter = new LocationAnalystParameter();
     parameter.WeightName = "length";
     parameter.TurnWeightField = "TurnCost";
     parameter.ReturnEdgeFeatures = true;
     parameter.ReturnEdgeGeometry = true;
     parameter.ReturnNodeFeatures = true;
     parameter.IsFromCenter = true;
     parameter.SupplyCenters = new List<SupplyCenter>();
     parameter.SupplyCenters.Add(new SupplyCenter() { NodeID = -11, MaxWeight = 100, Type = SupplyCenterType.FIXEDCENTER });
     parameter.SupplyCenters.Add(new SupplyCenter() { NodeID = 12, MaxWeight = 100, Type = SupplyCenterType.OPTIONALCENTER });
     parameter.ExpectedSupplyCenterCount = 1;
     LocationAnalystResult result = networkAnalyst.FindLocation("RoadNet@Changchun", parameter);
     Assert.IsNotNull(result);
     Assert.IsTrue(result.DemandResults != null);
     Assert.IsTrue(result.DemandResults.Count == 0);
     Assert.IsTrue(result.SupplyResults.Count == 1);
     Assert.IsTrue(result.SupplyResults != null);
     Assert.IsTrue(result.SupplyResults[0].AverageWeight == -1.0);
 }
 public void FindLocation_NetworkDatasetNameNotFound()
 {
     NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");
     LocationAnalystParameter parameter = new LocationAnalystParameter();
     parameter.WeightName = "length";
     parameter.TurnWeightField = "TurnCost";
     parameter.ReturnEdgeFeatures = true;
     parameter.ReturnEdgeGeometry = true;
     parameter.ReturnNodeFeatures = true;
     parameter.IsFromCenter = true;
     parameter.SupplyCenters = new List<SupplyCenter>();
     parameter.SupplyCenters.Add(new SupplyCenter() { NodeID = 11, MaxWeight = 100, Type = SupplyCenterType.FIXEDCENTER });
     parameter.SupplyCenters.Add(new SupplyCenter() { NodeID = 12, MaxWeight = 100, Type = SupplyCenterType.OPTIONALCENTER });
     parameter.ExpectedSupplyCenterCount = 2;
     try
     {
         LocationAnalystResult result = networkAnalyst.FindLocation("RoadNet1@Changchun", parameter);
     }
     catch (ServiceException exception)
     {
         Assert.IsTrue("不存在RoadNet1@Changchun对应的网络数据集。" == exception.Message);
         Assert.IsTrue(exception.Code == 400);
     }
 }
        public void FindClosestFacilityTest_Point_DatasetNULL()
        {
            //string networkDatasetName = "RoadNet@Changchun";
            Point2D[] facilities = new Point2D[3];
            facilities[0] = new Point2D(70.1515638201, -54.7406354454);
            facilities[1] = new Point2D(550.6770595320, -56.1050211383);
            facilities[2] = new Point2D(445.6471889264, -229.2074549041);
            Point2D eventPoint = new Point2D(119.6100397551, -122.6278394459);
            int expectFacilityCount = 2;
            bool fromEvent = false;
            double maxWeight = 0;
            TransportationAnalystParameter parameter = new TransportationAnalystParameter();
            parameter.WeightFieldName = "length";
            parameter.TurnWeightField = "TurnCost";

            NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");
            try
            {
                List<ClosestFacilityPath<Point2D>> pathResult = networkAnalyst.FindClosestFacility(string.Empty, facilities,
                    eventPoint, expectFacilityCount, fromEvent, maxWeight, parameter);
            }
            catch (ArgumentException e)
            {
                Assert.AreEqual(e.Message, "参数不能为空。\r\n参数名: networkDatasetName");
            }
        }
 public void TSPPathTest_IDNUll()
 {
     NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");
     int[] nodeIDs = new int[] { };
     TransportationAnalystParameter parameter = new TransportationAnalystParameter();
     parameter.WeightFieldName = "length";
     parameter.TurnWeightField = "TurnCost";
     try
     {
         List<TSPPath> path = networkAnalyst.FindTSPPath("RoadNet@Changchun", nodeIDs, false, parameter);
     }
     catch (ArgumentException e)
     {
         Assert.AreEqual(e.Message, "参数 nodeIDsToVisit 不合法,必须至少包含两个二维点。");
     }
 }
        public void FindPathTest_Points_ParameterNUll()
        {
            Point2D[] points = new Point2D[2];
            points[0] = new Point2D(119.6100397551, -122.6278394459);
            points[1] = new Point2D(171.9035599945, -113.2491141857);
            string networkDatasetName = "RoadNet@Changchun";

            NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");
            List<Path> paths = networkAnalyst.FindPath(networkDatasetName, points, true, null);
            Assert.IsNotNull(paths);
            Assert.IsNotNull(paths[0]);
            Assert.IsNotNull(paths[0].EdgeIDs[0]);
            Assert.IsNotNull(paths[0].NodeIDs[0]);
            Assert.IsNotNull(paths[0].Route);
            Assert.IsNotNull(paths[0].Route.Length);
            Assert.IsNotNull(paths[0].Route.Points[0]);
            Assert.AreEqual(paths[0].Route.Points[1].Measure, 42.273803871316005);
            Assert.IsNotNull(paths[0].Route.Type);
            Assert.AreEqual(paths[0].Route.MaxM, 53);
            Assert.AreEqual(paths[0].Route.MinM, 0.0);
            Assert.AreEqual(paths[0].StopWeights[0], 53);
            Assert.AreEqual(paths[0].Weight, 53);
        }
        public void FindPathTest_Parameter()
        {
            int[] nodeIDs = new int[] { 2, 3 };
            string networkDatasetName = "RoadNet@Changchun";
            TransportationAnalystParameter parameter = new TransportationAnalystParameter();
            parameter.ResultSetting = new TransportationAnalystResultSetting();
            parameter.WeightFieldName = "length";
            parameter.TurnWeightField = "TurnCost";

            NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");
            List<Path> paths = networkAnalyst.FindPath(networkDatasetName, nodeIDs, true, parameter);
            Assert.IsNotNull(paths);
            Assert.IsNotNull(paths[0]);
            Assert.IsNull(paths[0].EdgeFeatures);
            Assert.AreEqual(paths[0].EdgeIDs.Count(), 1);
            Assert.IsNull(paths[0].NodeFeatures);
            Assert.AreEqual(paths[0].NodeIDs.Count(), 2);
            Assert.IsNull(paths[0].PathGuideItems);
            Assert.IsNotNull(paths[0].Route);
            Assert.AreEqual(paths[0].Weight, 53);
            Assert.AreEqual(paths[0].StopWeights[0], 53);

        }
        public void FindClosestFacilityTest_Point_Geometry()
        {
            string networkDatasetName = "RoadNet@Changchun";
            Point2D[] facilities = new Point2D[3];
            facilities[0] = new Point2D(70.1515638201, -54.7406354454);
            facilities[1] = new Point2D(550.6770595320, -56.1050211383);
            facilities[2] = new Point2D(445.6471889264, -229.2074549041);
            Point2D eventPoint = new Point2D(119.6100397551, -122.6278394459);
            int expectFacilityCount = 2;
            bool fromEvent = false;
            double maxWeight = 0;
            TransportationAnalystParameter parameter = new TransportationAnalystParameter();
            parameter.WeightFieldName = "length";
            parameter.TurnWeightField = "TurnCost";
            parameter.ResultSetting = new TransportationAnalystResultSetting();
            parameter.ResultSetting.ReturnEdgeFeatures = false;
            parameter.ResultSetting.ReturnEdgeGeometry = true;
            parameter.ResultSetting.ReturnEdgeIDs = true;
            parameter.ResultSetting.ReturnNodeFeatures = false;
            parameter.ResultSetting.ReturnNodeGeometry = true;
            parameter.ResultSetting.ReturnNodeIDs = true;
            parameter.ResultSetting.ReturnPathGuides = true;
            parameter.ResultSetting.ReturnRoutes = true;

            NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");
            List<ClosestFacilityPath<Point2D>> pathResult = networkAnalyst.FindClosestFacility(networkDatasetName, facilities,
                eventPoint, expectFacilityCount, fromEvent, maxWeight, parameter);
            Assert.IsNotNull(pathResult);
            Assert.AreEqual(pathResult.Count, 2);
            Assert.AreEqual(pathResult[0].FacilityIndex, 0);
            Assert.AreEqual(pathResult[0].Facility.X, 70.1515638201);
            Assert.AreEqual(pathResult[0].Facility.Y, -54.7406354454);
            Assert.AreEqual(pathResult[1].FacilityIndex, 1);
            Assert.AreEqual(pathResult[1].Facility.X, 550.677059532);
            Assert.AreEqual(pathResult[1].Facility.Y, -56.1050211383);
            Assert.AreEqual(pathResult[0].Weight, 125);
            Assert.AreEqual(pathResult[1].Weight, 484);
            Assert.IsNotNull(pathResult[0].StopWeights);
            Assert.IsNotNull(pathResult[0].Route);
            Assert.IsNotNull(pathResult[0].PathGuideItems);
            Assert.IsNotNull(pathResult[0].NodeIDs);
            Assert.IsNotNull(pathResult[0].EdgeIDs);
        }
        public void FindPathTest_Points_RouteType()
        {
            Point2D[] points = new Point2D[2];
            points[0] = new Point2D(119.6100397551, -122.6278394459);
            points[1] = new Point2D(171.9035599945, -113.2491141857);
            string networkDatasetName = "RoadNet@Changchun";

            NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");
            List<Path> paths = networkAnalyst.FindPath(networkDatasetName, points, true, null);
            Assert.IsNotNull(paths);
            Assert.IsNotNull(paths[0]);
            Assert.AreEqual(paths[0].Route.Type, GeometryType.LINEM);
        }
 public void TSPPathTest_DatasetNameNUll()
 {
     NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");
     int[] nodeIDs = new int[] { 2, 3 };
     TransportationAnalystParameter parameter = new TransportationAnalystParameter();
     parameter.WeightFieldName = "length";
     parameter.TurnWeightField = "TurnCost";
     try
     {
         List<TSPPath> path = networkAnalyst.FindTSPPath(string.Empty, nodeIDs, false, parameter);
     }
     catch (ArgumentNullException e)
     {
         Assert.AreEqual(e.Message, "参数不能为空。\r\n参数名: networkDatasetName");
     }
 }
        public void FindPathTest_Points_Parameter()
        {
            Point2D[] points = new Point2D[2];
            points[0] = new Point2D(119.6100397551, -122.6278394459);
            points[1] = new Point2D(171.9035599945, -113.2491141857);
            string networkDatasetName = "RoadNet@Changchun";
            TransportationAnalystParameter parameter = new TransportationAnalystParameter();
            parameter.ResultSetting = new TransportationAnalystResultSetting();
            parameter.WeightFieldName = "length";
            parameter.TurnWeightField = "TurnCost";

            NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");
            List<Path> paths = networkAnalyst.FindPath(networkDatasetName, points, true, parameter);
            Assert.IsNotNull(paths);
            Assert.IsNotNull(paths[0]);
            Assert.IsNull(paths[0].EdgeFeatures);
            Assert.AreEqual(paths[0].EdgeIDs.Count(), 1);
            Assert.IsNull(paths[0].NodeFeatures);
            Assert.AreEqual(paths[0].NodeIDs.Count(), 2);
            Assert.IsNull(paths[0].PathGuideItems);
            Assert.IsNotNull(paths[0].Route);
            Assert.AreEqual(paths[0].Weight, 53);
            Assert.AreEqual(paths[0].StopWeights[0], 53);

        }
        public void TSPPathTest_Point()
        {
            NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");
            Point2D[] points = new Point2D[4];
            points[0] = new Point2D(119.6100397551, -122.6278394459);
            points[1] = new Point2D(171.9035599945, -113.2491141857);
            points[2] = new Point2D(181.9035599945, -123.2491141857);
            points[3] = new Point2D(161.9035599945, -123.2491141857);
            TransportationAnalystParameter parameter = new TransportationAnalystParameter();
            parameter.WeightFieldName = "length";
            parameter.TurnWeightField = "TurnCost";
            parameter.ResultSetting = new TransportationAnalystResultSetting();
            parameter.ResultSetting.ReturnEdgeFeatures = true;
            parameter.ResultSetting.ReturnEdgeGeometry = true;
            parameter.ResultSetting.ReturnEdgeIDs = true;
            parameter.ResultSetting.ReturnNodeFeatures = true;
            parameter.ResultSetting.ReturnNodeGeometry = true;
            parameter.ResultSetting.ReturnNodeIDs = true;
            parameter.ResultSetting.ReturnPathGuides = true;
            parameter.ResultSetting.ReturnRoutes = true;

            List<TSPPath> paths = networkAnalyst.FindTSPPath("RoadNet@Changchun", points, false, parameter);

            Assert.IsNotNull(paths);
            Assert.IsNotNull(paths[0]);
            Assert.IsNotNull(paths[0].EdgeFeatures[0]);
            Assert.IsNotNull(paths[0].EdgeIDs[0]);
            Assert.IsNotNull(paths[0].NodeFeatures[0]);
            Assert.IsNotNull(paths[0].NodeIDs[0]);
            Assert.IsNotNull(paths[0].PathGuideItems[0]);
            Assert.IsNotNull(paths[0].Route);
            Assert.IsNotNull(paths[0].Route.Length);
            Assert.IsNotNull(paths[0].Route.Points[0]);
            Assert.AreEqual(paths[0].Route.Points[1].Measure, 40.716434549740718);
            Assert.IsNotNull(paths[0].Route.Type);
            Assert.AreEqual(paths[0].Route.MaxM, 66);
            Assert.AreEqual(paths[0].Route.MinM, 0.0);
            Assert.AreEqual(paths[0].StopIndexes[0], 0);
            Assert.AreEqual(paths[0].StopIndexes[1], 3);
            Assert.AreEqual(paths[0].Route.Type, GeometryType.LINEM);
        }
        public void FindPathTest_PointssNull1()
        {
            Point2D[] points = new Point2D[1];
            string networkDatasetName = "RoadNet@Changchun";
            TransportationAnalystParameter parameter = new TransportationAnalystParameter();
            parameter.ResultSetting = new TransportationAnalystResultSetting();
            parameter.WeightFieldName = "length";
            parameter.TurnWeightField = "TurnCost";

            NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");
            try
            {
                List<Path> paths = networkAnalyst.FindPath(networkDatasetName, points, true, parameter);
            }
            catch (ArgumentException e)
            {
                Assert.AreEqual(e.Message, "参数 points 不合法,必须至少包含两个二维点。");
            }
        }
        public void TSPPathTest_PointPointNull()
        {
            NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");
            Point2D[] points = new Point2D[1];
            points[0] = new Point2D(119.6100397551, -122.6278394459);

            TransportationAnalystParameter parameter = new TransportationAnalystParameter();
            parameter.WeightFieldName = "length";
            parameter.TurnWeightField = "TurnCost";
            try
            {
                List<TSPPath> paths = networkAnalyst.FindTSPPath("RoadNet@Changchun", points, false, parameter);
            }
            catch (ArgumentException e)
            {
                Assert.AreEqual(e.Message, "参数 pointsToVisit 不合法,必须至少包含两个二维点。");
            }

        }
        public void FindPathTest_Points_networkDatasetNameNull()
        {
            Point2D[] points = new Point2D[2];
            points[0] = new Point2D(119.6100397551, -122.6278394459);
            points[1] = new Point2D(171.9035599945, -113.2491141857);
            //string networkDatasetName = "RoadNet@Changchun";
            TransportationAnalystParameter parameter = new TransportationAnalystParameter();
            parameter.ResultSetting = new TransportationAnalystResultSetting();
            parameter.WeightFieldName = "length";
            parameter.TurnWeightField = "TurnCost";

            NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");
            try
            {
                List<Path> paths = networkAnalyst.FindPath(string.Empty, points, true, parameter);
            }
            catch (ArgumentException e)
            {
                Assert.AreEqual(e.Message, "参数不能为空。\r\n参数名: networkDatasetName");
            }
        }
        public void MTSPPathTest_Point()
        {
            NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");
            Point2D[] points = new Point2D[4];
            points[0] = new Point2D(119.6100397551, -122.6278394459);
            points[1] = new Point2D(171.9035599945, -113.2491141857);
            points[2] = new Point2D(181.9035599945, -123.2491141857);
            points[3] = new Point2D(161.9035599945, -123.2491141857);
            Point2D[] centerPoints = new Point2D[2];
            centerPoints[0] = new Point2D(111.6100397551, -111.6278394459);
            centerPoints[1] = new Point2D(171.9035599945, -133.2491141857);

            List<MTSPPath<Point2D>> paths = networkAnalyst.FindMTSPPath("RoadNet@Changchun", points, centerPoints, false, null);

            Assert.IsNotNull(paths);
            Assert.IsNotNull(paths[0]);
            Assert.AreEqual(paths[0].StopIndexes[0], 0);
            Assert.AreEqual(paths[1].StopIndexes.Length, 3);
            Assert.AreEqual(paths[0].Center.X, 111.6100397551);
            Assert.AreEqual(paths[1].Center.X, 171.9035599945);
            Assert.AreEqual(paths[0].NodesVisited.Length, 1);
            Assert.AreEqual(paths[1].NodesVisited.Length, 3);
            Assert.IsNotNull(paths[0].EdgeIDs[0]);
            Assert.IsNotNull(paths[0].NodeIDs[0]);
            Assert.IsNotNull(paths[0].Route);
            Assert.IsNotNull(paths[0].Route.Length);
            Assert.IsNotNull(paths[0].Route.Points[0]);
        }
        public void FindClosestFacilityTest_ID_DatasetNULL()
        {
            //string networkDatasetName = "RoadNet@Changchun";
            int[] facilityIDs = new int[] { 1, 6, 52 };
            int eventID = 2;
            int expectFacilityCount = 2;
            bool fromEvent = false;
            double maxWeight = 0;
            TransportationAnalystParameter parameter = new TransportationAnalystParameter();
            parameter.WeightFieldName = "length";
            parameter.TurnWeightField = "TurnCost";

            NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");
            try
            {
                List<ClosestFacilityPath<int>> pathResult = networkAnalyst.FindClosestFacility(string.Empty, facilityIDs,
                    eventID, expectFacilityCount, fromEvent, maxWeight, parameter);
            }
            catch (ArgumentException e)
            {
                Assert.AreEqual(e.Message, "参数不能为空。\r\n参数名: networkDatasetName");
            }
        }
        public void FindClosestFacilityTest_ID_TAParameterNULL()
        {
            string networkDatasetName = "RoadNet@Changchun";
            int[] facilityIDs = new int[] { 1, 6, 52 };
            int eventID = 2;
            int expectFacilityCount = 2;
            bool fromEvent = false;
            double maxWeight = 0;

            NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");
            List<ClosestFacilityPath<int>> pathResult = networkAnalyst.FindClosestFacility(networkDatasetName, facilityIDs,
                eventID, expectFacilityCount, fromEvent, maxWeight, null);
            Assert.IsNotNull(pathResult);
            Assert.AreEqual(pathResult.Count, 2);
            Assert.AreEqual(pathResult[0].FacilityIndex, 0);
            Assert.AreEqual(pathResult[0].Facility, 1);
            Assert.AreEqual(pathResult[1].FacilityIndex, 1);
            Assert.AreEqual(pathResult[1].Facility, 6);
            Assert.AreEqual(pathResult[0].Weight, 125);
            Assert.AreEqual(pathResult[1].Weight, 454);
            Assert.IsNotNull(pathResult[0].Route);
            Assert.IsNull(pathResult[0].PathGuideItems);
            Assert.IsNotNull(pathResult[0].NodeIDs);
            Assert.IsNull(pathResult[0].NodeFeatures);
            Assert.IsNull(pathResult[0].EdgeFeatures);
            Assert.IsNotNull(pathResult[0].EdgeIDs);
        }
        public void ComputeWeightMatrix_NodeIDs()
        {
            NetworkAnalyst networkAnalyst = new NetworkAnalyst("http://" + ip + ":8090/iserver/services/transportationanalyst-sample/rest");

            TransportationAnalystParameter parameter = new TransportationAnalystParameter();
            parameter.WeightFieldName = "length";
            parameter.TurnWeightField = "TurnCost";
            List<int> nodes = new List<int>() { 2, 6, 9 };
            double[][] weightMatrix = networkAnalyst.ComputeWeightMatrix("RoadNet@Changchun", nodes.ToArray(), null);

            Assert.IsNotNull(weightMatrix);
            Assert.IsTrue(weightMatrix.Length == 3);
            Assert.IsTrue(weightMatrix[0].Length == 3);
            Assert.IsTrue(weightMatrix[0][1] == 454);
        }