public async Task NgramSentiment()
        {
            ActualWordsHandler.InstanceOpen.Container.Context.DisableFeatureSentiment = true;
            var words = Path.Combine(TestContext.CurrentContext.TestDirectory, @"Adjustment/words.csv");
            ISentimentDataHolder lexicon = SentimentDataHolder.Load(words);

            var loader = SentimentDataHolder.Load(new[] { "veto it really" }.Select(item =>
                                                                                    new WordSentimentValueData(
                                                                                        item,
                                                                                        new SentimentValueData(2))));

            lexicon.Merge(loader);

            var text   = "I Veto it really";
            var result = await ActualWordsHandler.InstanceOpen.TextSplitter.Process(new ParseRequest(text)).ConfigureAwait(false);

            var document = result.Construct(ActualWordsHandler.InstanceOpen.WordFactory);

            ActualWordsHandler.InstanceOpen.Container.Context.Lexicon = lexicon;
            Text.Data.IParsedReview review = ActualWordsHandler.InstanceOpen.Container.Resolve <Func <Document, IParsedReviewManager> >()(document).Create();
            Assert.AreEqual(1, review.CalculateRawRating().StarsRating);

            ActualWordsHandler.InstanceOpen.Container.Context.NGram = 3;
            review = ActualWordsHandler.InstanceOpen.Container.Resolve <Func <Document, IParsedReviewManager> >()(document).Create();
            Assert.AreEqual(5, review.CalculateRawRating().StarsRating);

            IRatingAdjustment adjustment = RatingAdjustment.Create(review, null);
            var resultDocument           = new DocumentFromReviewFactory(ActualWordsHandler.InstanceOpen.Container.Resolve <INRCDictionary>()).ReparseDocument(adjustment);


            Assert.AreEqual(5, resultDocument.Stars);
            Assert.AreEqual("I Veto it really", resultDocument.Text);
        }
示例#2
0
        public void ReparseDocument()
        {
            review.Setup(item => item.Text).Returns("DataRow");
            var words     = new List <TestWordItem>();
            var sentences = new List <Mock <ISentence> >();

            sentences.Add(new Mock <ISentence>());
            sentences.Add(new Mock <ISentence>());
            foreach (var sentence in sentences)
            {
                sentence.Setup(item => item.Text).Returns("Sentence");
                var currentWords = new List <TestWordItem>();
                for (var i = 0; i < 2; i++)
                {
                    var wordItem = new TestWordItem();
                    wordItem.Text                   = "Word";
                    wordItem.Relationship           = new TestWordItemRelationship();
                    wordItem.Relationship.Sentiment = new SentimentValue(wordItem, i + 1);
                    currentWords.Add(wordItem);
                    words.Add(wordItem);
                }

                sentence.Setup(item => item.Occurrences).Returns(currentWords.ToArray());
            }

            var adjustment = new Mock <IRatingAdjustment>();
            var rating     = new RatingData();

            rating.AddPositive(2);
            adjustment.Setup(item => item.Rating)
            .Returns(rating);

            for (var i = 0; i < words.Count; i++)
            {
                var word = words[i];
                adjustment.Setup(item => item.GetSentiment(word)).Returns(new SentimentValue(word, 10));
            }

            review.Setup(item => item.Sentences).Returns(sentences.Select(item => item.Object).ToList());
            adjustment.Setup(item => item.Review).Returns(review.Object);
            review.Setup(item => item.Document).Returns(new Document("Test"));
            var document = new DocumentFromReviewFactory().ReparseDocument(adjustment.Object);

            Assert.AreEqual(2, document.Sentences.Count);
            foreach (var sentenceItem in document.Sentences)
            {
                Assert.AreEqual(2, sentenceItem.Words.Count);
                Assert.AreEqual("Sentence", sentenceItem.Text);
                for (var i = 0; i < sentenceItem.Words.Count; i++)
                {
                    Assert.AreEqual(i + 1, sentenceItem.Words[i].Value);
                    Assert.AreEqual(10, sentenceItem.Words[i].CalculatedValue);
                }
            }

            Assert.AreEqual("Test", document.Text);
            Assert.IsTrue(document.GetPositivity() == PositivityType.Positive);
        }
示例#3
0
        public async Task <Document> InitDocument(string name = "cv000_29416.txt")
        {
            var result = await helper.GetTextSplitter().Process(new ParseRequest(File.ReadAllText(Path.Combine(path, name)))).ConfigureAwait(false);

            var factory            = helper.Resolve <IWordFactory>();
            var document           = result.Construct(factory);
            var review             = helper.Resolve <Func <Document, IParsedReviewManager> >()(document).Create();
            var documentFromReview = new DocumentFromReviewFactory();

            return(documentFromReview.ReparseDocument(new NullRatingAdjustment(review)));
        }
示例#4
0
        public async Task TestAttributes()
        {
            ActualWordsHandler.InstanceOpen.Container.Context.ExtractAttributes = true;
            var result = await ActualWordsHandler.InstanceOpen.TextSplitter.Process(new ParseRequest("In the forest I like perfect dinner")).ConfigureAwait(false);

            var document = result.Construct(ActualWordsHandler.InstanceOpen.WordFactory);

            Text.Data.IParsedReview review = ActualWordsHandler.InstanceOpen.Container.Resolve <Func <Document, IParsedReviewManager> >()(document).Create();
            Assert.AreEqual(4, review.ImportantWords.Count());
            var reparse = new DocumentFromReviewFactory(ActualWordsHandler.InstanceOpen.Container.Resolve <INRCDictionary>());
            IRatingAdjustment adjustment = RatingAdjustment.Create(review, null);

            document = reparse.ReparseDocument(adjustment);
            Assert.AreEqual(8, document.Attributes.Count);
            Assert.AreEqual(7, document.Words.Count(item => item.Attributes.Length > 0));
            Assert.AreEqual(2, document.Words.Count(item => item.Emotions?.Length > 0));
            ActualWordsHandler.InstanceOpen.Container.Context.ExtractAttributes = false;
        }