UnityGame/Library/PackageCache/com.unity.collections/Unity.Collections.Tests/UnsafeAppendBufferTests.cs

using System;
using NUnit.Framework;
using Unity.Burst;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Collections.Tests;
using Unity.Jobs;

internal class UnsafeAppendBufferTests : CollectionsTestCommonBase
{
    struct TestHeader
    {
        public int Type;
        public int PayloadSize;
    }

    [Test]
    public void UnsafeAppendBuffer_DisposeAllocated()
    {
        var buffer = new UnsafeAppendBuffer(1, 8, Allocator.Temp);
        Assert.True(buffer.IsCreated);
        Assert.True(buffer.IsEmpty);
        buffer.Dispose();
    }

    [Test]
    unsafe public void UnsafeAppendBuffer_DisposeExternal()
    {
        var data = stackalloc int[1];
        var buffer = new UnsafeAppendBuffer(data, sizeof(int));
        buffer.Add(5);
        buffer.Dispose();
        Assert.AreEqual(5, data[0]);
    }

    [Test]
    [TestRequiresDotsDebugOrCollectionChecks]
    public void UnsafeAppendBuffer_ThrowZeroAlignment()
    {
        Assert.Throws<ArgumentException>(() =>
        {
            var buffer = new UnsafeAppendBuffer(0, 0, Allocator.Temp);
        });
    }

    void AddAndVerify<T>(ref UnsafeAppendBuffer buffer, T value, ref int expectedLength) where T : unmanaged
    {
        buffer.Add(value);
        expectedLength += UnsafeUtility.SizeOf<T>();
        Assert.AreEqual(expectedLength, buffer.Length);
    }

    [Test]
    public unsafe void UnsafeAppendBuffer_AddAndPop_UnalignedRead()
    {
        int expectedLength = 0;
        byte value = 0;
        var buffer = new UnsafeAppendBuffer(0, 8, Allocator.Temp);
        Assert.IsTrue(buffer.IsEmpty);
        Assert.AreEqual(expectedLength, buffer.Length);

        AddAndVerify<int>(ref buffer, value++, ref expectedLength);
        AddAndVerify<byte>(ref buffer, value++, ref expectedLength);
        AddAndVerify<int>(ref buffer, value++, ref expectedLength);
        Assert.AreEqual(9, buffer.Length);
        AddAndVerify<byte>(ref buffer, value++, ref expectedLength);
        AddAndVerify<int>(ref buffer, value++, ref expectedLength);
        Assert.AreEqual(14, buffer.Length);

        {
            var array = new NativeArray<int>(3, Allocator.Temp);
            for (int i = 0; i < array.Length; ++i)
                array[i] = value++;

            int oldLen = buffer.Length;
            buffer.AddArray<int>(array.GetUnsafePtr(), 3);

            Assert.AreEqual(30, buffer.Length);
        }

        {
            var array = new NativeArray<int>(3, Allocator.Temp);
            for (int i = 0; i < array.Length; ++i)
                array[i] = value++;

            int oldLen = buffer.Length;
            buffer.AddArray<int>(array.GetUnsafePtr(), 3);

            Assert.AreEqual(46, buffer.Length);
        }

        // popping

        // array elements + count
        for (int i = 0; i < 3; ++i)
        {
            Assert.AreEqual(--value, buffer.Pop<int>());
        }
        Assert.AreEqual(3, buffer.Pop<int>());

        // array elements + count
        for (int i = 0; i < 3; ++i)
        {
            Assert.AreEqual(--value, buffer.Pop<int>());
        }
        Assert.AreEqual(3, buffer.Pop<int>());

        Assert.AreEqual(--value, buffer.Pop<int>());
        Assert.AreEqual(--value, buffer.Pop<byte>());
        Assert.AreEqual(--value, buffer.Pop<int>());
        Assert.AreEqual(--value, buffer.Pop<byte>());
        Assert.AreEqual(--value, buffer.Pop<int>());

        Assert.IsTrue(buffer.IsEmpty);
        Assert.AreEqual(0, buffer.Length);
    }

    [Test]
    public unsafe void UnsafeAppendBuffer_AddAndRead_UnalignedRead()
    {
        var buffer = new UnsafeAppendBuffer(0, 8, Allocator.Temp);
        buffer.Add<byte>(1);
        buffer.Add<float>(1.0f);
        var reader = buffer.AsReader();
        Assert.AreEqual(reader.ReadNext<byte>(), 1);
        Assert.AreEqual(reader.ReadNext<float>(), 1.0f);
        buffer.Dispose();
    }

    [Test]
    public unsafe void UnsafeAppendBuffer_PushHeadersWithPackets()
    {
        var buffer = new UnsafeAppendBuffer(0, 8, Allocator.Temp);
        var scratchPayload = stackalloc byte[1024];
        var expectedSize = 0;
        for (int i = 0; i < 1024; i++)
        {
            var packeType = i;
            var packetSize = i;

            buffer.Add(new TestHeader
            {
                Type = packeType,
                PayloadSize = packetSize
            });
            expectedSize += UnsafeUtility.SizeOf<TestHeader>();

            buffer.Add(scratchPayload, i);
            expectedSize += i;
        }
        Assert.True(expectedSize == buffer.Length);

        buffer.Dispose();
    }

    [Test]
    public unsafe void UnsafeAppendBuffer_ReadHeadersWithPackets()
    {
        var buffer = new UnsafeAppendBuffer(0, 8, Allocator.Temp);
        var scratchPayload = stackalloc byte[1024];
        for (int i = 0; i < 1024; i++)
        {
            var packeType = i;
            var packetSize = i;

            buffer.Add(new TestHeader
            {
                Type = packeType,
                PayloadSize = packetSize
            });

            UnsafeUtility.MemSet(scratchPayload, (byte)(i & 0xff), packetSize);

            buffer.Add(scratchPayload, i);
        }

        var reader = buffer.AsReader();
        for (int i = 0; i < 1024; i++)
        {
            var packetHeader = reader.ReadNext<TestHeader>();
            Assert.AreEqual(i, packetHeader.Type);
            Assert.AreEqual(i, packetHeader.PayloadSize);
            if (packetHeader.PayloadSize > 0)
            {
                var packetPayload = reader.ReadNext(packetHeader.PayloadSize);
                Assert.AreEqual((byte)(i & 0xff), *(byte*)packetPayload);
            }
        }
        Assert.True(reader.EndOfBuffer);

        buffer.Dispose();
    }

    [Test]
    public unsafe void UnsafeAppendBuffer_AddAndPop()
    {
        var buffer = new UnsafeAppendBuffer(0, 8, Allocator.Temp);

        buffer.Add<int>(123);
        buffer.Add<int>(234);
        buffer.Add<int>(345);

        {
            var array = new NativeArray<int>(3, Allocator.Temp);
            buffer.Pop(array.GetUnsafePtr(), 3 * UnsafeUtility.SizeOf<int>());
            CollectionAssert.AreEqual(new[] {123, 234, 345}, array);
        }

        {
            var array = new NativeArray<int>(4, Allocator.Temp);
            array.CopyFrom(new[] {987, 876, 765, 654});
            buffer.Add(array.GetUnsafePtr(), 4 * UnsafeUtility.SizeOf<int>());
        }

        Assert.AreEqual(654, buffer.Pop<int>());
        Assert.AreEqual(765, buffer.Pop<int>());
        Assert.AreEqual(876, buffer.Pop<int>());
        Assert.AreEqual(987, buffer.Pop<int>());

        buffer.Dispose();
    }

    [Test]
    public unsafe void UnsafeAppendBuffer_ReadNextArray()
    {
        var values = new NativeArray<int>(new[] {123, 234, 345}, Allocator.Temp);
        var buffer = new UnsafeAppendBuffer(0, 8, Allocator.Temp);
        buffer.Add(values);

        var array = (int*)buffer.AsReader().ReadNextArray<int>(out var count);

        Assert.AreEqual(values.Length, count);
        for (int i = 0; i < count; ++i)
        {
            Assert.AreEqual(values[i], array[i]);
        }

        values.Dispose();
        buffer.Dispose();
    }

    [Test]
    public unsafe void UnsafeAppendBuffer_DisposeJob()
    {
        var sizeOf = UnsafeUtility.SizeOf<int>();
        var alignOf = UnsafeUtility.AlignOf<int>();

        var container = new UnsafeAppendBuffer(5, 16, Allocator.Persistent);

        var disposeJob = container.Dispose(default);

        Assert.IsTrue(container.Ptr == null);

        disposeJob.Complete();
    }

    [Test]
    public void UnsafeAppendBuffer_CustomAllocatorTest()
    {
        AllocatorManager.Initialize();
        var allocatorHelper = new AllocatorHelper<CustomAllocatorTests.CountingAllocator>(AllocatorManager.Persistent);
        ref var allocator = ref allocatorHelper.Allocator;
        allocator.Initialize();

        using (var container = new UnsafeAppendBuffer(1, 1, allocator.Handle))
        {
        }

        Assert.IsTrue(allocator.WasUsed);
        allocator.Dispose();
        allocatorHelper.Dispose();
        AllocatorManager.Shutdown();
    }

    [BurstCompile]
    struct BurstedCustomAllocatorJob : IJob
    {
        [NativeDisableUnsafePtrRestriction]
        public unsafe CustomAllocatorTests.CountingAllocator* Allocator;

        public void Execute()
        {
            unsafe
            {
                using (var container = new UnsafeAppendBuffer(1, 1, Allocator->Handle))
                {
                }
            }
        }
    }

    [Test]
    public unsafe void UnsafeAppendBuffer_BurstedCustomAllocatorTest()
    {
        AllocatorManager.Initialize();
        var allocatorHelper = new AllocatorHelper<CustomAllocatorTests.CountingAllocator>(AllocatorManager.Persistent);
        ref var allocator = ref allocatorHelper.Allocator;
        allocator.Initialize();

        var allocatorPtr = (CustomAllocatorTests.CountingAllocator*)UnsafeUtility.AddressOf<CustomAllocatorTests.CountingAllocator>(ref allocator);
        unsafe
        {
            var handle = new BurstedCustomAllocatorJob {Allocator = allocatorPtr}.Schedule();
            handle.Complete();
        }

        Assert.IsTrue(allocator.WasUsed);
        allocator.Dispose();
        allocatorHelper.Dispose();
        AllocatorManager.Shutdown();
    }
}