public void TryExpandNameRelativeToAnother() { var hnt = new HierarchicalNameTable(new StringTable(), true, Path.DirectorySeparatorChar); HierarchicalNameId root = hnt.AddName(A("c", "dir", "root")); HierarchicalNameId immediateDescendant = hnt.AddName(A("c", "dir", "root", "file")); HierarchicalNameId furtherDescendant = hnt.AddName(A("c", "dir", "root", "moredir", "file2")); HierarchicalNameId sibling = hnt.AddName(A("c", "dir", "sibling")); string immediateDescendantPath; XAssert.IsTrue(hnt.TryExpandNameRelativeToAnother(root, immediateDescendant, out immediateDescendantPath)); XAssert.AreEqual("file", immediateDescendantPath); string furtherDescendantPath; XAssert.IsTrue(hnt.TryExpandNameRelativeToAnother(root, furtherDescendant, out furtherDescendantPath)); XAssert.AreEqual(R("moredir", "file2"), furtherDescendantPath); string siblingPath; XAssert.IsFalse(hnt.TryExpandNameRelativeToAnother(root, sibling, out siblingPath)); XAssert.IsNull(siblingPath); string emptyPath; XAssert.IsTrue(hnt.TryExpandNameRelativeToAnother(root, root, out emptyPath)); XAssert.AreEqual(string.Empty, emptyPath); }
public void EnumeratingImmediateChildren() { var ht = new HierarchicalNameTable(new StringTable(), true, Path.DirectorySeparatorChar); HierarchicalNameId rootChild1 = ht.AddName(R("root", "rootChild1")); HierarchicalNameId otherRoot = ht.AddName(R("otherRoot")); HierarchicalNameId rootChild2 = ht.AddName(R("root", "rootChild2")); HierarchicalNameId rootGrandchild1 = ht.AddName(R("root", "rootChild1", "grandchild1")); HierarchicalNameId rootGrandchild2 = ht.AddName(R("root", "rootChild2", "grandchild2")); HierarchicalNameId rootGrandchild3 = ht.AddName(R("root", "rootChild2", "grandchild3")); HierarchicalNameId root = ht.AddName(R("root")); XAssert.AreEqual(0, ht.EnumerateImmediateChildren(otherRoot).Count()); Assert.Equal( ht.EnumerateImmediateChildren(root).ToArray(), new[] { // Siblings are in reverse addition order. rootChild2, rootChild1, }); Assert.Equal( ht.EnumerateImmediateChildren(rootChild1).ToArray(), new[] { rootGrandchild1 }); Assert.Equal( ht.EnumerateImmediateChildren(rootChild2).ToArray(), new[] { rootGrandchild3, rootGrandchild2, }); XAssert.AreEqual(0, ht.EnumerateImmediateChildren(rootGrandchild2).Count()); }
public void GetAndSetFlags() { var ht = new HierarchicalNameTable(new StringTable(), true, Path.DirectorySeparatorChar); HierarchicalNameId tag1 = ht.AddName(R("c", "tag1")); HierarchicalNameId tag2 = ht.AddName(R("c", "tag2")); XAssert.AreEqual(ht.GetContainer(tag1), ht.GetContainerAndFlags(tag1).Item1); XAssert.IsTrue(ht.SetFlags(tag2, HierarchicalNameTable.NameFlags.Marked)); XAssert.IsTrue(ht.SetFlags(tag1, HierarchicalNameTable.NameFlags.Marked)); XAssert.IsFalse(ht.SetFlags(tag1, HierarchicalNameTable.NameFlags.Marked)); XAssert.AreEqual(HierarchicalNameTable.NameFlags.Marked, ht.GetContainerAndFlags(tag1).Item2); XAssert.IsTrue(ht.SetFlags(tag1, HierarchicalNameTable.NameFlags.Sealed)); XAssert.AreEqual(HierarchicalNameTable.NameFlags.Marked | HierarchicalNameTable.NameFlags.Sealed, ht.GetContainerAndFlags(tag1).Item2); XAssert.IsTrue(ht.SetFlags(tag1, HierarchicalNameTable.NameFlags.Sealed, clear: true)); XAssert.AreEqual(HierarchicalNameTable.NameFlags.Marked, ht.GetContainerAndFlags(tag1).Item2); XAssert.IsFalse(ht.SetFlags(tag1, HierarchicalNameTable.NameFlags.Marked | HierarchicalNameTable.NameFlags.Sealed, clear: true)); XAssert.AreEqual(HierarchicalNameTable.NameFlags.None, ht.GetContainerAndFlags(tag1).Item2); // tag2 should be the same as before XAssert.AreEqual(HierarchicalNameTable.NameFlags.Marked, ht.GetContainerAndFlags(tag2).Item2); }
public void IsWithin() { var hnt = new HierarchicalNameTable(new StringTable(), true, Path.DirectorySeparatorChar); HierarchicalNameId tree = hnt.AddName(A("c")); HierarchicalNameId path = hnt.AddName(A("c","windows")); XAssert.IsTrue(hnt.IsWithin(tree, path)); XAssert.IsFalse(hnt.IsWithin(path, tree)); XAssert.IsTrue(hnt.IsWithin(tree, tree)); XAssert.IsTrue(hnt.IsWithin(path, path)); }
private bool TryGetRootToken(HierarchicalNameId name, HierarchicalNameTable.NameFlags nameFlags, out string rootToken) { if (((nameFlags & HierarchicalNameTable.NameFlags.Root) == HierarchicalNameTable.NameFlags.Root) && m_replacements.TryGetValue(name, out rootToken)) { return(true); } rootToken = null; return(false); }
public static bool TryGetName(this HierarchicalNameTable table, string name, out HierarchicalNameId hierarchicalNameId) { Contract.Requires(name != null); string[] components = GetComponents(table, name); var componentIds = new StringId[components.Length]; for (int i = 0; i < components.Length; i++) { componentIds[i] = table.StringTable.AddString(components[i]); } return(table.TryGetName(componentIds, out hierarchicalNameId)); }
public void GetContainer() { var hnt = new HierarchicalNameTable(new StringTable(), true, Path.DirectorySeparatorChar); HierarchicalNameId cid = hnt.AddName(A("c", "a", "b", "c")); HierarchicalNameId bid = hnt.GetContainer(cid); HierarchicalNameId aid = hnt.GetContainer(bid); HierarchicalNameId root = hnt.GetContainer(aid); HierarchicalNameId invalid = hnt.GetContainer(root); XAssert.AreEqual(A("c", "a", "b", "c"), hnt.ExpandName(cid)); XAssert.AreEqual(A("c", "a", "b"), hnt.ExpandName(bid)); XAssert.AreEqual(A("c", "a"), hnt.ExpandName(aid)); XAssert.AreEqual(OperatingSystemHelper.IsUnixOS ? Path.VolumeSeparatorChar.ToString() : "c:", hnt.ExpandName(root)); XAssert.AreEqual(HierarchicalNameId.Invalid, invalid); }
public void ExpandFinalComponent() { var hnt = new HierarchicalNameTable(new StringTable(), true, Path.DirectorySeparatorChar); HierarchicalNameId id = hnt.AddName(A("c","a","b","c")); XAssert.AreEqual("c", hnt.ExpandFinalComponent(id)); id = hnt.GetContainer(id); XAssert.AreEqual("b", hnt.ExpandFinalComponent(id)); id = hnt.GetContainer(id); XAssert.AreEqual("a", hnt.ExpandFinalComponent(id)); id = hnt.GetContainer(id); XAssert.AreEqual(OperatingSystemHelper.IsUnixOS ? Path.VolumeSeparatorChar.ToString() : "c:", hnt.ExpandFinalComponent(id)); }
public void SetFlags() { var ht = new HierarchicalNameTable(new StringTable(), true, Path.DirectorySeparatorChar); HierarchicalNameId tag1 = ht.AddName(R("c", "tag1")); XAssert.IsTrue(ht.SetFlags(tag1, HierarchicalNameTable.NameFlags.Marked)); XAssert.IsFalse(ht.SetFlags(tag1, HierarchicalNameTable.NameFlags.Marked)); XAssert.IsTrue(ht.SetFlags(tag1, HierarchicalNameTable.NameFlags.Root)); XAssert.IsFalse(ht.SetFlags(tag1, HierarchicalNameTable.NameFlags.Root)); HierarchicalNameId tag2 = ht.AddName(R("c", "tag2")); XAssert.IsTrue(ht.SetFlags(tag2, HierarchicalNameTable.NameFlags.Marked | HierarchicalNameTable.NameFlags.Root)); XAssert.IsFalse(ht.SetFlags(tag2, HierarchicalNameTable.NameFlags.Marked)); XAssert.IsFalse(ht.SetFlags(tag2, HierarchicalNameTable.NameFlags.Root)); }
public void IgnoreCase() { var hnt = new HierarchicalNameTable(new StringTable(), true, Path.DirectorySeparatorChar); { HierarchicalNameId id1 = hnt.AddName("A"+Path.DirectorySeparatorChar+"B"); HierarchicalNameId id2 = hnt.AddName("a" + Path.DirectorySeparatorChar + "b"); XAssert.AreEqual(id1, id2); } hnt = new HierarchicalNameTable(new StringTable(), false, Path.DirectorySeparatorChar); { HierarchicalNameId id1 = hnt.AddName("A" + Path.DirectorySeparatorChar + "B"); HierarchicalNameId id2 = hnt.AddName("a" + Path.DirectorySeparatorChar + "b"); XAssert.AreNotEqual(id1, id2); } }
public void EnumeratingBottomUp() { var ht = new HierarchicalNameTable(new StringTable(), true, Path.DirectorySeparatorChar); ht.AddName(R("a", "b", "sibling", "sibling.txt")); HierarchicalNameId name = ht.AddName(R("a", "b", "c", "d.cpp")); var enumeration = ht.EnumerateHierarchyBottomUp(name).ToArray(); var expectation = new[] { ht.AddName(R("a","b","c","d.cpp")), ht.AddName(R("a","b","c")), ht.AddName(R("a","b")), ht.AddName(R("a")) }; Assert.Equal(enumeration, expectation); }
public void TryGetValue() { var hnt = new HierarchicalNameTable(new StringTable(), true, Path.DirectorySeparatorChar); HierarchicalNameId other; XAssert.IsFalse(hnt.TryGetName(string.Empty, out other)); XAssert.IsFalse(hnt.TryGetName(A("c","d"), out other)); HierarchicalNameId id = hnt.AddName(A("c","a","b","c")); XAssert.IsTrue(hnt.TryGetName(A("c", "a", "b", "c"), out other)); XAssert.AreEqual(id, other); XAssert.IsTrue(hnt.TryGetName(A("c", "a", "b"), out other)); XAssert.IsFalse(hnt.TryGetName(A("c","d"), out other)); }
/// <inheritdoc /> public override int GetLength( HierarchicalNameId name, StringTable stringTable, StringId stringId, HierarchicalNameTable.NameFlags nameFlags, out bool expandContainer) { string rootToken; if (TryGetRootToken(name, nameFlags, out rootToken)) { expandContainer = false; return(rootToken.Length); } return(base.GetLength(name, stringTable, stringId, nameFlags, out expandContainer)); }
/// <inheritdoc /> public override int CopyString( HierarchicalNameId name, StringTable stringTable, StringId stringId, HierarchicalNameTable.NameFlags nameFlags, char[] buffer, int endIndex) { string rootToken; if (TryGetRootToken(name, nameFlags, out rootToken)) { rootToken.CopyTo(0, buffer, endIndex - rootToken.Length, rootToken.Length); return(rootToken.Length); } return(base.CopyString(name, stringTable, stringId, nameFlags, buffer, endIndex)); }
public void Basic() { var hnt = new HierarchicalNameTable(new StringTable(), true, Path.DirectorySeparatorChar); int c1 = hnt.Count; XAssert.IsTrue(c1 > 0); HierarchicalNameId id = hnt.AddName(A("c", "a", "b", "c")); string str = hnt.ExpandName(id); XAssert.AreEqual(A("c", "a", "b", "c"), str); int c2 = hnt.Count; XAssert.IsTrue(c2 > c1); hnt.AddName(A("c", "a", "b", "c", "d")); hnt.AddName(A("c", "a", "b", "c")); int c3 = hnt.Count; XAssert.IsTrue(c3 > c2); long size = hnt.SizeInBytes; XAssert.IsTrue(size > 0); if (OperatingSystemHelper.IsUnixOS) { var id2 = hnt.AddName("/"); c3 = hnt.Count; XAssert.AreEqual("/", hnt.ExpandName(id2)); XAssert.ArrayEqual(new[] { id2 }, hnt.EnumerateHierarchyBottomUp(id2).ToArray()); } hnt.Freeze(); size = hnt.SizeInBytes; XAssert.IsTrue(size > 0); int c4 = hnt.Count; XAssert.AreEqual(c3, c4); }
public void CaseFolding() { var hnt = new HierarchicalNameTable(new StringTable(), true, Path.DirectorySeparatorChar); // shouldn't be interference between different hierarchies and case should be preserved HierarchicalNameId id1 = hnt.AddName(A("c","a","b","c")); HierarchicalNameId id3 = hnt.AddName(A("c","A","B","C")); HierarchicalNameId id2 = hnt.AddName(A("c","X","A","B","C")); XAssert.AreEqual(A("c","a","b","c"), hnt.ExpandName(id1)); XAssert.AreEqual(A("c","X","A","B","C"), hnt.ExpandName(id2)); // we expect to find an existing path when using different casing // HierarchicalNameId id3 = hnt.AddName((A("c","\A\B\C"); XAssert.AreEqual(id1, id3); // and we expect for common paths to have "first one in wins" casing HierarchicalNameId id4 = hnt.AddName(A("c","A","B","C","D")); XAssert.AreEqual(A("c","a","b","c","D"), hnt.ExpandName(id4)); }
public void EnumeratingBottomUpWithFlagFilter() { var ht = new HierarchicalNameTable(new StringTable(), true, Path.DirectorySeparatorChar); HierarchicalNameId tag1 = ht.AddName(R("c", "tag1")); HierarchicalNameId tag2 = ht.AddName(R("c", "tag1", "notag", "tag2")); HierarchicalNameId wrongTag = ht.AddName(R("c", "tag1", "notag", "tag2", "wrongtag")); HierarchicalNameId leafTag = ht.AddName(R("c", "tag1", "notag", "tag2", "wrongtag", "leaftag")); ht.SetFlags(tag1, HierarchicalNameTable.NameFlags.Marked); ht.SetFlags(tag2, HierarchicalNameTable.NameFlags.Marked); ht.SetFlags(wrongTag, HierarchicalNameTable.NameFlags.Root); ht.SetFlags(leafTag, HierarchicalNameTable.NameFlags.Marked); Assert.Equal( ht.EnumerateHierarchyBottomUp(leafTag, HierarchicalNameTable.NameFlags.Marked).ToArray(), new[] { leafTag, tag2, tag1, }); }
private void CheckExpandedNameComparerWithCaseSensitivity(bool ignoreCase, params string[] names) { // For all-pairs in 'names', verifies the expanded name comparer agrees with expanding the names and then comparing. var ht = new HierarchicalNameTable(new StringTable(), ignoreCase, Path.DirectorySeparatorChar); IComparer <string> stringComparer = ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal; IComparer <HierarchicalNameId> nameComparer = ht.ExpandedNameComparer; HierarchicalNameId[] nameIds = new HierarchicalNameId[names.Length]; for (int i = 0; i < names.Length; i++) { nameIds[i] = ht.AddName(names[i]); } for (int i = 0; i < names.Length; i++) { for (int j = 0; i < names.Length; i++) { string expandedI = ht.ExpandName(nameIds[i]); string expandedJ = ht.ExpandName(nameIds[j]); int expected = stringComparer.Compare(expandedI, expandedJ); int actual = nameComparer.Compare(nameIds[i], nameIds[j]); if (expected < 0) { XAssert.IsTrue(actual < 0, "Case-sensitive: {3} ; Result {0}, expecting {1} < {2}", actual, names[i], names[j], !ignoreCase); } else if (expected > 0) { XAssert.IsTrue(actual > 0, "Case-sensitive: {3} ; Result {0}, expecting {1} > {2}", actual, names[i], names[j], !ignoreCase); } else { XAssert.IsTrue(actual == 0, "Case-sensitive: {3} ; Result {0}, expecting {1} == {2}", actual, names[i], names[j], !ignoreCase); } } } }
public void EnumeratingDescendants() { var ht = new HierarchicalNameTable(new StringTable(), true, Path.DirectorySeparatorChar); HierarchicalNameId rootChild1 = ht.AddName(R("root", "rootChild1")); HierarchicalNameId otherRoot = ht.AddName(R("otherRoot")); HierarchicalNameId rootChild2 = ht.AddName(R("root", "rootChild2")); HierarchicalNameId rootGrandchild1 = ht.AddName(R("root", "rootChild1", "grandchild1")); HierarchicalNameId rootGrandchild2 = ht.AddName(R("root", "rootChild2", "grandchild2")); HierarchicalNameId rootGrandchild3 = ht.AddName(R("root", "rootChild2", "grandchild3")); HierarchicalNameId root = ht.AddName(R("root")); XAssert.AreEqual(0, ht.EnumerateHierarchyTopDown(otherRoot).Count()); Assert.Equal( ht.EnumerateHierarchyTopDown(root).ToArray(), new[] { // Note that the we traverse depth first, and with siblings in reverse order of addition. rootChild2, rootGrandchild3, rootGrandchild2, rootChild1, rootGrandchild1, }); Assert.Equal( ht.EnumerateHierarchyTopDown(rootChild1).ToArray(), new[] { rootGrandchild1 }); Assert.Equal( ht.EnumerateHierarchyTopDown(rootChild2).ToArray(), new[] { rootGrandchild3, rootGrandchild2, }); XAssert.AreEqual(0, ht.EnumerateHierarchyTopDown(rootGrandchild2).Count()); }
public void GetAndSetExtendedFlags() { var ht = new HierarchicalNameTable(new StringTable(), true, Path.DirectorySeparatorChar); HierarchicalNameId tag1 = ht.AddName(R("c", "tag1")); HierarchicalNameId tag2 = ht.AddName(R("c", "tag2")); XAssert.IsTrue(ht.SetExtendedFlags(tag2, HierarchicalNameTable.ExtendedNameFlags.Flag1)); XAssert.IsTrue(ht.SetExtendedFlags(tag1, HierarchicalNameTable.ExtendedNameFlags.Flag1)); XAssert.IsFalse(ht.SetExtendedFlags(tag1, HierarchicalNameTable.ExtendedNameFlags.Flag1)); XAssert.AreEqual(HierarchicalNameTable.ExtendedNameFlags.Flag1, ht.GetExtendedFlags(tag1)); XAssert.IsTrue(ht.SetExtendedFlags(tag1, HierarchicalNameTable.ExtendedNameFlags.Flag3)); XAssert.AreEqual(HierarchicalNameTable.ExtendedNameFlags.Flag1 | HierarchicalNameTable.ExtendedNameFlags.Flag3, ht.GetExtendedFlags(tag1)); XAssert.IsTrue(ht.SetExtendedFlags(tag1, HierarchicalNameTable.ExtendedNameFlags.Flag3, clear: true)); XAssert.AreEqual(HierarchicalNameTable.ExtendedNameFlags.Flag1, ht.GetExtendedFlags(tag1)); XAssert.IsFalse(ht.SetExtendedFlags(tag1, HierarchicalNameTable.ExtendedNameFlags.Flag1 | HierarchicalNameTable.ExtendedNameFlags.Flag3, clear: true)); XAssert.AreEqual(HierarchicalNameTable.ExtendedNameFlags.None, ht.GetExtendedFlags(tag1)); // tag2 should be the same as before XAssert.AreEqual(HierarchicalNameTable.ExtendedNameFlags.Flag1, ht.GetExtendedFlags(tag2)); }
public void IsValid() { HierarchicalNameId path = HierarchicalNameId.Invalid; XAssert.IsFalse(path.IsValid); }