Art test

cmd/radFS/arttest/main.go

@@ -0,0 +1,86 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/acmpesuecc/radFS/internal/art"
+)
+
+func main() {
+	t := art.New()
+
+	fmt.Println("====== PHASE 1: STRESS TESTING GROWTH (4 -> 16 -> 48 -> 256) ======")
+
+	// We use keys with a single byte difference to ensure they all go into the SAME internal node
+	for i := 0; i < 256; i++ {
+		key := []byte{byte(i)}
+		t.Insert(key, fmt.Sprintf("%d", i))
+
+		switch i + 1 {
+
+		case 5:
+			fmt.Printf("[Check] Inserted 5 keys.  (Current: %d children)\n", i+1)
+			fmt.Printf("NodeType: %s\n", art.GetNodeTypeName(t.Root()))
+		case 17:
+			fmt.Printf("[Check] Inserted 17 keys.  (Current: %d children)\n", i+1)
+			fmt.Printf("NodeType: %s\n", art.GetNodeTypeName(t.Root()))
+		case 49:
+			fmt.Printf("[Check] Inserted 49 keys. (Current: %d children)\n", i+1)
+			fmt.Printf("NodeType: %s\n", art.GetNodeTypeName(t.Root()))
+		}
+	}
+
+	fmt.Printf("Final Growth State: %d children in root.\n", 256)
+
+	fmt.Println("\n===== PHASE 2: SEARCH VERIFICATION =====")
+	// Verify we didn't lose data during the messy pointer copying in grow/shrink
+	testKeys := []int{0, 15, 47, 100, 255}
+	for _, tk := range testKeys {
+		val, ok := t.Search([]byte{byte(tk)})
+		fmt.Printf("Searching for key %d: Found=%v, Value=%v\n", tk, ok, val)
+	}
+
+	fmt.Println("\n===== PHASE 3: STRESS TESTING SHRINK (256 -> 48 -> 16 -> 4) =====")
+
+	for i := 255; i >= 37; i-- {
+		t.Delete([]byte{byte(i)})
+	}
+	fmt.Println("[Check] Deleted down to 37 keys")
+	fmt.Printf("NodeType: %s\n", art.GetNodeTypeName(t.Root()))
+
+	for i := 36; i >= 12; i-- {
+		t.Delete([]byte{byte(i)})
+	}
+	fmt.Println("[Check] Deleted down to 12 keys. ")
+	fmt.Printf("NodeType: %s\n", art.GetNodeTypeName(t.Root()))
+
+	for i := 11; i >= 3; i-- {
+		t.Delete([]byte{byte(i)})
+	}
+	fmt.Println("[Check] Deleted down to 3 keys. ")
+	fmt.Printf("NodeType: %s\n", art.GetNodeTypeName(t.Root()))
+
+	fmt.Println("\n===== PHASE 4: FULL COLLAPSE (Node4 -> Leaf -> Nil) =====")
+
+	// Delete until only 1 key remains (should collapse Node4 into a Leaf)
+	for i := 2; i >= 1; i-- {
+		t.Delete([]byte{byte(i)})
+	}
+	fmt.Println("[Check] Deleted down to 1 key. Tree should be a single Leaf (no Internal Node).")
+	art.PrintTree(t.Root(), 0, 0)
+
+	// Delete the very last key
+	t.Delete([]byte{byte(0)})
+	fmt.Println("[Check] Deleted last key. Root should be nil.")
+
+	if t.Root() == nil {
+		fmt.Println("SUCCESS: Tree is fully empty (Root is nil).")
+	} else {
+		fmt.Println("WARNING: Root is not nil. Check your Node4 -> Leaf collapse logic.")
+		art.PrintTree(t.Root(), 0, 0)
+	}
+
+	fmt.Println("\n===== FINAL TREE STRUCTURE =====")
+	fmt.Printf("NodeType: %s\n", art.GetNodeTypeName(t.Root()))
+
+}

docs/weekly/angelo/week_4.md

@@ -0,0 +1,8 @@
+## Angelo's Progress
+* implemented the insert function
+* implemented update function in addchild
+
+
+## What's next?
+* implement grow to transition to larger nodes
+* fix the bugs in insert 

internal/art/art.go

@@ -0,0 +1,58 @@
+package art
+
+// TODO: Public API (Tree struct, Insert, Search, Delete)
+
+type Tree struct {
+	root *Node
+}
+
+func (t *Tree) Root() *Node {
+	return t.root
+}
+
+func (t *Tree) Insert(key []byte, value interface{}) {
+	t.root = insert(t.root, value, key, 0)
+}
+
+func (t *Tree) Search(key []byte) (interface{}, bool) {
+	leaf := search(t.root, key, 0) // start from root and depth 0
+	if leaf != nil && isleaf(leaf) {
+		return leaf.leaf.values, true //Node->innerleaf->values
+	}
+	return nil, false
+}
+func (t *Tree) Delete(key []byte) bool {
+	if t.root == nil {
+		return false
+	}
+
+	newRoot, deleted := deletekey(t.root, key, 0)
+
+	if deleted {
+		t.root = newRoot
+		return true
+	}
+
+	return false
+}
+
+func GetNodeTypeName(n *Node) string {
+	if n == nil {
+		return "Nil"
+	}
+	if isleaf(n) {
+		return "Leaf"
+	}
+
+	types := []string{"Node4", "Node16", "Node48", "Node256"}
+	return types[n.innerNode.nodeType]
+}
+func (t *Tree) ForEach(fn func([]byte, interface{})) {
+	traverse(t.root, 0, fn)
+}
+func New() *Tree {
+	return &Tree{}
+}
+func (t *Tree) Empty() bool {
+	return t.root == nil
+}

internal/art/art_test.go

@@ -0,0 +1,184 @@
+package art
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestInsertAndSearch(t *testing.T) {
+	var tree Tree
+
+	tree.Insert([]byte("hello"), "world")
+
+	v, ok := tree.Search([]byte("hello"))
+	if !ok {
+		t.Fatal("key not found")
+	}
+	if v != "world" {
+		t.Fatalf("got %v wanted world", v)
+	}
+
+}
+func TestSearchMissing(t *testing.T) {
+	var tree Tree
+
+	_, ok := tree.Search([]byte("ghost"))
+
+	if ok {
+		t.Fatal("expected key not found")
+	}
+}
+
+func TestDelete(t *testing.T) {
+	var tree Tree
+
+	tree.Insert([]byte("hello"), "world")
+
+	if !tree.Delete([]byte("hello")) {
+		t.Fatal("delete failed")
+	}
+
+	_, ok := tree.Search([]byte("hello"))
+
+	if ok {
+		t.Fatal("key still exists")
+	}
+}
+
+func TestPrefixOverlap(t *testing.T) {
+	var tree Tree
+
+	keys := []string{
+		"a",
+		"ab",
+		"abc",
+		"abcd",
+	}
+
+	for _, k := range keys {
+		tree.Insert([]byte(k), k)
+	}
+
+	for _, k := range keys {
+		_, ok := tree.Search([]byte(k))
+
+		if !ok {
+			t.Fatalf("missing key %s", k)
+		}
+	}
+}
+
+func TestDeletePrefix(t *testing.T) {
+	var tree Tree
+
+	tree.Insert([]byte("a"), "a")
+	tree.Insert([]byte("ab"), "ab")
+	tree.Insert([]byte("abc"), "abc")
+
+	tree.Delete([]byte("ab"))
+
+	if _, ok := tree.Search([]byte("ab")); ok {
+		t.Fatal("ab still exists")
+	}
+
+	if _, ok := tree.Search([]byte("a")); !ok {
+		t.Fatal("a missing")
+	}
+
+	if _, ok := tree.Search([]byte("abc")); !ok {
+		t.Fatal("abc missing")
+	}
+}
+func TestUpdate(t *testing.T) {
+	var tree Tree
+
+	tree.Insert([]byte("hello"), "goob")
+
+	tree.Insert([]byte("hello"), "new")
+
+	v, _ := tree.Search([]byte("hello"))
+	fmt.Printf("%v", v)
+
+	if v != "new" {
+		t.Fatalf("got %v want new", v)
+	}
+}
+func TestForEach(t *testing.T) {
+	var tree Tree
+
+	tree.Insert([]byte("cat"), "cat")
+	tree.Insert([]byte("apple"), "apple")
+	tree.Insert([]byte("banana"), "banana")
+
+	var result []string
+
+	tree.ForEach(func(k []byte, v interface{}) {
+		result = append(result, string(k))
+	})
+
+	expected := []string{
+		"apple",
+		"banana",
+		"cat",
+	}
+
+	for i := range expected {
+		if result[i] != expected[i] {
+			t.Fatalf("got %v want %v", result, expected)
+		}
+	}
+}
+
+func TestNodeGrowth(t *testing.T) {
+	var tree Tree
+
+	for i := 0; i < 5; i++ {
+		tree.Insert([]byte{byte(i)}, "x")
+	}
+
+	if GetNodeTypeName(tree.Root()) != "Node16" {
+		t.Fatal("expected Node16")
+	}
+	for i := 0; i < 17; i++ {
+		tree.Insert([]byte{byte(i)}, "x")
+	}
+
+	if GetNodeTypeName(tree.Root()) != "Node48" {
+		t.Fatal("expected Node48")
+	}
+	for i := 0; i < 49; i++ {
+		tree.Insert([]byte{byte(i)}, "x")
+	}
+
+	if GetNodeTypeName(tree.Root()) != "Node256" {
+		t.Fatal("expected Node256")
+	}
+
+}
+
+func TestNodeShrink(t *testing.T) {
+	var tree Tree
+
+	for i := 0; i < 49; i++ {
+		tree.Insert([]byte{byte(i)}, "x")
+	}
+	tree.Delete([]byte{byte(48)})
+	if GetNodeTypeName(tree.Root()) != "Node48" {
+		t.Fatal("expected Node48")
+	}
+	for i := 47; i > 15; i-- {
+		tree.Delete([]byte{byte(i)})
+
+	}
+	if GetNodeTypeName(tree.Root()) != "Node16" {
+		t.Fatal("expected Node16")
+	}
+	for i := 15; i > 3; i-- {
+		tree.Delete([]byte{byte(i)})
+
+	}
+	if GetNodeTypeName(tree.Root()) != "Node4" {
+		t.Fatal("expected Node4")
+	}
+
+}

internal/art/delete.go

@@ -0,0 +1,53 @@
+package art
+
+import (
+	"bytes"
+)
+
+func deletekey(n *Node, key []byte, depth int) (*Node, bool) {
+	if n == nil {
+		return nil, false
+	}
+
+	if isleaf(n) {
+		if bytes.Equal(n.leaf.key, key) {
+			return nil, true
+		}
+		return n, false
+	}
+
+	p := checkprefix(n, key, depth)
+	if p != n.innerNode.meta.prefixlen {
+		return n, false
+	}
+	depth += n.innerNode.meta.prefixlen
+
+	// 3. KEY EXHAUSTION (The Fix)
+	// If the key ends here, the value is in the inner node's leaf field
+	if depth == len(key) {
+		if n.innerNode.leaf != nil {
+			n.innerNode.leaf = nil // Remove the value
+			return n, true
+		}
+		return n, false
+	}
+
+	k := key[depth]
+	child, pos := findchild(k, n)
+	if child == nil {
+		return n, false
+	}
+
+	newChild, deleted := deletekey(child, key, depth+1)
+	if !deleted {
+		return n, false
+	}
+
+	if newChild == nil {
+		n = removechild(n, k)
+	} else {
+		n.innerNode.children[pos] = newChild
+	}
+
+	return n, true
+}