builder uses partition

BitFaster.Caching.UnitTests/Lru/CapacityPartitionExtensionsTests.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using BitFaster.Caching.Lru;
+using FluentAssertions;
+using Xunit;
+
+namespace BitFaster.Caching.UnitTests.Lru
+{
+    public class CapacityPartitionExtensionsTests
+    {
+        [Fact]
+        public void WhenCapacityIsValidDoesNotThrow()
+        {
+            var p = new TestCapacityPartition { Cold = 2, Warm = 2, Hot = 2 };
+
+            Action validate = () => { p.Validate(); };
+
+            validate.Should().NotThrow();
+        }
+
+        [Fact]
+        public void WhenColdIsZeroThrows()
+        {
+            var p = new TestCapacityPartition { Cold = 0, Warm = 2, Hot = 2 };
+
+            Action validate = () => { p.Validate(); };
+
+            validate.Should().Throw<ArgumentOutOfRangeException>();
+        }
+
+        [Fact]
+        public void WhenWarmIsZeroThrows()
+        {
+            var p = new TestCapacityPartition { Cold = 2, Warm = 0, Hot = 2 };
+
+            Action validate = () => { p.Validate(); };
+
+            validate.Should().Throw<ArgumentOutOfRangeException>();
+        }
+
+        [Fact]
+        public void WhenHotIsZeroThrows()
+        {
+            var p = new TestCapacityPartition { Cold = 2, Warm = 2, Hot = 0 };
+
+            Action validate = () => { p.Validate(); };
+
+            validate.Should().Throw<ArgumentOutOfRangeException>();
+        }
+    }
+}

BitFaster.Caching.UnitTests/Lru/LruBuilderTests.cs → BitFaster.Caching.UnitTests/Lru/ConcurrentLruBuilderTests.cs

@@ -9,7 +9,7 @@
 
 namespace BitFaster.Caching.UnitTests.Lru
 {
-    public class LruBuilderTests
+    public class ConcurrentLruBuilderTests
     {
         [Fact]
         public void TestFastLru()
@@ -86,5 +86,25 @@ public void TestConcurrencyLevel()
 
             constructor.Should().Throw<ArgumentOutOfRangeException>();
         }
+
+        [Fact]
+        public void TestIntCapacity()
+        {
+            var lru = new ConcurrentLruBuilder<int, Disposable>()
+                .WithCapacity(3)
+                .Build();
+
+            lru.Capacity.Should().Be(3);
+        }
+
+        [Fact]
+        public void TestPartitionCapacity()
+        {
+            var lru = new ConcurrentLruBuilder<int, Disposable>()
+                .WithCapacity(new FavorFrequencyPartition(6))
+                .Build();
+
+            lru.Capacity.Should().Be(6);
+        }
     }
 }

BitFaster.Caching.UnitTests/Lru/ConcurrentLruTests.cs

@@ -59,6 +59,15 @@ public void WhenPartitionIsNullCtorThrows()
             constructor.Should().Throw<ArgumentNullException>();
         }
 
+        [Fact]
+        public void WhenPartitionIsInvalidThrows()
+        {
+            var p = new TestCapacityPartition { Cold = 2, Warm = 0, Hot = 2 };
+            Action constructor = () => { var x = new ConcurrentLru<int, string>(1, p, EqualityComparer<int>.Default); };
+
+            constructor.Should().Throw<ArgumentOutOfRangeException>();
+        }
+
         [Fact]
         public void WhenComparerIsNullCtorThrows()
         {

BitFaster.Caching.UnitTests/Lru/TestCapacityPartition.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using BitFaster.Caching.Lru;
+
+namespace BitFaster.Caching.UnitTests.Lru
+{
+    public class TestCapacityPartition : ICapacityPartition
+    {
+        public int Cold { get; set; }
+
+        public int Warm { get; set; }
+
+        public int Hot { get; set; }
+    }
+}

BitFaster.Caching/Lru/Builder/LruBuilderBase.cs

@@ -25,6 +25,18 @@ protected LruBuilderBase(LruInfo<K> info)
         /// <param name="capacity">The maximum number of values to keep in the cache.</param>
         /// <returns>A ConcurrentLruBuilder</returns>
         public TBuilder WithCapacity(int capacity)
+        {
+            this.info.Capacity = new FavorFrequencyPartition(capacity);
+            return this as TBuilder;
+        }
+
+        /// <summary>
+        /// Set the maximum number of values to keep in the cache. If more items than this are added, 
+        /// the cache eviction policy will determine which values to remove.
+        /// </summary>
+        /// <param name="capacity">The capacity partition scheme to use.</param>
+        /// <returns>A ConcurrentLruBuilder</returns>
+        public TBuilder WithCapacity(ICapacityPartition capacity)
         {
             this.info.Capacity = capacity;
             return this as TBuilder;

BitFaster.Caching/Lru/Builder/LruInfo.cs

@@ -8,7 +8,7 @@ namespace BitFaster.Caching.Lru.Builder
 {
     public sealed class LruInfo<K>
     {
-        public int Capacity { get; set; } = 128;
+        public ICapacityPartition Capacity { get; set; } = new FavorFrequencyPartition(128);
 
         public int ConcurrencyLevel { get; set; } = Defaults.ConcurrencyLevel;
 

BitFaster.Caching/Lru/CapacityPartitionExtensions.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BitFaster.Caching.Lru
+{
+    public static class CapacityPartitionExtensions
+    {
+        public static void Validate(this ICapacityPartition capacity)
+        {
+            if (capacity.Cold < 1)
+            { 
+                throw new ArgumentOutOfRangeException(nameof(capacity.Cold));
+            }
+
+            if (capacity.Warm < 1)
+            {
+                throw new ArgumentOutOfRangeException(nameof(capacity.Warm));
+            }
+
+            if (capacity.Hot < 1)
+            {
+                throw new ArgumentOutOfRangeException(nameof(capacity.Hot));
+            }
+        }
+    }
+}

BitFaster.Caching/Lru/TemplateConcurrentLru.cs

@@ -70,6 +70,7 @@ public TemplateConcurrentLru(
                 throw new ArgumentNullException(nameof(comparer));
             }
 
+            capacity.Validate();
             this.capacity = capacity;
 
             this.hotQueue = new ConcurrentQueue<I>();