public static void Main(string[] args) { HashedSet<string> students = new HashedSet<string>(); students.Add("Pesho"); students.Add("Pesho"); students.Add("Gosho"); students.Remove("Gosho"); students.Add("Misho"); students.Add("Ivan"); Console.WriteLine("Student count: {0}", students.Count); HashedSet<string> users = new HashedSet<string>(); users.Add("Mariq"); users.Add("Pesho"); users.Add("Misho"); HashedSet<string> intersection = students.Intersect(users); Console.WriteLine("Intersection:"); foreach (var name in intersection) { Console.WriteLine(name); } HashedSet<string> union = students.Union(users); Console.WriteLine("Union: "); foreach (var name in union) { Console.WriteLine(name); } }
public void IntersectExpectedToWorkProperly() { var firstSet = new HashedSet <string>(); for (int i = 1; i <= 10; i++) { firstSet.Add("test" + i); } var secondSet = new HashedSet <string>(); for (int i = 6; i <= 15; i++) { secondSet.Add("test" + i); } firstSet.Intersect(secondSet); Assert.AreEqual(5, firstSet.Count); for (int i = 6; i <= 10; i++) { Assert.IsTrue(firstSet.Find("test" + i)); } }
public static void Main() { var firstSet = new HashedSet<string>(); var secondSet = new HashedSet<string>(); firstSet.Add("Pesho"); firstSet.Add("Gosho"); firstSet.Add("Tosho"); secondSet.Add("Ivan"); secondSet.Add("Petkan"); secondSet.Add("Dragan"); Console.WriteLine(firstSet); Console.WriteLine(secondSet); Console.WriteLine(firstSet.Intersect(secondSet)); Console.WriteLine(secondSet.Intersect(firstSet)); Console.WriteLine(firstSet.Union(secondSet)); Console.WriteLine(secondSet.Union(firstSet)); firstSet.Remove("Pesho"); firstSet.Remove("Tosho"); Console.WriteLine(firstSet); Console.WriteLine(firstSet.Find("Tosho")); Console.WriteLine(firstSet.Find("Gosho")); Console.WriteLine(firstSet.Count); }
public static void Main() { HashedSet<float> firstSet = new HashedSet<float>(); firstSet.Add(1f); firstSet.Add(1.4f); firstSet.Add(1.7f); firstSet.Add(2f); firstSet.Add(2.2f); firstSet.Remove(1.7f); Console.WriteLine(firstSet.Find(1f)); Console.WriteLine(firstSet.Count); HashedSet<float> secondSet = new HashedSet<float>(); secondSet.Add(1f); secondSet.Add(2f); secondSet.Add(3f); secondSet.Add(5f); HashedSet<float> thirdSet = new HashedSet<float>(); thirdSet.Add(1f); thirdSet.Add(2f); thirdSet.Add(3f); thirdSet.Add(5f); secondSet.Union(firstSet); thirdSet.Intersect(firstSet); firstSet.Clear(); }
static void Main() { var set = new HashedSet<int>(); set.Add(5); set.Add(3); set.Add(-4); set.Add(12); set.Add(0); set.Add(-50); set.Add(10); Console.WriteLine("Set contains 12 -> {0}", set.Find(12)); Console.WriteLine("Set contains 13 -> {0}", set.Find(13)); set.Remove(10); Console.WriteLine("Removed 10\nSet contains 10 -> {0}", set.Find(10)); Console.WriteLine("Set contains {0} items", set.Count); Console.WriteLine("Set 1: {0}", set); var anotherSet = new HashedSet<int>(); anotherSet.Add(-4); anotherSet.Add(15); anotherSet.Add(0); anotherSet.Add(-122); anotherSet.Add(35); Console.WriteLine("Set 2: {0}", anotherSet); set.Union(anotherSet); Console.WriteLine("Set after union: {0}", set); set.Intersect(anotherSet); Console.WriteLine("Set after intersect: {0}", set); set.Clear(); Console.WriteLine("Set contains {0} items after clear", set.Count); }
public void HashedSetIntersectNoCommonElements() { HashedSet <int> firstSet = new HashedSet <int>(); int firstSetLength = 5; for (int i = 0; i < firstSetLength; i++) { firstSet.Add(i); } HashedSet <int> secondSet = new HashedSet <int>(); int secondSetLength = 5; for (int i = 0; i < secondSetLength; i++) { secondSet.Add(i + firstSetLength); } Assert.AreEqual(firstSetLength, firstSet.Count, "Incorrect set count!"); Assert.AreEqual(secondSetLength, secondSet.Count, "Incorrect set count!"); firstSet.Intersect(secondSet); Assert.AreEqual(0, firstSet.Count, "Incorrect amount of elements after union"); }
public void Intersect_Test() { HashedSet<int> set = new HashedSet<int>(); HashedSet<int> otherSet = new HashedSet<int>(); set.Add(1); set.Add(2); set.Add(3); otherSet.Add(3); otherSet.Add(4); otherSet.Add(5); set.Intersect(otherSet); StringBuilder actual = new StringBuilder(); foreach (var item in set) { actual.Append(item + " "); } string expected = "3 "; Assert.AreEqual(expected, actual.ToString()); }
public void UpdateReservedWordsInDialect() { var reservedDb = new HashedSet<string>(); var configuration = TestConfigurationHelper.GetDefaultConfiguration(); var dialect = Dialect.Dialect.GetDialect(configuration.Properties); var connectionHelper = new ManagedProviderConnectionHelper(configuration.Properties); connectionHelper.Prepare(); try { var metaData = dialect.GetDataBaseSchema(connectionHelper.Connection); foreach (var rw in metaData.GetReservedWords()) { reservedDb.Add(rw.ToLowerInvariant()); } } finally { connectionHelper.Release(); } var sf = (ISessionFactoryImplementor) configuration.BuildSessionFactory(); SchemaMetadataUpdater.Update(sf); var match = reservedDb.Intersect(sf.Dialect.Keywords); Assert.That(match, Is.EquivalentTo(reservedDb)); }
static void Main() { HashedSet<string> myBestFriends = new HashedSet<string>(); myBestFriends.Add("Ivan"); myBestFriends.Add("Daniel"); myBestFriends.Add("Cecilia"); Console.WriteLine(myBestFriends.Count); myBestFriends.Remove("Cecilia"); Console.WriteLine(myBestFriends.Count); HashedSet<string> yourBestFriends = new HashedSet<string>(); yourBestFriends.Add("Petar"); yourBestFriends.Add("Daniel"); yourBestFriends.Add("Monika"); HashedSet<string> allBestFriends = myBestFriends.Union(yourBestFriends); Console.WriteLine("All best friends: "); foreach (var item in allBestFriends.setOfData) { Console.WriteLine("{0}", item.Value); } HashedSet<string> mutualBestFriends = myBestFriends.Intersect(yourBestFriends); Console.WriteLine("Mutual best friends: "); foreach (var item in mutualBestFriends.setOfData) { Console.WriteLine("{0}", item.Value); } }
public void TestIntersectMethodToReturnCorrectResults() { int matchedValue1 = 18; int matchedValue2 = -5; HashedSet <int> first = new HashedSet <int>(); first.Add(3); first.Add(matchedValue2); first.Add(matchedValue1); first.Add(14); HashedSet <int> second = new HashedSet <int>(); second.Add(20); second.Add(22); second.Add(matchedValue1); second.Add(290); second.Add(matchedValue2); second.Add(300); first.Intersect(second); Assert.AreEqual(2, first.Count); var testResult = first.Find(matchedValue1); Assert.AreEqual(matchedValue1, testResult); testResult = first.Find(matchedValue2); Assert.AreEqual(matchedValue2, testResult); }
public void AutoQuoteTableAndColumnsAtStratupIncludeKeyWordsImport() { var reservedDb = new HashedSet <string>(); var configuration = TestConfigurationHelper.GetDefaultConfiguration(); var dialect = Dialect.Dialect.GetDialect(configuration.Properties); var connectionHelper = new ManagedProviderConnectionHelper(configuration.Properties); connectionHelper.Prepare(); try { var metaData = dialect.GetDataBaseSchema(connectionHelper.Connection); foreach (var rw in metaData.GetReservedWords()) { reservedDb.Add(rw.ToLowerInvariant()); } } finally { connectionHelper.Release(); } configuration.SetProperty(Environment.Hbm2ddlKeyWords, "auto-quote"); configuration.AddResource("NHibernate.Test.Tools.hbm2ddl.SchemaMetadataUpdaterTest.HeavyEntity.hbm.xml", GetType().Assembly); var sf = (ISessionFactoryImplementor)configuration.BuildSessionFactory(); var match = reservedDb.Intersect(sf.Dialect.Keywords); Assert.That(match, Is.EquivalentTo(reservedDb)); }
public void TestIntersectMethodToReturnCorrectResultsWithStrings() { string matchedValue1 = "Java"; string matchedValue2 = "CSharp"; HashedSet <string> first = new HashedSet <string>(); first.Add("3"); first.Add(matchedValue2); first.Add(matchedValue1); first.Add("test"); HashedSet <string> second = new HashedSet <string>(); second.Add("testMethod"); second.Add("TestClass"); second.Add(matchedValue1); second.Add("TestData"); second.Add(matchedValue2); second.Add(" "); first.Intersect(second); Assert.AreEqual(2, first.Count); var testResult = first.Find(matchedValue1); Assert.AreEqual(matchedValue1, testResult); testResult = first.Find(matchedValue2); Assert.AreEqual(matchedValue2, testResult); }
public void UpdateReservedWordsInDialect() { var reservedDb = new HashedSet <string>(); var configuration = TestConfigurationHelper.GetDefaultConfiguration(); var dialect = Dialect.Dialect.GetDialect(configuration.Properties); var connectionHelper = new ManagedProviderConnectionHelper(configuration.Properties); connectionHelper.Prepare(); try { var metaData = dialect.GetDataBaseSchema(connectionHelper.Connection); foreach (var rw in metaData.GetReservedWords()) { reservedDb.Add(rw.ToLowerInvariant()); } } finally { connectionHelper.Release(); } var sf = (ISessionFactoryImplementor)configuration.BuildSessionFactory(); SchemaMetadataUpdater.Update(sf); var match = reservedDb.Intersect(sf.Dialect.Keywords); Assert.That(match, Is.EquivalentTo(reservedDb)); }
public void Intersect_Test() { HashedSet <int> set = new HashedSet <int>(); HashedSet <int> otherSet = new HashedSet <int>(); set.Add(1); set.Add(2); set.Add(3); otherSet.Add(3); otherSet.Add(4); otherSet.Add(5); set.Intersect(otherSet); StringBuilder actual = new StringBuilder(); foreach (var item in set) { actual.Append(item + " "); } string expected = "3 "; Assert.AreEqual(expected, actual.ToString()); }
public void IntersectShouldWorkCorrectlyOnValidInput() { var set1 = new HashedSet <int>(); set1.Add(1); set1.Add(2); set1.Add(3); var set2 = new HashedSet <int>(); set2.Add(2); set2.Add(3); set2.Add(4); var expectedResultElements = new List <int>() { 2, 3 }; set1.Intersect(set2); foreach (var value in set1) { expectedResultElements.Remove(value); } Assert.AreEqual(0, expectedResultElements.Count); }
public void IntersectShouldThrowOnInvalidInput() { var set1 = new HashedSet <int>(); set1.Add(5); set1.Add(3); set1.Intersect(null); }
public static void Main(string[] args) { var hashedSet1 = new HashedSet<string>(); for (int i = 0; i < 4; i++) { hashedSet1.Add("pesho" + i); } Console.ForegroundColor = ConsoleColor.Yellow; Console.WriteLine("First hashed set:"); foreach (var item in hashedSet1) { Console.WriteLine(item); } var hashedSet2 = new HashedSet<string>(); for (int i = 2; i < 6; i++) { hashedSet2.Add("pesho" + i); } Console.ForegroundColor = ConsoleColor.Cyan; Console.WriteLine("\nSecond hashed set:"); foreach (var item in hashedSet2) { Console.WriteLine(item); } var intersected = hashedSet1.Intersect(hashedSet2); Console.ForegroundColor = ConsoleColor.White; Console.WriteLine("\nIntersected:"); foreach (var item in intersected) { Console.WriteLine(item); } var unioned = hashedSet1.Union(hashedSet2); Console.ForegroundColor = ConsoleColor.Green; Console.WriteLine("\nUnioned:"); foreach (var item in unioned) { Console.WriteLine(item); } }
public static void Main() { HashedSet<string> hashedSet = new HashedSet<string>(); for (int i = 0; i < 5; i++) { hashedSet.Add("item " + i); } var set = new List<string> { "item 3", "item 5" }; var unionSet = hashedSet.Union(set); var intersectSet = hashedSet.Intersect(set); Console.WriteLine("Union: {0}", string.Join(", ", unionSet)); Console.WriteLine("Intersect: {0}", string.Join(", ", intersectSet)); }
public IUndoableEdit MergeCombinations(IList <Combination> combinationsToMerge) { if (combinationsToMerge.Count < 1) { throw new ArgumentException("The list of combinations to merge is empty"); } if (combination.Origin != CombinationOrigin.PERMUTATION) { throw new InvalidOperationException("The merge is available only for combinations generated by permutation"); } CompoundEdit ce = new CompoundEdit(); //first merge the effects ce.AddEdit(MergeEffects(combinationsToMerge)); foreach (Combination combi in combinationsToMerge) { if (!combination.Combinations.Contains(combi) && combination != combi) { ce.AddEdit(EditFactory.instance.CreateAddCombinationEdit(combination, combi)); combination.AddCombination(combi); } } //remove all test cases referenced by the merged combinations (invalid testcases now) if (combination.ParentDependency != null && combination.ParentDependency.ParentStructure != null) { ISet <Combination> combinationsMerged = new HashedSet <Combination>(combinationsToMerge); IList <TestCase> deletedTCs = new List <TestCase>(); foreach (TestCase testCase in combination.ParentDependency.ParentStructure.TestCases) { ISet <Combination> tcCombinations = new HashedSet <Combination>(testCase.Combinations); if (tcCombinations.Intersect(combinationsMerged).Count > 0) { //delete the referenced test case deletedTCs.Add(testCase); } } foreach (TestCase tc in deletedTCs) { ce.AddEdit( EditFactory.instance.CreateRemoveTestCaseEdit(combination.ParentDependency.ParentStructure, tc)); combination.ParentDependency.ParentStructure.RemoveTestCase(tc); } } return(ce); }
static void Main(string[] args) { var set = new HashedSet<int>(); set.Add(8); set.Add(8); set.Add(133); Console.WriteLine(set.Count); var set2 = new HashedSet<int>(); set2.Add(13); set2.Add(133); var res = set.Intersect(set2); Console.WriteLine(string.Join(", ", res)); }
static void Main(string[] args) { HashedSet <int> set = new HashedSet <int>(2); HashedSet <int> set1 = new HashedSet <int>(5); set.Add(3); set.Add(4); set.Add(5); set.Add(6); set.Add(7); set1.Add(5); set1.Add(7); set1.Add(13); set1.Add(43); set1.Add(123); var intersect = set.Intersect(set1); foreach (var item in intersect) { Console.WriteLine(item); } //Console.WriteLine("Count:{0}", set.Count); //set.Remove(5); //set.Add(15); //Console.WriteLine("Find:{0}", set.Find(3)); //Console.WriteLine("Items"); //foreach (var item in set) //{ // Console.WriteLine(item); //} //Console.WriteLine("Count:{0}", set.Count); //set.Clear(); //Console.WriteLine("Count:{0}", set.Count); //foreach (var item in set) //{ // Console.WriteLine(item); //} }
static void Main(string[] args) { HashedSet<int> set = new HashedSet<int>(2); HashedSet<int> set1 = new HashedSet<int>(5); set.Add(3); set.Add(4); set.Add(5); set.Add(6); set.Add(7); set1.Add(5); set1.Add(7); set1.Add(13); set1.Add(43); set1.Add(123); var intersect = set.Intersect(set1); foreach (var item in intersect) { Console.WriteLine(item); } //Console.WriteLine("Count:{0}", set.Count); //set.Remove(5); //set.Add(15); //Console.WriteLine("Find:{0}", set.Find(3)); //Console.WriteLine("Items"); //foreach (var item in set) //{ // Console.WriteLine(item); //} //Console.WriteLine("Count:{0}", set.Count); //set.Clear(); //Console.WriteLine("Count:{0}", set.Count); //foreach (var item in set) //{ // Console.WriteLine(item); //} }
static void Main() { HashedSet <string> mySet = new HashedSet <string>(); mySet.Add("Gogo"); mySet.Add("Mimi"); mySet.Add("Tosho"); mySet.Add("Pesho"); mySet.Add("Vankata"); HashedSet <string> otherSet = new HashedSet <string>(); otherSet.Add("Tosho"); otherSet.Add("Pesho"); otherSet.Add("Moni"); Console.WriteLine(mySet.Find("Gogo")); Console.WriteLine(mySet.Find("Gogo2")); mySet.Remove("Gogo"); var union = mySet.Union(otherSet); var intersect = mySet.Intersect(otherSet); Console.WriteLine(mySet.Count()); Console.WriteLine("\nMySet"); foreach (var item in mySet) { Console.WriteLine(item.ToString()); } Console.WriteLine("\nUnion"); foreach (var item in union) { Console.WriteLine(item.ToString()); } Console.WriteLine("\nIntersect"); foreach (var item in intersect) { Console.WriteLine(item.ToString()); } }
internal static void Main() { HashedSet<int> test = new HashedSet<int>(); HashedSet<int> other = new HashedSet<int>(); test.Add(1); test.Add(2); test.Add(3); test.Add(4); test.Add(5); test.Add(6); other.Add(4); other.Add(5); other.Add(6); other.Add(7); other.Add(8); Console.WriteLine("Initial hash set:"); Console.WriteLine(string.Join(", ", test)); Console.WriteLine("--------------------------------------------------------------"); Console.WriteLine("After removal of 3:"); test.Remove(3); Console.WriteLine(string.Join(", ", test)); Console.WriteLine("--------------------------------------------------------------"); Console.WriteLine("Is 1 found? {0}", test.Find(1)); Console.WriteLine("Is 3 found? {0}", test.Find(3)); Console.WriteLine("--------------------------------------------------------------"); Console.WriteLine("First hash set:"); Console.WriteLine(string.Join(", ", test)); Console.WriteLine("Member count: {0}", test.Count); Console.WriteLine("--------------------------------------------------------------"); Console.WriteLine("Second hash set:"); Console.WriteLine(string.Join(", ", other)); Console.WriteLine("Member count: {0}", other.Count); Console.WriteLine("--------------------------------------------------------------"); Console.WriteLine("Intersect of the first and second:"); Console.WriteLine(string.Join(", ", test.Intersect(other))); Console.WriteLine("--------------------------------------------------------------"); Console.WriteLine("Union of the first and second:"); Console.WriteLine(string.Join(", ", test.Union(other))); Console.WriteLine("--------------------------------------------------------------"); test.Clear(); Console.WriteLine("First hash set after clear:"); Console.WriteLine(string.Join(", ", test)); }
static void Main() { HashedSet <int> hSet = new HashedSet <int>(); hSet.Add(5); hSet.Add(15); hSet.Add(5); Console.WriteLine(hSet.Find(45)); Console.WriteLine(hSet.Find(15)); hSet.Remove(5); Console.WriteLine(hSet.Find(5)); hSet.Clear(); Console.WriteLine(hSet.Count); hSet.Add(5); hSet.Add(15); hSet.Add(25); hSet.Add(35); HashedSet <int> hSetTwo = new HashedSet <int>(); hSetTwo.Add(4); hSetTwo.Add(24); hSetTwo.Add(25); hSetTwo.Add(35); var newIntersectedSet = hSet.Intersect(hSetTwo); foreach (var item in newIntersectedSet.Keys) { Console.WriteLine(item); } var newUnitedSet = hSet.Union(hSetTwo); foreach (var item in newUnitedSet.Keys) { Console.WriteLine(item); } }
static void Main() { HashedSet<int> hSet = new HashedSet<int>(); hSet.Add(5); hSet.Add(15); hSet.Add(5); Console.WriteLine(hSet.Find(45)); Console.WriteLine(hSet.Find(15)); hSet.Remove(5); Console.WriteLine(hSet.Find(5)); hSet.Clear(); Console.WriteLine(hSet.Count); hSet.Add(5); hSet.Add(15); hSet.Add(25); hSet.Add(35); HashedSet<int> hSetTwo = new HashedSet<int>(); hSetTwo.Add(4); hSetTwo.Add(24); hSetTwo.Add(25); hSetTwo.Add(35); var newIntersectedSet = hSet.Intersect(hSetTwo); foreach (var item in newIntersectedSet.Keys) { Console.WriteLine(item); } var newUnitedSet = hSet.Union(hSetTwo); foreach (var item in newUnitedSet.Keys) { Console.WriteLine(item); } }
/* Task 5: * Implement the data structure "set" in a class HashedSet<T> using your class HashTable<K,T> * to hold the elements. Implement all standard set operations like Add(T), Find(T), Remove(T), * Count, Clear(), union and intersect. */ static void Main(string[] args) { var setOne = new HashedSet<int>(); for (int i = 0; i < 50; i++) { setOne.Add(i); } Console.WriteLine(setOne.Count()); for (int i = 25; i < 50; i++) { setOne.Remove(i); } Console.WriteLine(setOne.Count()); var setTwo = new HashedSet<int>(); setTwo.Add(100); setTwo.Add(101); setTwo.Add(102); setTwo.Add(103); setTwo.Add(104); setTwo.Add(105); //Saving all results from Union setOne = setOne.Union(setTwo); Console.WriteLine(setOne.Count()); setTwo.Clear(); for (int i = 10; i < 25; i++) { setTwo.Add(i); } //Saving only the intersect Results setOne = setOne.Intersect(setTwo); Console.WriteLine(setOne.Count()); }
static void Main(string[] args) { var set = new HashedSet<int>(); set.Add(1); set.Add(1); set.Add(1); set.Add(1); Console.WriteLine(set.Count); set.Add(2); set.Add(3); set.Add(4); set.Add(10); var otherSet = new HashedSet<int>(); otherSet.Add(1); otherSet.Add(2); otherSet.Add(190); Console.WriteLine(string.Join(",",set.Union(otherSet))); Console.WriteLine(string.Join(",", set.Intersect(otherSet))); }
public void TestIntersectMethodWhenThereAreNoMathes() { HashedSet <string> first = new HashedSet <string>(); first.Add("3"); first.Add("PHP"); first.Add("Python"); first.Add("test"); HashedSet <string> second = new HashedSet <string>(); second.Add("testMethod"); second.Add("TestClass"); second.Add("Ruby On Rails"); second.Add("TestData"); second.Add("Cloud"); second.Add(" "); first.Intersect(second); Assert.AreEqual(0, first.Count); }
static void Main(string[] args) { var set = new HashedSet<int>(new[] { 1, 2, 3, 4, 5 }); Console.WriteLine("Set: {0}", set); // Add set.Add(6); Console.WriteLine("Add '6' -> {0}", set); // Add existing set.Add(6); Console.WriteLine("Add '6' -> {0}", set); // Find Console.WriteLine("Find '0': {0}", set.Find(0)); Console.WriteLine("Find '6': {0}", set.Find(6)); // Remove set.Remove(3); Console.WriteLine("Remove '3' -> {0}", set); // Count Console.WriteLine("Number of elements: {0}", set.Count); // Union var collection = new[] { 3, 7 }; set.Union(collection); Console.WriteLine("Union with [{0}] -> {1}", string.Join(", ", collection), set); // Intersection collection = new[] { 5, 6, 7, 8, 9 }; set.Intersect(collection); Console.WriteLine("Intersection with [{0}] -> {1}", string.Join(", ", collection), set); // Clear set.Clear(); Console.WriteLine("Clear set..."); Console.WriteLine("Number of elements: {0}", set.Count); }
static void Main(string[] args) { HashedSet<int> hashedSet = new HashedSet<int>(); for (int i = 0; i < 10; i++) { hashedSet.Add(i); } Console.WriteLine("First hashedset -> {0}", string.Join(" ", hashedSet.Values)); HashedSet<int> otherHashedSet = new HashedSet<int>(); for (int i = 5; i < 15; i++) { otherHashedSet.Add(i); } Console.WriteLine("Second hashedset -> {0}", string.Join(" ", otherHashedSet.Values)); var unionSet = hashedSet.Union(otherHashedSet); Console.WriteLine("After union -> {0}", string.Join(" ", unionSet.Values)); var intersectSet = hashedSet.Intersect(otherHashedSet); Console.WriteLine("After intersect -> {0}", string.Join(" ", intersectSet.Values)); }
public void IntersectExpectedToWorkProperly() { var firstSet = new HashedSet<string>(); for (int i = 1; i <= 10; i++) { firstSet.Add("test" + i); } var secondSet = new HashedSet<string>(); for (int i = 6; i <= 15; i++) { secondSet.Add("test" + i); } firstSet.Intersect(secondSet); Assert.AreEqual(5, firstSet.Count); for (int i = 6; i <= 10; i++) { Assert.IsTrue(firstSet.Find("test" + i)); } }
public void TestIntersectShouldProperlyWork() { var set1 = new HashedSet<string>(); set1.Add("Pesho"); set1.Add("Tosho"); var set2 = new HashedSet<string>(); set2.Add("Pesho"); set2.Add("Maria"); var result = set1.Intersect(set2); Assert.AreEqual(1, result.Count); }
public void AutoQuoteTableAndColumnsAtStratupIncludeKeyWordsImport() { var reservedDb = new HashedSet<string>(); var configuration = TestConfigurationHelper.GetDefaultConfiguration(); var dialect = Dialect.Dialect.GetDialect(configuration.Properties); var connectionHelper = new ManagedProviderConnectionHelper(configuration.Properties); connectionHelper.Prepare(); try { var metaData = dialect.GetDataBaseSchema(connectionHelper.Connection); foreach (var rw in metaData.GetReservedWords()) { reservedDb.Add(rw.ToLowerInvariant()); } } finally { connectionHelper.Release(); } configuration.SetProperty(Environment.Hbm2ddlKeyWords, "auto-quote"); configuration.AddResource("NHibernate.Test.Tools.hbm2ddl.SchemaMetadataUpdaterTest.HeavyEntity.hbm.xml", GetType().Assembly); var sf = (ISessionFactoryImplementor)configuration.BuildSessionFactory(); var match = reservedDb.Intersect(sf.Dialect.Keywords); Assert.That(match, Is.EquivalentTo(reservedDb)); }
public void HashedSetIntersect() { HashedSet<int> firstSet = new HashedSet<int>(); int firstSetLength = 5; for (int i = 0; i < firstSetLength; i++) { firstSet.Add(i); } HashedSet<int> secondSet = new HashedSet<int>(); int secondSetLength = 5; for (int i = 0; i < secondSetLength; i++) { secondSet.Add(i); } Assert.AreEqual(firstSetLength, firstSet.Count, "Incorrect set count!"); Assert.AreEqual(secondSetLength, secondSet.Count, "Incorrect set count!"); firstSet.Intersect(secondSet); for (int i = 0; i < firstSetLength; i++) { Assert.IsTrue(firstSet.Contains(i), "Incorrect intersect"); } Assert.AreEqual(firstSetLength, firstSet.Count, "Incorrect amount of elements after union"); }