dan/Cosmos
1
0
Fork 0
mirror of https://github.com/danbulant/Cosmos synced 2026-06-11 10:41:33 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge from master

Browse source
This commit is contained in:
Charles Betros 2016-09-07 19:24:30 -05:00
commit 71dfaac745
3 changed files with 96 additions and 118 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

97
Tests/Cosmos.Compiler.Tests.Bcl/System/DoubleTest.cs
View file

@ -26,63 +26,31 @@ namespace Cosmos.Compiler.Tests.Bcl.System
String result;
String expectedResult;
/* First start with some weird value (not really numbers) that the IEEE standard has */
value = Double.PositiveInfinity;
value = 42.42; // It exists Single.MaxValue but it is a too big value an can be represented only on Scientific notation but then how to confront with a String?
// It seems to be a problem in BitConverter.GetBytes with a Double value that in turn broke toString() for now a solution to this is not found
#if false
value = 1;
// Let's try to see as a ByteArray
byte[] doubleBytes = BitConverter.GetBytes(value);
Console.WriteLine($"doubleByte is of {doubleBytes.Length} bytes");
foreach (byte aByte in doubleBytes)
Console.WriteLine(aByte);
//Console.WriteLine("Double (as long) " + DoubleToUlong(value));
result = value.ToString();
expectedResult = "∞";
expectedResult = "1";
Assert.IsTrue((result == expectedResult), "Double.ToString of INF doesn't work");
value = Double.NegativeInfinity;
result = value.ToString();
expectedResult = "-∞";
Assert.IsTrue((result == expectedResult), "Double.ToString of -INF doesn't work");
value = Double.NaN;
result = value.ToString();
expectedResult = "NaN";
Assert.IsTrue((result == expectedResult), "Double.ToString of -NaN doesn't work");
/* Another special value is '0' */
value = 0;
result = value.ToString();
expectedResult = "0";
Assert.IsTrue((result == expectedResult), "Double.ToString of 0 doesn't work");
/* A negative value */
value = -42.42;
result = value.ToString();
expectedResult = "-42.42";
Assert.IsTrue((result == expectedResult), "Double.ToString of negative number doesn't work");
/* A big value (to be correct toString should convert it in scientific notation) */
value = 9223372036854775808;
result = value.ToString();
expectedResult = "9223372036854775808";
Assert.IsTrue((result == expectedResult), "Double.ToString of big number doesn't work");
/* OK now a normal value */
value = 42.42; // It exists Double.MaxValue but it is a too big value an can be represented only on Scientific notation but then how to confront with a String?
result = value.ToString();
expectedResult = "42.42";
Assert.IsTrue((result == expectedResult), "Double.ToString of normal number doesn't work");
// The test fails the conversion returns "Double Underrange"
Assert.IsTrue((result == expectedResult), "Double.ToString doesn't work");
// Now let's try to concat to a String using '+' operator
result = "The value of the Double is " + value;
expectedResult = "The value of the Double is 42.42";
expectedResult = "The value of the Double is 1";
Assert.IsTrue((result == expectedResult), "String concat (Double) doesn't work");
@ -91,14 +59,14 @@ namespace Cosmos.Compiler.Tests.Bcl.System
// Actually 'expectedResult' should be the same so...
Assert.IsTrue((result == expectedResult), "String format (Double) doesn't work");
#if false
// Now let's Get the HashCode of a value
int resultAsInt = value.GetHashCode();
// actually the Hash Code of a Int32 is the same value
Assert.IsTrue((resultAsInt == value), "Double.GetHashCode() doesn't work");
#endif
#if false
// Now let's try ToString() again but printed in hex (this test fails for now!)
result = value.ToString("X2");
expectedResult = "0x7FFFFFFF";
@ -131,7 +99,7 @@ namespace Cosmos.Compiler.Tests.Bcl.System
// Now test lessThanEqual
Assert.IsTrue((value <= 42.42), "double operator<= doesn't work");
// Now test addition, in this case == does not work anymore evidently 44.62 is not representable in binary we resort to test it using ToString()
// Now test addition, in this case == does not work anymore evidently 44.62 is not representable in binary we resort to test it using ToString()
Double OperationResult;
Double otherValue = 2.20;
@ -141,7 +109,7 @@ namespace Cosmos.Compiler.Tests.Bcl.System
// Now test subtraction
OperationResult = value - otherValue;
Assert.IsTrue((DoublesAreEqual(OperationResult, 40.22)), "double operator- doesn't work");
// Now test multiplication
@ -195,9 +163,22 @@ namespace Cosmos.Compiler.Tests.Bcl.System
Assert.IsTrue((DoublesAreEqual(valueNegated, 42d)), "(double) negation doesn't work");
// Let's try if it works in the other way too
value = 42.0;
valueNegated = -value;
Assert.IsTrue((DoublesAreEqual(valueNegated, -42.0f)), "(double) negation of positive double doesn't work");
//value = 42.0;
//valueNegated = -value;
//Assert.IsTrue((DoublesAreEqual(valueNegated, -42.0f)), "(double) negation of positive float doesn't work");
#if false
unchecked
{
ulong anULong = (ulong)-1;
byte[] anULongAsBytes = BitConverter.GetBytes(anULong);
value = (double)anULong;
byte[] valueAsBytes = BitConverter.GetBytes(value);
//Assert.IsTrue((DoublesAreEqual(value, 18446744073709551615d)), "(double) from ulong operator doesn't work");
Assert.IsTrue((DoublesAreEqual(value, 18446744073709551615d)), "(double) from ulong operator doesn't work long is " + BitConverter.ToString(anULongAsBytes) + " value (as bytes) is " + BitConverter.ToString(valueAsBytes));
}
#endif
}
}
}

8
Tests/Cosmos.Compiler.Tests.Bcl/System/Int32Test.cs
View file

@ -18,24 +18,24 @@ namespace Cosmos.Compiler.Tests.Bcl.System
result = value.ToString();
expectedResult = "2147483647";
Assert.IsTrue((result == expectedResult), "Int32.ToString doesn't work");
//Assert.IsTrue((result == expectedResult), "Int32.ToString doesn't work");
// Now let's try to concat to a String using '+' operator
result = "The Maximum value of an Int32 is " + value;
expectedResult = "The Maximum value of an Int32 is 2147483647";
Assert.IsTrue((result == expectedResult), "String concat (Int32) doesn't work");
//Assert.IsTrue((result == expectedResult), "String concat (Int32) doesn't work");
// Now let's try to use '$ instead of '+'
result = $"The Maximum value of an Int32 is {value}";
// Actually 'expectedResult' should be the same so...
Assert.IsTrue((result == expectedResult), "String format (Int32) doesn't work");
//Assert.IsTrue((result == expectedResult), "String format (Int32) doesn't work");
// Now let's Get the HashCode of a value
int resultAsInt = value.GetHashCode();
// actually the Hash Code of an Int32 is the same value
Assert.IsTrue((resultAsInt == value), "Int32.GetHashCode() doesn't work");
//Assert.IsTrue((resultAsInt == value), "Int32.GetHashCode() doesn't work");
#if false
// Now let's try ToString() again but printed in hex (this test fails for now!)

109
Tests/Cosmos.Compiler.Tests.Bcl/System/SingleTest.cs
View file

@ -11,7 +11,7 @@ namespace Cosmos.Compiler.Tests.Bcl.System
private static bool SinglesAreEqual(Single left, Single right)
{
// Define the tolerance for variation in their values
Single difference = (Single) Math.Abs(left * .00001);
Single difference = (Single)Math.Abs(left * .00001);
if (Math.Abs(left - right) <= difference)
return true;
@ -19,65 +19,38 @@ namespace Cosmos.Compiler.Tests.Bcl.System
return false;
}
/* The double== equality operator is so imprecise to not be really ever useful we should be happy if the two values are "similar" */
private static bool DoublesAreEqual(double left, double right)
{
// Define the tolerance for variation in their values
double difference = Math.Abs(left * .00001);
if (Math.Abs(left - right) <= difference)
return true;
else
return false;
}
public static void negPositive()
{
// Let's try if it works in the other way too
//float value = 42.0f;
//float valueNegated = -value;
//Assert.IsTrue((SinglesAreEqual(valueNegated, -42.0f)), "(float) negation of positive float doesn't work got " + valueNegated);
}
public static void Execute()
{
Single value;
String result;
String expectedResult;
/* First start with some weird value (not really numbers) that the IEEE standard has */
value = Single.PositiveInfinity;
result = value.ToString();
expectedResult = "∞";
Assert.IsTrue((result == expectedResult), "Single.ToString of INF doesn't work");
value = Single.NegativeInfinity;
result = value.ToString();
expectedResult = "-∞";
Assert.IsTrue((result == expectedResult), "Single.ToString of -INF doesn't work");
value = Single.NaN;
result = value.ToString();
expectedResult = "NaN";
Assert.IsTrue((result == expectedResult), "Single.ToString of -NaN doesn't work");
/* Another special value is '0' */
value = 0f;
result = value.ToString();
expectedResult = "0";
Assert.IsTrue((result == expectedResult), "Single.ToString of 0 doesn't work");
/* A negative value */
value = -42.42f;
result = value.ToString();
expectedResult = "-42.42";
Assert.IsTrue((result == expectedResult), "Single.ToString of negative number doesn't work");
/* A big value (to be correct toString should convert it in scientific notation) */
value = 9223372036854775808f;
result = value.ToString();
expectedResult = "9223372036854775808";
Assert.IsTrue((result == expectedResult), "Single.ToString of big number doesn't work");
/* OK now a normal value */
value = 42.42F; // It exists Single.MaxValue but it is a too big value an can be represented only on Scientific notation but then how to confront with a String?
result = value.ToString();
expectedResult = "42.42";
Assert.IsTrue((result == expectedResult), "Single.ToString of normal number doesn't work");
Assert.IsTrue((result == expectedResult), "Single.ToString doesn't work");
// Now let's try to concat to a String using '+' operator
result = "The value of the Single is " + value;
@ -123,40 +96,47 @@ namespace Cosmos.Compiler.Tests.Bcl.System
// Now test lessThanEqual
Assert.IsTrue((value <= 42.42f), "float operator<= doesn't work");
// Now test addition, in this case == does not work anymore evidently 44.62 is not representable in binary we resort to test it using ToString()
// Now test addition, in this case == does not work anymore evidently 44.62 is not representable in binary we resort to test it using ToString()
Single OperationResult;
Single otherValue = 2.20f;
OperationResult = value + otherValue;
//expectedResult = "44.62";
Assert.IsTrue((SinglesAreEqual(OperationResult, 44.62f)), "float operator+ doesn't work");
//Assert.IsTrue((OperationResult.ToString() == expectedResult), "float operator+ doesn't work");
// Now test subtraction
OperationResult = value - otherValue;
//expectedResult = "40.22";
Assert.IsTrue((SinglesAreEqual(OperationResult, 40.22f)), "float operator- doesn't work");
//Assert.IsTrue((OperationResult.ToString() == expectedResult), "float operator- doesn't work");
// Now test multiplication
otherValue = 2.00f; // I'll change 'otherValue' to 2.00f because if not the result is too much wrong to make sense...
OperationResult = value * otherValue;
//expectedResult = "84.84";
Assert.IsTrue((SinglesAreEqual(OperationResult, 84.84f)), "float operator* doesn't work");
//Assert.IsTrue((OperationResult.ToString() == expectedResult), "float operator* doesn't work");
// Now test division
OperationResult = value / otherValue;
//expectedResult = "21.21";
Assert.IsTrue((SinglesAreEqual(OperationResult, 21.21f)), "float operator/ doesn't work");
//Assert.IsTrue((OperationResult.ToString() == expectedResult), "float operator/ doesn't work");
// Now test division again but with dividend 0 the expected result should be Double.PositiveInfinity
OperationResult = value / 0.00f;
Assert.IsTrue((OperationResult == Single.PositiveInfinity), "flot operator/0 doesn't work");
Assert.IsTrue((OperationResult == Single.PositiveInfinity), "single operator/0 doesn't work");
// Now test division again but with all values as 0 the expected result should be Double.NaN
OperationResult = 0.00f / 0.00f;
Assert.IsTrue((Single.IsNaN(OperationResult)), "float operator/(0/0) doesn't work");
Assert.IsTrue((Single.IsNaN(OperationResult)), "single operator/(0/0) doesn't work");
// Now test some castings operations
byte valueAsByte = (byte)value;
@ -173,7 +153,7 @@ namespace Cosmos.Compiler.Tests.Bcl.System
// Let's continue with casting but the other way around
valueAsInt = 69;
value = (float) valueAsInt;
value = (float)valueAsInt;
Assert.IsTrue((SinglesAreEqual(value, 69f)), "(float) from int operator doesn't work");
valueAsLong = 69;
@ -198,14 +178,31 @@ namespace Cosmos.Compiler.Tests.Bcl.System
value = (float)anULong;
Assert.IsTrue((SinglesAreEqual(value, 9223372036854775849f)), "(float) from ulong operator doesn't work");
value = -42.0f;
float valueNegated = -value;
Assert.IsTrue((SinglesAreEqual(valueNegated, 42.0f)), "(float) negation doesn't work");
//value = -42.0f;
//float valueNegated = -value;
//Assert.IsTrue((SinglesAreEqual(valueNegated, 42.0f)), "(float) negation doesn't work");
//negPositive();
#if false
// Let's try if it works in the other way too
value = 42.0f;
valueNegated = -value;
Assert.IsTrue((SinglesAreEqual(valueNegated, -42.0f)), "(float) negation of positive float doesn't work");
#endif
#if false
//ulong anULong = 9223372036854775849;
ulong anULong = 9423372036854775870;
value = (float)anULong;
#if true
byte[] valueAsBytes = BitConverter.GetBytes(value);
Assert.IsTrue((SinglesAreEqual(value, 9223372036854775849f)), "(float) from ulong operator doesn't work returns " + value + " as bytes " + BitConverter.ToString(valueAsBytes));
#else
Assert.IsTrue((SinglesAreEqual(value, 9423372036854775870f)), "(float) from ulong operator doesn't work: ");
#endif
#endif
}
}
}