Changeset

--- a/tests/test_util_cache.lua	Thu Mar 17 18:08:44 2016 +0100
+++ b/tests/test_util_cache.lua	Thu Mar 17 19:16:43 2016 +0000
@@ -1,21 +1,44 @@
-
 function new(new)
 	local c = new(5);
 
+	local function expect_kv(key, value, actual_key, actual_value)
+		assert_equal(key, actual_key, "key incorrect");
+		assert_equal(value, actual_value, "value incorrect");
+	end
+
+	expect_kv(nil, nil, c:head());
+	expect_kv(nil, nil, c:tail());
+
 	assert_equal(c:count(), 0);
 	
 	c:set("one", 1)
 	assert_equal(c:count(), 1);
+	expect_kv("one", 1, c:head());
+	expect_kv("one", 1, c:tail());
+
 	c:set("two", 2)
+	expect_kv("two", 2, c:head());
+	expect_kv("one", 1, c:tail());
+
 	c:set("three", 3)
+	expect_kv("three", 3, c:head());
+	expect_kv("one", 1, c:tail());
+
 	c:set("four", 4)
 	c:set("five", 5);
 	assert_equal(c:count(), 5);
+	expect_kv("five", 5, c:head());
+	expect_kv("one", 1, c:tail());
 	
 	c:set("foo", nil);
 	assert_equal(c:count(), 5);
+	expect_kv("five", 5, c:head());
+	expect_kv("one", 1, c:tail());
 	
 	assert_equal(c:get("one"), 1);
+	expect_kv("five", 5, c:head());
+	expect_kv("one", 1, c:tail());
+
 	assert_equal(c:get("two"), 2);
 	assert_equal(c:get("three"), 3);
 	assert_equal(c:get("four"), 4);
@@ -26,6 +49,8 @@
 	
 	c:set("six", 6);
 	assert_equal(c:count(), 5);
+	expect_kv("six", 6, c:head());
+	expect_kv("two", 2, c:tail());
 	
 	assert_equal(c:get("one"), nil);
 	assert_equal(c:get("two"), 2);
@@ -197,22 +222,21 @@
 	local c3 = new(1, function (_key, _value, c3)
 		evicted_key, evicted_value = _key, _value;
 		if _key == "a" then
-			-- Put it back in...
-			-- Check that the newest key/value was set before on_evict was called
-			assert_equal(c3:get("b"), 2);
 			-- Sanity check for what we're evicting
 			assert_equal(_key, "a");
 			assert_equal(_value, 1);
-			-- Re-insert the evicted key (causes this evict function to run again with "b",2)
-			c3:set(_key, _value)
-			assert_equal(c3:get(_key), _value)
+			-- We're going to block eviction of this key/value, so set to nil...
+			evicted_key, evicted_value = nil, nil;
+			-- Returning false to block eviction
+			return false
 		end
 	end);
 	local function set(k, v, should_evict_key, should_evict_value)
 		evicted_key, evicted_value = nil, nil;
-		c3:set(k, v);
+		local ret = c3:set(k, v);
 		assert_equal(evicted_key, should_evict_key);
 		assert_equal(evicted_value, should_evict_value);
+		return ret;
 	end
 	set("a", 1)
 	set("a", 1)
@@ -220,10 +244,55 @@
 	set("a", 1)
 	set("a", 1)
 
-	-- The evict handler re-inserts "a"->1, so "b" gets evicted:
-	set("b", 2, "b", 2)
+	-- Our on_evict prevents "a" from being evicted, causing this to fail...
+	assert_equal(set("b", 2), false, "Failed to prevent eviction, or signal result");
+	
+	expect_kv("a", 1, c3:head());
+	expect_kv("a", 1, c3:tail());
+	
 	-- Check the final state is what we expect
 	assert_equal(c3:get("a"), 1);
 	assert_equal(c3:get("b"), nil);
 	assert_equal(c3:count(), 1);
+
+
+	local c4 = new(3, false);
+	
+	assert_equal(c4:set("a", 1), true);
+	assert_equal(c4:set("a", 1), true);
+	assert_equal(c4:set("a", 1), true);
+	assert_equal(c4:set("a", 1), true);
+	assert_equal(c4:set("b", 2), true);
+	assert_equal(c4:set("c", 3), true);
+	assert_equal(c4:set("d", 4), false);
+	assert_equal(c4:set("d", 4), false);
+	assert_equal(c4:set("d", 4), false);
+
+	expect_kv("c", 3, c4:head());
+	expect_kv("a", 1, c4:tail());
+
+	local c5 = new(3, function (k, v)
+		if k == "a" then
+			return nil;
+		elseif k == "b" then
+			return true;
+		end
+		return false;
+	end);
+	
+	assert_equal(c5:set("a", 1), true);
+	assert_equal(c5:set("a", 1), true);
+	assert_equal(c5:set("a", 1), true);
+	assert_equal(c5:set("a", 1), true);
+	assert_equal(c5:set("b", 2), true);
+	assert_equal(c5:set("c", 3), true);
+	assert_equal(c5:set("d", 4), true); -- "a" evicted (cb returned nil)
+	assert_equal(c5:set("d", 4), true); -- nop
+	assert_equal(c5:set("d", 4), true); -- nop
+	assert_equal(c5:set("e", 5), true); -- "b" evicted (cb returned true)
+	assert_equal(c5:set("f", 6), false); -- "c" won't evict (cb returned false)
+
+	expect_kv("e", 5, c5:head());
+	expect_kv("c", 3, c5:tail());
+
 end

--- a/util/cache.lua	Thu Mar 17 18:08:44 2016 +0100
+++ b/util/cache.lua	Thu Mar 17 19:16:43 2016 +0000
@@ -51,10 +51,13 @@
 		return true;
 	end
 	-- Check whether we need to remove oldest k/v
-	local on_evict, evicted_key, evicted_value;
 	if self._count == self.size then
 		local tail = self._tail;
-		on_evict, evicted_key, evicted_value = self._on_evict, tail.key, tail.value;
+		local on_evict, evicted_key, evicted_value = self._on_evict, tail.key, tail.value;
+		if on_evict ~= nil and (on_evict == false or on_evict(evicted_key, evicted_value) == false) then
+			-- Cache is full, and we're not allowed to evict
+			return false;
+		end
 		_remove(self, tail);
 		self._data[evicted_key] = nil;
 	end
@@ -62,9 +65,6 @@
 	m = { key = k, value = v, prev = nil, next = nil };
 	self._data[k] = m;
 	_insert(self, m);
-	if on_evict and evicted_key then
-		on_evict(evicted_key, evicted_value, self);
-	end
 	return true;
 end
 
@@ -92,6 +92,18 @@
 	return self._count;
 end
 
+function cache_methods:head()
+	local head = self._head;
+	if not head then return nil, nil; end
+	return head.key, head.value;
+end
+
+function cache_methods:tail()
+	local tail = self._tail;
+	if not tail then return nil, nil; end
+	return tail.key, tail.value;
+end
+
 local function new(size, on_evict)
 	size = assert(tonumber(size), "cache size must be a number");
 	size = math.floor(size);