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

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

@Test
public class MemorycacheBasicTest {
    @TestCase
    public func testPut(): Unit {
        var cache = LruDiskCache();
        cache.set("key", "key")
        @Assert(cache.getSize(),3)
        var res = cache.get("key")
        @Assert(res,"key".toArray())
    }

    @TestCase
    public func testPath(): Unit {
        var cache = LruDiskCache();
        var defaultpath = cache.getPath()
        @Assert(defaultpath.startsWith("./cache/LruDiskCache/"))
    }

    @TestCase
    public func testMaxSize(): Unit {
        var cache = LruDiskCache();
        var size = cache.getMaxSize()
        @Assert(size,3 * 1024 * 1024)
    }

    @TestCase
    public func testset(): Unit {
        var cache = LruDiskCache();
        var val: Array<Byte> = [107, 101, 121]
        cache.set("key4", val)
        @Assert(cache.getSize(),3)
        var res = cache.get("key4")
        @Assert(res,val)
    }

    @TestCase
    public func testset2(): Unit {
        var cache = LruDiskCache();
        var val: Array<Byte> = [107, 101, 121]
        cache["key5", val]
        @Assert(cache.getSize(),3)
        var res = cache.get("key5")
        @Assert(res,val)
    }

    @TestCase
    public func testset3(): Unit {
        var cache = LruDiskCache();
        var val = "value"
        cache["testset3", val]
        @Assert(cache.getSize(),5)
        var res = cache.get("testset3")
        @Assert(res,val.toArray())
    }

    @TestCase
    public func testContains(): Unit {
        var cache = LruDiskCache();
        var val = "value"
        cache["keytestContains", val]
        var res = cache.contains("keytestContains")
        @Assert(res,true)
    }

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

    @TestCase
    public func setMaxSize2(): Unit {
        var cache = LruDiskCache();
        var flag = true
        try {
            cache.set("key1", "1")
            cache.set("key2", "2")
            cache.setMaxSize(1)
        } catch (e: Exception) {
            flag = false
            e.printStackTrace()
        }
        @Assert(flag,true)
    }

    @TestCase
    public func setException(): Unit {
        var err = MemoryCacheException();
        try {
            throw err
        } catch (e: MemoryCacheException) {
            @Assert(e.toString().contains("MemoryCacheException:"))
        }
    }

    @TestCase
    public func getCacheMap(): Unit {
        var cache = LruDiskCache();
        var flag = true
        try {
            cache.set("key1", "1")
            cache.set("key2", "2")
            cache.setMaxSize(2)
            var mapsize = cache.getCacheMap().size()
            @Assert(mapsize,2)
        } catch (e: Exception) {
            flag = false
        }
        @Assert(flag,true)
    }
}