private bool CheckMeaning(TestWordItem wordItem, string answer)
{
if (answer.Length == 0)
{
return(false);
}
if (wordItem.answers.Any(x => x.Contains(answer)))
{
return(true);
}
try
{
foreach (var word in wordItem.answers)
{
var result = nlp.WordSimEmbedding(word, answer);
if (result.Value <float>("score") > Config.transScoreThres)
{
return(true);
}
}
}
catch (Exception ex)
{
Console.WriteLine("百度词义API出问题了 - " + ex.Message);
}
return(false);
}
public void GetImportant()
{
var phrase = new TestPhrase();
var word = new TestWordItem
{
IsSentiment = true,
Text = "A",
Parent = phrase
};
var word2 = new TestWordItem
{
IsStopWord = true,
Text = "B",
Parent = phrase
};
phrase.Add(word);
phrase.Add(word2);
var words = new[] { word, word2 };
var result = SentenceExtensions.GetImportant(words).ToArray();
Assert.AreEqual(1, result.Length);
Assert.AreEqual(word, result[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);
}
public void Setup()
{
handler = new Mock <IContextWordsHandler>();
handler.Setup(item => item.Context).Returns(new SessionContext(new NullLogger <SessionContext>()));
parent = new TestWordItem("Text");
parent.WordIndex = 1;
instance = new WordItemRelationships(handler.Object, parent);
parent.Relationship = instance;
}
public void GetLexicon()
{
instance.Load();
Assert.Throws <ArgumentOutOfRangeException>(() => instance.GetLexicon("Unknown"));
var word = new TestWordItem("one");
var result = instance.GetLexicon("base").MeasureSentiment(word).DataValue.Value;
Assert.AreEqual(1, result);
result = instance.GetLexicon("other").MeasureSentiment(word).DataValue.Value;
Assert.AreEqual(-1, result);
}
private TestWordItem SetupItem()
{
wordItem = new TestWordItem(string.Empty);
repairRule = new WordRepairRule();
repairRule.SuccesfulResult = true;
wordItem.Relationship = new WordItemRelationships(helper.Handler.Object, wordItem);
var next = new TestWordItem("working");
wordItem.Relationship.Next = next;
next.POS = POSTags.Instance.VB;
return(wordItem);
}
public void AddRemove()
{
var word = new TestWordItem("xxx");
var result = instance.IsAspect(word);
Assert.IsFalse(result);
instance.AddFeature(word);
result = instance.IsAspect(word);
Assert.IsTrue(result);
instance.Remove(word);
result = instance.IsAspect(word);
Assert.IsFalse(result);
}
public void SentimentCalculatorConstructorTest()
{
IWordItem invertor = new TestWordItem(String.Empty);
relationships.Setup(item => item.Inverted)
.Returns(invertor);
relationships.Setup(item => item.PriorQuants)
.Returns(new List <IWordItem>());
var value = SentimentValue.CreateGood(wordItem.Object);
var target = new SentimentCalculator(value);
Assert.AreEqual(wordItem.Object, target.GetField <IWordItem>("wordItem"));
Assert.AreEqual(value, target.GetField <SentimentValue>("sentimentValue"));
}
public void GetLexicon()
{
var path = Path.Combine(TestContext.CurrentContext.TestDirectory, "Data", "Lexicons");
instance.Load(path);
Assert.Throws <ArgumentOutOfRangeException>(() => instance.GetLexicon("Unknown"));
var word = new TestWordItem();
word.Text = "one";
var result = instance.GetLexicon("base").MeasureSentiment(word).DataValue.Value;
Assert.AreEqual(1, result);
result = instance.GetLexicon("other").MeasureSentiment(word).DataValue.Value;
Assert.AreEqual(-1, result);
}
public void CalculateInvertTest()
{
IWordItem invertor = new TestWordItem("Invert");
relationships.Setup(item => item.Inverted)
.Returns(invertor);
relationships.Setup(item => item.PriorQuants)
.Returns(new List <IWordItem>());
var value = SentimentValue.CreateGood(wordItem.Object);
var target = new SentimentCalculator(value);
var result = target.Calculate();
Assert.AreEqual(-1, result.DataValue.Value);
}
public void CalculateQuantInvertor()
{
var invertor = new TestWordItem(String.Empty);
relationships.Setup(item => item.Inverted)
.Returns(invertor);
relationships.Setup(item => item.PriorQuants)
.Returns(
new List <IWordItem>
{
new TestWordItem("Word")
{
QuantValue = 10,
}
});
var value = SentimentValue.CreateGood(wordItem.Object);
var target = new SentimentCalculator(value);
var result = (double)target.InvokeMethod("CalculateQuant");
Assert.AreEqual(10, result);
}
public void Setup()
{
helper = new WordsHandlerHelper();
wordItem = SetupItem();
}
private bool CheckWord(TestWordItem wordItem, string answer)
{
return(wordItem.word == answer);
}
