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();
}
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();
}
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();
}
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_Throws()
{
var numBits = 256;
var test = new UnsafeBitArray(numBits, Allocator.Persistent, NativeArrayOptions.ClearMemory);
Assert.DoesNotThrow(() => { test.TestAll(0, numBits); });
Assert.Throws <ArgumentException>(() => { test.IsSet(-1); });
Assert.Throws <ArgumentException>(() => { test.IsSet(numBits); });
Assert.Throws <ArgumentException>(() => { new UnsafeBitArray(null, 7); /* check sizeInBytes must be multiple of 8-bytes. */ });
test.Dispose();
}
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();
}
public unsafe void UnsafeBitArray_Throws()
{
var numBits = 256;
using (var test = new UnsafeBitArray(numBits, Allocator.Persistent, NativeArrayOptions.ClearMemory))
{
Assert.DoesNotThrow(() => { test.TestAll(0, numBits); });
Assert.Throws <ArgumentException>(() => { test.IsSet(-1); });
Assert.Throws <ArgumentException>(() => { test.IsSet(numBits); });
// GetBits numBits must be 1-64.
Assert.Throws <ArgumentException>(() => { test.GetBits(0, 0); });
Assert.Throws <ArgumentException>(() => { test.GetBits(0, 65); });
Assert.DoesNotThrow(() => { test.GetBits(63, 2); });
Assert.Throws <ArgumentException>(() => { new UnsafeBitArray(null, 7); /* check sizeInBytes must be multiple of 8-bytes. */ });
}
}
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));
}
private void Start()
{
//module.Init();
//var replace = module.Replace("ιδΈθ3r3r");
//Debug.Log(replace);
//this.TestCollectionHelp();
var bitArray = new UnsafeBitArray(129, Allocator.Temp);
bitArray.Set(0, true);
bitArray.Set(1, true);
bitArray.Set(5, true);
Debug.Log("Length:" + bitArray.Length);
for (int i = 0; i < bitArray.Length; i++)
{
var value = bitArray.GetBits(i);
Debug.Log("index:" + i);
var value2 = bitArray.TestAll(i);
Debug.Log(value2);
}
}
/// <summary>
/// Returns true if all of bits in range are set.
/// </summary>
/// <param name="pos">Position in bit array.</param>
/// <param name="numBits">Number of bits to test.</param>
/// <returns>Returns true if all bits are set.</returns>
public bool TestAll(int pos, int numBits = 1)
{
CheckRead();
return(m_BitArray.TestAll(pos, numBits));
}
public void CheckInternalConsistency(object[] managedComponentData)
{
Assert.IsTrue(ManagedChangesTracker.Empty);
var managedComponentIndices = new UnsafeBitArray(m_ManagedComponentIndex, Allocator.Temp);
Assert.IsTrue(managedComponentData.Length >= m_ManagedComponentIndex);
for (int i = m_ManagedComponentIndex; i < managedComponentData.Length; ++i)
{
Assert.IsNull(managedComponentData[i]);
}
// Iterate by archetype
var entityCountByArchetype = 0;
for (var i = 0; i < m_Archetypes.Length; ++i)
{
var archetype = m_Archetypes.Ptr[i];
int managedTypeBegin = archetype->FirstManagedComponent;
int managedTypeEnd = archetype->ManagedComponentsEnd;
var countInArchetype = 0;
for (var j = 0; j < archetype->Chunks.Count; ++j)
{
var chunk = archetype->Chunks.p[j];
Assert.IsTrue(chunk->Archetype == archetype);
Assert.IsTrue(chunk->Capacity >= chunk->Count);
Assert.AreEqual(chunk->Count, archetype->Chunks.GetChunkEntityCount(j));
var chunkEntities = (Entity *)chunk->Buffer;
AssertEntitiesExist(chunkEntities, chunk->Count);
if (!chunk->Locked)
{
if (chunk->Count < chunk->Capacity)
{
if (archetype->NumSharedComponents == 0)
{
Assert.IsTrue(chunk->ListWithEmptySlotsIndex >= 0 && chunk->ListWithEmptySlotsIndex <
archetype->ChunksWithEmptySlots.Length);
Assert.IsTrue(
chunk == archetype->ChunksWithEmptySlots.Ptr[chunk->ListWithEmptySlotsIndex]);
}
else
{
Assert.IsTrue(archetype->FreeChunksBySharedComponents.Contains(chunk));
}
}
}
countInArchetype += chunk->Count;
if (chunk->Archetype->HasChunkHeader) // Chunk entities with chunk components are not supported
{
Assert.IsFalse(chunk->Archetype->HasChunkComponents);
}
Assert.AreEqual(chunk->Archetype->HasChunkComponents, chunk->metaChunkEntity != Entity.Null);
if (chunk->metaChunkEntity != Entity.Null)
{
var chunkHeaderTypeIndex = TypeManager.GetTypeIndex <ChunkHeader>();
AssertEntitiesExist(&chunk->metaChunkEntity, 1);
AssertEntityHasComponent(chunk->metaChunkEntity, chunkHeaderTypeIndex);
var chunkHeader =
*(ChunkHeader *)GetComponentDataWithTypeRO(chunk->metaChunkEntity,
chunkHeaderTypeIndex);
Assert.IsTrue(chunk == chunkHeader.ArchetypeChunk.m_Chunk);
var metaChunk = GetChunk(chunk->metaChunkEntity);
Assert.IsTrue(metaChunk->Archetype == chunk->Archetype->MetaChunkArchetype);
}
for (int iType = managedTypeBegin; iType < managedTypeEnd; ++iType)
{
var managedIndicesInChunk = (int *)(chunk->Buffer + archetype->Offsets[iType]);
for (int ie = 0; ie < chunk->Count; ++ie)
{
var index = managedIndicesInChunk[ie];
if (index == 0)
{
continue;
}
Assert.IsTrue(index < m_ManagedComponentIndex, "Managed component index in chunk is out of range.");
Assert.IsFalse(managedComponentIndices.IsSet(index), "Managed component index is used multiple times.");
managedComponentIndices.Set(index, true);
}
}
}
Assert.AreEqual(countInArchetype, archetype->EntityCount);
entityCountByArchetype += countInArchetype;
}
for (int i = 0; i < m_ManagedComponentIndex; ++i)
{
Assert.AreEqual(managedComponentData[i] != null, managedComponentIndices.IsSet(i));
}
var freeManagedIndices = (int *)m_ManagedComponentFreeIndex.Ptr;
var freeManagedCount = m_ManagedComponentFreeIndex.Length / sizeof(int);
for (int i = 0; i < freeManagedCount; ++i)
{
var index = freeManagedIndices[i];
Assert.IsTrue(0 < index && index < m_ManagedComponentIndex, "Managed component index in free list is out of range.");
Assert.IsFalse(managedComponentIndices.IsSet(index), "Managed component was marked as free but is used in chunk.");
managedComponentIndices.Set(index, true);
}
Assert.IsTrue(m_ManagedComponentIndex - 1 == 0 || managedComponentIndices.TestAll(1, m_ManagedComponentIndex - 1), "Managed component index has leaked.");
managedComponentIndices.Dispose();
// Iterate by free list
Assert.IsTrue(m_EntityInChunkByEntity[m_NextFreeEntityIndex].Chunk == null);
var entityCountByFreeList = EntitiesCapacity;
int freeIndex = m_NextFreeEntityIndex;
while (freeIndex != -1)
{
Assert.IsTrue(m_EntityInChunkByEntity[freeIndex].Chunk == null);
Assert.IsTrue(freeIndex < EntitiesCapacity);
freeIndex = m_EntityInChunkByEntity[freeIndex].IndexInChunk;
entityCountByFreeList--;
}
// iterate by entities
var entityCountByEntities = 0;
var entityType = TypeManager.GetTypeIndex <Entity>();
for (var i = 0; i != EntitiesCapacity; i++)
{
var chunk = m_EntityInChunkByEntity[i].Chunk;
if (chunk == null)
{
continue;
}
entityCountByEntities++;
var archetype = m_ArchetypeByEntity[i];
Assert.AreEqual((IntPtr)archetype, (IntPtr)chunk->Archetype);
Assert.AreEqual(entityType, archetype->Types[0].TypeIndex);
Assert.IsTrue(m_EntityInChunkByEntity[i].IndexInChunk < m_EntityInChunkByEntity[i].Chunk->Count);
var entity = *(Entity *)ChunkDataUtility.GetComponentDataRO(m_EntityInChunkByEntity[i].Chunk,
m_EntityInChunkByEntity[i].IndexInChunk, 0);
Assert.AreEqual(i, entity.Index);
Assert.AreEqual(m_VersionByEntity[i], entity.Version);
Assert.IsTrue(Exists(entity));
}
Assert.AreEqual(entityCountByEntities, entityCountByArchetype);
// Enabling this fails SerializeEntitiesWorksWithBlobAssetReferences.
// There is some special entity 0 usage in the serialization code.
// @TODO: Review with simon looks like a potential leak?
//Assert.AreEqual(entityCountByEntities, entityCountByFreeList);
}
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();
}
