// EXEC: cjc %import-path %L %l %f --test  
// EXEC: ./main

import std.unittest.*
import std.unittest.testmacro.*
import memorycache.*

@Test
public class MemorycacheBasicTestfix {
    @TestCase
    public func bug_fix_issue23(): Unit {
        let ldc = LruDiskCache(maxSize: 10)
        ldc.set("key1", "hello")
        ldc.set("key2", "world")
        let ldc2 = LruDiskCache(maxSize: 10)
        ldc2.set("key1", "hello")
        ldc2.set("key2", "world")
        @Assert(ldc.get("key1").size + ldc.get("key2").size, 10)
    }

    @TestCase
    public func bug_fix_issue22(): Unit {
        var ldc= LruDiskCache()
        ldc.setMaxSize(3)
        ldc.set("key1",[1])
        ldc.set("key2",[2])
        ldc.set("key3",[3])
        ldc.get("key1")
        ldc.set("key4",[4])
        @Assert(ldc.get("key1").toString(),"[1]")
        @Assert(ldc.get("key2").toString(),"[]")
        @Assert(ldc.get("key3").toString(),"[3]")
        @Assert(ldc.get("key4").toString(),"[4]")
    }
    
    @TestCase
    public func bug_fix_issues21(): Unit {
        var fc= FifoCache(6)
        fc.put("content-one","content")
        fc.put("content-one","new")
        var re=fc.get("content-one").getOrThrow()
        @Assert(re,"new")
    }

    @TestCase
    public func bug_fix_issues20(): Unit {
        var entry = MemoryCache(2)
        entry.put("key1", "val1")
        entry.put("key2", "val2")
        entry.put("key3", "val3")
        @Assert(entry.get("key1"),None)
        @Assert(entry.get("key2"),"val2")
        @Assert(entry.get("key3"),"val3")
    }

    @TestCase
    public func bug_fix_issue9(): Unit {
        var cache = LruDiskCache();
        cache.set("key", "key")
        cache.set("key", "key2")
        var res = cache.get("key")
        @Assert(res,"keykey2".toArray())
    }

    @TestCase
    public func bug_fix_issue8(): Unit {
        var cache = LruDiskCache();
        var flag = false
        try {
            cache.setMaxSize(-1)
        } catch (e: MemoryCacheException) {
            flag = true
        }
        @Assert(flag,true)
    }

    @TestCase
    public func bug_fix_issue7(): Unit {
        var cache = FifoCache(10)
        var flag = true
        try {
            cache.remove()
        } catch (e: MemoryCacheException) {
            flag = false
        }
        @Assert(flag,true)
    }

    @TestCase
    public func bug_fix_issue6(): Unit {
        var flag = false
        try {
            FifoCache(-10)
        } catch (e: MemoryCacheException) {
            flag = true
        }
        @Assert(flag,true)
    }
}