public void TryRateAssignmentSet_RelationsPresent_SuccessCases(SetExpectation set)
{
Assert.True(GroupMatchSearchTransform.TryRateAssignmentSet(set.Members,
set.RelationRatings, set.LocalRelationIndices, set.RatingConfiguration, out var rating));
Assert.True(Mathf.Approximately(set.ApproximateExpectedRating, rating));
}
public void TryRateAssignmentSet_RelationsPresent_FailureCases(SetExpectation set)
{
Assert.False(GroupMatchSearchTransform.TryRateAssignmentSet(set.Members,
set.RelationRatings, set.LocalRelationIndices, set.RatingConfiguration, out var rating));
Assert.Zero(rating);
}
public void GetGroupSearchSpaceSizeTest(Dictionary <int, float>[] allMemberRatings, int expectedCount)
{
var memberIndices = new [] { 1, 2, 3, 4 };
var size = GroupMatchSearchTransform.GetGroupSearchSpaceSize(memberIndices, allMemberRatings);
Assert.AreEqual(expectedCount, size);
}
public void RemoveClaimedData()
{
var combo = new [] { 4, 5, 1 };
var allMemberExclusivities = new List <Exclusivity>
{
Exclusivity.Shared, Exclusivity.Reserved, Exclusivity.ReadOnly,
Exclusivity.Reserved, Exclusivity.Shared, Exclusivity.ReadOnly
};
var globalRatingSet = new List <Dictionary <int, float> >
{
new Dictionary <int, float> {
{ 0, 0.9f }, { 1, 0.7f }, { 4, 0.5f }, { 5, 0.2f }
},
new Dictionary <int, float> {
{ 5, 0.9f }
},
new Dictionary <int, float> {
{ 1, 0.9f }
},
new Dictionary <int, float> {
{ 2, 0.8f }, { 3, 0.7f }, { 4, 0.6f }, { 5, 0.5f }, { 10, 0.4f }, { 11, 0.2f }
},
new Dictionary <int, float> {
{ 4, 0.8f }, { 5, 0.7f }, { 13, 0.6f }, { 14, 0.5f }, { 1, 0.3f }, { 17, 0.2f }
},
new Dictionary <int, float> {
{ 7, 1f }, { 4, 0.9f }, { 9, 0.7f }, { 5, 0.5f }, { 30, 0.7f }
},
};
var selfMemberIndices = new [] { 0, 1, 2 };
var otherSetMemberIndices = new [] { 3, 4, 5 };
var member1 = globalRatingSet[3];
var member2 = globalRatingSet[4];
var member3 = globalRatingSet[5];
var member1CountBefore = member1.Count;
var member2CountBefore = member2.Count;
var member3CountBefore = member3.Count;
GroupMatchSearchTransform.RemoveClaimedData(combo, selfMemberIndices, otherSetMemberIndices,
allMemberExclusivities.ToArray(), globalRatingSet.ToArray());
// member 1 is reserved, so both shared and reserved IDs (4 & 5) should be gone
Assert.AreEqual(member1CountBefore - 2, member1.Count);
Assert.False(member1.ContainsKey(combo[0]));
Assert.False(member1.ContainsKey(combo[1]));
// because member 2 is shared, we only remove the reserved ID from its options
Assert.AreEqual(member2CountBefore - 1, member2.Count);
Assert.True(member2.ContainsKey(combo[0]));
Assert.False(member2.ContainsKey(combo[1]));
Assert.True(member2.ContainsKey(combo[2]));
// member 3 is readonly, so we don't remove any data
Assert.AreEqual(member3CountBefore, member3.Count);
Assert.True(member3.ContainsKey(combo[0]));
Assert.True(member3.ContainsKey(combo[1]));
}
public void GetIterationTargets(float portion, Dictionary <int, float>[] ratings, int[] expectedTargets)
{
var targets = new int[ratings.Length];
GroupMatchSearchTransform.GetIterationTargets(portion, ratings, targets);
for (var i = 0; i < expectedTargets.Length; i++)
{
Assert.AreEqual(expectedTargets[i], targets[i]);
}
}
public void CalculateSolveOrder(float[] weights, MarsEntityPriority[] priorities, List <int> workingIndices,
int[] expectedOrder)
{
var indexToWeight = new List <KeyValuePair <int, float> >();
GroupMatchSearchTransform.CalculateSolveOrder(weights, priorities, workingIndices, indexToWeight);
Assert.AreEqual(expectedOrder.Length, indexToWeight.Count);
var previousWeight = float.MaxValue;
var previousPriority = (int)MarsEntityPriority.Maximum;
for (var i = 0; i < expectedOrder.Length; i++)
{
var expected = expectedOrder[i];
var actualKvp = indexToWeight[i];
var actualSortedIndex = actualKvp.Key;
Assert.AreEqual(expected, actualSortedIndex);
var expectedPriority = (int)priorities[expected];
var actualPriority = (int)priorities[actualSortedIndex];
Assert.AreEqual(expectedPriority, actualPriority);
// make sure priority is sorted in descending order
Assert.LessOrEqual(actualPriority, previousPriority);
// make sure the result is sorted by weight within priority level
if (expectedPriority == previousPriority)
{
Assert.LessOrEqual(actualKvp.Value, previousWeight);
}
previousWeight = actualKvp.Value;
previousPriority = actualPriority;
}
}
public void AverageMemberRating(KeyValuePair <int, float>[] hypothesis, float expectedRating)
{
Assert.True(Mathf.Approximately(expectedRating, GroupMatchSearchTransform.AverageMemberRating(hypothesis)));
}
public void CheckDuplicateOrInvalidAssignments_DuplicatesPresentCases(KeyValuePair <int, float>[] hypothesis)
{
Assert.True(GroupMatchSearchTransform.AnyDuplicateOrInvalid(hypothesis));
}
