go-vise

Constrained Size Output Virtual Machine
Info | Log | Files | Refs | README | LICENSE

cache_test.go (4056B)

      1 package cache
      2 
      3 import (
      4 	"testing"
      5 	"slices"
      6 )
      7 
      8 func TestNewCache(t *testing.T) {
      9 	ca := NewCache()
     10 	if ca.CacheSize != 0 {
     11 		t.Errorf("cache size not 0")
     12 	}
     13 	ca = ca.WithCacheSize(102525)
     14 	if ca.CacheSize != 102525 {
     15 		t.Errorf("cache size not 102525")
     16 	}
     17 }
     18 
     19 func TestCacheUse(t *testing.T) {
     20 	ca := NewCache()
     21 	ca = ca.WithCacheSize(10)
     22 	ca.Push()
     23 	err := ca.Add("bar", "baz", 0)
     24 	if err != nil {
     25 		t.Error(err)
     26 	}
     27 	err = ca.Add("inky", "pinky", 0)
     28 	if err != nil {
     29 		t.Error(err)
     30 	}
     31 	err = ca.Add("blinky", "clyde", 0)
     32 	if err == nil {
     33 		t.Errorf("expected capacity error")
     34 	}
     35 	v := ca.Check("inky")
     36 	if v {
     37 		t.Fatal("expected true")
     38 	}
     39 	v = ca.Check("blinky")
     40 	if !v {
     41 		t.Fatal("expected false")
     42 	}
     43 }
     44 
     45 func TestCacheUpdate(t *testing.T) {
     46 	ca := NewCache()
     47 	ca = ca.WithCacheSize(10)
     48 	ca.Add("foo", "bar", 0)
     49 	err := ca.Add("foo", "barbarbar", 0)
     50 	if err != ErrDup {
     51 		t.Error(err)
     52 	}
     53 	v, err := ca.Get("foo")
     54 	if err != nil {
     55 		t.Error(err)
     56 	}
     57 	if v != "bar" {
     58 		t.Fatalf("expected 'bar', got '%s'", v)
     59 	}
     60 	err = ca.Update("foo", "barbarbar")
     61 	v, err = ca.Get("foo")
     62 	if err != nil {
     63 		t.Error(err)
     64 	}
     65 	if v != "barbarbar" {
     66 		t.Fatalf("expected 'barbarbar', got '%s'", v)
     67 	}
     68 	err = ca.Update("foo", "barbarbarbar")
     69 	if err == nil {
     70 		t.Fatalf("expect error")
     71 	}
     72 }
     73 
     74 func TestCacheLimits(t *testing.T) {
     75 	ca := NewCache()
     76 	ca = ca.WithCacheSize(8)
     77 	err := ca.Add("foo", "bar", 2)
     78 	if err == nil {
     79 		t.Fatal("expected error")
     80 	}
     81 	err = ca.Add("foo", "barbarbar", 0)
     82 	if err == nil {
     83 		t.Fatal("expected error")
     84 	}
     85 	err = ca.Add("foo", "bar", 0)
     86 	if err != nil {
     87 		t.Fatal(err)
     88 	}
     89 	err = ca.Add("baz", "barbar", 0)
     90 	if err == nil {
     91 		t.Fatal("expected error")
     92 	}
     93 	ca.Reset()
     94 	err = ca.Add("baz", "barbar", 0)
     95 	if err == nil {
     96 		t.Fatal("expected error")
     97 	}
     98 	ca.Pop()
     99 	err = ca.Add("baz", "barbar", 0)
    100 	if err != nil {
    101 		t.Fatal(err)
    102 	}
    103 }
    104 
    105 func TestStateDownUp(t *testing.T) {
    106 	ca := NewCache()
    107 	err := ca.Push()
    108 	if err != nil {
    109 		t.Error(err)
    110 	}
    111 	err = ca.Add("foo", "bar", 0)
    112 	if err != nil {
    113 		t.Error(err)
    114 	}
    115 	err = ca.Add("baz", "xyzzy", 0)
    116 	if err != nil {
    117 		t.Error(err)
    118 	}
    119 	if ca.CacheUseSize != 8 {
    120 		t.Errorf("expected cache use size 8 got %v", ca.CacheUseSize)
    121 	}
    122 	err = ca.Pop()
    123 	if err != nil {
    124 		t.Error(err)
    125 	}
    126 	l := len(ca.Cache)
    127 	if l != 1 {
    128 		t.Fatalf("expected cache length 1, got %d", l)
    129 	}
    130 	err = ca.Pop()
    131 	if err != nil {
    132 		t.Error(err)
    133 	}
    134 	l = len(ca.Cache)
    135 	if l != 1 {
    136 		t.Fatalf("expected cache length 1, got %d", l)
    137 	}
    138 	err = ca.Pop()
    139 	if err != nil {
    140 		t.Errorf("unexpected out of top frame error")
    141 	}
    142 	l = len(ca.Cache)
    143 	if l != 1 {
    144 		t.Fatalf("expected cache length 1, got %d", l) 
    145 	}
    146 }
    147 
    148 func TestCacheReset(t *testing.T) {
    149 	ca := NewCache()
    150 	err := ca.Add("foo", "bar", 0)
    151 	if err != nil {
    152 		t.Error(err)
    153 	}
    154 	ca.Push()
    155 	err = ca.Add("baz", "xyzzy", 0)
    156 	if err != nil {
    157 		t.Error(err)
    158 	}
    159 	ca.Reset()
    160 	if ca.CacheUseSize != 3 {
    161 		t.Errorf("expected cache use size 0, got %v", ca.CacheUseSize)
    162 	}
    163 }
    164 
    165 func TestCacheLoadDup(t *testing.T) {
    166 	ca := NewCache()
    167 	err := ca.Push()
    168 	if err != nil {
    169 		t.Error(err)
    170 	}
    171 	err = ca.Add("foo", "xyzzy", 0)
    172 	if err != nil {
    173 		t.Error(err)
    174 	}
    175 	err = ca.Push()
    176 	if err != nil {
    177 		t.Error(err)
    178 	}
    179 	err = ca.Add("foo", "baz", 0)
    180 	if err == nil {
    181 		t.Errorf("expect duplicate key in different frame")
    182 	}
    183 	ca.Pop()
    184 	err = ca.Add("foo", "baz", 0)
    185 	if err != ErrDup {
    186 		t.Error(err)
    187 	}
    188 }
    189 
    190 func TestCacheLast(t *testing.T) {
    191 	ca := NewCache()
    192 	v := ca.Last()
    193 	if v != "" {
    194 		t.Fatal("expected empty")
    195 	}
    196 	err := ca.Add("foo", "bar", 0)
    197 	if err != nil {
    198 		t.Error(err)
    199 	}
    200 	ca.Push()
    201 	err = ca.Add("baz", "xyzzy", 0)
    202 	if err != nil {
    203 		t.Error(err)
    204 	}
    205 	v = ca.Last()
    206 	if v != "xyzzy" {
    207 		t.Fatalf("expected 'xyzzy', got: '%s'", v)
    208 	}
    209 }
    210 
    211 func TestCacheKeys(t *testing.T) {
    212 	ca := NewCache()
    213 	ca.Add("inky", "tinkywinky", 0)
    214 	ca.Push()
    215 	ca.Add("pinky", "dipsy", 0)
    216 	ca.Push()
    217 	ca.Push()
    218 	ca.Add("blinky", "lala", 0)
    219 	ca.Add("clyde", "pu", 0)
    220 	ks := ca.Keys(3)
    221 	if !slices.Contains(ks, "blinky") {
    222 		t.Fatalf("Missing 'blinky'")
    223 	}
    224 	if !slices.Contains(ks, "clyde") {
    225 		t.Fatalf("Missing 'clyde'")
    226 	}
    227 }