mirror of
https://github.com/ICDSystems/ICD.Common.Utils.git
synced 2026-01-11 19:44:55 +00:00
352 lines
12 KiB
C#
352 lines
12 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using ICD.Common.Properties;
|
|
using NUnit.Framework;
|
|
using ICD.Common.Utils.Xml;
|
|
#if SIMPLSHARP
|
|
using Crestron.Xml;
|
|
#else
|
|
using System.Xml;
|
|
#endif
|
|
|
|
namespace ICD.Common.Utils.Tests.Xml
|
|
{
|
|
[TestFixture]
|
|
public sealed class XmlUtilsTest
|
|
{
|
|
// Whitespace is important for testing Insignificant Whitespace nodes.
|
|
private const string EXAMPLE_XML = " <Level1 attr1=\"1\" attr2=\"2\"> "
|
|
+ " <Level2> "
|
|
+ " </Level2> "
|
|
+ " <Level2> "
|
|
+ " <Level3>Some text</Level3> "
|
|
+ " </Level2> "
|
|
+ " </Level1> ";
|
|
|
|
// For testing empty elements
|
|
private const string EXAMPLE_XML_2 = "<Level1>"
|
|
+ "<Level2 />"
|
|
+ "<Level2 />"
|
|
+ "</Level1>";
|
|
|
|
[Flags]
|
|
public enum eTestEnum
|
|
{
|
|
A = 1,
|
|
B = 2,
|
|
C = 4
|
|
}
|
|
|
|
#region Attributes
|
|
|
|
[Test]
|
|
public void HasAttributeTest()
|
|
{
|
|
Assert.IsTrue(XmlUtils.HasAttribute(EXAMPLE_XML, "attr1"));
|
|
Assert.IsTrue(XmlUtils.HasAttribute(EXAMPLE_XML, "attr2"));
|
|
Assert.IsFalse(XmlUtils.HasAttribute(EXAMPLE_XML, "attr3"));
|
|
Assert.IsFalse(XmlUtils.HasAttribute(EXAMPLE_XML_2, "attr1"));
|
|
}
|
|
|
|
[Test, UsedImplicitly]
|
|
public void GetAttributesTest()
|
|
{
|
|
using (IcdXmlReader reader = new IcdXmlReader(EXAMPLE_XML))
|
|
{
|
|
reader.ReadToNextElement();
|
|
|
|
IcdXmlAttribute[] attributes = reader.GetAttributes().ToArray();
|
|
|
|
Assert.AreEqual(2, attributes.Length);
|
|
Assert.AreEqual("attr1", attributes[0].Name);
|
|
Assert.AreEqual("1", attributes[0].Value);
|
|
Assert.AreEqual("attr2", attributes[1].Name);
|
|
Assert.AreEqual("2", attributes[1].Value);
|
|
}
|
|
}
|
|
|
|
[Test, UsedImplicitly]
|
|
public void GetAttributeAsIntTest()
|
|
{
|
|
using (IcdXmlReader reader = new IcdXmlReader(EXAMPLE_XML))
|
|
{
|
|
reader.ReadToNextElement();
|
|
|
|
int value = reader.GetAttributeAsInt("attr1");
|
|
Assert.AreEqual(1, value);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
[Test, UsedImplicitly]
|
|
public void RecursionTest()
|
|
{
|
|
List<string[]> paths = new List<string[]>();
|
|
List<string> nodes = new List<string>();
|
|
|
|
XmlUtils.Recurse(EXAMPLE_XML, args =>
|
|
{
|
|
paths.Add(args.Path);
|
|
nodes.Add(args.Outer);
|
|
}
|
|
);
|
|
|
|
Assert.AreEqual(4, paths.Count);
|
|
|
|
Assert.AreEqual("Level1", paths[0][0]);
|
|
Assert.AreEqual("Level2", paths[1][1]);
|
|
Assert.AreEqual("Level2", paths[2][1]);
|
|
Assert.AreEqual("Level3", paths[3][2]);
|
|
|
|
using (IcdXmlReader reader = new IcdXmlReader(nodes[3]))
|
|
{
|
|
reader.ReadToNextElement();
|
|
Assert.AreEqual("Some text", reader.ReadInnerXml());
|
|
}
|
|
}
|
|
|
|
[Test, UsedImplicitly]
|
|
public void SkipInsignificantWhitespaceTest()
|
|
{
|
|
using (IcdXmlReader reader = new IcdXmlReader(EXAMPLE_XML))
|
|
{
|
|
reader.Read();
|
|
Assert.AreEqual(reader.NodeType, XmlNodeType.Whitespace);
|
|
|
|
reader.SkipInsignificantWhitespace();
|
|
Assert.AreNotEqual(reader.NodeType, XmlNodeType.Whitespace);
|
|
}
|
|
}
|
|
|
|
[Test, UsedImplicitly]
|
|
public void SkipToNextElementTest()
|
|
{
|
|
using (IcdXmlReader reader = new IcdXmlReader(EXAMPLE_XML))
|
|
{
|
|
reader.ReadToNextElement();
|
|
Assert.AreEqual("Level1", reader.Name);
|
|
|
|
reader.ReadToNextElement();
|
|
Assert.AreEqual("Level2", reader.Name);
|
|
}
|
|
}
|
|
|
|
[Test, UsedImplicitly]
|
|
public void GetChildElementsFromXmlTest()
|
|
{
|
|
IEnumerable<IcdXmlReader> results = XmlUtils.GetChildElements(EXAMPLE_XML);
|
|
IcdXmlReader[] children = results.ToArray();
|
|
|
|
Assert.AreEqual(2, children.Length);
|
|
Assert.AreEqual("Level2", children[0].Name);
|
|
Assert.AreEqual("Level2", children[1].Name);
|
|
|
|
foreach (IcdXmlReader child in children)
|
|
child.Dispose();
|
|
}
|
|
|
|
[Test, UsedImplicitly]
|
|
public void GetChildElementsAsStringEmptyElementTest()
|
|
{
|
|
string[] results = XmlUtils.GetChildElementsAsString(EXAMPLE_XML_2).ToArray();
|
|
|
|
Assert.AreEqual(2, results.Length);
|
|
Assert.AreEqual("<Level2 />", results[0]);
|
|
Assert.AreEqual("<Level2 />", results[1]);
|
|
}
|
|
|
|
[Test, UsedImplicitly]
|
|
public void GetChildElementsTest()
|
|
{
|
|
using (IcdXmlReader reader = new IcdXmlReader(EXAMPLE_XML))
|
|
{
|
|
reader.ReadToNextElement();
|
|
|
|
IEnumerable<IcdXmlReader> results = reader.GetChildElements();
|
|
IcdXmlReader[] children = results.ToArray();
|
|
|
|
Assert.AreEqual(2, children.Length);
|
|
Assert.AreEqual("Level2", children[0].Name);
|
|
Assert.AreEqual("Level2", children[1].Name);
|
|
|
|
foreach (IcdXmlReader child in children)
|
|
child.Dispose();
|
|
}
|
|
}
|
|
|
|
[Test, UsedImplicitly]
|
|
public void IsValidXmlTest()
|
|
{
|
|
Assert.IsFalse(XmlUtils.IsValidXml(@"<Foo></Bar>"));
|
|
Assert.IsTrue(XmlUtils.IsValidXml(EXAMPLE_XML));
|
|
}
|
|
|
|
[Test]
|
|
public void FormatTest()
|
|
{
|
|
const string xml = "<Test1><Test2></Test2><Test2></Test2></Test1>";
|
|
const string expected = @"<Test1>
|
|
<Test2></Test2>
|
|
<Test2></Test2>
|
|
</Test1>";
|
|
|
|
Assert.AreEqual(expected, XmlUtils.Format(xml));
|
|
}
|
|
|
|
#region Read Child Element
|
|
|
|
[TestCase("<Test><Child>Test</Child></Test>", "Child", "Test")]
|
|
public void ReadChildElementContentAsStringTest(string xml, string childElement, string expected)
|
|
{
|
|
Assert.AreEqual(expected, XmlUtils.ReadChildElementContentAsString(xml, childElement));
|
|
}
|
|
|
|
[TestCase("<Test><Child>1</Child></Test>", "Child", 1)]
|
|
public void ReadChildElementContentAsIntTest(string xml, string childElement, int expected)
|
|
{
|
|
Assert.AreEqual(expected, XmlUtils.ReadChildElementContentAsInt(xml, childElement));
|
|
}
|
|
|
|
[TestCase("<Test><Child>1</Child></Test>", "Child", (uint)1)]
|
|
public void ReadChildElementContentAsUintTest(string xml, string childElement, uint expected)
|
|
{
|
|
Assert.AreEqual(expected, XmlUtils.ReadChildElementContentAsUint(xml, childElement));
|
|
}
|
|
|
|
[TestCase("<Test><Child>1</Child></Test>", "Child", (long)1)]
|
|
public void ReadChildElementContentAsLongTest(string xml, string childElement, long expected)
|
|
{
|
|
Assert.AreEqual(expected, XmlUtils.ReadChildElementContentAsLong(xml, childElement));
|
|
}
|
|
|
|
[TestCase("<Test><Child>1</Child></Test>", "Child", (ushort)1)]
|
|
public void ReadChildElementContentAsUShortTest(string xml, string childElement, ushort expected)
|
|
{
|
|
Assert.AreEqual(expected, XmlUtils.ReadChildElementContentAsUShort(xml, childElement));
|
|
}
|
|
|
|
[TestCase("<Test><Child>1</Child></Test>", "Child", 1.0f)]
|
|
public void ReadChildElementContentAsFloatTest(string xml, string childElement, float expected)
|
|
{
|
|
Assert.AreEqual(expected, XmlUtils.ReadChildElementContentAsFloat(xml, childElement), 0.001f);
|
|
}
|
|
|
|
[TestCase("<Test><Child>True</Child></Test>", "Child", true)]
|
|
[TestCase("<Test><Child>true</Child></Test>", "Child", true)]
|
|
[TestCase("<Test><Child>False</Child></Test>", "Child", false)]
|
|
[TestCase("<Test><Child>false</Child></Test>", "Child", false)]
|
|
public void ReadChildElementContentAsBooleanTest(string xml, string childElement, bool expected)
|
|
{
|
|
Assert.AreEqual(expected, XmlUtils.ReadChildElementContentAsBoolean(xml, childElement));
|
|
}
|
|
|
|
[TestCase("<Test><Child>1</Child></Test>", "Child", (byte)1)]
|
|
[TestCase("<Test><Child>0x01</Child></Test>", "Child", (byte)1)]
|
|
[TestCase("<Test><Child>0X01</Child></Test>", "Child", (byte)1)]
|
|
public void ReadChildElementContentAsByteTest(string xml, string childElement, byte expected)
|
|
{
|
|
Assert.AreEqual(expected, XmlUtils.ReadChildElementContentAsByte(xml, childElement));
|
|
}
|
|
|
|
[TestCase("<Test><Child>A</Child></Test>", "Child", true, eTestEnum.A)]
|
|
[TestCase("<Test><Child>A, B</Child></Test>", "Child", true, eTestEnum.A | eTestEnum.B)]
|
|
public void ReadChildElementContentAsEnumTest<T>(string xml, string childElement, bool ignoreCase, T expected)
|
|
{
|
|
Assert.AreEqual(expected, XmlUtils.ReadChildElementContentAsEnum<T>(xml, childElement, ignoreCase));
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Try Read Child Element
|
|
|
|
[TestCase("<Test><Child>Test</Child></Test>", "Child", "Test")]
|
|
[TestCase("<Test></Test>", "Child", null)]
|
|
public void TryReadChildElementContentAsStringTest(string xml, string childElement, string expected)
|
|
{
|
|
Assert.AreEqual(expected, XmlUtils.TryReadChildElementContentAsString(xml, childElement));
|
|
}
|
|
|
|
[TestCase("<Test><Child>1</Child></Test>", "Child", 1)]
|
|
[TestCase("<Test><Child>fgfdgfd</Child></Test>", "Child", null)]
|
|
[TestCase("<Test></Test>", "Child", null)]
|
|
public void TryReadChildElementContentAsIntTest(string xml, string childElement, int? expected)
|
|
{
|
|
Assert.AreEqual(expected, XmlUtils.TryReadChildElementContentAsInt(xml, childElement));
|
|
}
|
|
|
|
[TestCase("<Test><Child>1</Child></Test>", "Child", (long)1)]
|
|
[TestCase("<Test><Child>fgfdgfd</Child></Test>", "Child", null)]
|
|
[TestCase("<Test></Test>", "Child", null)]
|
|
public void TryReadChildElementContentAsLongTest(string xml, string childElement, long? expected)
|
|
{
|
|
Assert.AreEqual(expected, XmlUtils.TryReadChildElementContentAsLong(xml, childElement));
|
|
}
|
|
|
|
[TestCase("<Test><Child>1</Child></Test>", "Child", (ushort)1)]
|
|
[TestCase("<Test><Child>fgfdgfd</Child></Test>", "Child", null)]
|
|
[TestCase("<Test></Test>", "Child", null)]
|
|
public void TryReadChildElementContentAsUShortTest(string xml, string childElement, ushort? expected)
|
|
{
|
|
Assert.AreEqual(expected, XmlUtils.TryReadChildElementContentAsUShort(xml, childElement));
|
|
}
|
|
|
|
[TestCase("<Test><Child>1</Child></Test>", "Child", 1.0f)]
|
|
[TestCase("<Test><Child>fgfdgfd</Child></Test>", "Child", null)]
|
|
[TestCase("<Test></Test>", "Child", null)]
|
|
public void TryReadChildElementContentAsFloatTest(string xml, string childElement, float? expected)
|
|
{
|
|
float? result = XmlUtils.TryReadChildElementContentAsFloat(xml, childElement);
|
|
|
|
if (result == null)
|
|
Assert.AreEqual(expected, null);
|
|
else if (expected == null)
|
|
Assert.Fail();
|
|
else
|
|
Assert.AreEqual((float)expected, (float)result, 0.001f);
|
|
}
|
|
|
|
[TestCase("<Test><Child>True</Child></Test>", "Child", true)]
|
|
[TestCase("<Test><Child>true</Child></Test>", "Child", true)]
|
|
[TestCase("<Test><Child>False</Child></Test>", "Child", false)]
|
|
[TestCase("<Test><Child>false</Child></Test>", "Child", false)]
|
|
[TestCase("<Test><Child>fgfdgfd</Child></Test>", "Child", null)]
|
|
[TestCase("<Test></Test>", "Child", null)]
|
|
public void TryReadChildElementContentAsBooleanTest(string xml, string childElement, bool? expected)
|
|
{
|
|
Assert.AreEqual(expected, XmlUtils.TryReadChildElementContentAsBoolean(xml, childElement));
|
|
}
|
|
|
|
[TestCase("<Test><Child>1</Child></Test>", "Child", (byte)1)]
|
|
[TestCase("<Test><Child>0x01</Child></Test>", "Child", (byte)1)]
|
|
[TestCase("<Test><Child>0X01</Child></Test>", "Child", (byte)1)]
|
|
[TestCase("<Test><Child>fgfdgfd</Child></Test>", "Child", null)]
|
|
[TestCase("<Test></Test>", "Child", null)]
|
|
public void TryReadChildElementContentAsByteTest(string xml, string childElement, byte? expected)
|
|
{
|
|
Assert.AreEqual(expected, XmlUtils.TryReadChildElementContentAsByte(xml, childElement));
|
|
}
|
|
|
|
[TestCase("<Test><Child>A</Child></Test>", "Child", true, eTestEnum.A)]
|
|
[TestCase("<Test><Child>A, B</Child></Test>", "Child", true, eTestEnum.A | eTestEnum.B)]
|
|
[TestCase("<Test><Child>fgfdgfd</Child></Test>", "Child", true, null)]
|
|
[TestCase("<Test></Test>", "Child", true, null)]
|
|
public void TryReadChildElementContentAsEnumTest(string xml, string childElement, bool ignoreCase, eTestEnum? expected)
|
|
{
|
|
Assert.AreEqual(expected, XmlUtils.TryReadChildElementContentAsEnum<eTestEnum>(xml, childElement, ignoreCase));
|
|
}
|
|
|
|
[TestCase("<Test><Child>A</Child></Test>", "Child", true, true)]
|
|
[TestCase("<Test><Child>A, B</Child></Test>", "Child", true, true)]
|
|
[TestCase("<Test><Child>fgfdgfd</Child></Test>", "Child", true, false)]
|
|
[TestCase("<Test></Test>", "Child", true, false)]
|
|
public void TryReadChildElementContentAsEnumTest(string xml, string childElement, bool ignoreCase, bool expected)
|
|
{
|
|
eTestEnum output;
|
|
Assert.AreEqual(expected, XmlUtils.TryReadChildElementContentAsEnum(xml, childElement, ignoreCase, out output));
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
} |