/*
Copyright 2021 The Kubernetes Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
/*
Copyright 2013 Google Inc.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package lru

import (
	"testing"
	"time"
)

type simpleStruct struct {
	int
	string
}

type complexStruct struct {
	int
	simpleStruct
}

var getTests = []struct {
	name       string
	keyToAdd   interface{}
	keyToGet   interface{}
	expectedOk bool
}{
	{"string_hit", "myKey", "myKey", true},
	{"string_miss", "myKey", "nonsense", false},
	{"simple_struct_hit", simpleStruct{1, "two"}, simpleStruct{1, "two"}, true},
	{"simple_struct_miss", simpleStruct{1, "two"}, simpleStruct{0, "noway"}, false},
	{"complex_struct_hit", complexStruct{1, simpleStruct{2, "three"}},
		complexStruct{1, simpleStruct{2, "three"}}, true},
}

func TestGet(t *testing.T) {
	for _, tt := range getTests {
		lru := New(0)
		lru.Add(tt.keyToAdd, 1234)
		val, ok := lru.Get(tt.keyToGet)
		if ok != tt.expectedOk {
			t.Fatalf("%s: cache hit = %v; want %v", tt.name, ok, !ok)
		} else if ok && val != 1234 {
			t.Fatalf("%s expected get to return 1234 but got %v", tt.name, val)
		}
	}
}

func TestRemove(t *testing.T) {
	lru := New(0)
	lru.Add("myKey", 1234)
	if val, ok := lru.Get("myKey"); !ok {
		t.Fatal("TestRemove returned no match")
	} else if val != 1234 {
		t.Fatalf("TestRemove failed.  Expected %d, got %v", 1234, val)
	}

	lru.Remove("myKey")
	if _, ok := lru.Get("myKey"); ok {
		t.Fatal("TestRemove returned a removed entry")
	}
}

func TestGetRace(_ *testing.T) {
	// size to force eviction and exercise next,curr,prev list behavior
	lru := New(25)

	stop := make(chan struct{})
	defer close(stop)

	// set up parallel getters/writers on 2x len keys
	for key := 0; key < 50; key++ {
		go func(key int) {
			for {
				select {
				case <-stop:
					return
				default:
					lru.Get(key)
					lru.Add(key, 1)
					lru.Get(key)
				}
			}
		}(key)
	}
	// let them run
	time.Sleep(5 * time.Second)
}

func TestEviction(t *testing.T) {
	var seenKey Key
	var seenVal interface{}

	lru := NewWithEvictionFunc(1, func(key Key, value interface{}) {
		seenKey = key
		seenVal = value
	})

	lru.Add(1, 2)
	lru.Add(3, 4)

	if seenKey != 1 || seenVal != 2 {
		t.Errorf("unexpected eviction data: key=%v val=%v", seenKey, seenVal)
	}
}

func TestSetEviction(t *testing.T) {
	var seenKey Key
	var seenVal interface{}

	lru := New(1)

	err := lru.SetEvictionFunc(func(key Key, value interface{}) {
		seenKey = key
		seenVal = value
	})

	if err != nil {
		t.Errorf("unexpected error setting eviction function: %v", err)
	}

	lru.Add(1, 2)
	lru.Add(3, 4)

	if seenKey != 1 || seenVal != 2 {
		t.Errorf("unexpected eviction data: key=%v val=%v", seenKey, seenVal)
	}

	err = lru.SetEvictionFunc(func(_ Key, _ interface{}) {})
	if err == nil {
		t.Errorf("expected error but got none")
	}
}
