public void CreateGrowArrayProcess()
        {
            var concurrentArray  = new ConcurrentArrayBuilder <string, object>().Build();
            var newArraySize     = LinearDoublingPrimeStrategy.GetNextCapacity(concurrentArray.Capacity);
            var spy              = new ExchangeArraySpy <string, object>();
            var growArrayProcess = new GrowArrayProcess <string, object>(concurrentArray, newArraySize, spy.ExchangeArray);

            var existingProcess = concurrentArray.EstablishGrowArrayProcess(growArrayProcess);

            existingProcess.Should().Be(null);
            concurrentArray.ReadGrowArrayProcessVolatile().Should().BeSameAs(growArrayProcess);
            spy.ExchangeArrayMustNotHaveBeenCalled();
        }
        public void GetExistingGrowArrayProcess()
        {
            var concurrentArray  = new ConcurrentArrayBuilder <Type, object>().Build();
            var newArraySize     = LinearDoublingPrimeStrategy.GetNextCapacity(concurrentArray.Capacity);
            var spy              = new ExchangeArraySpy <Type, object>();
            var growArrayProcess = new GrowArrayProcess <Type, object>(concurrentArray, newArraySize, spy.ExchangeArray);

            concurrentArray.EstablishGrowArrayProcess(growArrayProcess);

            var otherGrowArrayProcess = new GrowArrayProcess <Type, object>(concurrentArray, newArraySize, spy.ExchangeArray);
            var existingProcess       = concurrentArray.EstablishGrowArrayProcess(otherGrowArrayProcess);

            existingProcess.Should().BeSameAs(growArrayProcess);
            concurrentArray.ReadGrowArrayProcessVolatile().Should().BeSameAs(growArrayProcess);
        }
        public void ConcurrentAddTest()
        {
            var processorCount = Environment.ProcessorCount;
            var entryCount     = processorCount * 100000;
            var allNumbers     = Enumerable.Range(1, entryCount).ToArray();
            var groupsPerTask  = allNumbers.GroupBy(number => number % processorCount)
                                 .ToArray();
            var concurrentArray = new ConcurrentArrayBuilder <int, object>().WithCapacity(LinearDoublingPrimeStrategy.GetNextCapacity(entryCount))
                                  .Build();

            Parallel.ForEach(groupsPerTask, group =>
            {
                foreach (var number in group)
                {
                    var addResult = concurrentArray.TryAdd(new Entry <int, object>(number.GetHashCode(), number, null));
                    addResult.OperationResult.Should().Be(AddResult.AddSuccessful);
                }
            });

            concurrentArray.Count.Should().Be(allNumbers.Length);
            foreach (var number in allNumbers)
            {
                var entry = concurrentArray.Find(number.GetHashCode(), number);
                entry.Should().NotBeNull();
            }
        }