CSHARP-1117: Rename MaxPoolSize to MaxChunkCount in BsonChunkPool.

Author: rstam

src/MongoDB.Bson.Tests/IO/BsonChunkPoolTests.cs

@@ -42,13 +42,13 @@ public void ChunkSize_get_should_return_expected_result()
         [Test]
         public void constructor_should_initialize_subject()
         {
-            var maxPoolSize = 1;
+            var maxChunkCount = 1;
             var chunkSize = 16;
 
-            var subject = new BsonChunkPool(maxPoolSize, chunkSize);
+            var subject = new BsonChunkPool(maxChunkCount, chunkSize);
 
             var reflector = new Reflector(subject);
-            subject.MaxPoolSize.Should().Be(maxPoolSize);
+            subject.MaxChunkCount.Should().Be(maxChunkCount);
             subject.ChunkSize.Should().Be(chunkSize);
             reflector._disposed.Should().BeFalse();
         }
@@ -64,11 +64,11 @@ public void constructor_should_throw_chunkSize_is_less_than_zero(
         }
 
         [Test]
-        public void constructor_should_throw_whenMaxPoolSize_is_less_than_zero()
+        public void constructor_should_throw_when_MaxChunkCount_is_less_than_zero()
         {
             Action action = () => new BsonChunkPool(-1, 16);
 
-            action.ShouldThrow<ArgumentOutOfRangeException>().And.ParamName.Should().Be("maxPoolSize");
+            action.ShouldThrow<ArgumentOutOfRangeException>().And.ParamName.Should().Be("maxChunkCount");
         }
 
         [Test]
@@ -77,7 +77,7 @@ public void Default_get_should_return_expected_result()
             var result = BsonChunkPool.Default;
 
             result.ChunkSize.Should().Be(64 * 1024);
-            result.MaxPoolSize.Should().Be(8192);
+            result.MaxChunkCount.Should().Be(8192);
         }
 
         [Test]
@@ -166,11 +166,11 @@ public void GetChunk_should_throw_when_subject_is_disposed()
         }
 
         [Test]
-        public void MaxPoolSize_get_should_return_expected_result()
+        public void MaxChunkCount_get_should_return_expected_result()
         {
             var subject = new BsonChunkPool(1, 16);
 
-            var result = subject.MaxPoolSize;
+            var result = subject.MaxChunkCount;
 
             result.Should().Be(1);
         }
@@ -254,7 +254,7 @@ public void Dispose_should_return_chunk_to_the_pool()
 
             subject.Dispose();
 
-            pool.PoolSize.Should().Be(1);
+            pool.ChunkCount.Should().Be(1);
         }
 
         [Test]
@@ -284,11 +284,11 @@ public void Dispose_should_return_chunk_to_the_pool_after_all_handles_have_been_
 
             foreach (var handle in handles)
             {
-                pool.PoolSize.Should().Be(0);
+                pool.ChunkCount.Should().Be(0);
                 handle.Dispose();
             }
 
-            pool.PoolSize.Should().Be(1);
+            pool.ChunkCount.Should().Be(1);
         }
 
         [Test]

src/MongoDB.Bson/IO/BsonChunkPool.cs

@@ -54,26 +54,26 @@ public static BsonChunkPool Default
         private readonly int _chunkSize;
         private bool _disposed;
         private readonly object _lock = new object();
-        private readonly int _maxPoolSize;
+        private readonly int _maxChunkCount;
 
         // constructors
         /// <summary>
         /// Initializes a new instance of the <see cref="BsonChunkPool"/> class.
         /// </summary>
-        /// <param name="maxPoolSize">The maximum number of chunks to keep in the pool.</param>
+        /// <param name="maxChunkCount">The maximum number of chunks to keep in the pool.</param>
         /// <param name="chunkSize">The size of each chunk.</param>
-        public BsonChunkPool(int maxPoolSize, int chunkSize)
+        public BsonChunkPool(int maxChunkCount, int chunkSize)
         {
-            if (maxPoolSize < 0)
+            if (maxChunkCount < 0)
             {
-                throw new ArgumentOutOfRangeException("maxPoolSize");
+                throw new ArgumentOutOfRangeException("maxChunkCount");
             }
             if (chunkSize <= 0)
             {
                 throw new ArgumentOutOfRangeException("chunkSize");
             }
 
-            _maxPoolSize = maxPoolSize;
+            _maxChunkCount = maxChunkCount;
             _chunkSize = chunkSize;
         }
 
@@ -95,9 +95,9 @@ public int ChunkSize
         /// <value>
         /// The maximum size of the pool.
         /// </value>
-        public int MaxPoolSize
+        public int MaxChunkCount
         {
-            get { return _maxPoolSize; }
+            get { return _maxChunkCount; }
         }
 
         /// <summary>
@@ -106,7 +106,7 @@ public int MaxPoolSize
         /// <value>
         /// The size of the pool.
         /// </value>
-        public int PoolSize
+        public int ChunkCount
         {
             get
             {
@@ -158,7 +158,7 @@ private void ReleaseChunk(ReferenceCountedChunk chunk)
             {
                 lock (_lock)
                 {
-                    if (_chunks.Count < _maxPoolSize)
+                    if (_chunks.Count < _maxChunkCount)
                     {
                         _chunks.Push(chunk);
                     }