public bool IsSupersetOf(CustomSet <T> other)
{
if (factory != other.factory)
{
throw new NotImplementedException();
}
return(set.IsSupersetOf(other.set));
}
public void TestReadingConditionalWhiteList()
{
var analyzer = VaultSafeAnalyzerFactorySource.CreateDefaultAnalyzer();
ImmutableHashSet <string> expected = ImmutableHashSet.Create(new[]
{
typeof(KeyValuePair <,>).FullName,
typeof(ImmutableArray <>).FullName,
typeof(ImmutableArray <> .Enumerator).FullName,
typeof(ImmutableList <>).FullName,
typeof(ImmutableList <> .Enumerator).FullName,
typeof(ImmutableDictionary <,>).FullName,
typeof(ImmutableDictionary <,> .Enumerator).FullName,
typeof(ImmutableSortedDictionary <,>).FullName,
typeof(ImmutableSortedDictionary <,> .Enumerator).FullName,
typeof(ImmutableHashSet <>).FullName,
typeof(ImmutableHashSet <> .Enumerator).FullName,
typeof(ImmutableSortedSet <>).FullName,
typeof(ImmutableSortedSet <> .Enumerator).FullName,
typeof(ImmutableStack <>).FullName,
typeof(ImmutableStack <> .Enumerator).FullName,
typeof(ImmutableQueue <>).FullName,
typeof(ImmutableQueue <> .Enumerator).FullName,
});
ImmutableHashSet <string> actual = analyzer.ConditionalGenericWhiteList;
Assert.IsTrue(actual.IsSupersetOf(expected));
}
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]);
}
}
public ImmutableSentenceFormModel(ImmutableList<Expression> gameDescription,
ImmutableHashSet<ISentenceForm> sentenceForms,
ImmutableHashSet<ISentenceForm> constantSentenceForms,
ImmutableHashSet<ISentenceForm> independentSentenceForms,
MultiDictionary<ISentenceForm, ISentenceForm> dependencyGraph,
MultiDictionary<ISentenceForm, Implication> rulesByForm,
MultiDictionary<ISentenceForm, Fact> trueSentencesByForm)
{
Debug.Assert(sentenceForms.IsSupersetOf(independentSentenceForms));
Debug.Assert(independentSentenceForms.IsSupersetOf(constantSentenceForms));
Debug.Assert(sentenceForms.IsSupersetOf(dependencyGraph.Keys));
Debug.Assert(sentenceForms.IsSupersetOf(dependencyGraph.Values));
Debug.Assert(sentenceForms.IsSupersetOf(rulesByForm.Keys));
Debug.Assert(sentenceForms.IsSupersetOf(trueSentencesByForm.Keys));
Description = gameDescription;
SentenceForms = sentenceForms;
ConstantSentenceForms = constantSentenceForms;
IndependentSentenceForms = independentSentenceForms;
_dependencyGraph = dependencyGraph;
_rulesByForm = rulesByForm;
_trueSentencesByForm = trueSentencesByForm;
}
public bool IsSupersetOf(IEnumerable <string> other)
{
return(_set.IsSupersetOf(other));
}
