Adding config validation when creating new cache.

bigcache.go

@@ -46,10 +46,18 @@ func NewBigCache(config Config) (*BigCache, error) {
 }
 
 func newBigCache(config Config, clock clock) (*BigCache, error) {
-
 	if !isPowerOfTwo(config.Shards) {
 		return nil, fmt.Errorf("Shards number must be power of two")
 	}
+	if config.MaxEntrySize < 0 {
+		return nil, fmt.Errorf("MaxEntrySize must be >= 0")
+	}
+	if config.MaxEntriesInWindow < 0 {
+		return nil, fmt.Errorf("MaxEntriesInWindow must be >= 0")
+	}
+	if config.HardMaxCacheSize < 0 {
+		return nil, fmt.Errorf("HardMaxCacheSize must be >= 0")
+	}
 
 	if config.Hasher == nil {
 		config.Hasher = newDefaultHasher()

bigcache_test.go

@@ -156,21 +156,50 @@ func TestConstructCacheWithDefaultHasher(t *testing.T) {
 	assertEqual(t, true, ok)
 }
 
-func TestWillReturnErrorOnInvalidNumberOfPartitions(t *testing.T) {
+func TestWillReturnErrorOnInvalidNumberOfShards(t *testing.T) {
 	t.Parallel()
 
-	// given
-	cache, error := NewBigCache(Config{
-		Shards:             18,
-		LifeWindow:         5 * time.Second,
-		MaxEntriesInWindow: 10,
-		MaxEntrySize:       256,
-	})
+	cfg := DefaultConfig(5 * time.Second)
+	cfg.Shards = 18
+	cache, error := NewBigCache(cfg)
 
 	assertEqual(t, (*BigCache)(nil), cache)
 	assertEqual(t, "Shards number must be power of two", error.Error())
 }
 
+func TestWillReturnErrorOnInvalidMaxEntriesInWindow(t *testing.T) {
+	t.Parallel()
+
+	cfg := DefaultConfig(5 * time.Second)
+	cfg.MaxEntriesInWindow = -1
+	cache, error := NewBigCache(cfg)
+
+	assertEqual(t, (*BigCache)(nil), cache)
+	assertEqual(t, "MaxEntriesInWindow must be >= 0", error.Error())
+}
+
+func TestWillReturnErrorOnInvaliMaxEntrySize(t *testing.T) {
+	t.Parallel()
+
+	cfg := DefaultConfig(5 * time.Second)
+	cfg.MaxEntrySize = -1
+	cache, error := NewBigCache(cfg)
+
+	assertEqual(t, (*BigCache)(nil), cache)
+	assertEqual(t, "MaxEntrySize must be >= 0", error.Error())
+}
+
+func TestWillReturnErrorOnInvaliHardMaxCacheSize(t *testing.T) {
+	t.Parallel()
+
+	cfg := DefaultConfig(5 * time.Second)
+	cfg.HardMaxCacheSize = -1
+	cache, error := NewBigCache(cfg)
+
+	assertEqual(t, (*BigCache)(nil), cache)
+	assertEqual(t, "HardMaxCacheSize must be >= 0", error.Error())
+}
+
 func TestEntryNotFound(t *testing.T) {
 	t.Parallel()