public static void RunAll()
{
SemanticUIElements.RegisterToBuilder();
SplitJsElements.RegisterToBuilder();
CodeMirrorElements.RegisterToBuilder();
ViewerJsElements.RegisterToBuilder();
SwiperElements.RegisterToBuilder();
CastTest.Register();
RandomValueTest.Register();
JsonSerializerTest.Register();
RangeTest.Register();
QUnit.QUnit.Test(nameof(BindingTests), BindingTests);
QUnit.QUnit.Test(nameof(BindingInfoTest2), BindingInfoTest2.RunAll);
QUnit.QUnit.Test(nameof(BuilderTest), BuilderTest);
QUnit.QUnit.Test(nameof(ContentControlTest), ContentControlTest.AssingStringValueToContent);
QUnit.QUnit.Test(nameof(RunOldTests), RunOldTests);
ComboTest.RegisterAll();
}
public void TestInitialize()
{
testClass = new RangeTest()
{
CorrectValue = 6,
IncorrectValue = 7
};
}
public override void OnInspectorGUI()
{
RangeTest test = target as RangeTest;
base.OnInspectorGUI();
if (GUILayout.Button("Range"))
{
test.DoRangeStuff();
}
}
/// <summary>Computes the area of a polygon.</summary>
/// <returns>The area, which is always a multiple of 0.5 because the
/// input coordinates are integers. The result is negative if the polygon
/// is clockwise (assuming a coordinate system in which increasing Y goes
/// upward), or positive if the polygon is counterclockwise.</returns>
///
///
///
///
///
/*
* public static double Area(Polygon poly)
* {
* int highI = poly.Count - 1;
* if (highI < 2)
* return 0;
* bool UseFullInt64Range = false;
* RangeTest rt = TestRange(poly);
* switch (rt) {
* case RangeTest.Hi:
* UseFullInt64Range = true;
* break;
* case RangeTest.Error:
* throw new ArgumentException("Polygon coordinate is too large to process.");
* }
* if (UseFullInt64Range) {
* Int128 a = new Int128(0);
* a = Int128.Mul(poly[highI].x, poly[0].y) -
* Int128.Mul(poly[0].x, poly[highI].y);
* for (int i = 0; i < highI; ++i)
* a += Int128.Mul(poly[i].x, poly[i + 1].y) -
* Int128.Mul(poly[i + 1].x, poly[i].y);
* return a.ToDouble() / 2;
* } else {
* double area = (double)poly[highI].x * (double)poly[0].y -
* (double)poly[0].x * (double)poly[highI].y;
* for (int i = 0; i < highI; ++i)
* area += (double)poly[i].x * (double)poly[i + 1].y -
* (double)poly[i + 1].x * (double)poly[i].y;
* return area / 2;
* }
* }*/
private static RangeTest TestRange(Polygon pts)
{
RangeTest result = RangeTest.Lo;
for (int i = 0; i < pts.Count; i++)
{
if (Math.Abs(pts[i].x) > HiRange || Math.Abs(pts[i].y) > HiRange)
{
return(RangeTest.Error);
}
else if (Math.Abs(pts[i].x) > LoRange || Math.Abs(pts[i].y) > LoRange)
{
result = RangeTest.Hi;
}
}
return(result);
}
private SerializableRangeTestCollection ReadOutOfRangeMeasurementsFromTest(string acronym)
{
SerializableRangeTestCollection serializableCollection = new SerializableRangeTestCollection();
List <SerializableRangeTest> serializableTests = new List <SerializableRangeTest>();
RangeTest test = m_tests[acronym];
// Convert RangeTest to SerializableRangeTest and add it to the list of serializable tests.
SerializableRangeTest serializableTest = new SerializableRangeTest(test.Name);
List <SerializableOutOfRangeMeasurement> serializableMeasurements = new List <SerializableOutOfRangeMeasurement>();
ICollection <IMeasurement> outOfRangeMeasurements = test.GetOutOfRangeMeasurements();
// Convert IMeasurements to SerializableOutOfRangeMeasurements and add them to the list of serializable measurements.
foreach (IMeasurement measurement in outOfRangeMeasurements)
{
SerializableOutOfRangeMeasurement serializableMeasurement = CreateSerializableOutOfRangeMeasurement(test, measurement);
serializableMeasurements.Add(serializableMeasurement);
}
serializableTest.OutOfRangeMeasurements = serializableMeasurements.ToArray();
serializableTests.Add(serializableTest);
serializableCollection.RangeTests = serializableTests.ToArray();
return(serializableCollection);
}
private SerializableOutOfRangeMeasurement CreateSerializableOutOfRangeMeasurement(RangeTest test, IMeasurement measurement)
{
SerializableOutOfRangeMeasurement serializableMeasurement = new SerializableOutOfRangeMeasurement(measurement, test.LowRange, test.HighRange);
serializableMeasurement.ProcessException += serializableMeasurement_ProcessException;
serializableMeasurement.SetDeviceAndSignalType(test.DataSource);
return serializableMeasurement;
}
/// <summary>
/// Detaches a <see cref="RangeTest"/> from this <see cref="OutOfRangeService"/>.
/// </summary>
/// <param name="test">The <see cref="RangeTest"/> to be detached from this <see cref="OutOfRangeService"/>.</param>
public void DetachRangeTest(RangeTest test)
{
m_tests.Remove(test.Name);
}
/// <summary>
/// Attaches a <see cref="RangeTest"/> to this <see cref="OutOfRangeService"/>.
/// </summary>
/// <param name="test">The <see cref="RangeTest"/> to be attached to this <see cref="OutOfRangeService"/>.</param>
public void AttachRangeTest(RangeTest test)
{
m_tests[test.Name] = test;
}
private SerializableOutOfRangeMeasurement CreateSerializableOutOfRangeMeasurement(RangeTest test, IMeasurement measurement)
{
SerializableOutOfRangeMeasurement serializableMeasurement = new SerializableOutOfRangeMeasurement(measurement, test.LowRange, test.HighRange);
serializableMeasurement.ProcessException += serializableMeasurement_ProcessException;
serializableMeasurement.SetDeviceAndSignalType(test.DataSource);
return(serializableMeasurement);
}
/// <summary>
/// Detaches a <see cref="RangeTest"/> from this <see cref="OutOfRangeService"/>.
/// </summary>
/// <param name="test">The <see cref="RangeTest"/> to be detached from this <see cref="OutOfRangeService"/>.</param>
public void DetachRangeTest(RangeTest test)
{
m_tests.Remove(test.Name);
}
/// <summary>
/// Attaches a <see cref="RangeTest"/> to this <see cref="OutOfRangeService"/>.
/// </summary>
/// <param name="test">The <see cref="RangeTest"/> to be attached to this <see cref="OutOfRangeService"/>.</param>
public void AttachRangeTest(RangeTest test)
{
m_tests[test.Name] = test;
}
