public float getScoreFromList(string accountId, List <MatchDetail> listMatchDetail)
        {
            List <Participant> listMatchStats = getListMatchStats(accountId, listMatchDetail);
            List <float>       scores         = new List <float>();

            foreach (Participant participant in listMatchStats)
            {
                if (participant == null)
                {
                    break;
                }
                CalculatorTemplate calculator;
                var lane = participant.timeline.lane;
                switch (lane)
                {
                case "JUNGLE":
                    calculator = new JungleCalculator(participant);
                    break;

                case "TOP":
                    calculator = new TopCalculator(participant);
                    break;

                case "MIDDLE":
                    calculator = new MidCalculator(participant);
                    break;

                case "BOTTOM":
                    var role = participant.timeline.role;
                    if (role.Equals("DUO_CARRY"))
                    {
                        calculator = new ADCCalculator(participant);
                    }
                    else if (role.Equals("DUO_SUPPORT"))
                    {
                        calculator = new SupportCalculator(participant);
                    }
                    else
                    {
                        calculator = new DefaultCalculator(participant);
                    }
                    break;

                default:
                    calculator = new DefaultCalculator(participant);
                    break;
                }

                scores.Add(calculator.templateMethod());
            }

            if (scores.Count == 0)
            {
                return(0f);
            }
            return(scores.Average());
        }
Exemplo n.º 2
0
        public void TestMainSearcher()
        {
            //Arrange
            var         arguments             = new string[] { "java", ".net" };
            var         searchTerm            = new SearchTerm(arguments);
            ICalculator calculator            = new DefaultCalculator();
            var         yahooJavaSearchResult = new SearchResult {
                ResultsCount = 100, SearchEngine = "Yahoo", SearchTerm = "java"
            };
            var yahooDotNetSearchResult = new SearchResult {
                ResultsCount = 20, SearchEngine = "Yahoo", SearchTerm = ".net"
            };
            var yandexJavaSearchResult = new SearchResult {
                ResultsCount = 50, SearchEngine = "Yandex", SearchTerm = "java"
            };
            var yandexDotNetSearchResult = new SearchResult {
                ResultsCount = 80, SearchEngine = "Yandex", SearchTerm = ".net"
            };

            var moqYahooSearcher = new Mock <Searcher>();

            moqYahooSearcher.Setup(s => s.Search(It.Is <string>(term => term == "java"))).ReturnsAsync(yahooJavaSearchResult);
            moqYahooSearcher.Setup(s => s.Search(It.Is <string>(term => term == ".net"))).ReturnsAsync(yahooDotNetSearchResult);

            var moqYandexSearcher = new Mock <Searcher>();

            moqYandexSearcher.Setup(s => s.Search(It.Is <string>(term => term == "java"))).ReturnsAsync(yandexJavaSearchResult);
            moqYandexSearcher.Setup(s => s.Search(It.Is <string>(term => term == ".net"))).ReturnsAsync(yandexDotNetSearchResult);

            var searchers = new List <Searcher> {
                moqYahooSearcher.Object, moqYandexSearcher.Object
            };
            SearchService mainSearcher = new SearchService(searchTerm, searchers, calculator);

            //Act
            mainSearcher.Search().Wait();

            //Assert
            var searchResults = mainSearcher.SearchResults.ToArray();

            Assert.AreSame(yahooJavaSearchResult, searchResults[0]);
            Assert.AreSame(yandexJavaSearchResult, searchResults[2]);

            //Winner per engine
            Assert.AreEqual("java", mainSearcher.WinnersPerEngine["Yahoo"].SearchTerm);
            Assert.AreEqual(".net", mainSearcher.WinnersPerEngine["Yandex"].SearchTerm);

            //Total winner
            Assert.AreEqual("java", mainSearcher.TotalWinner.SearchTerm);
            Assert.AreEqual(150, mainSearcher.TotalWinner.SearchResultsCount);
        }
        public static IStatusCalculator CreateCalculator(string statusCalculatorName)
        {
            IStatusCalculator calculator;

            switch (statusCalculatorName)
            {
            case "WeightedAnswer":
                calculator = new WeightedAnswerCalculator();
                break;

            default:
                calculator = new DefaultCalculator();
                break;
            }

            return(calculator);
        }
Exemplo n.º 4
0
        static async Task MainAsync(string[] args)
        {
            var         searchTerm = new SearchTerm(args);
            var         searchers  = GetSearchers();
            ICalculator calculator = new DefaultCalculator();
            var         searcher   = new SearchService(searchTerm, searchers, calculator);

            await searcher.Search();

            IFormatter formatter = new DefaultFormatter();
            var        sb        = new StringBuilder();

            sb.Append(formatter.FormatResultsPerTerm(searcher.ResultsPerTerm));
            sb.Append(formatter.FormatWinnersPerEngine(searcher.WinnersPerEngine));
            sb.Append(formatter.FormatTotalWinner(searcher.TotalWinner));

            Console.WriteLine(sb);
            Console.ReadLine();
        }