diff --git a/bird/bird.go b/bird/bird.go
index 0d1d32e..953db74 100644
--- a/bird/bird.go
+++ b/bird/bird.go
@@ -68,14 +68,13 @@ func toCache(key string, val Parsed) bool {
  */
 func fromCache(key string) (Parsed, bool) {
 	val, err := cache.Get(key)
-	if err != nil {
-		log.Println(err)
-		return val, false
-	} else if IsSpecial(val) { // cache may return NilParse e.g. if ttl is expired
-		return val, false
-	} else {
+	if err == nil {
 		return val, true
+	} else {
+		return val, false
 	}
+	//DEBUG log.Println(err)
+
 }
 
 // Determines the key in the cache, where the result of specific functions are stored.
diff --git a/bird/memory_cache.go b/bird/memory_cache.go
index 8213336..89384b4 100644
--- a/bird/memory_cache.go
+++ b/bird/memory_cache.go
@@ -23,17 +23,17 @@ func (c *MemoryCache) Get(key string) (Parsed, error) {
 	c.RLock()
 	val, ok := c.m[key]
 	c.RUnlock()
-	if !ok {
-		return NilParse, errors.New("Could not retrive key" + key + "from MemoryCache.")
+	if !ok { // cache miss
+		return NilParse, errors.New("Failed to retrive key '" + key + "' from MemoryCache.")
 	}
 
 	ttl, correct := val["ttl"].(time.Time)
 	if !correct {
-		return NilParse, errors.New("Invalid TTL value for key" + key)
+		return NilParse, errors.New("Invalid TTL value for key '" + key + "'")
 	}
 
 	if ttl.Before(time.Now()) {
-		return NilParse, nil // TTL expired
+		return val, errors.New("TTL expired for key '" + key + "'") // TTL expired
 	} else {
 		return val, nil // cache hit
 	}
diff --git a/bird/memory_cache_test.go b/bird/memory_cache_test.go
new file mode 100644
index 0000000..b4a6a78
--- /dev/null
+++ b/bird/memory_cache_test.go
@@ -0,0 +1,74 @@
+package bird
+
+import (
+	"testing"
+)
+
+func Test_MemoryCacheAccess(t *testing.T) {
+
+	cache, err := NewMemoryCache()
+
+	parsed := Parsed{
+		"foo": 23,
+		"bar": 42,
+		"baz": true,
+	}
+
+	t.Log("Setting memory cache...")
+	err = cache.Set("testkey", parsed, 5)
+	if err != nil {
+		t.Error(err)
+	}
+
+	t.Log("Fetching from memory cache...")
+	parsed, err = cache.Get("testkey")
+	if err != nil {
+		t.Error(err)
+	}
+
+	t.Log(parsed)
+}
+
+func Test_MemoryCacheAccessKeyMissing(t *testing.T) {
+
+	cache, err := NewMemoryCache()
+
+	parsed, err := cache.Get("test_missing_key")
+	if !IsSpecial(parsed) {
+		t.Error(err)
+	}
+	t.Log("Cache error:", err)
+	t.Log(parsed)
+}
+
+func Test_MemoryCacheRoutes(t *testing.T) {
+	f, err := openFile("routes_bird1_ipv4.sample")
+	if err != nil {
+		t.Error(err)
+	}
+	defer f.Close()
+
+	parsed := parseRoutes(f)
+	_, ok := parsed["routes"].([]Parsed)
+	if !ok {
+		t.Fatal("Error getting routes")
+	}
+
+	cache, err := NewMemoryCache()
+
+	err = cache.Set("routes_protocol_test", parsed, 5)
+	if err != nil {
+		t.Error(err)
+	}
+
+	parsed, err = cache.Get("routes_protocol_test")
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	routes, ok := parsed["routes"].([]Parsed)
+	if !ok {
+		t.Error("Error getting routes")
+	}
+	t.Log("Retrieved routes:", len(routes))
+}