JeevanYewale-Java/src/test/java/com/thealgorithms/datastructures/trees/TernarySearchTreeTest.java at 336ca10dcc64100bb53dfa4b40827e4f3abeb0bd · JeevanYewale/JeevanYewale-Java · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
package com.thealgorithms.datastructures.trees;

import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

/**
 * Test cases for TernarySearchTree implementation.
 *
 * @author JeevanYewale
 */
class TernarySearchTreeTest {

    private TernarySearchTree tst;

    @BeforeEach
    void setUp() {
        tst = new TernarySearchTree();
    }

    @Test
    void testInsertAndSearch() {
        tst.insert("cat");
        tst.insert("cats");
        tst.insert("up");
        tst.insert("bug");

        assertTrue(tst.search("cat"));
        assertTrue(tst.search("cats"));
        assertTrue(tst.search("up"));
        assertTrue(tst.search("bug"));
        assertFalse(tst.search("ca"));
        assertFalse(tst.search("dog"));
    }

    @Test
    void testInsertNullOrEmpty() {
        assertThrows(IllegalArgumentException.class, () -> tst.insert(null));
        assertThrows(IllegalArgumentException.class, () -> tst.insert(""));
    }

    @Test
    void testSearchNullOrEmpty() {
        assertThrows(IllegalArgumentException.class, () -> tst.search(null));
        assertThrows(IllegalArgumentException.class, () -> tst.search(""));
    }

    @Test
    void testStartsWith() {
        tst.insert("cat");
        tst.insert("cats");
        tst.insert("car");
        tst.insert("card");

        assertTrue(tst.startsWith("ca"));
        assertTrue(tst.startsWith("cat"));
        assertTrue(tst.startsWith("car"));
        assertFalse(tst.startsWith("dog"));
        assertFalse(tst.startsWith("cb"));
    }

    @Test
    void testStartsWithNullOrEmpty() {
        assertThrows(IllegalArgumentException.class, () -> tst.startsWith(null));
        assertThrows(IllegalArgumentException.class, () -> tst.startsWith(""));
    }

    @Test
    void testDelete() {
        tst.insert("cat");
        tst.insert("cats");
        tst.insert("car");

        assertTrue(tst.delete("cat"));
        assertFalse(tst.search("cat"));
        assertTrue(tst.search("cats"));
        assertTrue(tst.search("car"));

        assertFalse(tst.delete("dog"));
        assertFalse(tst.delete("cat")); // Already deleted
    }

    @Test
    void testDeleteNullOrEmpty() {
        assertThrows(IllegalArgumentException.class, () -> tst.delete(null));
        assertThrows(IllegalArgumentException.class, () -> tst.delete(""));
    }

    @Test
    void testIsEmpty() {
        assertTrue(tst.isEmpty());

        tst.insert("test");
        assertFalse(tst.isEmpty());

        tst.delete("test");
        assertTrue(tst.isEmpty());
    }

    @Test
    void testSingleCharacterWords() {
        tst.insert("a");
        tst.insert("b");
        tst.insert("z");

        assertTrue(tst.search("a"));
        assertTrue(tst.search("b"));
        assertTrue(tst.search("z"));
        assertFalse(tst.search("c"));
    }

    @Test
    void testOverlappingWords() {
        tst.insert("he");
        tst.insert("she");
        tst.insert("his");
        tst.insert("hers");

        assertTrue(tst.search("he"));
        assertTrue(tst.search("she"));
        assertTrue(tst.search("his"));
        assertTrue(tst.search("hers"));

        assertTrue(tst.startsWith("he"));
        assertTrue(tst.startsWith("h"));
        assertFalse(tst.search("her"));
    }

    @Test
    void testCaseSensitivity() {
        tst.insert("Cat");
        tst.insert("cat");

        assertTrue(tst.search("Cat"));
        assertTrue(tst.search("cat"));
        assertFalse(tst.search("CAT"));
    }

    @Test
    void testLargeDataset() {
        String[] words = {"apple", "application", "apply", "appreciate", "approach",
                         "appropriate", "approve", "approximate", "april", "area"};

        for (String word : words) {
            tst.insert(word);
        }

        for (String word : words) {
            assertTrue(tst.search(word));
        }

        assertTrue(tst.startsWith("app"));
        assertTrue(tst.startsWith("appr"));
        assertFalse(tst.startsWith("orange"));
    }
}