public void Equals_NonGeneric_ThisIsNotEqualToObj_ReturnsFalse(int xMin, int xMax, int yMin, int yMax)
{
var uut1 = new MinMaxPair <int>(xMin, xMax);
var uut2 = new MinMaxPair <int>(yMin, yMax);
uut1.Equals((object)uut2).ShouldBeFalse();
}
public void Equals_Generic_ThisIsEqualToPair_ReturnsTrue(int xMin, int xMax, int yMin, int yMax)
{
var uut1 = new MinMaxPair <int>(xMin, xMax);
var uut2 = new MinMaxPair <int>(yMin, yMax);
uut1.Equals(uut2).ShouldBeTrue();
}
public void Contains_ComparerAlwaysReturnsLessThan_ReturnsFalse(int min, int max, int value)
{
var comparer = new DelegateComparer <int>((x, y) => - 1);
var uut = new MinMaxPair <int>(min, max, comparer);
uut.Contains(value).ShouldBeFalse();
}
static public float GetCornerDistanceExt(this Cover cover, bool rightSide, float testedCollisionDistance)
{
float testedCornerDistanceLeftRight = 1.2f;
float testedCornerDistanceForward = 1.0f; // TODO : we can compute this calue using distance to the wall
Vector3 fromPos, forward, rightPos, leftPos, right;
cover.GetMetricsExt(out fromPos, out right, out forward, out rightPos, out leftPos);
// new approach
Vector3 fromPosRFrom = rightPos + right * testedCornerDistanceLeftRight;
Vector3 fromPosRTo = fromPosRFrom + forward * testedCornerDistanceForward;
Vector3 fromPosLFrom = leftPos - right * testedCornerDistanceLeftRight;
Vector3 fromPosLTo = fromPosLFrom + forward * testedCornerDistanceForward;
MinMaxPair tmp = new MinMaxPair();
tmp.Reset();
if (rightSide)
{
CoverUtils.LineDistanceCast(fromPosRFrom, fromPosRTo, -right, testedCollisionDistance, ref tmp, testedCornerDistanceLeftRight);
}
else // left
{
CoverUtils.LineDistanceCast(fromPosLFrom, fromPosLTo, right, testedCollisionDistance, ref tmp, testedCornerDistanceLeftRight);
}
return(tmp.m_MaxValue);
}
public void Constructor_Value_ComparerIsNull_UsesDefault(int value)
{
var uut1 = new MinMaxPair <int>(value);
var uut2 = new MinMaxPair <int>(value + 1);
uut1.CompareTo(uut2).ShouldBe(-1);
}
public void Contains_ComparerAlwaysReturnsEqual_ReturnsTrue(int min, int max, int value)
{
var comparer = new DelegateComparer <int>((x, y) => 0);
var uut = new MinMaxPair <int>(min, max, comparer);
uut.Contains(value).ShouldBeTrue();
}
public void CompareTo_NonGeneric_ThisIsEqualToObj_Returns0(int xMin, int xMax, int yMin, int yMax)
{
var uut1 = new MinMaxPair <int>(xMin, xMax);
var uut2 = new MinMaxPair <int>(yMin, yMax);
uut1.CompareTo((object)uut2).ShouldBe(0);
}
public void CompareTo_Generic_ThisIsLessThanPair_ReturnsNegative1(int xMin, int xMax, int yMin, int yMax)
{
var uut1 = new MinMaxPair <int>(xMin, xMax);
var uut2 = new MinMaxPair <int>(yMin, yMax);
uut1.CompareTo(uut2).ShouldBe(-1);
}
public void GetHashCode_ForPairsNotEqual_ResultsAreNotEqual(int xMin, int xMax, int yMin, int yMax)
{
var uut1 = new MinMaxPair <int>(xMin, xMax);
var uut2 = new MinMaxPair <int>(yMin, yMax);
uut1.GetHashCode().ShouldNotBe(uut2.GetHashCode());
}
/// <summary>
/// Function returns for given axis min vertex index and breadth along it.
/// </summary>
public int GetAlongAxisData(Vector3 axis, out MinMaxPair breadthData)
{
Pair <int, float> minVertex = new Pair <int, float>(-1, float.MaxValue);
breadthData = new MinMaxPair();
Vector3 centroid = Centroid;
for (int i = 0; i < mDataCloud.Count; i++)
{
Vector3 point = mDataCloud[i];
Vector3 direction = point - centroid;
float distance = Vector3.Dot(direction, axis);
breadthData.CheckAgainst(distance);
if (ExtMathf.Less(distance, minVertex.Second))
{
minVertex.First = i;
minVertex.Second = distance;
}
}
return(minVertex.First);
}
public void AlgorithmAABB()
{
var dataCloud = mConvexHull3.DataCloud;
var points = mConvexHull3.Vertices;
MinMaxPair X = new MinMaxPair();
MinMaxPair Y = new MinMaxPair();
MinMaxPair Z = new MinMaxPair();
foreach (int point in points)
{
Vector3 dataCloudPoint = dataCloud[point];
X.CheckAgainst(dataCloudPoint.x);
Y.CheckAgainst(dataCloudPoint.y);
Z.CheckAgainst(dataCloudPoint.z);
}
mVolume = X.Delta * Y.Delta * Z.Delta;
mBox.Extents = new Vector3(X.Delta, Y.Delta, Z.Delta);
mBox.Corner = new Vector3(X.Min, Y.Min, Z.Min);
mBox.X = Vector3.right;
mBox.Y = Vector3.up;
mBox.Z = Vector3.forward;
}
public void CompareTo_NonGeneric_ObjIsNull_Returns1(int min, int max)
{
var uut = new MinMaxPair <int>(min, max);
var obj = (object)null;
uut.CompareTo(obj).ShouldBe(1);
}
public void OperatorNotEquals_XIsNotEqualToY_ReturnsTrue(int xMin, int xMax, int yMin, int yMax)
{
var uut1 = new MinMaxPair <int>(xMin, xMax);
var uut2 = new MinMaxPair <int>(yMin, yMax);
(uut1 != uut2).ShouldBeTrue();
}
public void CompareTo_NonGeneric_ThisIsGreaterThanObj_Returns1(int xMin, int xMax, int yMin, int yMax)
{
var uut1 = new MinMaxPair <int>(xMin, xMax);
var uut2 = new MinMaxPair <int>(yMin, yMax);
uut1.CompareTo((object)uut2).ShouldBe(1);
}
public void Equals_NonGeneric_ComparerAlwaysReturnsNegative1_ReturnsNegative1(int xMin, int xMax, int yMin, int yMax)
{
var comparer = new DelegateComparer <int>((x, y) => - 1);
var uut1 = new MinMaxPair <int>(xMin, xMax, comparer);
var uut2 = new MinMaxPair <int>(yMin, yMax, comparer);
uut1.CompareTo((object)uut2).ShouldBe(-1);
}
public void OperatorNotEquals_XIsSameAsY_ReturnsFalse(int min, int max)
{
var uut = new MinMaxPair <int>(min, max);
#pragma warning disable CS1718 // Comparison made to same variable
(uut != uut).ShouldBeFalse();
#pragma warning restore CS1718 // Comparison made to same variable
}
public void Equals_Generic_ComparerAlwaysReturnsNegative1_ReturnsFalse(int xMin, int xMax, int yMin, int yMax)
{
var comparer = new DelegateComparer <int>((x, y) => - 1);
var uut1 = new MinMaxPair <int>(xMin, xMax, comparer);
var uut2 = new MinMaxPair <int>(yMin, yMax, comparer);
uut1.Equals(uut2).ShouldBeFalse();
}
public void CompareTo_NonGeneric_ComparerAlwaysReturns0_Returns0(int xMin, int xMax, int yMin, int yMax)
{
var comparer = new DelegateComparer <int>((x, y) => 0);
var uut1 = new MinMaxPair <int>(xMin, xMax, comparer);
var uut2 = new MinMaxPair <int>(yMin, yMax, comparer);
uut1.CompareTo((object)uut2).ShouldBe(0);
}
public void OperatorNotEquals_ComparerAlwaysReturnsNegative1_ReturnsTrue(int xMin, int xMax, int yMin, int yMax)
{
var comparer = new DelegateComparer <int>((x, y) => - 1);
var uut1 = new MinMaxPair <int>(xMin, xMax, comparer);
var uut2 = new MinMaxPair <int>(yMin, yMax, comparer);
(uut1 != uut2).ShouldBeTrue();
}
public void DataContract_Always_OnDeserializedSetsGetHashCodeToExpected(int min, int max)
{
var uut = new MinMaxPair <int>(min, max);
var expected = uut.GetHashCode();
uut.OnDeserialized(new StreamingContext());
uut.GetHashCode().ShouldBe(expected);
}
public void ToString_Always_ContainsMinToStringAndMaxToString(int min, int max)
{
var uut = new MinMaxPair <int>(min, max);
var result = uut.ToString();
result.ShouldSatisfyAllConditions(
() => result.ShouldContain(min.ToString()),
() => result.ShouldContain(max.ToString()));
}
public static MinMaxPair <T>?MaxMinMeta <TCollect, TMaxComparer, TMinComparer, T>(ref TCollect collect, ref TMaxComparer maxComparer, ref TMinComparer minComparer)
where TCollect : struct, ICollectionWrapper <T>
where TMaxComparer : struct, IFunctor <T, T, bool>
where TMinComparer : struct, IFunctor <T, T, bool>
{
if (collect.HasIndexOverhead)
{
if (collect.HasNext)
{
var item = collect.Value;
var maxMin = new MinMaxPair <T>(item, item);
while (collect.HasNext)
{
item = collect.Value;
if (maxComparer.Invoke(item, maxMin.Max))
{
maxMin.Max = item;
}
if (minComparer.Invoke(item, maxMin.Min))
{
maxMin.Min = item;
}
}
return(maxMin);
}
}
else
{
var size = collect.Size;
if (size > 0)
{
var item = collect[0];
var maxMin = new MinMaxPair <T>(item, item);
for (var i = 1u; i < size; ++i)
{
item = collect[i];
if (maxComparer.Invoke(item, maxMin.Max))
{
maxMin.Max = item;
}
if (minComparer.Invoke(item, maxMin.Min))
{
maxMin.Min = item;
}
}
return(maxMin);
}
}
return(null);
}
private void OnColorChanged(SerializedProperty property, MinMaxPair pair)
{
m_oldAlpha = -1;
SerializedProperty minProp = property.FindPropertyRelative($"{pair.Name}Min");
minProp.floatValue = pair.Min;
SerializedProperty maxProp = property.FindPropertyRelative($"{pair.Name}Max");
maxProp.floatValue = pair.Max;
}
public void CompareTo_ObjTypeIsWrong_ThrowsException(int min, int max)
{
var uut = new MinMaxPair <int>(min, max);
var obj = new object();
var result = Should.Throw <ArgumentException>(() =>
{
uut.CompareTo(obj);
});
result.ParamName.ShouldBe(nameof(obj));
}
/// <summary>
/// Function for each axis returns it's min vertex index and breadth along it.
/// </summary>
public void GetAlongAxesData(
Vector3 xAxis, Vector3 yAxis, Vector3 zAxis,
out Pair <int, MinMaxPair> xAxisData,
out Pair <int, MinMaxPair> yAxisData,
out Pair <int, MinMaxPair> zAxisData
)
{
Pair <int, float> minVertexX = new Pair <int, float>(0, float.MaxValue);
Pair <int, float> minVertexY = new Pair <int, float>(0, float.MaxValue);
Pair <int, float> minVertexZ = new Pair <int, float>(0, float.MaxValue);
MinMaxPair breadthX = new MinMaxPair();
MinMaxPair breadthY = new MinMaxPair();
MinMaxPair breadthZ = new MinMaxPair();
Vector3 centroid = Centroid;
for (int i = 0; i < mDataCloud.Count; i++)
{
Vector3 point = mDataCloud[i];
Vector3 direction = point - centroid;
float xDistance = Vector3.Dot(direction, xAxis);
float yDistance = Vector3.Dot(direction, yAxis);
float zDistance = Vector3.Dot(direction, zAxis);
breadthX.CheckAgainst(xDistance);
breadthY.CheckAgainst(yDistance);
breadthZ.CheckAgainst(zDistance);
if (ExtMathf.Less(xDistance, minVertexX.Second))
{
minVertexX.First = i;
minVertexX.Second = xDistance;
}
if (ExtMathf.Less(yDistance, minVertexY.Second))
{
minVertexY.First = i;
minVertexY.Second = yDistance;
}
if (ExtMathf.Less(zDistance, minVertexZ.Second))
{
minVertexZ.First = i;
minVertexZ.Second = zDistance;
}
}
xAxisData = new Pair <int, MinMaxPair>(minVertexX.First, breadthX);
yAxisData = new Pair <int, MinMaxPair>(minVertexY.First, breadthY);
zAxisData = new Pair <int, MinMaxPair>(minVertexZ.First, breadthZ);
}
public void BaseModelChanged_ModelDoesNotEqualNewValueAndThisMaximumIsNotNullOrEmpty_SetsThisMaximumToEmpty(int previousMinimum, int previousMaximum, int modelMin, int modelMax)
{
var context = new TestContext <int>();
var uut = context.ConstructUUT();
uut.Minimum = previousMinimum;
uut.Maximum = previousMaximum;
var model = new MinMaxPair <int>(modelMin, modelMax);
uut.Model = model;
uut[nameof(uut.Maximum)].ShouldBeEmpty();
}
static public MinMaxPair GetWallDistanceExt(this Cover cover, float testedWallDistance)
{
float testedDistance = testedWallDistance + 0.05f;
Vector3 fromPos, forward, rightPos, leftPos, right;
cover.GetMetricsExt(out fromPos, out right, out forward, out rightPos, out leftPos);
MinMaxPair tmp = new MinMaxPair();
tmp.Reset();
CoverUtils.LineDistanceCast(rightPos, leftPos, forward, testedDistance, ref tmp);
return(tmp);
}
public void BaseModelChanged_ModelDoesNotEqualNewValueAndThisMaximumIsNotNullOrEmptyAndNewValueMaxEqualsMaximum_InvokesRaisePropertyChangedWithMaximum(int previousMinimum, int previousMaximum, int modelMin, int modelMax)
{
var context = new TestContext <int>();
var uut = context.ConstructUUT();
uut.Minimum = previousMinimum;
uut.Maximum = previousMaximum;
var model = new MinMaxPair <int>(modelMin, modelMax);
context.ClearReceivedCalls();
uut.Model = model;
context.propertyChangedHandler.Received(1).Invoke(uut, Arg.Is <PropertyChangedEventArgs>(x => x.PropertyName == nameof(uut.Maximum)));
}
private Color GetColor()
{
float pingPong = Mathf.PingPong((float)EditorApplication.timeSinceStartup, 1);
MinMaxPair huePair = GetHsvProperty(HsvLookup.H);
float hue = Mathf.Lerp(huePair.Min, huePair.Max, pingPong);
Color rgba = Color.HSVToRGB(
hue,
GetHsvProperty(HsvLookup.S).Min,
GetHsvProperty(HsvLookup.V).Min
);
rgba.a = GetHsvProperty(HsvLookup.A).Min;
return(rgba);
}
private bool TryUpdateHsvLookup(SerializedProperty property, string name, HsvLookup id)
{
SerializedProperty minProp = property.FindPropertyRelative($"{name}Min");
SerializedProperty maxProp = property.FindPropertyRelative($"{name}Max");
if (m_hsvLookup.TryGetValue(id, out MinMaxPair pair))
{
pair.Min = minProp.floatValue;
pair.Max = maxProp.floatValue;
return(true);
}
else
{
m_hsvLookup[id] = new MinMaxPair(name, minProp.floatValue, maxProp.floatValue);
return(false);
}
}
public VIZSGALATILAP( MinMaxPair<double?> _Brix,
MinMaxPair<double?> _Citromsav,
MinMaxPair<double?> _Ph,
MinMaxPair<double?> _Bostwick,
MinMaxPair<double?> _CitromsavAdagolas,
double? _Aszkorbinsav,
string _Hoteko,
string _Sarzs,
string _Megnevezes,
string _Paszirozottsag,
string _Csomagolas,
string _SzarmazasiHely )
{
Brix = _Brix;
Citromsav = _Citromsav;
Ph = _Ph;
Bostwick = _Bostwick;
CitromsavAdagolas = _CitromsavAdagolas;
Aszkorbinsav = _Aszkorbinsav;
Hoteko = _Hoteko;
Sarzs = _Sarzs;
Megnevezes = _Megnevezes;
Paszirozottsag = _Paszirozottsag;
Csomagolas = _Csomagolas;
SzarmazasiHely = _SzarmazasiHely;
}
MinMax( MinMaxPair<double?> _minmax )
{
string value = null;
if ( _minmax.min == null && _minmax.max == null ) { return value; }
if ( _minmax.min != null && _minmax.max != null ) { value = _minmax.min + " - " + _minmax.max; }
else if ( _minmax.min != null ) { value = _minmax.min.ToString( ); }
else { value = _minmax.max.ToString( ); }
return value;
}
