test_util_cache: rename a variable (c is already defined) [luacheck]

[prosody.git] / tests / test_util_cache.lua

diff --git a/tests/test_util_cache.lua b/tests/test_util_cache.lua
index 72cb5a856ed486cf437e05c588edad228fd2bdfb..cbc60bc7da7416d9f8945662acd5c2017ef0f096 100644 (file)
--- a/tests/test_util_cache.lua
+++ b/tests/test_util_cache.lua
@@ -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 @@ function new(new)
        
        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);
@@ -171,12 +196,12 @@ function new(new)
        assert_equal(i, 4);
        
        local evicted_key, evicted_value;
-       local c = new(3, function (_key, _value)
+       local c2 = new(3, function (_key, _value)
                evicted_key, evicted_value = _key, _value;
        end);
        local function set(k, v, should_evict_key, should_evict_value)
                evicted_key, evicted_value = nil, nil;
-               c:set(k, v);
+               c2:set(k, v);
                assert_equal(evicted_key, should_evict_key);
                assert_equal(evicted_value, should_evict_value);
        end
@@ -194,25 +219,24 @@ function new(new)
        
 
        local evicted_key, evicted_value;
-       local c3 = new(1, function (_key, _value, c3)
+       local c3 = new(1, function (_key, _value)
                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 @@ function new(new)
        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