github.com/fretkak/mattermost-mattermost-server@v5.11.1+incompatible/utils/lru_test.go (about)

     1  // This files was copied/modified from https://github.com/hashicorp/golang-lru
     2  // which was (see below)
     3  
     4  // This package provides a simple LRU cache. It is based on the
     5  // LRU implementation in groupcache:
     6  // https://github.com/golang/groupcache/tree/master/lru
     7  
     8  package utils
     9  
    10  import (
    11  	"testing"
    12  	"time"
    13  
    14  	"github.com/stretchr/testify/assert"
    15  )
    16  
    17  func TestLRU(t *testing.T) {
    18  	l := NewLru(128)
    19  
    20  	for i := 0; i < 256; i++ {
    21  		l.Add(i, i)
    22  	}
    23  	if l.Len() != 128 {
    24  		t.Fatalf("bad len: %v", l.Len())
    25  	}
    26  
    27  	for i, k := range l.Keys() {
    28  		if v, ok := l.Get(k); !ok || v != k || v != i+128 {
    29  			t.Fatalf("bad key: %v", k)
    30  		}
    31  	}
    32  	for i := 0; i < 128; i++ {
    33  		_, ok := l.Get(i)
    34  		if ok {
    35  			t.Fatalf("should be evicted")
    36  		}
    37  	}
    38  	for i := 128; i < 256; i++ {
    39  		_, ok := l.Get(i)
    40  		if !ok {
    41  			t.Fatalf("should not be evicted")
    42  		}
    43  	}
    44  	for i := 128; i < 192; i++ {
    45  		l.Remove(i)
    46  		_, ok := l.Get(i)
    47  		if ok {
    48  			t.Fatalf("should be deleted")
    49  		}
    50  	}
    51  
    52  	l.Get(192) // expect 192 to be last key in l.Keys()
    53  
    54  	for i, k := range l.Keys() {
    55  		if (i < 63 && k != i+193) || (i == 63 && k != 192) {
    56  			t.Fatalf("out of order key: %v", k)
    57  		}
    58  	}
    59  
    60  	l.Purge()
    61  	if l.Len() != 0 {
    62  		t.Fatalf("bad len: %v", l.Len())
    63  	}
    64  	if _, ok := l.Get(200); ok {
    65  		t.Fatalf("should contain nothing")
    66  	}
    67  }
    68  
    69  func TestLRUExpire(t *testing.T) {
    70  	l := NewLru(128)
    71  
    72  	l.AddWithExpiresInSecs(1, 1, 1)
    73  	l.AddWithExpiresInSecs(2, 2, 1)
    74  	l.AddWithExpiresInSecs(3, 3, 0)
    75  
    76  	time.Sleep(time.Millisecond * 2100)
    77  
    78  	if r1, ok := l.Get(1); ok {
    79  		t.Fatal(r1)
    80  	}
    81  
    82  	if _, ok2 := l.Get(3); !ok2 {
    83  		t.Fatal("should exist")
    84  	}
    85  }
    86  
    87  func TestLRUGetOrAdd(t *testing.T) {
    88  	l := NewLru(128)
    89  
    90  	// First GetOrAdd should save
    91  	value, loaded := l.GetOrAdd(1, 1, 0)
    92  	assert.Equal(t, 1, value)
    93  	assert.False(t, loaded)
    94  
    95  	// Second GetOrAdd should load original value, ignoring new value
    96  	value, loaded = l.GetOrAdd(1, 10, 0)
    97  	assert.Equal(t, 1, value)
    98  	assert.True(t, loaded)
    99  
   100  	// Third GetOrAdd should still load original value
   101  	value, loaded = l.GetOrAdd(1, 1, 0)
   102  	assert.Equal(t, 1, value)
   103  	assert.True(t, loaded)
   104  
   105  	// First GetOrAdd on a new key should save
   106  	value, loaded = l.GetOrAdd(2, 2, 0)
   107  	assert.Equal(t, 2, value)
   108  	assert.False(t, loaded)
   109  
   110  	l.Remove(1)
   111  
   112  	// GetOrAdd after a remove should save
   113  	value, loaded = l.GetOrAdd(1, 10, 0)
   114  	assert.Equal(t, 10, value)
   115  	assert.False(t, loaded)
   116  
   117  	// GetOrAdd after another key was removed should load original value for key
   118  	value, loaded = l.GetOrAdd(2, 2, 0)
   119  	assert.Equal(t, 2, value)
   120  	assert.True(t, loaded)
   121  
   122  	// GetOrAdd should expire
   123  	value, loaded = l.GetOrAdd(3, 3, 500*time.Millisecond)
   124  	assert.Equal(t, 3, value)
   125  	assert.False(t, loaded)
   126  	value, loaded = l.GetOrAdd(3, 4, 500*time.Millisecond)
   127  	assert.Equal(t, 3, value)
   128  	assert.True(t, loaded)
   129  	time.Sleep(1 * time.Second)
   130  	value, loaded = l.GetOrAdd(3, 5, 500*time.Millisecond)
   131  	assert.Equal(t, 5, value)
   132  	assert.False(t, loaded)
   133  }