/// <summary>
/// Updates the node's text by replacing the existing node with a new node that contains the matching translation
/// If no translation can be found, the node will be kept as is and will not be translated
/// </summary>
/// <param name="node">HTML node</param>
/// <param name="textTranslationsDict">Translations OrderedDictionary</param>
private void UpdateNodeWithTranslation(HtmlNode node, IOrderedDictionary <string, string> textTranslationsDict)
{
var key = node.InnerText;
if (string.IsNullOrEmpty(key))
{
return;
}
if (textTranslationsDict.ContainsKey(key))
{
node.ParentNode.ReplaceChild(HtmlNode.CreateNode(textTranslationsDict[key]), node);
}
}
/// <summary>
/// Updates the attribute's text with a matching translation
/// If no translation can be found, the attribute's text will not be translated
/// </summary>
/// <param name="attribute">HTML attribute</param>
/// <param name="textTranslationsDict">Translations OrderedDictionary</param>
private void UpdateAttributeWithTranslation(HtmlAttribute attribute, IOrderedDictionary <string, string> textTranslationsDict)
{
var key = attribute?.Value;
if (string.IsNullOrEmpty(key))
{
return;
}
if (textTranslationsDict.ContainsKey(key))
{
attribute.Value = textTranslationsDict[key];
}
}
/// <summary>
/// Create a unique id for each text value in the HTML being parsed and save in a dictionary.
/// This method is designed to collect identified text in an HTML
/// and track the number of occurences on the page.
/// This is done to prevent a case where we will have the same text appearing multiple times,
/// where however, we would like to have a different interpretation per appeareance.
/// </summary>
/// <param name="htmlOriginalValuesDict"></param>
/// <param name="htmlTextDict"></param>
/// <param name="text">The text used for generating the unique Id</param>
/// <returns>Returns eithe the text as is or with the number of encounters that have been detected previously on the page</returns>
private void AddUniqueIdToDictionary(IOrderedDictionary <string, string> htmlOriginalValuesDict, IOrderedDictionary <string, int> htmlTextDict, string text)
{
if (!htmlTextDict.ContainsKey(text))
{
htmlOriginalValuesDict.Add(text, text); // Save the text to a OrderedDictionary that keeps the original values
htmlTextDict.Add(text, 1); // Default to one enocunter
return;
}
htmlTextDict[text] = htmlTextDict[text] + 1; // Increase encounters
var textEncountersCount = htmlTextDict[text];
htmlOriginalValuesDict.Add($"{text}{textEncountersCount}", text); // Save the text to a OrderedDictionary that keeps the original values
htmlTextDict.Add($"{text}{textEncountersCount}", 1); // Save new encounter to the OrderedDictionary with a default of 1
}
private static void AssertOrderedDictionary(
IOrderedDictionary <int, IList <SupportBean> > treemap,
IOrderedDictionary <object, ICollection <EventBean> > actual)
{
Assert.AreEqual(treemap.Count, actual.Count);
foreach (var key in treemap.Keys)
{
var expectedEvents = treemap.Get(key).ToArray();
EPAssertionUtil.AssertEqualsExactOrder(expectedEvents, ToArrayOfUnderlying(actual.Get(key)));
}
CompareEntry(treemap.First(), actual.FirstEntry);
CompareEntry(treemap.Last(), actual.LastEntry);
CompareEntry(treemap.LessThanOrEqualTo(5), actual.LessThanOrEqualTo(5));
CompareEntry(treemap.GreaterThanOrEqualTo(5), actual.GreaterThanOrEqualTo(5));
CompareEntry(treemap.LessThan(5), actual.LessThan(5));
CompareEntry(treemap.GreaterThan(5), actual.GreaterThan(5));
Assert.AreEqual(treemap.Keys.First(), actual.FirstEntry.Key);
Assert.AreEqual(treemap.Keys.Last(), actual.LastEntry.Key);
Assert.AreEqual(treemap.LessThanOrEqualTo(5)?.Key, actual.LessThanOrEqualTo(5)?.Key);
Assert.AreEqual(treemap.GreaterThanOrEqualTo(5)?.Key, actual.GreaterThanOrEqualTo(5)?.Key);
Assert.AreEqual(treemap.LessThan(5)?.Key, actual.LessThan(5)?.Key);
Assert.AreEqual(treemap.GreaterThan(5)?.Key, actual.GreaterThan(5)?.Key);
Assert.AreEqual(treemap.ContainsKey(5), actual.ContainsKey(5));
Assert.AreEqual(treemap.IsEmpty(), actual.IsEmpty());
EPAssertionUtil.AssertEqualsExactOrder(new object[] { 1, 4, 6, 8, 9 }, actual.Keys.ToArray());
Assert.AreEqual(1, actual.Between(9, true, 9, true).Count);
Assert.AreEqual(1, actual.Tail(9).Count);
Assert.AreEqual(1, actual.Tail(9, true).Count);
Assert.AreEqual(1, actual.Head(2).Count);
Assert.AreEqual(1, actual.Head(2, false).Count);
Assert.AreEqual(5, actual.Count);
Assert.AreEqual(5, actual.Keys.Count);
Assert.AreEqual(5, actual.Values.Count);
// values
var values = actual.Values;
Assert.That(values.Count, Is.EqualTo(5));
Assert.That(values.IsEmpty(), Is.False);
var valuesEnum = values.GetEnumerator();
Assert.That(valuesEnum, Is.Not.Null);
Assert.That(valuesEnum.MoveNext, Is.True);
CollectionAssert.AreEqual(
treemap.Get(1).ToArray(),
ToArrayOfUnderlying(valuesEnum.Current));
Assert.That(valuesEnum.MoveNext, Is.True);
Assert.That(values.ToArray(), Has.Length.EqualTo(5));
CollectionAssert.AreEqual(
treemap.Get(1).ToArray(),
ToArrayOfUnderlying((ICollection <EventBean>)values.ToArray()[0]));
// ordered key set
var oks = actual.OrderedKeys;
//Assert.That(oks.Comparator());
Assert.That(oks.FirstEntry, Is.EqualTo(1));
Assert.That(oks.LastEntry, Is.EqualTo(9));
Assert.That(oks.Count, Is.EqualTo(5));
Assert.That(oks.IsEmpty(), Is.False);
Assert.That(oks.Contains(6), Is.True);
Assert.That(oks.ToArray(), Is.Not.Null);
Assert.That(oks.LessThan(5), Is.EqualTo(4));
Assert.That(oks.GreaterThan(5), Is.EqualTo(6));
Assert.That(oks.LessThanOrEqualTo(5), Is.EqualTo(4));
Assert.That(oks.GreaterThanOrEqualTo(5), Is.EqualTo(6));
Assert.That(oks.Between(1, true, 100, true), Is.Not.Null);
Assert.That(oks.Head(100, true), Is.Not.Null);
Assert.That(oks.Tail(1, true), Is.Not.Null);
// ordered key set - enumerator
var oksit = oks.GetEnumerator();
Assert.That(oksit, Is.Not.Null);
Assert.That(oksit.MoveNext(), Is.True);
Assert.That(oksit.Current, Is.EqualTo(1));
Assert.That(oksit.MoveNext(), Is.True);
// entry set
ICollection <KeyValuePair <object, ICollection <EventBean> > > set = actual;
Assert.IsFalse(set.IsEmpty());
var setit = set.GetEnumerator();
var entry = setit.Advance();
Assert.AreEqual(1, entry.Key);
Assert.IsTrue(setit.MoveNext());
EPAssertionUtil.AssertEqualsExactOrder(treemap.Get(1).ToArray(), ToArrayOfUnderlying(entry.Value));
var array = set.ToArray();
Assert.AreEqual(5, array.Length);
Assert.AreEqual(1, array[0].Key);
EPAssertionUtil.AssertEqualsExactOrder(treemap.Get(1).ToArray(), ToArrayOfUnderlying(array[0].Value));
Assert.IsNotNull(set.ToArray());
// sorted map
var events = actual.Head(100);
Assert.AreEqual(5, events.Count);
}
