private static string DumpTree <T>(RedBlackSet <T> .Tree s) where T : IComparable <T>
{
var results = new StringBuilder();
results.Append('(');
results.Append(s.Color);
results.Append(": ");
if (s.Tree1 != RedBlackSet <T> .EmptyTree)
{
results.Append(DumpTree(s.Tree1));
results.Append(' ');
}
results.Append(s.Elem);
if (s.Tree2 != RedBlackSet <T> .EmptyTree)
{
results.Append(' ');
results.Append(DumpTree(s.Tree2));
}
results.Append(')');
return(results.ToString());
}
public void EmptyLeafTest()
{
var t = RedBlackSet <string> .EmptyTree;
var x1 = RedBlackSet <string> .Insert("C", t);
Assert.AreEqual("(B: C)", DumpSet(x1));
}
private void WriteAction()
{
var total = 0;
for (var i = 0; i < 2 * Count; i++)
{
var word = NextWord(1);
while (true)
{
total++;
var localCopy = _set;
Thread.MemoryBarrier();
var newSet = RedBlackSet <string> .Insert(word, localCopy);
var oldSet = Interlocked.CompareExchange(ref _set, newSet, localCopy);
if (ReferenceEquals(localCopy, oldSet))
{
break;
}
}
}
Console.WriteLine("Write Task={0}, Thread={1} : {2} average",
Task.CurrentId, Thread.CurrentThread.ManagedThreadId, 2.0 * Count / total);
}
private static string DumpSet <T>(RedBlackSet <T> .Tree s) where T : IComparable <T>
{
if (s == RedBlackSet <T> .EmptyTree)
{
return("\u2205");
}
return(DumpTree(s));
}
public void DuplicateRootMemberTest()
{
var t = RedBlackSet <string> .EmptyTree;
var x1 = RedBlackSet <string> .Insert("C", t);
var x2 = RedBlackSet <string> .Insert("C", x1);
Assert.AreEqual("(B: C)", DumpSet(x2));
Assert.AreNotSame(x1, x2);
}
public void MemberTest()
{
var t = RedBlackSet <string> .EmptyTree;
var x1 = RedBlackSet <string> .Insert("C", t);
var x2 = RedBlackSet <string> .Insert("B", x1);
Assert.IsTrue(RedBlackSet <string> .Member("B", x2));
Assert.IsFalse(RedBlackSet <string> .Member("A", x2));
Assert.IsFalse(RedBlackSet <string> .Member("D", x2));
}
private void WriteAction()
{
for (var i = 0; i < 2 * Count; i++)
{
var word = NextWord(1);
lock (_lockObject)
{
_set = RedBlackSet <string> .Insert(word, _set);
}
}
}
public void DuplicateLeafMemberTest()
{
var empty = RedBlackSet <string> .EmptyTree;
var a = RedBlackSet <string> .Insert("A", empty);
var b = RedBlackSet <string> .Insert("B", a);
var c1 = RedBlackSet <string> .Insert("C", b);
Assert.AreEqual("(B: (B: A) B (B: C))", DumpSet(c1));
var c2 = RedBlackSet <string> .Insert("C", c1);
Assert.AreEqual("(B: (B: A) B (B: C))", DumpSet(c2));
Assert.AreNotSame(c1, c2);
}
private void ReadAction()
{
var hits = 0;
for (var i = 0; i < Count; i++)
{
var word = NextWord(1);
if (RedBlackSet <string> .Member(word, _set))
{
hits++;
}
}
Console.WriteLine("Task={0}, Thread={1} : {2} words found",
Task.CurrentId, Thread.CurrentThread.ManagedThreadId, hits);
}
private void WriteAction()
{
for (var i = 0; i < 2 * Count; i++)
{
var word = NextWord(1);
_lockObject.EnterWriteLock();
try
{
_set = RedBlackSet <string> .Insert(word, _set);
}
finally
{
_lockObject.ExitWriteLock();
}
}
}
public void TestComparerForSet()
{
var a = new RedBlackSet<int>((x, y) => y - x)
{
23,
253,
7,
1,
52,
79,
834,
1,
};
var flat = a.Reverse().ToArray();
for (int i = 1; i < flat.Length; ++i)
{
Assert.That(flat[i - 1], Is.LessThanOrEqualTo(flat[i]));
}
}
public void BalanceTest6()
{
const string data = "y z x";
var t = data.Split().Aggregate(RedBlackSet <string> .EmptyTree, (current, word) => RedBlackSet <string> .Insert(word, current));
Assert.AreEqual("(B: (R: x) y (R: z))", DumpSet(t));
}
public void TestSetRemove()
{
var set = new RedBlackSet<char>
{
'a',
'b',
'c',
'd',
'e',
'f',
'g',
'h',
};
Assert.That(set.Count, Is.EqualTo(8));
Assert.That(set.Contains('f'), Is.True);
set.Remove('f');
Assert.That(set.Count, Is.EqualTo(7));
Assert.That(set.Contains('f'), Is.False);
}
public void TestSetClearing()
{
var set = new RedBlackSet<char>
{
'a',
'b',
'c',
'd',
};
Assert.That(set.Count, Is.GreaterThan(0));
set.Clear();
Assert.That(set.Empty, Is.True);
set.Add('z');
Assert.That(set.Count, Is.EqualTo(1));
}
public void TestDoubleInsertionSet()
{
var set = new RedBlackSet<char>
{
'a',
'b',
'c',
'd',
};
Assert.That(set.Empty, Is.False);
Assert.That(set.Count, Is.EqualTo(4));
Assert.That(set.Contains('e'), Is.False);
set.Add('e');
Assert.That(set.Contains('e'));
Assert.That(set.Count, Is.EqualTo(5));
set.Add('e');
Assert.That(set.Contains('e'));
Assert.That(set.Count, Is.EqualTo(5));
}
