public void DetermineUnionWithEnumerable() { IImmutableSet <int> seta = new ImmutableSet64().Add(1, 2, 3); var setb = Enumerable.Range(3, 3); seta.Union(setb).SequenceEqual(Enumerable.Range(1, 5)).Should().BeTrue(); }
public void CompareCreationTime() { var timer = new Stopwatch(); timer.Start(); for (int i = 0; i < 10_000; i++) { var set = ImmutableHashSet <int> .Empty; for (int j = 0; j < 64; j++) { set = set.Add(j); } } timer.Stop(); double time1 = timer.Elapsed.TotalMilliseconds; timer.Restart(); for (int i = 0; i < 10_000; i++) { var set = new ImmutableSet64(); for (int j = 0; j < 64; j++) { set = set.Add(j); } } timer.Stop(); double time2 = timer.Elapsed.TotalMilliseconds; var ratio = time1 / time2; time2.Should().BeLessThan(time1); }
public void ShiftValues() { var set = new ImmutableSet64().Add(1); set.Shift(1) .Single() .Should() .Be(2); set.Shift(-1) .Single() .Should() .Be(0); set.Shift(-2) .IsEmpty .Should() .BeTrue(); set = new ImmutableSet64().Add(0, 1, 2, 3, 12, 61, 62, 63); set.Shift(-2) .SequenceEqual(new int[] { 0, 1, 10, 59, 60, 61 }) .Should() .BeTrue(); set.Shift(2) .SequenceEqual(new int[] { 2, 3, 4, 5, 14, 63 }) .Should() .BeTrue(); }
public void RemoveItems() { var set = new ImmutableSet64().Add(1, 2, 3); var removed = set.Remove(2); set.Contains(2).Should().BeTrue(); removed.Contains(2).Should().BeFalse(); }
public void TrackCount() { var seta = new ImmutableSet64().Add(1, 2, 4, 5, 6, 30, 31, 32, 33, 34); seta.Count.Should().Be(10); seta = seta.Intersect(new ImmutableSet64().Add(1, 2, 4, 8, 16, 32)); seta.Count.Should().Be(4); }
public void BeClearable() { var set = new ImmutableSet64().Add(1); set = set.Clear(); set.Contains(1).Should().BeFalse(); set.IsEmpty.Should().BeTrue(); }
public void DetermineEquality() { var set = new ImmutableSet64().Add(1, 2, 3); set.SetEquals(new ImmutableSet64().Add(1, 2, 3)).Should().BeTrue(); set.Equals(new ImmutableSet64().Add(1, 2, 3)).Should().BeTrue(); set.Equals(14ul).Should().BeTrue(); }
public void DetermineOverlapWithEnumerable() { IImmutableSet <int> seta = new ImmutableSet64().Add(1, 2, 3); var setb = Enumerable.Range(3, 3); var setc = Enumerable.Range(5, 3); seta.Overlaps(setb).Should().BeTrue(); seta.Overlaps(setc).Should().BeFalse(); }
public void ContainItems() { var set = new ImmutableSet64().Add(1, 3, 10); for (int i = 0; i < 64; i++) { set.Contains(i).Should().Be(i == 1 | i == 3 | i == 10); } }
public void BeImmutable() { var seta = new ImmutableSet64().Add(3, 12); var setb = seta.Add(10); seta.Contains(10).Should().BeFalse(); setb.Contains(10).Should().BeTrue(); setb.Contains(3).Should().BeTrue(); }
public void DetermineIntersectionWithEnumerable() { IImmutableSet <int> seta = new ImmutableSet64().Add(1, 2, 4, 8, 16, 32); var setb = Enumerable.Range(1, 5); seta.Intersect(setb) .SequenceEqual(new int[] { 1, 2, 4 }) .Should() .BeTrue(); }
public void ExcludeEnumerable() { IImmutableSet <int> seta = new ImmutableSet64().Add(1, 2, 4, 8, 16, 32); var setb = Enumerable.Range(1, 5); seta.Except(setb) .SequenceEqual(new int[] { 8, 16, 32 }) .Should() .BeTrue(); }
public void DetermineOverlapWithSet() { var seta = new ImmutableSet64().Add(1, 2, 3); var setb = new ImmutableSet64().Add(3, 4, 5); var setc = new ImmutableSet64().Add(5, 6, 7); seta.Overlaps(setb).Should().BeTrue(); seta.Overlaps(setc).Should().BeFalse(); setb.Overlaps(setc).Should().BeTrue(); }
public void ExcludeSets() { var seta = new ImmutableSet64().Add(1, 2, 4, 8, 16, 32); var setb = new ImmutableSet64().Add(1, 2, 3, 4, 5); seta.Except(setb) .SequenceEqual(new int[] { 8, 16, 32 }) .Should() .BeTrue(); }
public void DetermineIntersectionWithSet() { var seta = new ImmutableSet64().Add(1, 2, 4, 8, 16, 32); var setb = new ImmutableSet64().Add(1, 2, 3, 4, 5); seta.Intersect(setb) .SequenceEqual(new int[] { 1, 2, 4 }) .Should() .BeTrue(); }
public void DetermineProperSupersetOfSet() { var seta = new ImmutableSet64().Add(1, 2, 4, 8, 16, 32); var setb = new ImmutableSet64().Add(1, 2, 3, 4, 5); var setc = new ImmutableSet64().Add(1, 2, 4); // proper superset should contain all values in subset seta.IsProperSupersetOf(setb).Should().BeFalse(); // proper superset should contain some values not in subset seta.IsProperSupersetOf(seta).Should().BeFalse(); seta.IsProperSupersetOf(setc).Should().BeTrue(); }
public void DetermineProperSupersetOfEnumerable() { IImmutableSet <int> seta = new ImmutableSet64().Add(1, 2, 4, 8, 16, 32); var setb = Enumerable.Range(1, 5); var setc = new int[] { 1, 2, 4 }; // proper superset should contain all values in subset seta.IsProperSupersetOf(setb).Should().BeFalse(); // proper superset should contain some values not in subset seta.IsProperSupersetOf(new int[] { 1, 2, 4, 8, 16, 32 }).Should().BeFalse(); seta.IsProperSupersetOf(setc).Should().BeTrue(); }
public void DetermineProperSubsetOfEnumerable() { var seta = new int[] { 1, 2, 4, 8, 16, 32 }; IImmutableSet <int> setb = new ImmutableSet64().Add(1, 2, 3, 4, 5); IImmutableSet <int> setc = new ImmutableSet64().Add(1, 2, 4); // proper subset should not include items not in super set setb.IsProperSubsetOf(seta).Should().BeFalse(); // proper subset should not contain all items in super set setc.IsProperSubsetOf(new int[] { 1, 2, 4 }).Should().BeFalse(); // proper subset should only contain values in super set setc.IsProperSubsetOf(seta).Should().BeTrue(); }
public void ShiftAndFillValues() { var seta = new ImmutableSet64().Add(0); var setb = new ImmutableSet64().Add(63); seta.Shift(1, setb) .SequenceEqual(new int[] { 0, 1 }) .Should().BeTrue(); seta = new ImmutableSet64().Add(63); setb = new ImmutableSet64().Add(1, 7); seta.Shift(-2, setb) .SequenceEqual(new int[] { 61, 63 }) .Should() .BeTrue(); }
public void CountBenchmark() { int faster = 0; double fast_total = 0; int slower = 0; double slow_total = 0; Random r = new Random(); for (int i = 0; i < ROUNDS; i++) { var count = (r.Next() % 64) + 1; var values = Enumerable.Range(0, count).Select(_ => r.Next() % 64).OrderBy(v => v).Distinct().ToList(); var actual = values.Count; var set = new ImmutableSet64().AddRange(values); set.Count.Should().Be(actual); set.EnumerateAndCount.Should().Be(actual); int c = 0; var clock = new Stopwatch(); clock.Start(); for (int j = 0; j < ITERATIONS; j++) { c = set.Count; } clock.Stop(); double fast_ms = clock.Elapsed.TotalMilliseconds; fast_total += fast_ms; clock.Restart(); for (int j = 0; j < ITERATIONS; j++) { c = set.EnumerateAndCount; } clock.Stop(); double slow_ms = clock.Elapsed.TotalMilliseconds; slow_total += slow_ms; if (fast_ms < slow_ms) { faster++; } else { slower++; } } faster.Should().BeGreaterThan(slower * 10); // should be faster in at least 10x as many cases fast_total.Should().BeLessThan(slow_total / 4); // should be at least 4x as fast on average }
public void DetermineEqualityWithEnumerable() { IImmutableSet <int> set = new ImmutableSet64().Add(1, 2, 3); set.SetEquals(Enumerable.Range(1, 3)).Should().BeTrue(); }