public void Behavior_Setter_Not_Test()
{
// The type we are testing
DistanceBetweenPoints target = new DistanceBetweenPoints()
{};
//Since the Behavior was not set, the string should be empty
bool expected = true;
bool actual = target.Behaviour.Equals(string.Empty);
//Assert they are the equal
Assert.AreEqual(expected, actual);
}
public void Behavior_Getter_Test()
{
// The type we are testing
DistanceBetweenPoints target = new DistanceBetweenPoints()
{
Behaviour = BehaviourTypes.Increasing
};
//Since the Behavior was set to decreasing, we want to check that this was set
bool expected = true;
bool actual = BehaviourTypes.Increasing.Equals(target.Behaviour);
//Assert they are the equal
Assert.AreEqual(expected, actual);
}
public IPrimitiveConditionData GenerateRuleData(List<TouchPoint2> points)
{
// Only check this if there are only TWO points and the points are simultaneous and not in different moments
String behaviour = "";
double distanceN = 0f, distanceN_1 = 0f;
int firstStrokeLen = points[0].Stroke.StylusPoints.Count;
int secondStrokeLen = points[1].Stroke.StylusPoints.Count;
//Sometimes we get to much precious data that captures unwanted behaviours...
//try few times to match the pattern
double maxDifference = 0;
for (int n = 1; n < 4; n++)
{
if (firstStrokeLen - n < 0 || secondStrokeLen - n < 0)
break;
// Get the point of two gestures at nth position
StylusPoint p1 = points[0].Stroke.StylusPoints[n];
StylusPoint p2 = points[1].Stroke.StylusPoints[n];
distanceN = TrigonometricCalculationHelper.GetDistanceBetweenPoints(p1, p2);
if (firstStrokeLen - n - 1 < 0 || secondStrokeLen - n - 1 < 0)
break;
// Get the point of two gestures at (n-1)th position
p1 = points[0].Stroke.StylusPoints[firstStrokeLen - n - 1];
p2 = points[1].Stroke.StylusPoints[secondStrokeLen - n - 1];
distanceN_1 = TrigonometricCalculationHelper.GetDistanceBetweenPoints(p1, p2);
double maxValue = Math.Max(distanceN_1,distanceN);
double currentDifference = Math.Abs(distanceN_1 - distanceN);
currentDifference = currentDifference / maxValue;
if (currentDifference > maxDifference)
maxDifference = currentDifference;
if (distanceN < distanceN_1)
{
behaviour = BehaviourTypes.Increasing;
break;
}
else if (distanceN > distanceN_1)
{
behaviour = BehaviourTypes.Decreasing;
break;
}
/* else if (_data.Behaviour.ToLower() == BehaviourTypes.Range)
{
if (distanceN >= _data.Min && distanceN <= _data.Max)
{
result = true;
break;
}
}
else if (_data.Behaviour.ToLower() == BehaviourTypes.UnChanged)
{
// Note: Check if the change is within acceptable range
// For example: unchanged 10% means if the change is
// below 10% of the distance than consider it acceptable
double diff = Math.Abs(distanceN - distanceN_1);
if (diff < distanceN / _data.Min)
{
result = true;
break;
}
}*/
}
DistanceBetweenPoints data = new DistanceBetweenPoints();
if (maxDifference > 0)
{
if (maxDifference <= UNCHANGED_TOLERANCE)
{
behaviour = BehaviourTypes.UnChanged;
data.Min = Convert.ToInt16(maxDifference);
}
}
data.Behaviour = behaviour;
return data;
}
public void Init(IPrimitiveConditionData ruleData)
{
_data = ruleData as DistanceBetweenPoints;
}
public void Union_With_A_Null_Test()
{
// The type we are testing
DistanceBetweenPoints target = new DistanceBetweenPoints()
{
Behaviour = BehaviourTypes.UnChanged,
Max = 2,
Min = 1
};
// Since the ruleData is null, the union should fail
IPrimitiveConditionData anotherRuleData = null;
//Union should fail
target.Union(anotherRuleData);
}
public void Union_Unchanged_and_Unchanged()
{
// The type we are testing
DistanceBetweenPoints target = new DistanceBetweenPoints()
{
Behaviour = BehaviourTypes.UnChanged,
Max = 3,
Min = 1
};
// Another instance of same type of ruleData
IPrimitiveConditionData anotherRuleData = new DistanceBetweenPoints()
{
Behaviour = BehaviourTypes.UnChanged,
Max = 4,
Min = 0
};
//Union the 2 rules
target.Union(anotherRuleData);
//We expect the min to be the original min and different from the 2nd rule
bool expected = true;
bool actual = target.Min.Equals(0);
Assert.AreNotEqual(expected, actual);
//We expect the behavior of the union'd rule to be "unchanged", as nothing was union'd
expected = true;
actual = target.Behaviour.Equals("unchanged");
Assert.AreEqual(expected, actual);
}
public void Union_Unchanged_and_Increasing()
{
// The type we are testing
DistanceBetweenPoints target = new DistanceBetweenPoints()
{
Behaviour = BehaviourTypes.UnChanged,
Max = 2,
Min = 1
};
// Another instance of same type of ruleData
IPrimitiveConditionData anotherRuleData = new DistanceBetweenPoints()
{
Behaviour = BehaviourTypes.Increasing,
Max = 3,
Min = 2
};
//Union the 2 rules
target.Union(anotherRuleData);
//We expect the max to be the max of 2nd rule, which is 3
bool expected = true;
bool actual = target.Max.Equals(3);
Assert.AreEqual(expected, actual);
//We expect the behavior of the union'd rule to be "increasing", given the union types
expected = true;
actual = target.Behaviour.Equals("increasing");
Assert.AreEqual(expected, actual);
}
public void toGDL_Unchanged_test()
{
// The type we are testing
DistanceBetweenPoints target = new DistanceBetweenPoints()
{
Behaviour = BehaviourTypes.UnChanged,
Max = 2,
Min = 0
};
// Since the behavior was set to unchanged, that should be reflected in the output of toGDL
bool expected = true;
bool actual = target.ToGDL().Equals("Distance between points: unchanged 0%");
Assert.AreEqual(expected, actual);
}
public void Union_Decreasing_and_Decreasing()
{
// The type we are testing
DistanceBetweenPoints target = new DistanceBetweenPoints()
{
Behaviour = BehaviourTypes.Decreasing,
Max = 3,
Min = 1
};
// Another instance of same type of ruleData
IPrimitiveConditionData anotherRuleData = new DistanceBetweenPoints()
{
Behaviour = BehaviourTypes.Decreasing,
Max = 4,
Min = 0
};
//Union the 2 rules
target.Union(anotherRuleData);
//We expect the min to be the min of 2nd rule, which is 0
bool expected = true;
bool actual = target.Min.Equals(0);
Assert.AreEqual(expected, actual);
//We expect the behavior of the union'd rule to be "decreasing", given the union types
expected = true;
actual = target.Behaviour.Equals("decreasing");
Assert.AreEqual(expected, actual);
}
public void EqualsTest_Same_Type_of_RuleData_with_same_value()
{
// The type we are testing
DistanceBetweenPoints target = new DistanceBetweenPoints()
{
Behaviour = BehaviourTypes.Increasing,
Max = -1,
Min = -1
};
// Another instance of same type of ruleData
IPrimitiveConditionData anotherRuleData = new DistanceBetweenPoints()
{
Behaviour = BehaviourTypes.Increasing,
Max = -1,
Min = -1
};
// Since the values are same, it should be equal
bool expected = true;
bool actual = target.Equals(anotherRuleData);
Assert.AreEqual(expected, actual);
}
public void Invalid_Union_Test_with_Increasing_and_Decreasing()
{
// The type we are testing
DistanceBetweenPoints target = new DistanceBetweenPoints()
{
Behaviour = BehaviourTypes.Increasing,
Max = -1,
Min = -1
};
// Another instance of same type of ruleData
IPrimitiveConditionData anotherRuleData = new DistanceBetweenPoints()
{
Behaviour = BehaviourTypes.Decreasing,
Max = -1,
Min = -1
};
// Since the behavior is different (increasing and decreasing), appropriate exception should be shown
target.Union(anotherRuleData);
}
public void EqualsTest_Null_Check()
{
// The type we are testing
DistanceBetweenPoints target = new DistanceBetweenPoints()
{
Behaviour = BehaviourTypes.Increasing,
Max = -1,
Min = -1
};
bool expected = false;
bool actual = target.Equals(null);
Assert.AreEqual(expected, actual);
}
public void EqualsTest_Different_Types_of_RuleData()
{
// The type we are testing
DistanceBetweenPoints target = new DistanceBetweenPoints()
{
Behaviour = BehaviourTypes.Increasing,
Max = -1,
Min = -1
};
// Any random type - just not the type that we are testing
IPrimitiveConditionData anotherRuleData = new ClosedLoop();
// Since the ruleData are of different type, it should not be equal
bool expected = false;
bool actual = target.Equals(anotherRuleData);
Assert.AreEqual(expected, actual, "Different types of rules should not match!");
}
public void DistanceBtwPoints_Min_Setter_Test()
{
// The type we are testing
DistanceBetweenPoints target = new DistanceBetweenPoints()
{
Behaviour = BehaviourTypes.UnChanged,
Min = 0
};
//The min was set to 0, so we confirm that the min was indeed set to 0
bool expected = true;
bool actual = target.Min.Equals(0);
//Assert they are equal
Assert.AreEqual(expected, actual);
}
public void DistanceBtwPoints_Min_Setter_Not_Set_Test()
{
// The type we are testing
DistanceBetweenPoints target = new DistanceBetweenPoints()
{
Behaviour = BehaviourTypes.UnChanged,
};
//Since the min was not set, we are verifying that it was set to 0 as specified in original code
bool expected = true;
bool actual = target.Min.Equals(0);
//Assert they are equal
Assert.AreEqual(expected, actual);
}
public void DistanceBtwPoints_Min_Getter_Test()
{
// The type we are testing
DistanceBetweenPoints target = new DistanceBetweenPoints()
{
Behaviour = BehaviourTypes.UnChanged,
Min = -1
};
//The max was set to 5, so test the getter to check if it returns 5
bool expected = true;
int actualMin = -1;
bool actual = actualMin == (target.Min);
//Assert they are equal
Assert.AreEqual(expected, actual);
}
