public void CreateFullyConnected_ConnectsCorrectly(int numPossibilities, int numRequired, bool asConcrete)
{
int size = 4;
var puzzle = new Puzzle(size);
var matrix = ExactCoverGraph.Create(puzzle);
var possibilities = Possibilities.CreatePossibilities(new Coordinate(), numPossibilities);
Objective objective;
if (asConcrete)
{
objective = Objective.CreateFullyConnected(matrix,
new ReadOnlySpan <Possibility>(possibilities),
numRequired);
}
else
{
objective = Objective.CreateFullyConnected(matrix,
new ReadOnlySpan <IPossibility>(possibilities),
numRequired);
}
Assert.True(objective.AllUnknownPossibilitiesAreConcrete);
Assert.True(((IObjective)objective).IsRequired);
Assert.Equal(numPossibilities == numRequired, objective.AllUnknownPossibilitiesAreRequired);
Assert.NotEqual(NodeState.SELECTED, objective.State);
Assert.Equal(possibilities.Length, objective.CountUnknown);
Assert.Equal(numRequired, objective.TotalCountToSatisfy);
Assert.All(possibilities,
p => Assert.Contains(p, ((IObjective)objective).GetUnknownDirectPossibilities()));
Assert.All(((IObjective)objective).GetUnknownDirectPossibilities(),
p => Assert.Contains(p, possibilities));
Assert.Contains(objective, matrix.GetUnsatisfiedRequiredObjectivesWithConcretePossibilities());
}
public void CreateWithPossibilities_NeedsMoreThanPossible_Throws()
{
var possibilities = Possibilities.CreatePossibilities(new Coordinate(), 1);
Assert.Throws <ArgumentException>(
() => OptionalObjective.CreateWithPossibilities(possibilities, 2));
}
public void CascadingDropUpDownUpWithDropAtMidpoint()
{
var puzzle = new Puzzle(4);
var matrix = ExactCoverGraph.Create(puzzle);
var possibilities = Possibilities.CreatePossibilities(new Coordinate(), 3);
var required = Objective.CreateFullyConnected(matrix, new ReadOnlySpan <Possibility>(possibilities), 1);
var fakePossibility = new FakePossibility();
var optional = OptionalObjective.CreateWithPossibilities(
possibilities[1..3], 2);
public void CreateWithPossibilities_ConnectsCorrectly(int numPossibilities, int numToSatisfy)
{
var possibilities = Possibilities.CreatePossibilities(new Coordinate(), numPossibilities);
var concreteObjective = OptionalObjective.CreateWithPossibilities(possibilities, numToSatisfy);
IObjective objective = concreteObjective;
Assert.Equal(numToSatisfy, concreteObjective.TotalCountToSatisfy);
Assert.Equal(NodeState.UNKNOWN, concreteObjective.State);
Assert.False(objective.IsRequired);
Assert.Equal(
new HashSet <IPossibility>(possibilities),
new HashSet <IPossibility>(objective.GetUnknownDirectPossibilities()));
}
public void CreateFullyConnected_WithOptionalObjectives_ConnectsCorrectly()
{
var puzzle = new Puzzle(4);
var matrix = ExactCoverGraph.Create(puzzle);
var optionalObjectives = new OptionalObjective[] {
OptionalObjective.CreateWithPossibilities(Possibilities.CreatePossibilities(new Coordinate(), 2), 1),
OptionalObjective.CreateWithPossibilities(Possibilities.CreatePossibilities(new Coordinate(), 2), 1),
};
var concreteObjective = Objective.CreateFullyConnected(matrix, optionalObjectives, 1);
IObjective objective = concreteObjective;
Assert.Equal(
new HashSet <IPossibility>(optionalObjectives),
new HashSet <IPossibility>(objective.GetUnknownDirectPossibilities()));
}
public void CascadingDropUpDownUp()
{
var puzzle = new Puzzle(4);
var matrix = ExactCoverGraph.Create(puzzle);
var possibilities = Possibilities.CreatePossibilities(new Coordinate(), 2);
var required = Objective.CreateFullyConnected(matrix, new ReadOnlySpan <Possibility>(possibilities), 1);
var fakePossibility = new FakePossibility();
var optional = OptionalObjective.CreateWithPossibilities(
possibilities.Cast <IPossibility>().ToArray(), 2);
var fakeLinkToOptional = Link.CreateConnectedLink(fakePossibility, optional);
var separateRequired = Objective.CreateFullyConnected(matrix, new IPossibility[] { optional }, 1);
// Additionally try one where optional ends up dropped before the cascade somehow... maybe add one to possibilities and to optional's countToSatisfy.
Assert.True(possibilities[0].TrySelect());
Assert.Equal(NodeState.SELECTED, possibilities[0].State);
Assert.Equal(NodeState.DROPPED, possibilities[1].State);
Assert.Equal(NodeState.UNKNOWN, optional.State);
Assert.Empty(fakePossibility.DroppedFromObjectives);
Assert.Equal(NodeState.SELECTED, required.State);
Assert.NotEqual(NodeState.SELECTED, separateRequired.State);
Assert.True(((IObjective)optional).TrySelectPossibility(fakeLinkToOptional));
Assert.Equal(NodeState.SELECTED, possibilities[0].State);
Assert.Equal(NodeState.DROPPED, possibilities[1].State);
Assert.Equal(NodeState.SELECTED, optional.State);
Assert.Equal(NodeState.SELECTED, required.State);
Assert.Equal(NodeState.SELECTED, separateRequired.State);
((IObjective)optional).DeselectPossibility(fakeLinkToOptional);
Assert.Equal(NodeState.SELECTED, possibilities[0].State);
Assert.Equal(NodeState.DROPPED, possibilities[1].State);
Assert.Equal(NodeState.UNKNOWN, optional.State);
Assert.Empty(fakePossibility.DroppedFromObjectives);
Assert.Equal(NodeState.SELECTED, required.State);
Assert.NotEqual(NodeState.SELECTED, separateRequired.State);
Assert.False(((IObjective)optional).TryDropPossibility(fakeLinkToOptional));
}
public void CreateFullyConnected_NeedsMoreThanPossible_Throws(bool asConcrete)
{
int size = 4;
var puzzle = new Puzzle(size);
var matrix = ExactCoverGraph.Create(puzzle);
var possibilities = Possibilities.CreatePossibilities(new Coordinate(), 1);
Assert.Single(possibilities);
Assert.Throws <ArgumentException>(
() =>
{
if (asConcrete)
{
Objective.CreateFullyConnected(matrix, new ReadOnlySpan <Possibility>(possibilities), possibilities.Length + 1);
}
else
{
Objective.CreateFullyConnected(matrix, new ReadOnlySpan <IPossibility>(possibilities), possibilities.Length + 1);
}
});
}
