| public UniformInt ( int maxExclusive ) : int | ||
| maxExclusive | int | One plus the largest possible value of /// the random number. |
| return | int | |
public static String RandomDecimalString(RandomGenerator r)
{
int count = r.UniformInt(40) + 1;
var sb = new StringBuilder();
if (r.UniformInt(2) == 0) {
sb.Append('-');
}
for (var i = 0; i < count; ++i) {
if (i == 0 && count > 1) {
sb.Append((char)('1' + r.UniformInt(9)));
} else {
sb.Append((char)('0' + r.UniformInt(10)));
}
}
if (r.UniformInt(2) == 0) {
sb.Append('.');
count = r.UniformInt(30) + 1;
for (var i = 0; i < count; ++i) {
sb.Append((char)('0' + r.UniformInt(10)));
}
}
if (r.UniformInt(2) == 0) {
sb.Append('E');
count = (r.UniformInt(100) < 10) ? r.UniformInt(5000) :
r.UniformInt(20);
if (count != 0) {
sb.Append(r.UniformInt(2) == 0 ? '+' : '-');
}
sb.Append(TestCommon.IntToString(count));
}
return sb.ToString();
}
public static byte[] RandomByteStringShort(RandomGenerator rand) {
int x = rand.UniformInt(50);
var bytes = new byte[x];
for (var i = 0; i < x; ++i) {
bytes[i] = unchecked((byte)rand.UniformInt(256));
}
return bytes;
}
public static string RandomLatinOne(RandomGenerator rnd)
{
int length = rnd.UniformInt(50) + 1;
var sb = new StringBuilder();
for (var i = 0; i < length; ++i) {
var c = (char)rnd.UniformInt(256);
sb.Append(c);
}
return sb.ToString();
}
public static String RandomBigIntString(RandomGenerator r)
{
int count = r.UniformInt(50) + 1;
var sb = new StringBuilder();
if (r.UniformInt(2) == 0) {
sb.Append('-');
}
for (var i = 0; i < count; ++i) {
if (i == 0) {
sb.Append((char)('1' + r.UniformInt(9)));
} else {
sb.Append((char)('0' + r.UniformInt(10)));
}
}
return sb.ToString();
}
public static double RandomDouble(RandomGenerator rand, int exponent) {
if (exponent == Int32.MaxValue) {
exponent = rand.UniformInt(2047);
}
long r = rand.UniformInt(0x10000);
r |= ((long)rand.UniformInt(0x10000)) << 16;
if (rand.UniformInt(2) == 0) {
r |= ((long)rand.UniformInt(0x10000)) << 32;
if (rand.UniformInt(2) == 0) {
r |= ((long)rand.UniformInt(0x10000)) << 48;
}
}
r &= ~0x7ff0000000000000L; // clear exponent
r |= ((long)exponent) << 52; // set exponent
return BitConverter.ToDouble(BitConverter.GetBytes((long)r), 0);
}
public static string RandomTextString(RandomGenerator rand) {
int length = rand.UniformInt(0x2000);
var sb = new StringBuilder();
for (var i = 0; i < length; ++i) {
int x = rand.UniformInt(100);
if (x < 95) {
// ASCII
sb.Append((char)(0x20 + rand.UniformInt(0x60)));
} else if (x < 98) {
// Supplementary character
x = rand.UniformInt(0x400) + 0xd800;
sb.Append((char)x);
x = rand.UniformInt(0x400) + 0xdc00;
sb.Append((char)x);
} else {
// BMP character
x = 0x20 + rand.UniformInt(0xffe0);
if (x >= 0xd800 && x < 0xe000) {
// surrogate code unit, generate ASCII instead
x = 0x20 + rand.UniformInt(0x60);
}
sb.Append((char)x);
}
}
return sb.ToString();
}
public static CBORObject RandomCBORArray(RandomGenerator rand, int depth)
{
int x = rand.UniformInt(100);
int count = (x < 80) ? 2 : ((x < 93) ? 1 : ((x < 98) ? 0 : 10));
CBORObject cborRet = CBORObject.NewArray();
for (var i = 0; i < count; ++i) {
cborRet.Add(RandomCBORObject(rand, depth + 1));
}
return cborRet;
}
public static CBORObject RandomCBORMap(RandomGenerator rand, int depth)
{
int x = rand.UniformInt(100);
int count = (x < 80) ? 2 : ((x < 93) ? 1 : ((x < 98) ? 0 : 10));
CBORObject cborRet = CBORObject.NewMap();
for (var i = 0; i < count; ++i) {
CBORObject key = RandomCBORObject(rand, depth + 1);
CBORObject value = RandomCBORObject(rand, depth + 1);
cborRet[key] = value;
}
return cborRet;
}
public static long RandomInt64(RandomGenerator rand) {
long r = rand.UniformInt(0x10000);
r |= ((long)rand.UniformInt(0x10000)) << 16;
if (rand.UniformInt(2) == 0) {
r |= ((long)rand.UniformInt(0x10000)) << 32;
if (rand.UniformInt(2) == 0) {
r |= ((long)rand.UniformInt(0x10000)) << 48;
}
}
return r;
}
public static bool Extra()
{
var rand = new RandomGenerator();
for (var i = 0; i < 20; ++i)
{
var array = new byte[rand.UniformInt(100000) + 1];
rand.GetBytes(array, 0, array.Length);
DateTime utcn = DateTime.UtcNow;
CBORTest.TestRandomOne(array);
var span = DateTime.UtcNow - utcn;
if (span.Seconds > 3)
{
Console.WriteLine("----" + i + ": " + span.Seconds + " " +
array.Length);
}
}
return(false);
}
public void TestGcd() {
try {
EInteger.Zero.Gcd(null);
Assert.Fail("Should have failed");
} catch (ArgumentNullException) {
new Object();
} catch (Exception ex) {
Assert.Fail(ex.ToString());
throw new InvalidOperationException(String.Empty, ex);
}
{
string stringTemp = EInteger.Zero.Gcd(BigFromString(
"244")).ToString();
Assert.AreEqual(
"244",
stringTemp);
}
{
string stringTemp = EInteger.Zero.Gcd(BigFromString(
"-244")).ToString();
Assert.AreEqual(
"244",
stringTemp);
}
{
string stringTemp = BigFromString(
"244").Gcd(EInteger.Zero).ToString();
Assert.AreEqual(
"244",
stringTemp);
}
{
string stringTemp = BigFromString(
"-244").Gcd(EInteger.Zero).ToString();
Assert.AreEqual(
"244",
stringTemp);
}
{
string stringTemp = EInteger.One.Gcd(BigFromString("244")).ToString();
Assert.AreEqual(
"1",
stringTemp);
}
{
string stringTemp = EInteger.One.Gcd(BigFromString(
"-244")).ToString();
Assert.AreEqual(
"1",
stringTemp);
}
{
string stringTemp = BigFromString("244").Gcd(EInteger.One).ToString();
Assert.AreEqual(
"1",
stringTemp);
}
{
string stringTemp = BigFromString(
"-244").Gcd(EInteger.One).ToString();
Assert.AreEqual(
"1",
stringTemp);
}
{
string stringTemp = BigFromString("15").Gcd(BigFromString(
"15")).ToString();
Assert.AreEqual(
"15",
stringTemp);
}
{
string stringTemp = BigFromString("-15").Gcd(
BigFromString("15")).ToString();
Assert.AreEqual(
"15",
stringTemp);
}
{
string stringTemp = BigFromString("15").Gcd(
BigFromString("-15")).ToString();
Assert.AreEqual(
"15",
stringTemp);
}
{
string stringTemp = BigFromString(
"-15").Gcd(BigFromString("-15")).ToString();
Assert.AreEqual(
"15",
stringTemp);
}
var prime = 0;
var rand = new RandomGenerator();
for (var i = 0; i < 1000; ++i) {
while (true) {
prime = rand.UniformInt(0x7fffffff);
prime |= 1;
if (IsPrime(prime)) {
break;
}
}
var bigprime = (EInteger)prime;
EInteger ba = RandomBigInteger(rand);
if (ba.IsZero) {
continue;
}
ba *= (EInteger)bigprime;
Assert.AreEqual(
bigprime,
bigprime.Gcd(ba));
}
TestGcdPair((EInteger)(-1867), (EInteger)(-4456), EInteger.One);
TestGcdPair((EInteger)4604, (EInteger)(-4516), (EInteger)4);
TestGcdPair((EInteger)(-1756), (EInteger)4525, EInteger.One);
TestGcdPair((EInteger)1568, (EInteger)(-4955), EInteger.One);
TestGcdPair((EInteger)2519, (EInteger)2845, EInteger.One);
TestGcdPair((EInteger)(-1470), (EInteger)132, (EInteger)6);
TestGcdPair((EInteger)(-2982), (EInteger)2573, EInteger.One);
TestGcdPair((EInteger)(-244), (EInteger)(-3929), EInteger.One);
TestGcdPair((EInteger)(-3794), (EInteger)(-2325), EInteger.One);
TestGcdPair((EInteger)(-2667), (EInteger)2123, EInteger.One);
TestGcdPair((EInteger)(-3712), (EInteger)(-1850), (EInteger)2);
TestGcdPair((EInteger)2329, (EInteger)3874, EInteger.One);
TestGcdPair((EInteger)1384, (EInteger)(-4278), (EInteger)2);
TestGcdPair((EInteger)213, (EInteger)(-1217), EInteger.One);
TestGcdPair((EInteger)1163, (EInteger)2819, EInteger.One);
TestGcdPair((EInteger)1921, (EInteger)(-579), EInteger.One);
TestGcdPair((EInteger)3886, (EInteger)(-13), EInteger.One);
TestGcdPair((EInteger)(-3270), (EInteger)(-3760), (EInteger)10);
TestGcdPair((EInteger)(-3528), (EInteger)1822, (EInteger)2);
TestGcdPair((EInteger)1547, (EInteger)(-333), EInteger.One);
TestGcdPair((EInteger)2402, (EInteger)2850, (EInteger)2);
TestGcdPair((EInteger)4519, (EInteger)1296, EInteger.One);
TestGcdPair((EInteger)1821, (EInteger)2949, (EInteger)3);
TestGcdPair((EInteger)(-2634), (EInteger)(-4353), (EInteger)3);
TestGcdPair((EInteger)(-1728), (EInteger)199, EInteger.One);
TestGcdPair((EInteger)(-4646), (EInteger)(-1418), (EInteger)2);
TestGcdPair((EInteger)(-35), (EInteger)(-3578), EInteger.One);
TestGcdPair((EInteger)(-2244), (EInteger)(-3250), (EInteger)2);
TestGcdPair((EInteger)(-3329), (EInteger)1039, EInteger.One);
TestGcdPair((EInteger)(-3064), (EInteger)(-4730), (EInteger)2);
TestGcdPair((EInteger)(-1214), (EInteger)4130, (EInteger)2);
TestGcdPair((EInteger)(-3038), (EInteger)(-3184), (EInteger)2);
TestGcdPair((EInteger)(-209), (EInteger)(-1617), (EInteger)11);
TestGcdPair((EInteger)(-1101), (EInteger)(-2886), (EInteger)3);
TestGcdPair((EInteger)(-3021), (EInteger)(-4499), EInteger.One);
TestGcdPair((EInteger)3108, (EInteger)1815, (EInteger)3);
TestGcdPair((EInteger)1195, (EInteger)4618, EInteger.One);
TestGcdPair((EInteger)(-3643), (EInteger)2156, EInteger.One);
TestGcdPair((EInteger)(-2067), (EInteger)(-3780), (EInteger)3);
TestGcdPair((EInteger)4251, (EInteger)1607, EInteger.One);
TestGcdPair((EInteger)438, (EInteger)741, (EInteger)3);
TestGcdPair((EInteger)(-3692), (EInteger)(-2135), EInteger.One);
TestGcdPair((EInteger)(-1076), (EInteger)2149, EInteger.One);
TestGcdPair((EInteger)(-3224), (EInteger)(-1532), (EInteger)4);
TestGcdPair((EInteger)(-3713), (EInteger)1721, EInteger.One);
TestGcdPair((EInteger)3038, (EInteger)(-2657), EInteger.One);
TestGcdPair((EInteger)4977, (EInteger)(-110), EInteger.One);
TestGcdPair((EInteger)(-3305), (EInteger)(-922), EInteger.One);
TestGcdPair((EInteger)1902, (EInteger)2481, (EInteger)3);
TestGcdPair((EInteger)(-4804), (EInteger)(-1378), (EInteger)2);
TestGcdPair((EInteger)(-1446), (EInteger)(-4226), (EInteger)2);
TestGcdPair((EInteger)(-1409), (EInteger)3303, EInteger.One);
TestGcdPair((EInteger)(-1626), (EInteger)(-3193), EInteger.One);
TestGcdPair((EInteger)912, (EInteger)(-421), EInteger.One);
TestGcdPair((EInteger)751, (EInteger)(-1755), EInteger.One);
TestGcdPair((EInteger)3135, (EInteger)(-3581), EInteger.One);
TestGcdPair((EInteger)(-4941), (EInteger)(-2885), EInteger.One);
TestGcdPair((EInteger)4744, (EInteger)3240, (EInteger)8);
TestGcdPair((EInteger)3488, (EInteger)4792, (EInteger)8);
TestGcdPair((EInteger)3632, (EInteger)3670, (EInteger)2);
TestGcdPair((EInteger)(-4821), (EInteger)(-1749), (EInteger)3);
TestGcdPair((EInteger)4666, (EInteger)2013, EInteger.One);
TestGcdPair((EInteger)810, (EInteger)(-3466), (EInteger)2);
TestGcdPair((EInteger)2199, (EInteger)161, EInteger.One);
TestGcdPair((EInteger)(-1137), (EInteger)(-1620), (EInteger)3);
TestGcdPair((EInteger)(-472), (EInteger)66, (EInteger)2);
TestGcdPair((EInteger)3825, (EInteger)2804, EInteger.One);
TestGcdPair((EInteger)(-2895), (EInteger)1942, EInteger.One);
TestGcdPair((EInteger)1576, (EInteger)(-4209), EInteger.One);
TestGcdPair((EInteger)(-277), (EInteger)(-4415), EInteger.One);
for (var i = 0; i < 1000; ++i) {
prime = rand.UniformInt(0x7fffffff);
if (rand.UniformInt(2) == 0) {
prime = -prime;
}
int intB = rand.UniformInt(0x7fffffff);
if (rand.UniformInt(2) == 0) {
intB = -intB;
}
var biga = (EInteger)prime;
var bigb = (EInteger)intB;
EInteger ba = biga.Gcd(bigb);
EInteger bb = bigb.Gcd(biga);
Assert.AreEqual(ba, bb);
}
}
private static byte[] RandomBytes(RandomGenerator rnd)
{
int count = 10 + rnd.UniformInt(350);
var arr = new byte[count];
for (var i = 0; i < count; ++i) {
arr[i] = (byte)rnd.UniformInt(0x100);
}
return arr;
}
public static string RandomString(RandomGenerator rnd)
{
int count = 10 + rnd.UniformInt(350);
var sb = new StringBuilder(count * 2);
int ui;
string problemChars = " \t\u0000\u0010\u001b\u001f" +
"\u007f\u008f\u009f%\\/*?|:<>\"\u0028\u0029" +
"\u00a0\u3000\u180e\u1680\u2000\u200b\u205f\u202f\ufeff" +
"\ufffe\uffff\ufdd0\ufdef";
for (var i = 0; i < count; ++i) {
var ch = 0;
ui = rnd.UniformInt(100);
if (ui < 2) {
ch = rnd.UniformInt(0x110000);
} else if (ui < 4) {
ch = rnd.UniformInt(0x10000);
} else if (ui < 10) {
ch = rnd.UniformInt(0x3000);
} else if (ui < 80) {
ch = 0x20 + rnd.UniformInt(0x5f);
} else if (ui < 83) {
ch = 0x20;
} else if (ui < 86) {
ch = (char)'.';
} else {
ui = rnd.UniformInt(problemChars.Length);
ch = problemChars[ui];
}
if ((ch & 0xf800) == 0xd800) {
ch &= 0xff;
}
if (ch < 0x10000) {
sb.Append((char)ch);
} else {
ch -= 0x10000;
int lead = (ch >> 10) + 0xd800;
int trail = (ch & 0x3ff) + 0xdc00;
sb.Append((char)lead);
sb.Append((char)trail);
}
}
string ret = sb.ToString();
return ret;
}
public static EInteger RandomSmallIntegral(RandomGenerator r)
{
int count = r.UniformInt(20) + 1;
var sb = new StringBuilder();
if (r.UniformInt(2) == 0) {
sb.Append('-');
}
for (var i = 0; i < count; ++i) {
if (i == 0) {
sb.Append((char)('1' + r.UniformInt(9)));
} else {
sb.Append((char)('0' + r.UniformInt(10)));
}
}
return EInteger.FromString(sb.ToString());
}
public static float RandomSingle(RandomGenerator rand, int exponent)
{
if (exponent == Int32.MaxValue) {
exponent = rand.UniformInt(255);
}
int r = rand.UniformInt(0x10000);
if (rand.UniformInt(2) == 0) {
r |= ((int)rand.UniformInt(0x10000)) << 16;
}
r &= ~0x7f800000; // clear exponent
r |= ((int)exponent) << 23; // set exponent
return BitConverter.ToSingle(BitConverter.GetBytes((int)r), 0);
}
public static EInteger RandomEInteger(RandomGenerator r)
{
int selection = r.UniformInt(100);
if (selection < 40) {
StringAndBigInt sabi = StringAndBigInt.Generate(r, 16);
return sabi.BigIntValue;
}
if (selection < 50) {
StringAndBigInt sabi = StringAndBigInt.Generate(
r,
2 + r.UniformInt(35));
return sabi.BigIntValue;
} else {
int count = r.UniformInt(60) + 1;
var bytes = new byte[count];
for (var i = 0; i < count; ++i) {
bytes[i] = (byte)((int)r.UniformInt(256));
}
return EInteger.FromBytes(bytes, true);
}
}
public static EInteger RandomBigInteger(RandomGenerator r) {
int selection = r.UniformInt(100);
int count = r.UniformInt(60) + 1;
if (selection < 40) {
count = r.UniformInt(7) + 1;
}
if (selection < 50) {
count = r.UniformInt(15) + 1;
}
var bytes = new byte[count];
for (var i = 0; i < count; ++i) {
bytes[i] = (byte)((int)r.UniformInt(256));
}
return BigFromBytes(bytes);
}
public void TestShiftRight() {
EInteger bigint = EInteger.One;
bigint <<= 80;
TestCommon.CompareTestEqualAndConsistent(bigint << 12, bigint >> -12);
TestCommon.CompareTestEqualAndConsistent(bigint << -12, bigint >> 12);
var r = new RandomGenerator();
EInteger minusone = EInteger.Zero;
minusone -= EInteger.One;
for (var i = 0; i < 1000; ++i) {
int smallint = r.UniformInt(0x7fffffff);
var bigintA = (EInteger)smallint;
string str = bigintA.ToString();
for (int j = 32; j < 80; ++j) {
DoTestShiftRight2(str, j, EInteger.Zero);
DoTestShiftRight2("-" + str, j, minusone);
}
}
for (var i = 0; i < 1000; ++i) {
EInteger bigintA = RandomBigInteger(r);
bigintA = bigintA.Abs();
EInteger bigintB = bigintA;
for (int j = 0; j < 100; ++j) {
EInteger ba = bigintA;
ba >>= j;
TestCommon.CompareTestEqualAndConsistent(bigintB, ba);
int negj = -j;
ba = bigintA;
ba <<= negj;
TestCommon.CompareTestEqualAndConsistent(bigintB, ba);
bigintB /= (EInteger)2;
}
}
}
public void TestMultiplyDivideA() {
var r = new RandomGenerator();
for (var i = 1; i < 25; ++i) {
for (var j = 1; j < i; ++j) {
EInteger bigA, bigB;
int highWord;
bigA = AllOnesInteger(i);
bigB = AllOnesInteger(j);
TestMultiplyDivideOne(bigA, bigB);
highWord = r.UniformInt(0x8000, 0x10000);
bigA = EInteger.FromInt32(highWord).ShiftLeft(i * 16).Add(bigA);
bigB = EInteger.FromInt32(highWord).ShiftLeft(j * 16).Add(bigB);
TestMultiplyDivideOne(bigA, bigB);
bigA = ZerosAndOnesInteger(i);
bigB = ZerosAndOnesInteger(j);
TestMultiplyDivideOne(bigA, bigB);
highWord = r.UniformInt(0x8000, 0x10000);
bigA = EInteger.FromInt32(highWord).ShiftLeft(i * 16).Add(bigA);
bigB = EInteger.FromInt32(highWord).ShiftLeft(j * 16).Add(bigB);
TestMultiplyDivideOne(bigA, bigB);
}
}
EInteger startIntA = ZerosAndOnesInteger(100);
EInteger startIntB = ZerosAndOnesInteger(50);
for (var i = 1; i < 500; ++i) {
EInteger bigA = FuzzInteger(startIntA, r.UniformInt(1, 100), r);
EInteger bigB = FuzzInteger(startIntB, r.UniformInt(1, 50), r);
TestMultiplyDivideOne(bigA, bigB);
}
{
EInteger ei1 = EInteger.FromRadixString(
"101000101010100000001000100000101000000000100000101000100010101000001010000000001010101000101010100010100",
16);
EInteger ei2 = EInteger.FromRadixString(
"100000000000100010000000100000000010001000100010000010101010100000000000000000000",
16);
TestMultiplyDivideOne(ei1, ei2);
ei1 = EInteger.FromString
("44461738044811866704570272160729755524383493147516085922742403681586307620758054502667856562873477505768158700319760453047044081412393321568753479912147358343844563186048273758088945022589574729044743021988362306225753942249201773678443992606696524197361479929661991788310321409367753462284203449631729626517511224343015354155975783754763572354740724506742793459644155837703671449155713000260325445046273385372701820583016334341594713806706345456633635125343104401883366671083569152");
ei2 = EInteger.FromString
("6667912688606651657935168942074070387623462798286393292334546164025938697493268465740399785103348978411106010660409247384863031649363973174034406552719188394559243700794785023362300512913065060420313203793021880700852215978918600154969735168");
TestMultiplyDivideOne (ei1, ei2);
}
for (var i = 0; i < 1000; ++i) {
EInteger bigA, bigB;
do {
bigA = WordAlignedInteger(r);
bigB = WordAlignedInteger(r);
} while (bigA.CompareTo(bigB) <= 0);
TestMultiplyDivideOne(bigA, bigB);
}
for (var i = 0; i < 10000; ++i) {
EInteger bigA = RandomObjects.RandomEInteger(r);
EInteger bigB = RandomObjects.RandomEInteger(r);
TestMultiplyDivideOne(bigA, bigB);
}
TestMultiplyDivideOne(EInteger.FromInt32(-985), EInteger.FromInt32(0));
}
private static void TestAddCloseExponent(RandomGenerator fr, int exp) {
for (var i = 0; i < 1000; ++i) {
EInteger exp1 = EInteger.FromInt32(exp)
.Add(EInteger.FromInt32(fr.UniformInt(32) - 16));
EInteger exp2 = exp1 .Add(EInteger.FromInt32(fr.UniformInt(18) - 9));
EInteger mant1 = RandomObjects.RandomEInteger(fr);
EInteger mant2 = RandomObjects.RandomEInteger(fr);
EDecimal decA = EDecimal.Create(mant1, exp1);
EDecimal decB = EDecimal.Create(mant2, exp2);
EDecimal decC = decA.Add(decB);
EDecimal decD = decC.Subtract(decA);
TestCommon.CompareTestEqual(decD, decB);
decD = decC.Subtract(decB);
TestCommon.CompareTestEqual(decD, decA);
}
}
public void TestToDouble() {
// test for correct rounding
double dbl;
dbl = EDecimal.FromString(
"1.972579273363468721491642554610734805464744567871093749999999999999")
.ToDouble();
{
string stringTemp = EFloat.FromDouble(dbl).ToPlainString();
Assert.AreEqual(
"1.9725792733634686104693400920950807631015777587890625",
stringTemp);
}
var fr = new RandomGenerator();
dbl = DoubleOverflowToInfinity.ToDouble();
Assert.IsTrue(Double.IsPositiveInfinity(dbl));
dbl = DoubleOverflowToInfinity.Negate().ToDouble();
Assert.IsTrue(Double.IsNegativeInfinity(dbl));
dbl = DoubleUnderflowToZero.ToDouble();
Assert.IsTrue(dbl == 0.0);
dbl = DoubleUnderflowToZero.Negate().ToDouble();
Assert.IsTrue(dbl == 0.0);
for (var i = 0; i < 10000; ++i) {
EDecimal edec;
if (fr.UniformInt(100) < 10) {
string decimals = RandomObjects.RandomBigIntString(fr);
if (decimals[0] == '-') {
decimals = decimals.Substring(1);
}
string edecstr = RandomObjects.RandomBigIntString(fr) +
"." + decimals + "e" + RandomObjects.RandomBigIntString(fr);
edec = EDecimal.FromString(edecstr);
} else {
edec = RandomObjects.RandomEDecimal(fr);
}
if (edec.IsFinite) {
dbl = edec.ToDouble();
if (Double.IsNegativeInfinity(dbl)) {
Assert.IsTrue(edec.IsNegative);
TestCommon.CompareTestGreaterEqual(edec.Abs(), DoubleOverflowToInfinity);
} else if (Double.IsPositiveInfinity(dbl)) {
Assert.IsTrue(!edec.IsNegative);
TestCommon.CompareTestGreaterEqual(edec.Abs(), DoubleOverflowToInfinity);
} else if (dbl == 0.0) {
TestCommon.CompareTestLessEqual(edec.Abs(), DoubleUnderflowToZero);
Assert.AreEqual(edec.IsNegative, EDecimal.FromDouble(dbl).IsNegative);
} else {
Assert.IsTrue(!Double.IsNaN(dbl));
edec = edec.Abs();
TestCommon.CompareTestGreater(edec, DoubleUnderflowToZero);
TestCommon.CompareTestLess(edec, DoubleOverflowToInfinity);
EDecimal halfUlp = GetHalfUlp(dbl);
EDecimal difference = EDecimal.FromDouble(dbl).Abs()
.Subtract(edec).Abs();
TestCommon.CompareTestLessEqual(difference, halfUlp);
}
}
}
}
private static EInteger WordAlignedInteger(RandomGenerator r) {
int size = r.UniformInt(150) + 1;
EInteger ei = EInteger.Zero;
for (var i = 0; i < size; ++i) {
ei = ei.ShiftLeft(16).Add(EInteger.FromInt32(r.UniformInt(0x10000) |
0x8000));
}
return ei;
}
public static EFloat RandomEFloat(RandomGenerator r)
{
if (r.UniformInt(100) == 0) {
int x = r.UniformInt(3);
if (x == 0) {
return EFloat.PositiveInfinity;
}
if (x == 1) {
return EFloat.NegativeInfinity;
}
if (x == 2) {
return EFloat.NaN;
}
}
return EFloat.Create(
RandomEInteger(r),
(EInteger)(r.UniformInt(400) - 200));
}
private static EInteger FuzzInteger(
EInteger ei,
int fuzzes,
RandomGenerator r) {
byte[] bytes = ei.ToBytes(true);
int bits = ei.GetUnsignedBitLength();
for (var i = 0; i < fuzzes; ++i) {
int bit = r.UniformInt(bits);
bytes[bit / 8] ^= (byte)(1 << (bit & 0x07));
}
return EInteger.FromBytes(bytes, true);
}
public void TestToSingle() {
var fr = new RandomGenerator();
float sng;
sng = SingleOverflowToInfinity.ToSingle();
Assert.IsTrue(Single.IsPositiveInfinity(sng));
sng = SingleOverflowToInfinity.Negate().ToSingle();
Assert.IsTrue(Single.IsNegativeInfinity(sng));
sng = SingleUnderflowToZero.ToSingle();
Assert.IsTrue(sng == 0.0);
sng = SingleUnderflowToZero.Negate().ToSingle();
Assert.IsTrue(sng == 0.0);
for (var i = 0; i < 10000; ++i) {
EDecimal edec;
if (fr.UniformInt(100) < 10) {
string decimals = RandomObjects.RandomBigIntString(fr);
if (decimals[0] == '-') {
decimals = decimals.Substring(1);
}
string edecstr = RandomObjects.RandomBigIntString(fr) +
"." + decimals + "e" + RandomObjects.RandomBigIntString(fr);
edec = EDecimal.FromString(edecstr);
} else {
edec = RandomObjects.RandomEDecimal(fr);
}
if (edec.IsFinite) {
sng = edec.ToSingle();
if (Single.IsNegativeInfinity(sng)) {
Assert.IsTrue(edec.IsNegative);
TestCommon.CompareTestGreaterEqual(edec.Abs(), SingleOverflowToInfinity);
} else if (Single.IsPositiveInfinity(sng)) {
Assert.IsTrue(!edec.IsNegative);
TestCommon.CompareTestGreaterEqual(edec.Abs(), SingleOverflowToInfinity);
} else if (sng == 0.0f) {
TestCommon.CompareTestLessEqual(edec.Abs(), SingleUnderflowToZero);
Assert.AreEqual(edec.IsNegative, EDecimal.FromSingle(sng).IsNegative);
} else {
Assert.IsTrue(!Single.IsNaN(sng));
edec = edec.Abs();
TestCommon.CompareTestGreater(edec, SingleUnderflowToZero);
TestCommon.CompareTestLess(edec, SingleOverflowToInfinity);
EDecimal halfUlp = GetHalfUlp(sng);
EDecimal difference = EDecimal.FromSingle(sng).Abs()
.Subtract(edec).Abs();
TestCommon.CompareTestLessEqual(difference, halfUlp);
}
}
}
}
public void TestPow() {
var r = new RandomGenerator();
for (var i = 0; i < 200; ++i) {
int power = 1 + r.UniformInt(8);
EInteger bigintA = RandomBigInteger(r);
EInteger bigintB = bigintA;
for (int j = 1; j < power; ++j) {
bigintB *= bigintA;
}
DoTestPow(bigintA.ToString(), power, bigintB.ToString());
}
}
public void TestRandomNonsense()
{
var rand = new RandomGenerator();
for (var i = 0; i < 200; ++i) {
var array = new byte[rand.UniformInt(1000000) + 1];
for (int j = 0; j < array.Length; ++j) {
if (j + 3 <= array.Length) {
int r = rand.UniformInt(0x1000000);
array[j] = (byte)(r & 0xff);
array[j + 1] = (byte)((r >> 8) & 0xff);
array[j + 2] = (byte)((r >> 16) & 0xff);
j += 2;
} else {
array[j] = (byte)rand.UniformInt(256);
}
}
using (var ms = new MemoryStream(array)) {
var iobj = 0;
while (iobj < 25 && ms.Position != ms.Length) {
++iobj;
try {
CBORObject o = CBORObject.Read(ms);
try {
if (o == null) {
Assert.Fail("object read is null");
} else {
CBORObject.DecodeFromBytes(o.EncodeToBytes());
}
} catch (Exception ex) {
Assert.Fail(ex.ToString());
throw new InvalidOperationException(String.Empty, ex);
}
String jsonString = String.Empty;
try {
if (o.Type == CBORType.Array || o.Type == CBORType.Map) {
jsonString = o.ToJSONString();
CBORObject.FromJSONString(jsonString);
TestWriteToJSON(o);
}
} catch (Exception ex) {
Assert.Fail(jsonString + "\n" + ex);
throw new InvalidOperationException(String.Empty, ex);
}
} catch (CBORException) {
new Object(); // Expected exception
}
}
}
}
}
public void TestToString() {
var bi = (EInteger)3;
AssertBigIntegersEqual("3", bi);
var negseven = (EInteger)(-7);
AssertBigIntegersEqual("-7", negseven);
var other = (EInteger)(-898989);
AssertBigIntegersEqual("-898989", other);
other = (EInteger)898989;
AssertBigIntegersEqual("898989", other);
var r = new RandomGenerator();
for (var i = 0; i < 1000; ++i) {
EInteger bigintA = RandomBigInteger(r);
ExtraTest.TestStringEqualRoundTrip(bigintA);
}
// Test serialization of relatively big numbers
for (var i = 0; i < 20; ++i) {
EInteger bigintA = RandomBigInteger(r);
bigintA = bigintA.ShiftLeft(r.UniformInt(2000) + (16 * 500));
bigintA = bigintA.Subtract(RandomBigInteger(r));
ExtraTest.TestStringEqualRoundTrip(bigintA);
}
}
public void TestRandomSlightlyModified()
{
var rand = new RandomGenerator();
// Test slightly modified objects
for (var i = 0; i < 200; ++i) {
CBORObject originalObject = CBORTestCommon.RandomCBORObject(rand);
byte[] array = originalObject.EncodeToBytes();
// Console.WriteLine(originalObject);
int count2 = rand.UniformInt(10) + 1;
for (int j = 0; j < count2; ++j) {
int index = rand.UniformInt(array.Length);
array[index] = unchecked((byte)rand.UniformInt(256));
}
using (var inputStream = new MemoryStream(array)) {
while (inputStream.Position != inputStream.Length) {
try {
CBORObject o = CBORObject.Read(inputStream);
byte[] encodedBytes = (o == null) ? null : o.EncodeToBytes();
try {
CBORObject.DecodeFromBytes(encodedBytes);
} catch (Exception ex) {
Assert.Fail(ex.ToString());
throw new InvalidOperationException(String.Empty, ex);
}
String jsonString = String.Empty;
try {
if (o == null) {
Assert.Fail("object is null");
}
if (o != null && (o.Type == CBORType.Array || o.Type ==
CBORType.Map)) {
jsonString = o.ToJSONString();
// reread JSON string to test validity
CBORObject.FromJSONString(jsonString);
TestWriteToJSON(o);
}
} catch (Exception ex) {
Assert.Fail(jsonString + "\n" + ex);
throw new InvalidOperationException(String.Empty, ex);
}
} catch (CBORException ex) {
// Expected exception
Console.WriteLine(ex.Message);
}
}
}
}
}
public void TestDivide() {
int intA, intB;
DoTestDivide
("39401404978667143593022554770633078187236345017741021112301638514137074723630749875836463116600753265992771999563776"
,
"6277005955876855982708123588802319701019026907066160578560",
"6277101735386680763835789423207589043669308487479442014208");
DoTestDivide ("340277174703306882242637262502835978240",
"79226953606891185567396986880", "4294967296");
DoTestDivide (
"44461738044811866704570272160729755524383493147516085922742403681586307620758054502667856562873477505768158700319760453047044081412393321568753479912147358343844563186048273758088945022589574729044743021988362306225753942249201773678443992606696524197361479929661991788310321409367753462284203449631729626517511224343015354155975783754763572354740724506742793459644155837703671449155713000260325445046273385372701820583016334341594713806706345456633635125343104401883366671083569152",
"6667912688606651657935168942074070387623462798286393292334546164025938697493268465740399785103348978411106010660409247384863031649363973174034406552719188394559243700794785023362300512913065060420313203793021880700852215978918600154969735168",
"6668014432879854274079851790721257797144739185760979705624542990230371779898108261760364709743735387156366994446448705720136517621612785459920009307944044809722559761949909348022458684413967432579072465854783948147327367860791365121685323776");
DoTestDivide(
"9999999999999999999999",
"281474976710655",
"35527136");
DoTestDivide("2472320648", "2831812081", "0");
DoTestDivide("-2472320648", "2831812081", "0");
var fr = new RandomGenerator();
for (var i = 0; i < 10000; ++i) {
intA = fr.UniformInt(0x1000000);
intB = fr.UniformInt(0x1000000);
if (intB == 0) {
continue;
}
int c = intA / intB;
var bigintA = (EInteger)intA;
var bigintB = (EInteger)intB;
EInteger bigintC = bigintA / (EInteger)bigintB;
Assert.AreEqual((int)bigintC, c);
}
DoTestDivide ("4294901760", "281470681808895", "0");
DoTestDivide ("281470681808895", "281470681808895", "1");
DoTestDivide ("281195803901951", "281470681808895", "0");
DoTestDivide ("281470681808895", "79226953606891185567396986880",
"0");
DoTestDivide ("1208907373151751269056511", "281470681808895",
"4294967295");
DoTestDivide ("1208907373151751269056511",
"79226953606891185567396986880", "0");
DoTestDivide ("79226953606891185567396986880",
"79226953606891185567396986880", "1");
DoTestDivide ("79226953606891185567396986880",
"79226953606891185567396986880", "1");
DoTestDivide ("79149582354435849300215791616",
"281470681808895", "281200094609408");
DoTestDivide ("79149582354435849304510693376",
"79226953606891185567396986880", "0");
DoTestDivide ("340277174703229510990181926235654782976",
"79226953606891185567396986880", "4294967295");
DoTestDivide ("340277174703229510990181926235654782976",
"79226953606891185567396986880", "4294967295");
DoTestDivide ("79226953606891185567396986880",
"6277005955876855982708123588802319701019026907066160578560",
"0");
DoTestDivide ("22278626849872979772991819660510225504468991",
"79226953606891185567396986880", "281200094609408");
DoTestDivide
("6270875973713392427274690200693718464284551950581721071616",
"79226953606891185567396986880",
"79150790081217380608951451648");
DoTestDivide
("6277005955876855982708123588802242329766571570798979383296",
"6277005955876855982708123588802319701019026907066160578560",
"0");
DoTestDivide
("6277005955876855982708123588802242329766571570798979383296",
"6277005955876855982708123588802319701019026907066160578560",
"0");
DoTestDivide
("26959535297282185466869868771998681536704617202858716036715199266816",
"6277005955876855982708123588802319701019026907066160578560",
"4294967295");
DoTestDivide
("496829980752160275550680055858571148163286974448396184421327120687227627818219200249856"
,
"6277005955876855982708123588802319701019026907066160578560",
"79150790081217380608951451648");
DoTestDivide
("2135954443842118711369801686589217620410698847025641089415087336821733096438436218376946913837056"
,
"6277005955876855982708123588802319701019026907066160578560",
"340282366920861091030327650447175712768");
}
public static EDecimal RandomEDecimal(RandomGenerator r)
{
if (r.UniformInt(100) == 0) {
int x = r.UniformInt(3);
if (x == 0) {
return EDecimal.PositiveInfinity;
}
if (x == 1) {
return EDecimal.NegativeInfinity;
}
if (x == 2) {
return EDecimal.NaN;
}
// Signaling NaN currently not generated because
// it doesn't round-trip as well
}
string str = RandomDecimalString(r);
return EDecimal.FromString(str);
}
