internal bool HasConstraint(SymbolicValueConstraint constraint)
{
SymbolicValueConstraint storedConstraint;
return(constraints.TryGetValue(constraint.GetType(), out storedConstraint) &&
storedConstraint == constraint);
}
public void TrySetConstraint(SymbolicValueConstraint constraint,
IList <SymbolicValueConstraint> existingConstraints,
IList <IList <SymbolicValueConstraint> > expectedConstraintsPerProgramState)
{
// Arrange
var sv = new SymbolicValue();
var ps = SetupProgramState(sv, existingConstraints);
// Act
var programStates = sv.TrySetConstraint(constraint, ps).ToList();
// Assert
programStates.Should().HaveCount(expectedConstraintsPerProgramState.Count);
for (var i = 0; i < programStates.Count; i++)
{
var programState = programStates[i];
var expectedConstraints = expectedConstraintsPerProgramState[i];
foreach (var expectedConstraint in expectedConstraints)
{
programState.HasConstraint(sv, expectedConstraint).Should().BeTrue(
$"{expectedConstraint} should be present in returned ProgramState.");
}
}
}
internal SymbolicValueConstraints WithConstraint(SymbolicValueConstraint constraint)
{
var constraintsCopy = new Dictionary <Type, SymbolicValueConstraint>(constraints);
SetConstraint(constraint, constraintsCopy);
return(new SymbolicValueConstraints(constraintsCopy));
}
internal SymbolicValueConstraint GetConstraintOrDefault(Type constraintType)
{
SymbolicValueConstraint constraint = null;
return(constraints.TryGetValue(constraintType, out constraint)
? constraint
: null);
}
public override IEnumerable <ProgramState> TrySetOppositeConstraint(SymbolicValueConstraint constraint, ProgramState programState)
{
var negateConstraint = constraint?.OppositeForLogicalNot;
return(constraint is BoolConstraint
? TrySetConstraint(negateConstraint, programState).Union(TrySetConstraint(NullableValueConstraint.NoValue, programState))
: TrySetConstraint(negateConstraint, programState));
}
public override IEnumerable <ProgramState> TrySetConstraint(SymbolicValueConstraint constraint, ProgramState programState)
{
if (!(constraint is BoolConstraint boolConstraint))
{
return(new[] { programState });
}
return(Operand.TrySetConstraint(boolConstraint.OppositeForLogicalNot, programState));
}
internal T GetConstraintOrDefault <T>()
where T : SymbolicValueConstraint
{
SymbolicValueConstraint constraint = null;
return(constraints.TryGetValue(typeof(T), out constraint)
? (T)constraint
: null);
}
internal SymbolicValueConstraints WithoutConstraint(SymbolicValueConstraint constraint)
{
var constraintsCopy = new Dictionary <Type, SymbolicValueConstraint>(constraints);
if (constraintsCopy.Remove(constraint.GetType()))
{
return(new SymbolicValueConstraints(constraintsCopy));
}
return(this);
}
public static bool HasConstraint(this ISymbol symbol, SymbolicValueConstraint constraint, ProgramState programState)
{
var symbolicValue = programState.GetSymbolValue(symbol);
if (symbolicValue == null)
{
return(false);
}
return(symbolicValue.HasConstraint(constraint, programState));
}
public static ProgramState SetConstraint(this ISymbol symbol, SymbolicValueConstraint constraint, ProgramState programState)
{
var symbolicValue = programState.GetSymbolValue(symbol);
if (symbolicValue == null ||
symbolicValue.HasConstraint(constraint, programState))
{
return(programState);
}
return(symbolicValue.SetConstraint(constraint, programState));
}
public static ProgramState RemoveConstraint(this ISymbol symbol, SymbolicValueConstraint constraint, ProgramState programState)
{
var symbolicValue = programState.GetSymbolValue(symbol);
if (symbolicValue == null ||
!programState.HasConstraint(symbolicValue, constraint))
{
return(programState);
}
return(programState.RemoveConstraint(symbolicValue, constraint));
}
public static ImmutableDictionary <SymbolicValue, SymbolicValueConstraints> AddConstraintForSymbolicValue(
this ImmutableDictionary <SymbolicValue, SymbolicValueConstraints> constraintMap,
SymbolicValue symbolicValue, SymbolicValueConstraint constraint)
{
var constraints = ImmutableDictionary.GetValueOrDefault(constraintMap, symbolicValue);
var updatedConstraints = constraints != null
? constraints.WithConstraint(constraint)
: SymbolicValueConstraints.Create(constraint);
return(constraintMap.SetItem(symbolicValue, updatedConstraints));
}
public override IEnumerable <ProgramState> TrySetConstraint(SymbolicValueConstraint constraint, ProgramState programState)
{
if (!(constraint is BoolConstraint boolConstraint))
{
return(new[] { programState });
}
var nullabilityConstraint = boolConstraint == BoolConstraint.True
? ObjectConstraint.NotNull
: ObjectConstraint.Null;
return(MemberExpression.TrySetConstraint(nullabilityConstraint, programState));
}
private static void SetConstraint(SymbolicValueConstraint constraint,
Dictionary <Type, SymbolicValueConstraint> constraints)
{
constraints[constraint.GetType()] = constraint;
if (constraint is BoolConstraint)
{
constraints[typeof(ObjectConstraint)] = ObjectConstraint.NotNull;
if (constraints.ContainsKey(typeof(NullableValueConstraint)))
{
constraints[typeof(NullableValueConstraint)] = NullableValueConstraint.HasValue;
}
}
}
public override IEnumerable <ProgramState> TrySetConstraint(SymbolicValueConstraint constraint, ProgramState currentProgramState)
{
var boolConstraint = constraint as BoolConstraint;
if (boolConstraint == null)
{
return(new[] { currentProgramState });
}
var nullabilityConstraint = boolConstraint == BoolConstraint.True
? ObjectConstraint.NotNull
: ObjectConstraint.Null;
return(MemberExpression.TrySetConstraint(nullabilityConstraint, currentProgramState));
}
public static ImmutableDictionary <SymbolicValue, SymbolicValueConstraints> RemoveConstraintForSymbolicValue(
this ImmutableDictionary <SymbolicValue, SymbolicValueConstraints> constraintMap,
SymbolicValue symbolicValue, SymbolicValueConstraint constraint)
{
var constraints = ImmutableDictionary.GetValueOrDefault(constraintMap, symbolicValue);
if (constraints == null)
{
return(constraintMap);
}
var updatedConstraints = constraints.WithoutConstraint(constraint);
return(constraintMap.SetItem(symbolicValue, updatedConstraints));
}
public static ImmutableDictionary <SymbolicValue, SymbolicValueConstraints> AddConstraintTo <TRelationship>(
this ImmutableDictionary <SymbolicValue, SymbolicValueConstraints> constraintsMap,
SymbolicValue symbolicValue, SymbolicValueConstraint constraint, ProgramState programState)
where TRelationship : BinaryRelationship
{
var newConstraintsMap = constraintsMap;
var equalSymbols = programState.Relationships
.OfType <TRelationship>()
.Select(r => GetOtherOperandFromMatchingRelationship(symbolicValue, r))
.WhereNotNull();
foreach (var equalSymbol in equalSymbols.Where(e => !programState.HasConstraint(e, constraint)))
{
newConstraintsMap = newConstraintsMap.AddConstraintForSymbolicValue(equalSymbol, constraint);
}
return(newConstraintsMap);
}
public override IEnumerable <ProgramState> TrySetConstraint(SymbolicValueConstraint constraint, ProgramState programState)
{
if (!(constraint is BoolConstraint boolConstraint))
{
return(new[] { programState });
}
var relationship = GetRelationship(boolConstraint);
var newProgramState = programState.TrySetRelationship(relationship);
if (newProgramState == null)
{
return(Enumerable.Empty <ProgramState>());
}
return(new[] { newProgramState });
}
public override IEnumerable <ProgramState> TrySetConstraint(SymbolicValueConstraint constraint, ProgramState programState)
{
var boolConstraint = constraint as BoolConstraint;
if (boolConstraint == null)
{
return(new[] { programState });
}
SymbolicValueConstraints oldConstraints;
BoolConstraint oldBoolConstraint = null;
if (TryGetConstraints(programState, out oldConstraints))
{
oldBoolConstraint = oldConstraints.GetConstraintOrDefault <BoolConstraint>();
}
if (oldBoolConstraint != null /* could also be ObjectConstraint.NotNull, which can be overridden */ &&
oldBoolConstraint != boolConstraint)
{
return(Enumerable.Empty <ProgramState>());
}
SymbolicValueConstraints leftConstraints;
var leftHasConstraint = LeftOperand.TryGetConstraints(programState, out leftConstraints);
SymbolicValueConstraints rightConstraints;
var rightHasConstraint = RightOperand.TryGetConstraints(programState, out rightConstraints);
var relationship = GetRelationship(boolConstraint);
var newProgramState = programState.TrySetRelationship(relationship);
if (newProgramState == null)
{
return(Enumerable.Empty <ProgramState>());
}
if (!rightHasConstraint && !leftHasConstraint)
{
return(new[] { newProgramState });
}
return(SetConstraint(boolConstraint, leftConstraints, rightConstraints, newProgramState));
}
public override IEnumerable <ProgramState> TrySetConstraint(SymbolicValueConstraint constraint, ProgramState programState)
{
if (!(constraint is BoolConstraint boolConstraint))
{
return(new[] { programState });
}
if (boolConstraint == BoolConstraint.True)
{
return(ThrowIfTooMany(
LeftOperand.TrySetConstraint(BoolConstraint.True, programState)
.SelectMany(ps => RightOperand.TrySetConstraint(BoolConstraint.True, ps))));
}
return(ThrowIfTooMany(
LeftOperand.TrySetConstraint(BoolConstraint.True, programState)
.SelectMany(ps => RightOperand.TrySetConstraint(BoolConstraint.False, ps))
.Union(LeftOperand.TrySetConstraint(BoolConstraint.False, programState)
.SelectMany(ps => RightOperand.TrySetConstraint(BoolConstraint.True, ps)))
.Union(LeftOperand.TrySetConstraint(BoolConstraint.False, programState)
.SelectMany(ps => RightOperand.TrySetConstraint(BoolConstraint.False, ps)))));
}
public override IEnumerable <ProgramState> TrySetConstraint(SymbolicValueConstraint constraint,
ProgramState programState)
{
if (constraint == null)
{
return(new[] { programState });
}
if (constraint is ObjectConstraint)
{
var optionalConstraint = constraint == ObjectConstraint.Null
? NullableValueConstraint.NoValue
: NullableValueConstraint.HasValue;
return(TrySetConstraint(optionalConstraint, programState));
}
var oldConstraint = programState.Constraints.GetValueOrDefault(this)?
.GetConstraintOrDefault <NullableValueConstraint>();
if (constraint is NullableValueConstraint)
{
if (oldConstraint == null)
{
return(new[] { programState.SetConstraint(this, constraint) });
}
if (oldConstraint != constraint)
{
return(Enumerable.Empty <ProgramState>());
}
return(new[] { programState });
}
return(TrySetConstraint(NullableValueConstraint.HasValue, programState)
.SelectMany(ps => WrappedValue.TrySetConstraint(constraint, ps)));
}
internal virtual bool Implies(SymbolicValueConstraint constraint)
{
return this == constraint;
}
internal virtual bool Implies(SymbolicValueConstraint constraint)
{
return(this == constraint);
}
private void ShouldHaveConstraint(ProgramState ps, SymbolicValue sv, SymbolicValueConstraint expectedConstraint)
{
sv.TryGetConstraints(ps, out var constraints).Should().BeTrue();
constraints.HasConstraint(expectedConstraint).Should().BeTrue();
}
internal override bool Implies(SymbolicValueConstraint constraint)
{
return(base.Implies(constraint) ||
constraint == ObjectConstraint.NotNull);
}
public static SymbolicValueConstraints Create(SymbolicValueConstraint constraint)
{
return(new SymbolicValueConstraints(constraint));
}
private SymbolicValueConstraints(SymbolicValueConstraint constraint)
{
SetConstraint(constraint, constraints);
hashCode = ComputeHashcode();
}
private static void ShouldHaveConstraint(ProgramState ps, SymbolicValue sv, SymbolicValueConstraint constraint)
{
sv.TryGetConstraints(ps, out var existing).Should().BeTrue();
existing.HasConstraint(constraint).Should().BeTrue();
}
public static SymbolicValueConstraints Create(SymbolicValueConstraint constraint) => new SymbolicValueConstraints(constraint);
internal override bool Implies(SymbolicValueConstraint constraint)
{
return base.Implies(constraint) ||
constraint == ObjectConstraint.NotNull;
}
