public void ImmutableSetAdapter_Ctor_Succeeds() { const int NumberOfMethods = 17; int[] methodsCalled = new int[NumberOfMethods]; ImmutableHashSet <int> realSet = ImmutableHashSet <int> .Empty; System.Collections.Immutable.IImmutableSet <int> backingSet = new MockSystemImmutableSet <int>( addDelegate: x => { methodsCalled[0]++; return(realSet.Add(x)); }, clearDelegate: () => { methodsCalled[1]++; return(realSet.Clear()); }, containsDelegate: x => { methodsCalled[2]++; return(realSet.Contains(x)); }, countDelegate: () => { methodsCalled[3]++; return(realSet.Count); }, equalsDelegate: null, exceptDelegate: x => { methodsCalled[4]++; return(realSet.Except(x)); }, getEnumeratorDelegate: () => { methodsCalled[5]++; return(realSet.GetEnumerator()); }, getHashCodeDelegate: null, intersectDelegate: x => { methodsCalled[6]++; return(realSet.Intersect(x)); }, isProperSubsetOfDelegate: x => { methodsCalled[7]++; return(realSet.IsProperSubsetOf(x)); }, isProperSupersetOfDelegate: x => { methodsCalled[8]++; return(realSet.IsProperSupersetOf(x)); }, isSubsetOfDelegate: x => { methodsCalled[9]++; return(realSet.IsSubsetOf(x)); }, isSupersetOfDelegate: x => { methodsCalled[10]++; return(realSet.IsSupersetOf(x)); }, overlapsDelegate: x => { methodsCalled[11]++; return(realSet.Overlaps(x)); }, removeDelegate: x => { methodsCalled[12]++; return(realSet.Remove(x)); }, setEqualsDelegate: x => { methodsCalled[13]++; return(realSet.SetEquals(x)); }, symmetricExceptDelegate: x => { methodsCalled[14]++; return(realSet.SymmetricExcept(x)); }, toStringDelegate: null, tryGetValueDelegate: (int x, out int y) => { methodsCalled[15]++; return(realSet.TryGetValue(x, out y)); }, unionDelegate: x => { methodsCalled[16]++; return(realSet.Union(x)); }); #pragma warning disable IDE0028 // Simplify collection initialization. Intentionally calling .Add separately for clarity ImmutableSetAdapter <int> set = new ImmutableSetAdapter <int>(backingSet); #pragma warning restore IDE0028 // Simplify collection initialization. set.Add(12); set.Clear(); set.Contains(12); _ = set.Count; set.Except(Array.Empty <int>()); set.GetEnumerator(); set.Intersect(Array.Empty <int>()); set.IsProperSubsetOf(Array.Empty <int>()); set.IsProperSupersetOf(Array.Empty <int>()); set.IsSubsetOf(Array.Empty <int>()); set.IsSupersetOf(Array.Empty <int>()); set.Overlaps(Array.Empty <int>()); set.Remove(12); set.SetEquals(Array.Empty <int>()); set.SymmetricExcept(Array.Empty <int>()); set.TryGetValue(12, out _); set.Union(Array.Empty <int>()); for (int counter = 0; counter < NumberOfMethods; counter++) { Assert.AreEqual(1, methodsCalled[counter]); } }
/// <inheritdoc /> public IImmutableSet <T> SymmetricExcept(IEnumerable <T> other) { return(new SetEqualedReadOnlySet <T>(_set.SymmetricExcept(other))); }
/// <summary> /// Contant sentences are those that do not have a dependency on 'true' or 'does' facts /// </summary> /// <param name="sentenceForms"></param> /// <param name="dependencyGraph"></param> /// <returns></returns> private static ImmutableHashSet<ISentenceForm> GetConstantSentenceForms(ImmutableHashSet<ISentenceForm> sentenceForms, MultiDictionary<ISentenceForm, ISentenceForm> dependencyGraph) { MultiDictionary<ISentenceForm, ISentenceForm> augmentedGraph = AugmentGraphWithLanguageRules(dependencyGraph, sentenceForms); ImmutableHashSet<ISentenceForm> changingSentenceForms = DependencyGraphs.GetMatchingAndDownstream(sentenceForms, augmentedGraph, d => SentenceForms.TruePred(d) || SentenceForms.DoesPred(d)); return sentenceForms.SymmetricExcept(changingSentenceForms).ToImmutableHashSet(); }