public void BasicAVLTreeTest() { var tree = new AVLTree<int>(); Assert.AreEqual(0, tree.Height); for (int i = 0; i < 10; i++) { tree.Add(i); } Assert.AreEqual(4, tree.Height); Assert.AreEqual(10, tree.Size); for (int i = 0; i < 10; i++) { Assert.IsTrue(tree.Contains(i)); } Assert.IsFalse(tree.Contains(11)); for (int i = 0; i < 10; i++) { Assert.IsTrue(tree.Remove(i)); } Assert.AreEqual(0, tree.Height); Assert.AreEqual(0, tree.Size); }
public void AVLContains() { AVLTree tree = AVLcreateTree(); Assert.AreEqual(true, tree.Contains(3)); Assert.AreEqual(true, tree.Contains(15)); Assert.AreEqual(true, tree.Contains(10)); Assert.AreNotEqual(true, tree.Contains(22)); }
public void TestContains() { var testTree = new AVLTree <int>(); var hasOne = testTree.Contains(1); Assert.AreEqual(false, hasOne); testTree.Insert(1); var hasOneAfterInsert = testTree.Contains(1); Assert.AreEqual(true, hasOneAfterInsert); }
public void RemoveTest() { tree.AddRange(listStu.ToArray()); Assert.IsTrue(tree.ToList().Count <= listStu.Count); Student stu = null; var list = new List <Student>(tree.ToList()); foreach (var item in list) { var check = tree.Remove(item); var checkContains = tree.Contains(new Node <Student>(item)); Assert.IsFalse(checkContains); } }
public void Contains_ExistingElement_ShouldReturnTrue() { // Arrange AVLTree <int> avl = new AVLTree <int>(); avl.Insert(2); avl.Insert(1); avl.Insert(3); // Act // Assert Assert.IsTrue(avl.Contains(1)); Assert.IsTrue(avl.Contains(2)); Assert.IsTrue(avl.Contains(3)); }
public void DeleteTest_WhenLeftTreeIsNull_And_GivenNodeIsRightChildOfParent() { // Arrange var tree = new AVLTree <decimal>(); tree.Insert(4m, false); // r(4) tree.Insert(7m, false); // l(null) r(7) tree.Insert(8m, false); // l(null) r(8) Assert.Equal(3, tree.Count); Assert.Equal(2, tree.Height()); // Act tree.Delete(7m, false); // Assert tree.RecomputeHeight(tree.Root); Assert.Equal(2, tree.Count); Assert.Equal(1, tree.Height()); Assert.False(tree.Contains(7m)); Assert.Equal(4m, tree.Root.Value); Assert.Null(tree.Root.Left); Assert.Equal(8m, tree.Root.Right.Value); Assert.Equal(4m, tree.Root.Right.Parent.Value); }
public void DeleteTestWhenLeftTreeIsNullAndGivenNodeIsRoot() { // Arrange var tree = new AVLTree <decimal>(); tree.Insert(4m, false); tree.Insert(5m, false); tree.Insert(6m, false); Assert.Equal(3, tree.Count); Assert.Equal(2, tree.Height()); // Act tree.Delete(4m, false); // Assert tree.RecomputeHeight(tree.Root); Assert.Equal(2, tree.Count); Assert.Equal(1, tree.Height()); Assert.False(tree.Contains(4m)); Assert.Equal(5m, tree.Root.Value); Assert.Null(tree.Root.Left); Assert.Equal(6m, tree.Root.Right.Value); Assert.Equal(5m, tree.Root.Right.Parent.Value); }
public void DeleteTest_WhenRightTreeIsNull_And_GivenNodeIsLeftChildOfParent() { // Arrange var tree = new AVLTree <decimal>(); tree.Insert(5m, false); // 5 tree.Insert(4m, false); // 4 n tree.Insert(3m, false); // 3 n tree.Insert(3.5m, false); // n 3.5 Assert.Equal(4, tree.Count); // Act tree.Delete(4m, false); // Assert Assert.Equal(3, tree.Count); Assert.False(tree.Contains(4m)); Assert.Equal(5m, tree.Root.Value); Assert.Null(tree.Root.Right); Assert.Equal(3m, tree.Root.Left.Value); Assert.Equal(5m, tree.Root.Left.Parent.Value); Assert.Equal(3.5m, tree.Root.Left.Right.Value); Assert.Equal(3m, tree.Root.Left.Right.Parent.Value); }
public void RemoveAllExceptOne() { var tree = new AVLTree <int>(); int elementsCount = 100000; //Adding every seventh number, then every fifth number, //every third and at last all numbers for (int i = 7; i > 0; i -= 2) { int el = 0; while (el < elementsCount) { if (!tree.Contains(el)) { tree.Add(el); } el += i; } } bool removedEverything = true; for (int i = 0; i < elementsCount - 1; i++) { if (!tree.Remove(i)) { removedEverything = false; } } Assert.IsTrue(tree.Count == 1 && removedEverything && tree.Root.Value == elementsCount - 1); }
/// <summary> /// Check contains specified user. /// </summary> /// <param name="id">user id</param> /// <returns>if contains specified user, return true.</returns> public bool Contains(long id) { lock (_collectionLock) { return(_collection.Contains(id)); } }
public void Remove() { AVLTree <int> tree1 = new AVLTree <int>(); tree1.Add(99); tree1.Add(23); tree1.Add(45); tree1.Add(99); tree1.Add(37); tree1.Add(16); tree1.Add(22); tree1.Add(3); Assert.AreEqual(tree1.Contains(45), true); tree1.remove(45); Assert.AreEqual(tree1.Contains(45), false); }
public static void RunSearchingSpeedTest() { const int NUMBER_OF_ELEMENTS_IN_TREE1 = 1000; const int NUMBER_OF_ELEMENTS_IN_TREE2 = 10000; const int NUMBER_OF_ELEMENTS_IN_TREE3 = 1000000; const int TIMES_SEARCHED = 100000; AVLTree<int> tree1 = new AVLTree<int>(); AVLTree<int> tree2 = new AVLTree<int>(); AVLTree<int> tree3 = new AVLTree<int>(); for (int i = 0; i < NUMBER_OF_ELEMENTS_IN_TREE3; i++) { if (i < NUMBER_OF_ELEMENTS_IN_TREE1) { tree1.Insert(i); } if (i < NUMBER_OF_ELEMENTS_IN_TREE2) { tree2.Insert(i); } tree3.Insert(i); } Console.WriteLine("Searching in tree1..."); var watch1 = System.Diagnostics.Stopwatch.StartNew(); for (int i = 0; i < TIMES_SEARCHED; i++) { tree1.Contains(GetRandomNumber(NUMBER_OF_ELEMENTS_IN_TREE1)); } watch1.Stop(); Console.WriteLine("Elapsed time: {0}ms\n", watch1.ElapsedMilliseconds); Console.WriteLine("Searching in tree2..."); var watch2 = System.Diagnostics.Stopwatch.StartNew(); for (int i = 0; i < TIMES_SEARCHED; i++) { tree1.Contains(GetRandomNumber(NUMBER_OF_ELEMENTS_IN_TREE2)); } watch2.Stop(); Console.WriteLine("Elapsed time: {0}ms\n", watch2.ElapsedMilliseconds); Console.WriteLine("Searching in tree3..."); var watch3 = System.Diagnostics.Stopwatch.StartNew(); for (int i = 0; i < TIMES_SEARCHED; i++) { tree1.Contains(GetRandomNumber(NUMBER_OF_ELEMENTS_IN_TREE3)); } watch3.Stop(); Console.WriteLine("Elapsed time: {0}ms\n", watch3.ElapsedMilliseconds); int magicNumberOutside = 1230; int magicNumberInside = 900; Console.WriteLine("Tree1 contains {0}: {1}\n", magicNumberOutside, tree1.Contains(magicNumberOutside)); // expected output - false Console.WriteLine("Tree1 contains {0}: {1}\n", magicNumberInside, tree1.Contains(magicNumberInside)); // expected output - true }
public static bool IsOfficialMuted(long userId) { CheckUpdateOfficialMutes(); lock (_officialMuteUserIds) { return(_officialMuteUserIds.Contains(userId)); } }
public static bool IsBlocked(long userId) { CheckUpdateBlocks(); lock (_blockingUserIds) { return(_blockingUserIds.Contains(userId)); } }
public static bool IsNoRetweet(long userId) { CheckUpdateNoRetweets(); lock (_noRetweetUserIds) { return(_noRetweetUserIds.Contains(userId)); } }
public void Insert() { AVLTree <int> tree1 = new AVLTree <int>(); tree1.Add(99); tree1.Add(23); tree1.Add(45); tree1.Add(99); tree1.Add(37); tree1.Add(16); tree1.Add(22); tree1.Add(3); Assert.AreEqual(tree1.Contains(99), true); Assert.AreEqual(tree1.Contains(16), true); Assert.AreEqual(tree1.Contains(37), true); Assert.AreEqual(tree1.Contains(22), true); Assert.AreEqual(tree1.Contains(3), true); }
public override Func <TwitterStatus, bool> GetEvaluator() { // accept all status via web. return(status => { lock (_acceptIds) { return _acceptIds.Contains(status.Id); } }); }
private bool CheckConversation(TwitterStatus status) { lock (_statuses) { if (_statuses.Contains(status.Id)) { return(true); } if (status.InReplyToStatusId == null) { return(false); } if (_statuses.Contains(status.InReplyToStatusId.Value)) { _statuses.Add(status.Id); return(true); } } return(false); }
public void ExistedKeyFound() { var tree = new AVLTree <int, int>(); var n = 10; for (int i = 0; i < n; i++) { tree.Add(i, i); } Assert.AreEqual(tree.Contains(5), true); }
public void AddTest() { AVLTree <int> AVL = new AVLTree <int>(); Assert.AreEqual(0, AVL.Size()); AVL.Insert(5); AVL.Insert(3); AVL.Insert(2); AVL.Insert(6); AVL.Insert(1); AVL.Insert(4); Assert.AreEqual(true, AVL.Contains(6)); Assert.AreEqual(true, AVL.Contains(3)); Assert.AreEqual(false, AVL.Contains(23)); Assert.AreEqual(true, AVL.ValidateBSTInvariant()); AVL.Insert(-6); Assert.AreEqual(true, AVL.ValidateBSTInvariant()); }
// //You can use the following additional attributes as you write your tests: // //Use ClassInitialize to run code before running the first test in the class //[ClassInitialize()] //public static void MyClassInitialize(TestContext testContext) //{ //} // //Use ClassCleanup to run code after all tests in a class have run //[ClassCleanup()] //public static void MyClassCleanup() //{ //} // //Use TestInitialize to run code before running each test //[TestInitialize()] //public void MyTestInitialize() //{ //} // //Use TestCleanup to run code after each test has run //[TestCleanup()] //public void MyTestCleanup() //{ //} // #endregion /// <summary> ///A test for Add ///</summary> public void AddTestHelper <T>() { AVLTree <double> target = new AVLTree <double>(); double data = 3; target.Add(1); target.Add(2); target.Add(data); SearchResult actual = target.Contains(data); Assert.IsNotNull(actual.SearchPath); }
public void NotExistedKeyNotFound() { var tree = new AVLTree <int, int>(); var n = 10; for (int i = 0; i < n; i++) { tree.Add(i, i); } Assert.AreEqual(tree.Contains(9000), false); }
public void SortedElementsAfterAddingAndRemoving() { var tree = new AVLTree <int>(); int elementsCount = 100000; //Adding every seventh number, then every fifth number, //every third and at last all numbers for (int i = 7; i > 0; i -= 2) { int el = 0; while (el < elementsCount) { if (!tree.Contains(el)) { tree.Add(el); } el += i; } } bool removedEverything = true; //Removing every second number for (int i = 0; i < elementsCount; i += 2) { if (!tree.Remove(i)) { removedEverything = false; } } int last = -1; int count = 0; bool elementsAreSorted = true; foreach (var item in tree) { if (last > item) { elementsAreSorted = false; } last = item; count++; } Trace.WriteLine(tree.Count); Assert.IsTrue(tree.Count == count && elementsAreSorted && removedEverything); }
public void RemoveRootEveryTimeUntilTreeElementsAreHalfed() { var tree = new AVLTree <int>(); int elementsCount = 100000; //Adding every seventh number, then every fifth number, //every third and at last all numbers for (int i = 7; i > 0; i -= 2) { int el = 0; while (el < elementsCount) { if (!tree.Contains(el)) { tree.Add(el); } el += i; } } bool removedEverything = true; while (tree.Count > elementsCount / 2) { if (!tree.Remove(tree.Root.Value)) { removedEverything = false; } } int last = -1; int count = 0; bool elementsAreSorted = true; foreach (var item in tree) { if (last > item) { elementsAreSorted = false; } last = item; count++; } Trace.WriteLine(tree.Count); Assert.IsTrue(tree.Count == count && elementsAreSorted && count == elementsCount / 2 && removedEverything); }
public void Contains_NonAddedElement_ShouldReturnFalse() { var numbers = TestUtils.ToIntArrayUnique("1 7 3 -4 10 0"); var tree = new AVLTree <int>(); foreach (int number in numbers) { tree.Add(number); } var contains2 = tree.Contains(2); Assert.IsFalse(contains2); }
public void Contains_AddedElement_ShouldReturnTrue() { var numbers = TestUtils.ToIntArrayUnique("-2 3 10 0 1 -16"); var tree = new AVLTree <int>(); foreach (int number in numbers) { tree.Add(number); } var contains3 = tree.Contains(3); Assert.IsTrue(contains3); }
public void Performance_Insert_Contains() { var avl = new AVLTree <int>(); for (int i = 0; i < 100000; i++) { avl.Insert(i); } for (int i = 0; i < 100000; i++) { Assert.IsTrue(avl.Contains(i)); } }
public void TestRemoveRoot() { var testTree = new AVLTree <int>(); var initialSize = testTree.Size; var initialContains = testTree.Contains(4); Assert.AreEqual(0, initialSize); Assert.AreEqual(false, initialContains); testTree.Insert(4); var oneSize = testTree.Size; var fourContains = testTree.Contains(4); Assert.AreEqual(1, oneSize); Assert.AreEqual(true, fourContains); testTree.Remove(4); var twoSize = testTree.Size; var fourContainsAfterRemove = testTree.Contains(4); Assert.AreEqual(0, twoSize); Assert.AreEqual(false, fourContainsAfterRemove); }
public void Add_And_Remove_1k_Unique_Items() { AVLTree <int> tree = new AVLTree <int>(); List <int> items = new List <int>(); // add random unique items to the tree Random rng = new Random(); while (items.Count < 1000) { int next = rng.Next(); if (!items.Contains(next)) { items.Add(next); tree.Add(next); Assert.AreEqual(items.Count, tree.Count, "items and tree collection should have the same count"); } } // make sure they all exist in the tree foreach (int value in items) { Assert.IsTrue(tree.Contains(value), "The tree does not contain the expected value " + value.ToString()); } // remove the item from the tree and make sure it's gone foreach (int value in items) { Assert.IsTrue(tree.Remove(value), "The tree does not contain the expected value " + value.ToString()); Assert.IsFalse(tree.Contains(value), "The tree should not have contained the value " + value.ToString()); Assert.IsFalse(tree.Remove(value), "The tree should not have contained the value " + value.ToString()); } // now make sure the tree is empty Assert.AreEqual(0, tree.Count, "The tree should be empty"); }
public void InsertAndContainsTest() { var treeString = new AVLTree <string>(); var newTree = new AVLTree <int>(new Node <int>(1, new Node <int>(1), new Node <int>(0))); var newTree2 = new AVLTree <int>(new Node <int>(1, new Node <int>(2), new Node <int>(0))); treeString.Insert(new Node <string>("S")); var item1C = tree.Contains(item1); var item2C = tree.Contains(item3); var strC = treeString.Contains(new Node <string>("S")); var falseCon = tree.Contains(new Node <int>()); var falseNull = tree.Contains(null); Assert.IsTrue(strC); Assert.IsTrue(item1C); Assert.IsTrue(item2C); Assert.IsFalse(falseCon); Assert.IsFalse(falseNull); }
public void Enumerator_Of_Single() { var tree = new AVLTree <int>(); foreach (var item in tree) { Assert.IsTrue(false, "An empty tree should not enumerate any values"); } Assert.IsFalse(tree.Contains(10), "Tree should not contain 10 yet"); tree.Add(10); Assert.IsTrue(tree.Contains(10), "Tree should contain 10"); var count = 0; foreach (var item in tree) { count++; Assert.AreEqual(1, count); Assert.AreEqual(10, item); } }
public void Contains_NonExistingElement_ShouldReturnFalse() { // Arrange AVLTree <int> avl = new AVLTree <int>(); avl.Insert(2); avl.Insert(1); avl.Insert(3); // Act bool contains = avl.Contains(5); // Assert Assert.IsFalse(contains); }
public void SingleElementsAddsUpToTree() { AVLTree<int> tree = new AVLTree<int>(); foreach (int item in tree) { Assert.Fail("An empty tree should not enumerate any values"); } Assert.IsFalse(tree.Contains(10), "Tree should not contain 10 yet"); tree.Add(10); Assert.IsTrue(tree.Contains(10), "Tree should contain 10"); int count = 0; foreach (int item in tree) { count++; Assert.AreEqual(1, count, "There should be exactly one item"); Assert.AreEqual(item, 10, "The item value should be 10"); } }