public unsafe void Utilities_CanCopyMemoryWithMask()
    {
        using (var from = new NativeArray <byte>(6, Allocator.Temp))
            using (var to = new NativeArray <byte>(6, Allocator.Temp))
                using (var mask = new NativeArray <byte>(6, Allocator.Temp))
                {
                    var fromPtr = (byte *)from.GetUnsafePtr();
                    var toPtr   = (byte *)to.GetUnsafePtr();
                    var maskPtr = (byte *)mask.GetUnsafePtr();

                    toPtr[0] = 0xff;
                    toPtr[1] = 0xf0;
                    toPtr[2] = 0x0f;
                    toPtr[3] = 0x01;
                    toPtr[4] = 0x40;
                    toPtr[5] = 0x00;

                    fromPtr[0] = 0x00;
                    fromPtr[1] = 0x01;
                    fromPtr[2] = 0x12;
                    fromPtr[3] = 0x10;
                    fromPtr[4] = 0x88;
                    fromPtr[5] = 0xC1;

                    maskPtr[0] = 0xF0;
                    maskPtr[1] = 0xF0;
                    maskPtr[2] = 0x0F;
                    maskPtr[3] = 0x00;
                    maskPtr[4] = 0xC0;
                    maskPtr[5] = 0x11;

                    MemoryHelpers.MemCpyMasked(toPtr, fromPtr, 6, maskPtr);

                    Assert.That(toPtr[0], Is.EqualTo(0x0F));
                    Assert.That(toPtr[1], Is.EqualTo(0x00));
                    Assert.That(toPtr[2], Is.EqualTo(0x02));
                    Assert.That(toPtr[3], Is.EqualTo(0x01));
                    Assert.That(toPtr[4], Is.EqualTo(0x80));
                    Assert.That(toPtr[5], Is.EqualTo(0x01));
                }
    }