public void ParallelForJobCanUseParallelPtr()
        {
            using (NativeArray <long> array = new NativeArray <long>(
                       3,
                       Allocator.TempJob))
            {
                NativeArray <long> arrayCopy = array;
                arrayCopy[0] = 10;
                arrayCopy[1] = 20;
                arrayCopy[2] = 30;

                using (NativePerJobThreadLongPtr sum = new NativePerJobThreadLongPtr(
                           Allocator.TempJob))
                {
                    ParallelForTestJob job = new ParallelForTestJob
                    {
                        Array = array,
                        Sum   = sum.GetParallel()
                    };
                    job.Run(array.Length);

                    Assert.That(sum.Value, Is.EqualTo(60));
                }
            }
        }
 public void ConstructorSetsInitialValue()
 {
     using (NativePerJobThreadLongPtr longPtr = new NativePerJobThreadLongPtr(
                Allocator.Temp, 123))
     {
         Assert.That(longPtr.Value, Is.EqualTo(123));
     }
 }
 public void ConstructorDefaultsValueToZero()
 {
     using (NativePerJobThreadLongPtr longPtr = new NativePerJobThreadLongPtr(
                Allocator.Temp))
     {
         Assert.That(longPtr.Value, Is.EqualTo(0));
     }
 }
        public void DisposeMakesUnusable()
        {
            NativePerJobThreadLongPtr longPtr = new NativePerJobThreadLongPtr(
                Allocator.Temp);

            longPtr.Dispose();
            Assert.That(
                () => longPtr.Value = 10,
                Throws.TypeOf <InvalidOperationException>());
        }
 public void DisposeRequiresReadAccess()
 {
     using (NativePerJobThreadLongPtr longPtr = new NativePerJobThreadLongPtr(
                Allocator.Temp))
     {
         AssertRequiresReadOrWriteAccess(
             longPtr,
             longPtr.Dispose);
     }
 }
 public void SetValueRequiresReadAccess()
 {
     using (NativePerJobThreadLongPtr longPtr = new NativePerJobThreadLongPtr(
                Allocator.Temp))
     {
         NativePerJobThreadLongPtr copy = longPtr;
         AssertRequiresReadOrWriteAccess(
             longPtr,
             () => copy.Value = 123);
     }
 }
 public void GetValueRequiresReadAccess()
 {
     using (NativePerJobThreadLongPtr longPtr = new NativePerJobThreadLongPtr(
                Allocator.Temp))
     {
         long value;
         AssertRequiresReadOrWriteAccess(
             longPtr,
             () => value = longPtr.Value);
     }
 }
        public void GetValueReturnsWhatSetValueSets()
        {
            using (NativePerJobThreadLongPtr longPtr = new NativePerJobThreadLongPtr(
                       Allocator.Temp))
            {
                NativePerJobThreadLongPtr copy = longPtr;
                copy.Value = 123;

                Assert.That(longPtr.Value, Is.EqualTo(123));
            }
        }
        public void IsCreatedOnlyReturnsTrueBeforeDispose()
        {
            NativePerJobThreadLongPtr longPtr = new NativePerJobThreadLongPtr(
                Allocator.Temp);

            Assert.That(longPtr.IsCreated, Is.True);

            longPtr.Dispose();

            Assert.That(longPtr.IsCreated, Is.False);
        }
 public void ParallelAddRequiresReadAccess()
 {
     using (NativePerJobThreadLongPtr longPtr = new NativePerJobThreadLongPtr(
                Allocator.Temp))
     {
         NativePerJobThreadLongPtr.Parallel parallel = longPtr.GetParallel();
         AssertRequiresReadOrWriteAccess(
             longPtr,
             () => parallel.Add(10));
     }
 }
 public void ParallelDecrementRequiresReadAccess()
 {
     using (NativePerJobThreadLongPtr longPtr = new NativePerJobThreadLongPtr(
                Allocator.Temp))
     {
         NativePerJobThreadLongPtr.Parallel parallel = longPtr.GetParallel();
         AssertRequiresReadOrWriteAccess(
             longPtr,
             parallel.Decrement);
     }
 }
        public void ParallelDecrementIncrementsValue()
        {
            using (NativePerJobThreadLongPtr longPtr = new NativePerJobThreadLongPtr(
                       Allocator.Temp,
                       123))
            {
                NativePerJobThreadLongPtr.Parallel parallel = longPtr.GetParallel();
                parallel.Decrement();

                Assert.That(longPtr.Value, Is.EqualTo(122));
            }
        }
        public void CanDeallocateOnJobCompletion()
        {
            NativePerJobThreadLongPtr longPtr = new NativePerJobThreadLongPtr(
                Allocator.TempJob);
            var job = new DeallocateOnJobCompletionJob {
                LongPtr = longPtr
            };

            job.Run();

            Assert.That(
                () => longPtr.Value = 10,
                Throws.TypeOf <InvalidOperationException>());
        }
 private static void AssertRequiresReadOrWriteAccess(
     NativePerJobThreadLongPtr longPtr,
     Action action)
 {
     longPtr.TestUseOnlySetAllowReadAndWriteAccess(false);
     try
     {
         Assert.That(
             () => action(),
             Throws.TypeOf <InvalidOperationException>());
     }
     finally
     {
         longPtr.TestUseOnlySetAllowReadAndWriteAccess(true);
     }
 }
        public void ParallelAddOffsetsValue()
        {
            using (NativePerJobThreadLongPtr longPtr = new NativePerJobThreadLongPtr(
                       Allocator.Temp,
                       123))
            {
                NativePerJobThreadLongPtr.Parallel parallel = longPtr.GetParallel();
                parallel.Add(5);

                Assert.That(longPtr.Value, Is.EqualTo(128));

                parallel.Add(-15);

                Assert.That(longPtr.Value, Is.EqualTo(113));
            }
        }