public void BeforeClass() { mySliceInt = BitSlice.Int(4); mySliceEnum = BitSlice.Enum <E4>(mySliceInt); mySliceBool = BitSlice.Bool(mySliceEnum); mySliceE1 = BitSlice.Enum <E1>(mySliceBool); }
public void TestBadEnums() { Assert.Throws <Assertion.AssertionException>(() => BitSlice.Enum <EMinus>()); Assert.Throws <Assertion.AssertionException>(() => BitSlice.Enum <EUint>()); Assert.Throws <Assertion.AssertionException>(() => BitSlice.Enum <E0>()); Assert.Throws <TypeInitializationException>(() => BitSlice.Enum <ELong>()); }
public void InterlockedUpdateStressTest2() { const int bitCount = 8; const int n = (1 << bitCount) - 1; var slice1 = BitSlice.Int(bitCount); var slice2 = BitSlice.Int(bitCount, slice1); var slice3 = BitSlice.Int(bitCount, slice2); var slice4 = BitSlice.Int(bitCount, slice3); for (var i = 0; i < 1000; i++) { var state = 0; Parallel.Invoke(() => { for (var j = 0; j < n; j++) { slice1.InterlockedUpdate(ref state, slice1[state] + 1); } }, () => { for (var j = 0; j < n; j++) { slice2.InterlockedUpdate(ref state, slice2[state] + 1); } }, () => { for (var j = 0; j < n; j++) { slice3.InterlockedUpdate(ref state, slice3[state] + 1); } }, () => { for (var j = 0; j < n; j++) { slice4.InterlockedUpdate(ref state, slice4[state] + 1); } }); Assert.AreEqual(n, slice1[state]); Assert.AreEqual(n, slice2[state]); Assert.AreEqual(n, slice3[state]); Assert.AreEqual(n, slice4[state]); } }
public void CreateStreamWithSourceByteArray() { byte[] byteArray = new byte[100]; byteArray[0] = (byte)'a'; byteArray[1] = (byte)'b'; byteArray[2] = (byte)'c'; BitStream bitStream; using (bitStream = new BitStream(byteArray, Allocator.Persistent)) { var slice = new BitSlice(ref bitStream, 0, byteArray.Length); for (int i = 0; i < slice.Length; ++i) { Assert.AreEqual(byteArray[i], slice.ReadByte()); } } }
public void InterlockedUpdateStressTest() { const int n = 10000; var slice1 = BitSlice.Bool(); var slice2 = BitSlice.Bool(slice1); var state = 0; for (var i = 0; i < 500; i++) { Parallel.Invoke(() => { for (var j = 0; j < n; j++) { Enter(slice1); Release(slice1); } }, () => { for (var j = 0; j < n; j++) { Enter(slice2); Release(slice2); } }); } void Enter(BoolBitSlice slice) { Assert.IsFalse(slice[state]); slice.InterlockedUpdate(ref state, true); } void Release(BoolBitSlice slice) { Assert.IsTrue(slice[state]); slice.InterlockedUpdate(ref state, false); } }
public void CreateStreamWithPartOfSourceByteArray() { byte[] byteArray = { (byte)'s', (byte)'o', (byte)'m', (byte)'e', (byte)' ', (byte)'d', (byte)'a', (byte)'t', (byte)'a' }; BitStream bitStream; using (bitStream = new BitStream(byteArray, Allocator.Persistent, 4)) { Assert.AreEqual(bitStream.Length, 4); var slice = new BitSlice(ref bitStream, 0, bitStream.Length); for (int i = 0; i < slice.Length; ++i) { Assert.AreEqual(byteArray[i], slice.ReadByte()); } // TODO: Make sure it doesn't read out of bounds Assert.AreNotEqual((byte)' ', slice.ReadByte()); } }
public unsafe void DummyIntegrationTest() { int start, cSeed = 12345; start = cSeed; int maxSize = 65536; var arrOut = new NativeArray <byte>(maxSize, Allocator.Temp); NativeSlice <byte> arrIn; for (int a = 0; a < 1; a++) { byte[] packet = new byte[maxSize]; System.Random r = new System.Random(cSeed); r.NextBytes(packet); // Overwrite first 4 bytes with seed so we can validate the packet even if it arrives Out Of Order packet[0] = (byte)(cSeed >> 0); packet[1] = (byte)(cSeed >> 8); packet[2] = (byte)(cSeed >> 16); packet[3] = (byte)(cSeed >> 24); arrOut.CopyFrom(packet); fragmenter.FragmentPacket(arrOut.Slice(0, 22 /*maxSize / 2*/), cSeed); cSeed++; } NativeArray <byte> buffer = new NativeArray <byte>(1400, Allocator.Temp); while (fragmenter.fragmentedOutgoing.Count > 0) { var f = fragmenter.fragmentedOutgoing.Dequeue(); /* * var bw = new ByteWriter(buffer.GetUnsafePtr(), buffer.Length); * bw.Write(f.ID); * bw.Write(f.SequenceNum); * bw.Write(f.SequenceCnt); * bw.Write(f.packetData.Length); * bw.WriteBytes((byte*)f.packetData.GetUnsafePtr(), f.packetData.Length); * * var written = bw.GetBytesWritten(); */ var ret = fragmenter.DefragmentPacket(f, out arrIn); //var ret = fragmenter.DefragmentPacket(buffer.Slice(), arrIn); if (!ret) { continue; } using (var bs = new BitStream(64, Allocator.Persistent)) { BitSlice slice = bs.GetBitSlice(0, 64); int seed = slice.ReadInt(); Debug.Log("seed " + seed + " start " + start); for (int i = 0; i < arrIn.Length; ++i) { if (arrIn[i] != arrOut[i]) { Debug.Log("arr in = " + arrIn[i] + " arr out = " + arrOut[i]); } Assert.AreEqual((byte)arrIn[i], (byte)arrOut[i]); } } } buffer.Dispose(); arrOut.Dispose(); //arrIn.Dispose(); }
public void TestBadEnums() { Assert.Throws <Assertion.AssertionException>(() => BitSlice.Enum <EMinus>()); Assert.Throws <Assertion.AssertionException>(() => BitSlice.Enum <E0>()); Assert.Throws <Assertion.AssertionException>(() => BitSlice.Enum <EUlong>()); }