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