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);
}
