| public static AreEquivalent ( IEnumerable expected, IEnumerable actual ) : void | ||
| expected | IEnumerable | The first IEnumerable of objects to be considered |
| actual | IEnumerable | The second IEnumerable of objects to be considered |
| return | void | |
public void GetNounDeclensionName_KidsClubSelect_Success()
{
var obj = RulesPrivate.InvokeStatic(GetNounDeclensionName, "клуб");
var listObj = (List <string>)obj;
var result = listObj.Select(word => $"{word} для детей").ToList();
var kids = listObj.Select(word => $"{word} для ребёнка").ToList();
result.AddRange(kids);
result.AddRange(kids.Select(word =>
word.Replace('ё', 'е'))); // include typos
var expected = new List <string>
{
"клуб для детей", "клуба для детей", "клубу для детей", "клубом для детей", "клубе для детей",
"клубы для детей", "клубов для детей", "клубам для детей", "клубами для детей", "клубах для детей",
"клуб для ребёнка", "клуба для ребёнка", "клубу для ребёнка", "клубом для ребёнка", "клубе для ребёнка",
"клубы для ребёнка", "клубов для ребёнка", "клубам для ребёнка", "клубами для ребёнка",
"клубах для ребёнка",
"клуб для ребенка", "клуба для ребенка", "клубу для ребенка", "клубом для ребенка", "клубе для ребенка",
"клубы для ребенка", "клубов для ребенка", "клубам для ребенка", "клубами для ребенка",
"клубах для ребенка"
};
CollectionAssert.AreEquivalent(expected, result);
}
public void GivenStatementAndWordDictionaryCheckStatementWordSplit(bool removePunctuation, string[] wordDictionary)
{
var res = "Hello, I am Slava!".ToWordArray(removePunctuation);
CollectionAssert.AllItemsAreInstancesOfType(res, typeof(string));
CollectionAssert.AllItemsAreNotNull(res);
CollectionAssert.AreEquivalent(res, wordDictionary);
}
public void GetNounDeclension_WordWithoutPluralAndWithDuplicates_Success()
{
var obj = RulesPrivate.InvokeStatic(GetNounDeclensionName, "еда");
var expected = new List <string> {
"еда", "еды", "еде", "еду", "едой"
};
CollectionAssert.AreEquivalent(expected, (List <string>)obj);
}
public void GetPhraseDeclensionName_KidsFood_Success()
{
var obj = RulesPrivate.InvokeStatic(GetPhraseDeclensionReducedName, "детская еда");
var expected = new List <string>
{
"детская еда", "детской еды", "детскую еду", "детской едой", "детской еде"
};
CollectionAssert.AreEquivalent(expected, (List <string>)obj);
}
public void GetAdjectiveDeclensionName_WordWithPluralAndWithDuplicates_Success()
{
var obj = RulesPrivate.InvokeStatic(GetAdjectiveDeclensionName, "красивый");
var expected = new List <string>
{
"красивый", "красивого", "красивому", "красивым", "красивом",
"красивые", "красивых", "красивыми"
};
CollectionAssert.AreEquivalent(expected, (List <string>)obj);
}
public void GetNounDeclension_WordWithPluralAndWithDuplicates_Success()
{
var obj = RulesPrivate.InvokeStatic(GetNounDeclensionName, "компьютер");
var expected = new List <string>
{
"компьютер", "компьютера", "компьютеру", "компьютером", "компьютере",
"компьютеры", "компьютеров", "компьютерам", "компьютерами", "компьютерах"
};
CollectionAssert.AreEquivalent(expected, (List <string>)obj);
}
public void GivenStatementAndWordCountDictionaryCheckCountedWordsInStatement(bool removePunctuation)
{
var wc = removePunctuation ? wc1 : wc2;
var res = "HELLO, HELLO, HELLO, HELLO, HELLO!"
.ToWordArray(removePunctuation)
.CountWordOccurences();
CollectionAssert.AllItemsAreInstancesOfType(res, typeof(WordCount));
CollectionAssert.AllItemsAreNotNull(res);
CollectionAssert.AreEquivalent(res, wc);
}
public void GetPhraseDeclensionName_SimplePhrase_Success()
{
var obj = RulesPrivate.InvokeStatic(GetPhraseDeclensionName, "самый недорогой");
var expected = new List <string>
{
"самый недорогой", "самого недорогого", "самому недорогому", "самым недорогим", "самом недорогом",
"самые недорогие", "самых недорогих", "самыми недорогими"
};
CollectionAssert.AreEquivalent(expected, (List <string>)obj);
}
public void ParentsTextNode()
{
CQ dom = CQ.Create("<div>abc <a href=\"\">def</a> ghi</div>", HtmlParsingMode.Content);
CQ textNodes = new CQ(dom.Select("*").Contents().Where(item => item.NodeType == NodeType.TEXT_NODE));
var p = textNodes.Parents();
CollectionAssert.AreEquivalent(
new IDomObject[] { dom["div"][0], dom["a"][0] }, p
);
}
public void NumberWithNoun_SimpleInput_Success()
{
var result = Vocabulary.GetNumbersWithNoun("бассейн");
var expected = new List <string>
{
"один бассейн", "два бассейна", "три бассейна", "четыре бассейна", "пять бассейнов",
"шесть бассейнов", "семь бассейнов", "восемь бассейнов", "девять бассейнов", "десять бассейнов"
};
CollectionAssert.AreEquivalent(expected, result);
}
public void AddMovements_Movements_MustBeAdded()
{
Account account = new Account();
RandomGenerator generator = new RandomGenerator();
var list = Builder <Expense> .CreateListOfSize(45).All().WithConstructor(() => new Expense(1, generator.Next(January.The1st, February.The15th))).Build();
account.AddMovements(list);
CollectionAssert.AreEquivalent(list, account.Movements);
}
public void GetNounDeclension_InsertTextAfterDeclension_Success()
{
var obj = RulesPrivate.InvokeStatic(GetNounDeclensionName, "бар");
var result = ((List <string>)obj).Select(word => word.Insert(word.Length, " на пляже"));
var expected = new List <string>
{
"бар на пляже", "бары на пляже", "бара на пляже", "баров на пляже", "бару на пляже",
"барам на пляже", "баром на пляже", "барами на пляже", "баре на пляже", "барах на пляже"
};
CollectionAssert.AreEquivalent(expected, result);
}
public void GetPhraseDeclensionName_CheapestTypo_Success()
{
var obj = RulesPrivate.InvokeStatic(GetPhraseDeclensionName, "самый дешёвый");
var result = ((List <string>)obj).Select(phrase => phrase.Replace('ё', 'е'));
var expected = new List <string>
{
"самый дешевый", "самого дешевого", "самому дешевому", "самым дешевым", "самом дешевом",
"самые дешевые", "самых дешевых", "самыми дешевыми",
};
CollectionAssert.AreEquivalent(expected, result);
}
public static void AreEquivalent <T>(IEnumerable <T> expected, IEnumerable <T> actual, string message = null)
{
#if XUNIT
var comparison = new Comparison <T>((x, y) => String.CompareOrdinal(x.ToString(), y.ToString()));
var sortedExpected = expected.ToImmutableList().Sort(comparison);
var sortedActual = actual.ToImmutableList().Sort(comparison);
XUnitAssert.Equal(sortedExpected, sortedActual);
XUnitAssert.Equal(sortedExpected, sortedActual);
#else
NUnitCollectionAssert.AreEquivalent(expected, actual, message);
#endif
}
public void GetPhraseDeclensionReplacedCharName_SportAndTraining_Success()
{
var phrases = RulesPrivate.InvokeStatic(GetPhraseDeclensionName, "тренажерный зал");
var obj = RulesPrivate.InvokeStatic(GetPhraseDeclensionReplacedCharName, (List <string>)phrases, 6, 'ё');
var expected = new List <string>
{
"тренажёрный зал", "тренажёрные залы", "тренажёрного зала", "тренажёрных залов",
"тренажёрному залу", "тренажёрным залам", "тренажёрным залом", "тренажёрными залами",
"тренажёрном зале", "тренажёрных залах",
};
CollectionAssert.AreEquivalent(expected, (List <string>)obj);
}
public void GetAdjectiveDeclensionName_LINQSelect_Success()
{
var obj = RulesPrivate.InvokeStatic(GetAdjectiveDeclensionName, "привередливый");
var result = ((List <string>)obj).Select(word => $"не {word}");
var expected = new List <string>
{
"не привередливый", "не привередливого", "не привередливому", "не привередливом",
"не привередливые", "не привередливых", "не привередливым", "не привередливыми"
};
CollectionAssert.AreEquivalent(expected, result);
}
public void Empty()
{
var res = Dom["span:empty"];
Assert.AreEqual(2, res.Length);
CollectionAssert.AreEquivalent(res, Dom[".badge2,.badge3"]);
res = Dom["body :empty"];
Assert.AreEqual(5, res.Length);
res = Dom[":empty"];
Assert.AreEqual(6, res.Length, "6 total element seleced (5 in body, + title & html nopde ");
}
public void OnlyOfType()
{
var res = Dom["span:only-of-type"];
Assert.AreEqual(4, res.Length);
CollectionAssert.AreEquivalent(res, Dom["#hlinks-user,.reputation-score,#hidden-span,#non-hidden-span"]);
res = Dom["body :only-of-type"];
Assert.AreEqual(11, res.Length);
res = Dom["a:only-of-type"];
Assert.AreEqual(0, res.Length);
}
public void GetNumbersWithNounDeclension_SimpleInput_Success()
{
var result = Vocabulary.GetNumbersWithNounDeclension("бассейн");
var expected = new List <string>
{
"один бассейн", "одного бассейна", "одному бассейну", "одним бассейном", "одном бассейне",
"два бассейна", "двух бассейнов", "двум бассейнам", "двумя бассейнами", "двух бассейнах",
"десять бассейнов", "десяти бассейнов", "десяти бассейнам", "десятью бассейнами", "десяти бассейнах"
};
var notAllResult = new List <string>();
for (var i = 0; i < result.Count; i++)
{
if (i >= 0 && i < 10 || i >= result.Count - 5)
{
notAllResult.Add(result[i]);
}
}
CollectionAssert.AreEquivalent(expected, notAllResult);
}
