github.com/gnolang/gno@v0.0.0-20240520182011-228e9d0192ce/examples/gno.land/p/demo/avl/tree_test.gno (about)

     1  package avl
     2  
     3  import (
     4  	"testing"
     5  )
     6  
     7  func TestNewTree(t *testing.T) {
     8  	tree := NewTree()
     9  	if tree.node != nil {
    10  		t.Error("Expected tree.node to be nil")
    11  	}
    12  }
    13  
    14  func TestTreeSize(t *testing.T) {
    15  	tree := NewTree()
    16  	if tree.Size() != 0 {
    17  		t.Error("Expected empty tree size to be 0")
    18  	}
    19  
    20  	tree.Set("key1", "value1")
    21  	tree.Set("key2", "value2")
    22  	if tree.Size() != 2 {
    23  		t.Error("Expected tree size to be 2")
    24  	}
    25  }
    26  
    27  func TestTreeHas(t *testing.T) {
    28  	tree := NewTree()
    29  	tree.Set("key1", "value1")
    30  
    31  	if !tree.Has("key1") {
    32  		t.Error("Expected tree to have key1")
    33  	}
    34  
    35  	if tree.Has("key2") {
    36  		t.Error("Expected tree to not have key2")
    37  	}
    38  }
    39  
    40  func TestTreeGet(t *testing.T) {
    41  	tree := NewTree()
    42  	tree.Set("key1", "value1")
    43  
    44  	value, exists := tree.Get("key1")
    45  	if !exists || value != "value1" {
    46  		t.Error("Expected Get to return value1 and true")
    47  	}
    48  
    49  	_, exists = tree.Get("key2")
    50  	if exists {
    51  		t.Error("Expected Get to return false for non-existent key")
    52  	}
    53  }
    54  
    55  func TestTreeGetByIndex(t *testing.T) {
    56  	tree := NewTree()
    57  	tree.Set("key1", "value1")
    58  	tree.Set("key2", "value2")
    59  
    60  	key, value := tree.GetByIndex(0)
    61  	if key != "key1" || value != "value1" {
    62  		t.Error("Expected GetByIndex(0) to return key1 and value1")
    63  	}
    64  
    65  	key, value = tree.GetByIndex(1)
    66  	if key != "key2" || value != "value2" {
    67  		t.Error("Expected GetByIndex(1) to return key2 and value2")
    68  	}
    69  
    70  	defer func() {
    71  		if r := recover(); r == nil {
    72  			t.Error("Expected GetByIndex to panic for out-of-range index")
    73  		}
    74  	}()
    75  	tree.GetByIndex(2)
    76  }
    77  
    78  func TestTreeRemove(t *testing.T) {
    79  	tree := NewTree()
    80  	tree.Set("key1", "value1")
    81  
    82  	value, removed := tree.Remove("key1")
    83  	if !removed || value != "value1" || tree.Size() != 0 {
    84  		t.Error("Expected Remove to remove key-value pair")
    85  	}
    86  
    87  	_, removed = tree.Remove("key2")
    88  	if removed {
    89  		t.Error("Expected Remove to return false for non-existent key")
    90  	}
    91  }
    92  
    93  func TestTreeIterate(t *testing.T) {
    94  	tree := NewTree()
    95  	tree.Set("key1", "value1")
    96  	tree.Set("key2", "value2")
    97  	tree.Set("key3", "value3")
    98  
    99  	var keys []string
   100  	tree.Iterate("", "", func(key string, value interface{}) bool {
   101  		keys = append(keys, key)
   102  		return false
   103  	})
   104  
   105  	expectedKeys := []string{"key1", "key2", "key3"}
   106  	if !slicesEqual(keys, expectedKeys) {
   107  		t.Errorf("Expected keys %v, got %v", expectedKeys, keys)
   108  	}
   109  }
   110  
   111  func TestTreeReverseIterate(t *testing.T) {
   112  	tree := NewTree()
   113  	tree.Set("key1", "value1")
   114  	tree.Set("key2", "value2")
   115  	tree.Set("key3", "value3")
   116  
   117  	var keys []string
   118  	tree.ReverseIterate("", "", func(key string, value interface{}) bool {
   119  		keys = append(keys, key)
   120  		return false
   121  	})
   122  
   123  	expectedKeys := []string{"key3", "key2", "key1"}
   124  	if !slicesEqual(keys, expectedKeys) {
   125  		t.Errorf("Expected keys %v, got %v", expectedKeys, keys)
   126  	}
   127  }
   128  
   129  func TestTreeIterateByOffset(t *testing.T) {
   130  	tree := NewTree()
   131  	tree.Set("key1", "value1")
   132  	tree.Set("key2", "value2")
   133  	tree.Set("key3", "value3")
   134  
   135  	var keys []string
   136  	tree.IterateByOffset(1, 2, func(key string, value interface{}) bool {
   137  		keys = append(keys, key)
   138  		return false
   139  	})
   140  
   141  	expectedKeys := []string{"key2", "key3"}
   142  	if !slicesEqual(keys, expectedKeys) {
   143  		t.Errorf("Expected keys %v, got %v", expectedKeys, keys)
   144  	}
   145  }
   146  
   147  func TestTreeReverseIterateByOffset(t *testing.T) {
   148  	tree := NewTree()
   149  	tree.Set("key1", "value1")
   150  	tree.Set("key2", "value2")
   151  	tree.Set("key3", "value3")
   152  
   153  	var keys []string
   154  	tree.ReverseIterateByOffset(1, 2, func(key string, value interface{}) bool {
   155  		keys = append(keys, key)
   156  		return false
   157  	})
   158  
   159  	expectedKeys := []string{"key2", "key1"}
   160  	if !slicesEqual(keys, expectedKeys) {
   161  		t.Errorf("Expected keys %v, got %v", expectedKeys, keys)
   162  	}
   163  }