tree - walk_test.go

     1  package tree
     2  
     3  import (
     4  	"errors"
     5  	"reflect"
     6  	"slices"
     7  	"strings"
     8  	"testing"
     9  )
    10  
    11  func TestWalk(t *testing.T) {
    12  	tree := Branch{
    13  		{"A", Branch{
    14  			{"AA", Branch{
    15  				{"AAA", Branch{
    16  					{"AAAA", Leaf("")},
    17  					{"AAAB", Leaf("")},
    18  				}},
    19  				{"AAB", Branch{
    20  					{"AABA", Leaf("")},
    21  					{"AABB", Leaf("")},
    22  				}},
    23  			}},
    24  			{"AB", Branch{
    25  				{"ABA", Leaf("")},
    26  			}},
    27  			{"AC", Branch{
    28  				{"ACA", Leaf("")},
    29  				{"ACB", Leaf("")},
    30  			}},
    31  		}},
    32  		{"B", Leaf("")},
    33  	}
    34  
    35  	var paths [][]string
    36  
    37  	if err := Walk(&tree, func(path []string, node Node) error {
    38  		paths = append(paths, slices.Clone(path))
    39  
    40  		if len(path) > 2 {
    41  			return SkipNode
    42  		}
    43  
    44  		if len(paths) >= 7 {
    45  			return SkipAll
    46  		}
    47  
    48  		return nil
    49  	}); err != nil {
    50  		t.Errorf("unexpected error: %s", err)
    51  	}
    52  
    53  	expectation := [][]string{
    54  		{"A"},
    55  		{"A", "AA"},
    56  		{"A", "AA", "AAA"},
    57  		{"A", "AA", "AAB"},
    58  		{"A", "AB"},
    59  		{"A", "AB", "ABA"},
    60  		{"A", "AC"},
    61  	}
    62  
    63  	if !reflect.DeepEqual(paths, expectation) {
    64  		t.Errorf("expecting paths %v, got %v", expectation, paths)
    65  	}
    66  
    67  	paths = paths[:0]
    68  
    69  	customError := errors.New("custom")
    70  
    71  	if err := Walk(&tree, func(path []string, node Node) error {
    72  		paths = append(paths, slices.Clone(path))
    73  
    74  		if len(path) > 2 {
    75  			return customError
    76  		}
    77  
    78  		return nil
    79  	}); err != customError {
    80  		t.Errorf("expecting error %s, got %s", customError, err)
    81  	}
    82  }
    83  
    84  func TestFlatten(t *testing.T) {
    85  	tree := Branch{
    86  		{"A", Branch{
    87  			{"AA", Branch{
    88  				{"AAA", Branch{
    89  					{"AAAA", Leaf("")},
    90  					{"AAAB", Leaf("")},
    91  				}},
    92  				{"AAB", Branch{
    93  					{"AABA", Leaf("")},
    94  					{"AABB", Leaf("")},
    95  				}},
    96  			}},
    97  			{"AB", Branch{
    98  				{"ABA", Leaf("")},
    99  			}},
   100  			{"AC", Branch{
   101  				{"ACA", Leaf("")},
   102  				{"ACB", Leaf("")},
   103  			}},
   104  		}},
   105  		{"B", Leaf("")},
   106  	}
   107  
   108  	expectation := map[string]Node{
   109  		"A":             navigate(t, tree, []string{"A"}),
   110  		"A/AA":          navigate(t, tree, []string{"A", "AA"}),
   111  		"A/AA/AAA":      navigate(t, tree, []string{"A", "AA", "AAA"}),
   112  		"A/AA/AAA/AAAA": navigate(t, tree, []string{"A", "AA", "AAA", "AAAA"}),
   113  		"A/AA/AAA/AAAB": navigate(t, tree, []string{"A", "AA", "AAA", "AAAB"}),
   114  		"A/AA/AAB":      navigate(t, tree, []string{"A", "AA", "AAB"}),
   115  		"A/AA/AAB/AABA": navigate(t, tree, []string{"A", "AA", "AAB", "AABA"}),
   116  	}
   117  	got := map[string]Node{}
   118  
   119  	for name, n := range Flatten(tree) {
   120  		got[strings.Join(name, "/")] = n
   121  
   122  		if len(got) == 7 {
   123  			break
   124  		}
   125  	}
   126  
   127  	if !reflect.DeepEqual(got, expectation) {
   128  		t.Errorf("expected map %v, got %v", expectation, got)
   129  	}
   130  }
   131  
   132  func navigate(t *testing.T, n Node, path []string) Node {
   133  	node, err := Navigate(n, slices.Values(path))
   134  	if err != nil {
   135  		t.Fatalf("unexpected error: %s", err)
   136  	}
   137  
   138  	return node
   139  }
   140  
   141  func TestFilter(t *testing.T) {
   142  	tree := Branch{
   143  		{"A", Branch{
   144  			{"AA", Branch{
   145  				{"AAA", Branch{
   146  					{"AAAA", Leaf("")},
   147  					{"AAAB", Leaf("")},
   148  				}},
   149  				{"AAB", Branch{
   150  					{"AABA", Leaf("")},
   151  					{"AABB", Leaf("")},
   152  				}},
   153  			}},
   154  			{"AB", Branch{
   155  				{"ABA", Leaf("")},
   156  			}},
   157  			{"AC", Branch{
   158  				{"ACA", Leaf("")},
   159  				{"ACB", Leaf("")},
   160  			}},
   161  		}},
   162  		{"B", Leaf("")},
   163  	}
   164  
   165  	var leafs [][]string
   166  
   167  	for name := range Filter(tree, func(_ []string, n Node) int {
   168  		_, ok := n.(Leaf)
   169  
   170  		if ok {
   171  			return 1
   172  		}
   173  
   174  		return 0
   175  	}) {
   176  		leafs = append(leafs, name)
   177  	}
   178  
   179  	expectation := [][]string{
   180  		{"A", "AA", "AAA", "AAAA"},
   181  		{"A", "AA", "AAA", "AAAB"},
   182  		{"A", "AA", "AAB", "AABA"},
   183  		{"A", "AA", "AAB", "AABB"},
   184  		{"A", "AB", "ABA"},
   185  		{"A", "AC", "ACA"},
   186  		{"A", "AC", "ACB"},
   187  		{"B"},
   188  	}
   189  
   190  	if !reflect.DeepEqual(leafs, expectation) {
   191  		t.Errorf("expecting leafs %v, got %v", expectation, leafs)
   192  	}
   193  }
   194