static void CopyBitsTest(ref UnsafeBitArray test, int dstPos, int srcPos, int numBits)
{
for (int pos = 0; pos < test.Length; pos += 64)
{
test.SetBits(pos, 0xaaaaaaaaaaaaaaaaul, 64);
}
test.SetBits(srcPos, true, numBits);
test.Copy(dstPos, srcPos, numBits);
Assert.AreEqual(true, test.TestAll(dstPos, numBits));
for (int pos = 0; pos < test.Length; ++pos)
{
if ((pos >= dstPos && pos < dstPos + numBits) ||
(pos >= srcPos && pos < srcPos + numBits))
{
Assert.AreEqual(true, test.IsSet(pos));
}
else
{
Assert.AreEqual((0 != (pos & 1)), test.IsSet(pos));
}
}
test.Clear();
}
public unsafe void UnsafeBitArray_Find_With_Begin_End()
{
var numBits = 512;
using (var test = new UnsafeBitArray(numBits, Allocator.Persistent, NativeArrayOptions.ClearMemory))
{
Assert.AreEqual(0, test.Find(0, 2, 1));
Assert.AreEqual(1, test.Find(1, 2, 1));
test.SetBits(0, true, 6);
Assert.AreEqual(int.MaxValue, test.Find(0, 2, 1));
for (var j = 0; j < 64; ++j)
{
for (var i = 0; i < 256; ++i)
{
var numBitsToFind = 7 + i;
var padding = 11;
var begin = 37 + j;
var end = begin + padding + numBitsToFind;
var count = end - begin;
test.Clear();
test.SetBits(begin, true, count);
test.SetBits(begin + padding + 1, false, numBitsToFind - 1);
Assert.AreEqual(begin + padding + 1, test.Find(begin, count, numBitsToFind - 1)); //, $"{j}/{i}: begin {begin}, end {end}, count {count}, numBitsToFind {numBitsToFind}");
Assert.AreEqual(int.MaxValue, test.Find(begin, count, numBitsToFind)); //, $"{j}/{i}: begin {begin}, end {end}, count {count}, numBitsToFind {numBitsToFind}");
}
}
}
}
public void UnsafeBitArray_CopyBetweenBitArrays()
{
var numBits = 512;
var test0 = new UnsafeBitArray(numBits, Allocator.Persistent, NativeArrayOptions.ClearMemory);
var test1 = new UnsafeBitArray(numBits, Allocator.Persistent, NativeArrayOptions.ClearMemory);
var test2 = new UnsafeBitArray(numBits, Allocator.Persistent, NativeArrayOptions.ClearMemory);
for (int pos = 0; pos < test0.Length; pos += 64)
{
test0.SetBits(pos, 0xaaaaaaaaaaaaaaaaul, 64);
test1.SetBits(pos, 0x5555555555555555ul, 64);
}
var numCopyBits = 255;
test0.SetBits(13, true, numCopyBits);
test1.Copy(1, ref test0, 13, numCopyBits);
Assert.AreEqual(true, test1.TestAll(1, numCopyBits));
test2.Copy(43, ref test1, 1, numCopyBits);
Assert.AreEqual(true, test2.TestAll(43, numCopyBits));
test0.Dispose();
test1.Dispose();
test2.Dispose();
}
static void GetBitsTest(ref UnsafeBitArray test, int pos, int numBits)
{
test.SetBits(pos, true, numBits);
Assert.AreEqual(numBits, test.CountBits(0, test.Length));
Assert.AreEqual(0xfffffffffffffffful >> (64 - numBits), test.GetBits(pos, numBits));
test.Clear();
}
public void UnsafeBitArray_FindInTinyBitArray()
{
var test = new UnsafeBitArray(3, Allocator.Persistent, NativeArrayOptions.ClearMemory);
Assert.AreEqual(3, test.Length);
test.SetBits(0, 0x55, test.Length);
Assert.AreEqual(1, test.Find(0, 1));
Assert.AreEqual(1, test.Find(0, test.Length, 1));
test.SetBits(1, true, 1);
Assert.True(test.TestAll(0, test.Length));
Assert.AreEqual(int.MaxValue, test.Find(0, test.Length, 1));
test.Dispose();
}
static void CopyBitsTest(ref UnsafeBitArray dstBitArray, int dstPos, ref UnsafeBitArray srcBitArray, int srcPos, int numBits)
{
for (int pos = 0; pos < dstBitArray.Length; pos += 64)
{
dstBitArray.SetBits(pos, 0xaaaaaaaaaaaaaaaaul, 64);
}
srcBitArray.SetBits(srcPos, true, numBits);
dstBitArray.Copy(dstPos, ref srcBitArray, srcPos, numBits);
Assert.AreEqual(true, dstBitArray.TestAll(dstPos, numBits));
for (int pos = 0; pos < dstBitArray.Length; ++pos)
{
if ((pos >= dstPos && pos < dstPos + numBits) ||
(pos >= srcPos && pos < srcPos + numBits))
{
Assert.AreEqual(true, dstBitArray.IsSet(pos));
}
else
{
Assert.AreEqual((0 != (pos & 1)), dstBitArray.IsSet(pos));
}
}
dstBitArray.Clear();
}
void findWithPattern(ref UnsafeBitArray test, byte pattern, int numBits)
{
for (int pos = 0; pos < test.Length; pos += 8)
{
test.SetBits(pos, pattern, 8);
}
var bitCount = math.countbits((int)pattern);
var numEmptyBits = test.Length - (test.Length / 8 * bitCount);
for (int i = 0; i < numEmptyBits; i += numBits)
{
var pos = test.Find(0, numBits);
Assert.AreNotEqual(int.MaxValue, pos, $"{i}");
test.SetBits(pos, true, numBits);
}
Assert.True(test.TestAll(0, test.Length));
}
public void UnsafeBitArray_FindLastUnsetBit([NUnit.Framework.Range(1, 64)] int numBits)
{
using (var bits = new UnsafeBitArray(numBits, Allocator.Persistent))
{
// Set all bits to one then unset a single bit to find.
for (int i = 0; i < numBits; ++i)
{
bits.SetBits(0, true, numBits);
bits.Set(i, false);
Assert.AreEqual(i, bits.Find(0, 1));
}
}
}
public void UnsafeBitArray_Get_Set()
{
var numBits = 256;
var test = new UnsafeBitArray(numBits, Allocator.Persistent, NativeArrayOptions.ClearMemory);
Assert.False(test.IsSet(123));
test.Set(123, true);
Assert.True(test.IsSet(123));
Assert.False(test.TestAll(0, numBits));
Assert.False(test.TestNone(0, numBits));
Assert.True(test.TestAny(0, numBits));
Assert.AreEqual(1, test.CountBits(0, numBits));
Assert.False(test.TestAll(0, 122));
Assert.True(test.TestNone(0, 122));
Assert.False(test.TestAny(0, 122));
test.Clear();
Assert.False(test.IsSet(123));
Assert.AreEqual(0, test.CountBits(0, numBits));
test.SetBits(40, true, 4);
Assert.AreEqual(4, test.CountBits(0, numBits));
test.SetBits(0, true, numBits);
Assert.False(test.TestNone(0, numBits));
Assert.True(test.TestAll(0, numBits));
test.SetBits(0, false, numBits);
Assert.True(test.TestNone(0, numBits));
Assert.False(test.TestAll(0, numBits));
test.SetBits(123, true, 7);
Assert.True(test.TestAll(123, 7));
test.Dispose();
}
public unsafe void UnsafeBitArray_Find()
{
var numBits = 512;
using (var test = new UnsafeBitArray(numBits, Allocator.Persistent, NativeArrayOptions.ClearMemory))
{
test.SetBits(0, true, 11);
for (var i = 0; i < 256; ++i)
{
Assert.AreEqual(11, test.Find(0, i + 1));
}
for (var j = 0; j < 64; ++j)
{
for (var i = 0; i < 256; ++i)
{
var numBitsToFind = 7 + i;
var pos = 37 + j;
test.SetBits(0, true, test.Length);
test.SetBits(pos, false, numBitsToFind);
Assert.AreEqual(pos, test.Find(0, numBitsToFind), $"{j}/{i}: pos {pos}, numBitsToFind {numBitsToFind}");
Assert.AreEqual(pos, test.Find(pos, numBitsToFind), $"{j}/{i}:pos {pos}, numBitsToFind {numBitsToFind}");
Assert.AreEqual(pos, test.Find(0, numBitsToFind), $"{j}/{i}: pos {pos}, numBitsToFind {numBitsToFind}");
Assert.AreEqual(pos, test.Find(pos, numBitsToFind), $"{j}/{i}: pos {pos}, numBitsToFind {numBitsToFind}");
Assert.IsTrue(test.TestNone(test.Find(0, numBitsToFind), numBitsToFind));
Assert.AreEqual(int.MaxValue, test.Find(pos + 1, numBitsToFind), $"{j}/{i}: pos {pos}, numBitsToFind {numBitsToFind}");
}
}
}
}
static void SetBitsTest(ref UnsafeBitArray test, int pos, ulong value, int numBits)
{
test.SetBits(pos, value, numBits);
Assert.AreEqual(value, test.GetBits(pos, numBits));
test.Clear();
}
/// <summary>
/// Set bits to desired boolean value.
/// </summary>
/// <param name="pos">Position in bit array.</param>
/// <param name="value">Value of bits to set.</param>
/// <param name="numBits">Number of bits to set.</param>
public void SetBits(int pos, bool value, int numBits)
{
CheckWrite();
m_BitArray.SetBits(pos, value, numBits);
}
public void UnsafeBitArray_Get_Set_Short()
{
var numBits = 31;
var test = new UnsafeBitArray(numBits, Allocator.Persistent, NativeArrayOptions.ClearMemory);
Assert.False(test.IsSet(13));
test.Set(13, true);
Assert.True(test.IsSet(13));
Assert.False(test.TestAll(0, numBits));
Assert.False(test.TestNone(0, numBits));
Assert.True(test.TestAny(0, numBits));
Assert.AreEqual(1, test.CountBits(0, numBits));
Assert.False(test.TestAll(0, 12));
Assert.True(test.TestNone(0, 12));
Assert.False(test.TestAny(0, 12));
test.Clear();
Assert.False(test.IsSet(13));
Assert.AreEqual(0, test.CountBits(0, numBits));
test.SetBits(4, true, 4);
Assert.AreEqual(4, test.CountBits(0, numBits));
test.SetBits(0, true, numBits);
Assert.False(test.TestNone(0, numBits));
Assert.True(test.TestAll(0, numBits));
test.SetBits(0, false, numBits);
Assert.True(test.TestNone(0, numBits));
Assert.False(test.TestAll(0, numBits));
test.SetBits(13, true, 7);
Assert.True(test.TestAll(13, 7));
test.Clear();
test.SetBits(4, true, 4);
Assert.AreEqual(false, test.IsSet(3));
Assert.AreEqual(true, test.TestAll(4, 4));
Assert.AreEqual(false, test.IsSet(18));
Assert.AreEqual(4, test.CountBits(4, 4));
Assert.AreEqual(4, test.CountBits(0, numBits));
test.Clear();
test.SetBits(5, true, 2);
Assert.AreEqual(false, test.IsSet(4));
Assert.AreEqual(true, test.TestAll(5, 2));
Assert.AreEqual(false, test.IsSet(17));
Assert.AreEqual(2, test.CountBits(4, 4));
Assert.AreEqual(2, test.CountBits(0, numBits));
test.Clear();
test.SetBits(6, true, 4);
Assert.AreEqual(false, test.IsSet(5));
Assert.AreEqual(true, test.TestAll(6, 4));
Assert.AreEqual(false, test.IsSet(10));
Assert.AreEqual(4, test.CountBits(6, 4));
Assert.AreEqual(4, test.CountBits(0, numBits));
test.Dispose();
}
