public override float Start()
{
var num = PRNG.Next(1, 5);
m_args = new object[num];
m_done = new bool[num];
for (int i = 0; i < m_args.Length; i++)
{
m_args[i] = StringUtils.ToHex(PRNG.NextUInt32());
}
JobService.ForEachArgument(m_name, Execute, m_args, OnDone, "onDone");
return(1.0f);
}
public JobTest()
{
m_name = GetType().Name + StringUtils.ToHex(PRNG.NextUInt32());
}
public void Test7BitEncoding()
{
byte[] arr = new byte[1024];
// test variable lengths
var numbers = new ulong[7];
numbers = new ulong[] { 1, 25, 137, 255, 256, 10000, 1000000 };
ulong state = RandomSeed.GetUInt64();
for (int runs = 0; runs < 250000; runs++)
{
var work = arr.AsSpan();
for (int i = 0; i < numbers.Length; i++)
{
work.WriteVariableUInt64(numbers[i]);
}
int resultLength = arr.Length - work.Length;
ReadOnlySpan <byte> res = arr.AsSpan(0, resultLength);
for (int i = 0; i < numbers.Length; i++)
{
var nr = res.ReadVariableUInt64();
Assert.AreEqual(numbers[i], nr);
}
// re-randomize
numbers[0] = (ulong)PRNG.Next(ref state, 0, 6);
numbers[1] = (ulong)PRNG.Next(ref state, 7, 300);
numbers[2] = (ulong)PRNG.Next(ref state, 300, 5000);
numbers[3] = (ulong)PRNG.Next(ref state, 5000, 50000);
numbers[4] = (ulong)PRNG.Next(ref state, 50000, 500000);
numbers[5] = (ulong)PRNG.NextUInt64(ref state);
numbers[6] = (ulong)PRNG.NextUInt64(ref state);
}
// signed 64 bit
var signed64 = new long[7];
for (int runs = 0; runs < 250000; runs++)
{
// re-randomize
signed64[0] = (long)PRNG.Next(ref state, -5, 5);
signed64[1] = (long)PRNG.Next(ref state, -100, 100);
signed64[2] = (long)PRNG.Next(ref state, -300, 300);
signed64[3] = (long)PRNG.Next(ref state, -5000, 5000);
signed64[4] = (long)PRNG.Next(ref state, -70000, 70000);
signed64[5] = (long)PRNG.NextUInt64(ref state);
signed64[6] = (long)PRNG.NextUInt64(ref state);
var work = arr.AsSpan();
for (int i = 0; i < signed64.Length; i++)
{
work.WriteVariableInt64(signed64[i]);
}
int resultLength = arr.Length - work.Length;
ReadOnlySpan <byte> res = arr.AsSpan(0, resultLength);
for (int i = 0; i < signed64.Length; i++)
{
var nr = res.ReadVariableInt64();
Assert.AreEqual(signed64[i], nr);
}
}
// signed int32
var signed32 = new int[7];
for (int runs = 0; runs < 250000; runs++)
{
// re-randomize
signed32[0] = (int)PRNG.Next(ref state, -5, 5);
signed32[1] = (int)PRNG.Next(ref state, -100, 100);
signed32[2] = (int)PRNG.Next(ref state, -300, 300);
signed32[3] = (int)PRNG.Next(ref state, -5000, 5000);
signed32[4] = (int)PRNG.Next(ref state, -70000, 70000);
signed32[5] = (int)PRNG.NextUInt32(ref state);
signed32[6] = (int)PRNG.NextUInt32(ref state);
var work = arr.AsSpan();
for (int i = 0; i < signed32.Length; i++)
{
work.WriteVariableInt32(signed32[i]);
}
int resultLength = arr.Length - work.Length;
ReadOnlySpan <byte> res = arr.AsSpan(0, resultLength);
for (int i = 0; i < signed64.Length; i++)
{
var nr = res.ReadVariableInt32();
Assert.AreEqual(signed32[i], nr);
}
}
}
public void TestDataWriter2()
{
ulong ss = RandomSeed.GetUInt64();
byte[] small = new byte[64];
using (var wrt = new DataWriter(1))
{
for (int runs = 0; runs < 10000; runs++)
{
wrt.Clear();
var originalSeed = PRNG.NextUInt64(ref ss);
var seed = originalSeed;
{
int numOps = PRNG.Next(ref seed, 1, 15);
for (int o = 0; o < numOps; o++)
{
switch (PRNG.Next(ref seed, 0, 6))
{
case 0:
wrt.WriteBool(PRNG.NextBool(ref seed));
break;
case 1:
wrt.WriteSingle((float)PRNG.Next(ref seed, 1, 100));
break;
case 2:
wrt.WriteVariableInt32(PRNG.Next(ref seed, -50, 50));
break;
case 3:
wrt.WriteString(PRNG.NextUInt32(ref seed).ToString());
break;
case 4:
wrt.WriteUInt16((ushort)PRNG.Next(ref seed, 0, ushort.MaxValue));
break;
case 5:
var sss = small.AsSpan(0, PRNG.Next(ref seed, 1, 25));
wrt.WriteBytes(sss);
break;
}
}
}
// read
var rdr = wrt.ReadOnlySpan;
seed = originalSeed;
{
int numOps = PRNG.Next(ref seed, 1, 15);
for (int o = 0; o < numOps; o++)
{
switch (PRNG.Next(ref seed, 0, 6))
{
case 0:
{
var facit = PRNG.NextBool(ref seed);
Assert.AreEqual(facit, rdr.ReadBool());
}
break;
case 1:
{
var facit = (float)PRNG.Next(ref seed, 1, 100);
Assert.AreEqual(facit, rdr.ReadSingle());
}
break;
case 2:
{
var facit = PRNG.Next(ref seed, -50, 50);
Assert.AreEqual(facit, rdr.ReadVariableInt32());
}
break;
case 3:
{
var facit = PRNG.NextUInt32(ref seed).ToString();
Assert.AreEqual(facit, rdr.ReadString());
}
break;
case 4:
{
var facit = (ushort)PRNG.Next(ref seed, 0, ushort.MaxValue);
Assert.AreEqual(facit, rdr.ReadUInt16());
}
break;
case 5:
{
var sss = small.AsSpan(0, PRNG.Next(ref seed, 1, 25));
var aaa = rdr.ReadBytes(sss.Length);
Assert.IsTrue(sss.SequenceEqual(aaa));
}
break;
}
}
}
}
}
}
public void TestPriorityQueue()
{
{
// just enqueue a bunch
var pq = new PriorityQueue <uint, uint>(100);
for (int i = 0; i < 1000; i++)
{
var r = PRNG.NextUInt32();
if (r == 0)
{
r = 1;
}
pq.Enqueue(r, r);
}
// dequeue and verify
uint last = 0;
while (pq.Count > 0)
{
var ok = pq.Peek(out var nextprio, out var nextItem);
Assert.IsTrue(ok);
Assert.AreEqual(nextprio, nextItem);
Assert.IsTrue(nextprio >= last);
last = nextprio;
var pok = pq.TryDequeue(out var dequeuedItem);
Assert.IsTrue(pok);
Assert.AreEqual(dequeuedItem, nextItem);
}
}
{
var queue = new PriorityQueue <int, string>(4);
queue.Enqueue(5, "five");
queue.Enqueue(3, "three");
queue.Enqueue(8, "eight");
queue.Enqueue(1, "one");
queue.Enqueue(3, "three-again");
bool ok = queue.TryDequeue(out var str);
Assert.IsTrue(ok);
Assert.AreEqual("one", str);
ok = queue.TryDequeue(out str);
Assert.IsTrue(ok);
Assert.IsTrue(str == "three" || str == "three-again");
ok = queue.TryDequeue(out str);
Assert.IsTrue(ok);
Assert.IsTrue(str == "three" || str == "three-again");
ok = queue.PeekPriority(out var nextPrio);
Assert.IsTrue(ok);
Assert.AreEqual(5, nextPrio);
ok = queue.TryDequeue(out str);
Assert.IsTrue(ok);
Assert.AreEqual("five", str);
Assert.AreEqual(1, queue.Count);
queue.Enqueue(6, "six");
ok = queue.TryDequeue(out str);
Assert.IsTrue(ok);
Assert.AreEqual("six", str);
ok = queue.TryDequeue(out str);
Assert.IsTrue(ok);
Assert.AreEqual("eight", str);
ok = queue.TryDequeue(out str);
Assert.IsFalse(ok);
Assert.AreEqual(0, queue.Count);
queue.Clear();
queue.Enqueue(3, "3");
queue.Enqueue(1, "1");
queue.Enqueue(2, "2");
ok = queue.Remove("22");
Assert.IsFalse(ok);
Assert.AreEqual(3, queue.Count);
ok = queue.Remove("2");
Assert.IsTrue(ok);
Assert.AreEqual("1", queue.Dequeue());
Assert.AreEqual("3", queue.Dequeue());
ok = queue.TryDequeue(out _);
Assert.IsFalse(ok);
var facit = new List <(int, string)>();
queue.Clear();
for (int op = 0; op < 1000000; op++)
{
switch (PRNG.Next(0, 8))
{
case 0:
queue.Clear();
facit.Clear();
break;
case 1:
case 2:
case 3:
case 4:
// enqueue
int add = PRNG.Next(0, 50);
queue.Enqueue(add, add.ToString());
facit.Add((add, add.ToString()));
break;
case 5:
// remove
int rem = PRNG.Next(0, 50);
var fok = Remove(facit, rem.ToString());
var qok = queue.Remove(rem.ToString());
Assert.AreEqual(fok, qok);
break;
case 6:
case 7:
// dequeue
if (facit.Count <= 0)
{
continue;
}
var fitem = Dequeue(facit);
var qitem = queue.Dequeue();
Assert.AreEqual(fitem, qitem);
break;
}
Assert.AreEqual(facit.Count, queue.Count);
if (facit.Count > 0)
{
ok = queue.Peek(out var peekprio, out var peekitem);
Assert.IsTrue(ok);
Peek(facit, out var facitpeekprio, out var facitpeekitem);
Assert.AreEqual(facitpeekprio, peekprio);
Assert.AreEqual(facitpeekitem, peekitem);
}
}
}
}
public void TestPRNG()
{
const int iterations = 10000000;
Console.WriteLine();
int trues = 0;
int larger = 0;
int smaller = 0;
for (int i = 0; i < iterations; i++)
{
if (PRNG.NextBool())
{
trues++;
}
int val = PRNG.Next(5, 8); // 5, 6 or 7
switch (val)
{
case 5:
smaller++;
break;
case 6:
break;
case 7:
larger++;
break;
default:
Assert.Fail("Value " + val + " isn't 5, 6 or 7");
break;
}
// ranged
var r1 = (int)PRNG.NextUInt32();
var r2 = (int)PRNG.NextUInt32();
if (r1 < r2)
{
var rr = PRNG.Next(r1, r2);
Assert.IsTrue(rr >= r1 && rr < r2, rr.ToString() + " is not between " + r1 + " and " + r2);
}
else if (r1 > r2)
{
var rr = PRNG.Next(r2, r1);
Assert.IsTrue(rr >= r2 && rr < r1, rr.ToString() + " is not between " + r2 + " and " + r1);
}
}
var p = (double)trues / (double)iterations;
Assert.IsTrue(p > 0.495 && p < 0.505);
const double third = 1.0 / 3.0;
const double offset = third * 0.05;
const double low = third - offset;
const double high = third + offset;
p = (double)smaller / (double)iterations;
Assert.IsTrue(p > low && p < high);
p = (double)larger / (double)iterations;
Assert.IsTrue(p > low && p < high);
}
public void TestPRNG()
{
const int iterations = 5000000;
Console.WriteLine();
int trues = 0;
int larger = 0;
int smaller = 0;
for (int i = 0; i < iterations; i++)
{
if (PRNG.NextBool())
{
trues++;
}
int val = PRNG.Next(5, 8); // 5, 6 or 7
switch (val)
{
case 5:
smaller++;
break;
case 6:
break;
case 7:
larger++;
break;
default:
Assert.Fail("Value " + val + " isn't 5, 6 or 7");
break;
}
// ranged
var r1 = (int)PRNG.NextUInt32();
var r2 = (int)PRNG.NextUInt32();
if (r1 < r2)
{
var rr = PRNG.Next(r1, r2);
Assert.IsTrue(rr >= r1 && rr < r2, rr.ToString() + " is not between " + r1 + " and " + r2);
}
else if (r1 > r2)
{
var rr = PRNG.Next(r2, r1);
Assert.IsTrue(rr >= r2 && rr < r1, rr.ToString() + " is not between " + r2 + " and " + r1);
}
}
var p = (double)trues / (double)iterations;
Assert.IsTrue(p > 0.495 && p < 0.505);
const double third = 1.0 / 3.0;
const double offset = third * 0.05;
const double low = third - offset;
const double high = third + offset;
p = (double)smaller / (double)iterations;
Assert.IsTrue(p > low && p < high);
p = (double)larger / (double)iterations;
Assert.IsTrue(p > low && p < high);
// make sure nextdouble() and nextfloat() don't generate numbers outside range
var state = RandomSeed.GetUInt64();
for (int r = 0; r < 10000000; r++)
{
double d = PRNG.NextDouble(ref state);
Assert.IsTrue(d >= 0.0 && d < 1.0);
float f = PRNG.NextFloat(ref state);
Assert.IsTrue(f >= 0.0f && f < 1.0f);
}
}
