C# (CSharp) RouteAnalysis示例

示例#1

        protected virtual void MapHandler(object sender, EventArgs e)
        {
            var result = new RouteAnalysis(app.Context);
            var curr   = (AppState)null;
            var ctx    = new HttpContextEx(app.Context);
            var msg    = new Message(ctx);

            if (result.IsRoutable)
            {
                try
                {
                    curr = GetRoot(ctx);

                    foreach (var path in result)
                    {
                        msg.Text = path;
                        curr     = TranslateNull(curr.Next(msg), app.Context);
                    }
                }
                catch (ArcException ex)
                {
                    if (ex.CanHandle)
                    {
                        curr = ex.AppState;
                    }
                    else
                    {
                        throw;
                    }
                }

                app.Context.RemapHandler(curr.GetRepresentation(ctx));
            }
        }

示例#2

        public async Task OnGet()
        {
            InputModel input       = null;
            InputModel backupInput = null;

            try
            {
                input = await _liveDataSource
                        .Get <InputModel>()
                        .ConfigureAwait(false);

#if !DEBUG
                await _backupService
                .Add(JsonConvert.SerializeObject(input))
                .ConfigureAwait(false);
#endif
                string backupDataSerialised = await _backupService.GetOldest();

                backupInput = JsonConvert.DeserializeObject <InputModel>(backupDataSerialised);
            }
            catch (Exception)
            {
                // Yep.
            }

            if (input == null)
            {
                return;
            }

            Scoreboard oldScoreboard = null;

            if (backupInput != null)
            {
                var backupParsedInput = new InputParser(backupInput);

                oldScoreboard = new Scoreboard(backupParsedInput.Climbers, null);
            }

            var parsedInput = new InputParser(input);

            Scoreboard    = new Scoreboard(parsedInput.Climbers, oldScoreboard?.AnalysedClimbersInRankOrder);
            Narrator      = new ScoreboardNarrator(oldScoreboard, Scoreboard);
            RouteAnalysis = new RouteAnalysis(parsedInput.Climbers, MaxPopularRoutes);
        }

示例#3

        public void AscentsByGrade_GivenRoutes_ShouldReturnCorrectAscentCountsByGrade()
        {
            // Arrange.
            var climbers = new List <IClimber>
            {
                Substitute.For <IClimber>(),
                Substitute.For <IClimber>()
            };

            var climber1 = climbers[0];
            var climber2 = climbers[1];

            climber1
            .Routes
            .Returns(
                new[]
            {
                Route.Create("Route1 (19)"),
                Route.Create("Route2 (21)"),
                Route.Create("RouteX")
            });

            climber2
            .Routes
            .Returns(
                new[]
            {
                Route.Create("Route1 (19)"),
                Route.Create("Route2 (21)"),
                Route.Create("Route3 (16)")
            });

            // Act.
            var testObject = new RouteAnalysis(climbers, 3);

            // Assert.
            Assert.AreEqual(3, testObject.AscentsByGrade.Keys.Count());
            Assert.AreEqual(1, testObject.AscentsByGrade[16]);
            Assert.AreEqual(2, testObject.AscentsByGrade[19]);
            Assert.AreEqual(2, testObject.AscentsByGrade[21]);
        }

示例#4

        public void PopularRoutes_GivenRoutes_ShouldReturnCorrectAscentCounts()
        {
            // Arrange.
            var climbers = new List <IClimber>
            {
                Substitute.For <IClimber>(),
                Substitute.For <IClimber>()
            };

            var climber1 = climbers[0];
            var climber2 = climbers[1];

            climber1
            .Routes
            .Returns(
                new[]
            {
                Route.Create("Route1"),
                Route.Create("Route2")
            });

            climber2
            .Routes
            .Returns(
                new[]
            {
                Route.Create("Route1"),
                Route.Create("Route2"),
                Route.Create("Route3")
            });

            // Act.
            var testObject = new RouteAnalysis(climbers, 3);

            // Assert.
            Assert.AreEqual(2, testObject.PopularRoutes.ElementAt(0).AscentCount);
            Assert.AreEqual(2, testObject.PopularRoutes.ElementAt(1).AscentCount);
            Assert.AreEqual(1, testObject.PopularRoutes.ElementAt(2).AscentCount);
        }

示例#5

        public void PopularRoutes_GivenLimit_ShouldReturnNoMoreRoutesThanLimit()
        {
            // Arrange.
            var climbers = new List <IClimber>
            {
                Substitute.For <IClimber>(),
                Substitute.For <IClimber>()
            };

            var climber1 = climbers[0];
            var climber2 = climbers[1];

            climber1
            .Routes
            .Returns(
                new[]
            {
                Route.Create("Route1"),
                Route.Create("Route2")
            });

            climber2
            .Routes
            .Returns(
                new[]
            {
                Route.Create("Route1"),
                Route.Create("Route2"),
                Route.Create("Route3")
            });

            // Act.
            var testObject = new RouteAnalysis(climbers, 2);

            // Assert.
            Assert.AreEqual(2, testObject.PopularRoutes.Count());
        }