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); } }