Clover icon

together Platform [Module:core] - Coverage Report

  1. Project Clover database Mon Dec 22 2025 14:59:38 CST
  2. Package org.europa.together.application

File ListTreeTest.java

 

Code metrics

0
259
47
1
573
436
47
0.18
5.51
47
1

Classes

Class Line # Actions
ListTreeTest 27 259 0% 47 0
1.0100%
 

Contributing tests

This file is covered by 41 tests. .

Source view

1    package org.europa.together.application;
2   
3    import static com.google.code.beanmatchers.BeanMatchers.*;
4    import java.util.List;
5    import org.europa.together.JUnit5Preperator;
6    import org.europa.together.business.Logger;
7    import org.europa.together.business.TreeWalker;
8    import org.europa.together.domain.LogLevel;
9    import org.europa.together.domain.TreeNode;
10    import org.europa.together.utils.StringUtils;
11    import static org.hamcrest.MatcherAssert.assertThat;
12    import org.junit.jupiter.api.AfterAll;
13    import org.junit.jupiter.api.AfterEach;
14    import static org.junit.jupiter.api.Assertions.*;
15    import org.junit.jupiter.api.Assumptions;
16    import org.junit.jupiter.api.BeforeAll;
17    import org.junit.jupiter.api.BeforeEach;
18    import org.junit.jupiter.api.Test;
19    import org.junit.jupiter.api.extension.ExtendWith;
20    import org.springframework.beans.factory.annotation.Autowired;
21    import org.springframework.test.context.ContextConfiguration;
22    import org.springframework.test.context.junit.jupiter.SpringExtension;
23   
24    @SuppressWarnings("unchecked")
25    @ExtendWith({SpringExtension.class, JUnit5Preperator.class})
26    @ContextConfiguration(locations = {"/applicationContext.xml"})
 
27    public class ListTreeTest {
28   
29    private static final Logger LOGGER = new LogbackLogger(ListTreeTest.class);
30   
31    @Autowired
32    private TreeWalker<Boolean> treeWalker;
33   
34    //<editor-fold defaultstate="collapsed" desc="Test Preparation">
 
35  1 toggle @BeforeAll
36    static void setUp() {
37  1 Assumptions.assumeTrue(true, "Assumtion failed.");
38   
39  1 LOGGER.log("Assumptions passed ...\n\n", LogLevel.DEBUG);
40    }
41   
 
42  1 toggle @AfterAll
43    static void tearDown() {
44    }
45   
 
46  41 toggle @BeforeEach
47    void testCaseInitialization() {
48  41 treeWalker.addRoot(new TreeNode<Boolean>("Root Node"));
49    }
50   
 
51  41 toggle @AfterEach
52    void testCaseTermination() {
53  41 treeWalker.clear();
54    }
55    //</editor-fold>
56   
 
57  1 toggle @Test
58    void constructor() {
59  1 LOGGER.log("TEST CASE: constructor", LogLevel.DEBUG);
60   
61  1 assertThat(ListTree.class, hasValidBeanConstructor());
62    }
63   
 
64  1 toggle @Test
65    void addRoot() throws Exception {
66  1 LOGGER.log("TEST CASE: addRoot", LogLevel.DEBUG);
67   
68  1 TreeNode<Boolean> root = new TreeNode<Boolean>();
69  1 root.setNodeName("ROOT");
70  1 TreeWalker<Boolean> walker = new ListTree<Boolean>(root);
71   
72  1 assertEquals("ROOT", walker.getRoot().getNodeName());
73    }
74   
 
75  1 toggle @Test
76    void failAddRootTwice() {
77  1 LOGGER.log("TEST CASE: failAddRoot", LogLevel.DEBUG);
78   
79  1 TreeNode<Boolean> root = new TreeNode<>("ROOT");
80  1 TreeWalker<Boolean> walker = new ListTree<Boolean>(root);
81   
82  1 assertFalse(walker.addRoot(root));
83    }
84   
 
85  1 toggle @Test
86    void getRoot() throws Exception {
87  1 LOGGER.log("TEST CASE: getRoot", LogLevel.DEBUG);
88   
89  1 TreeWalker<Boolean> walker
90    = new ListTree<Boolean>(new TreeNode<Boolean>("Root Node"));
91   
92  1 TreeNode<Boolean> root = walker.getRoot();
93   
94  1 assertEquals("Root Node", walker.getRoot().getNodeName());
95  1 assertEquals("-1", walker.getRoot().getParent());
96    }
97   
 
98  1 toggle @Test
99    void failGetRootNotExist() {
100  1 LOGGER.log("TEST CASE: failGetRoot", LogLevel.DEBUG);
101   
102  1 TreeWalker<Boolean> walker = new ListTree<Boolean>();
103  1 assertNull(walker.getRoot());
104    }
105   
 
106  1 toggle @Test
107    void countNodes() throws Exception {
108  1 LOGGER.log("TEST CASE: countNodes", LogLevel.DEBUG);
109   
110  1 buildTree();
111  1 assertEquals(12, treeWalker.countNodes());
112    }
113   
 
114  1 toggle @Test
115    void countNodesEmptyTree() {
116  1 LOGGER.log("TEST CASE: countNodes", LogLevel.DEBUG);
117   
118  1 assertEquals(0, new ListTree<Boolean>().countNodes());
119    }
120   
 
121  1 toggle @Test
122    void addNode() throws Exception {
123  1 LOGGER.log("TEST CASE: addNode", LogLevel.DEBUG);
124   
125  1 buildTree();
126   
127  1 TreeNode<Boolean> node = new TreeNode<>("06.1");
128  1 node.setParent(
129    treeWalker.getElementByName("06").get(0).getUuid()
130    );
131  1 treeWalker.addNode(node);
132   
133  1 assertEquals(13, treeWalker.countNodes());
134    }
135   
 
136  1 toggle @Test
137    void failAddEmptyNode() throws Exception {
138  1 LOGGER.log("TEST CASE: failAddEmptyNode", LogLevel.DEBUG);
139   
140  1 buildTree();
141  1 assertFalse(treeWalker.addNode(null));
142    }
143   
 
144  1 toggle @Test
145    void failAddNodeOfSameNameAndParent() throws Exception {
146  1 LOGGER.log("TEST CASE: failAddNodeOfSameNameAndParent", LogLevel.DEBUG);
147   
148  1 TreeWalker<Boolean> walker = new ListTree<Boolean>();
149   
150  1 TreeNode<Boolean> root = new TreeNode<>("Root");
151  1 TreeNode<Boolean> node_01 = new TreeNode<>("Node");
152  1 node_01.setParent(root.getUuid());
153  1 TreeNode<Boolean> node_02 = new TreeNode<>("Node");
154  1 node_02.setParent(root.getUuid());
155   
156  1 assertTrue(walker.addRoot(root));
157  1 assertTrue(walker.addNode(node_01));
158  1 assertFalse(walker.addNode(node_02));
159   
160  1 assertEquals(2, walker.countNodes());
161    }
162   
 
163  1 toggle @Test
164    void failAddNodeOfSameUuid() throws Exception {
165  1 LOGGER.log("TEST CASE: failAddNodeOfSameUuid", LogLevel.DEBUG);
166   
167  1 TreeWalker<Boolean> walker = new ListTree<Boolean>();
168  1 TreeNode<Boolean> node_01 = new TreeNode<>("01");
169  1 TreeNode<Boolean> node_02 = node_01.copy(node_01);
170  1 node_02.setNodeName("02");
171   
172  1 assertEquals(node_01.getUuid(), node_02.getUuid());
173  1 assertEquals("01", node_01.getNodeName());
174  1 assertTrue(walker.addNode(node_01));
175  1 assertEquals("02", node_02.getNodeName());
176  1 assertFalse(walker.addNode(node_02));
177    }
178   
 
179  1 toggle @Test
180    void getLeafCount() throws Exception {
181  1 LOGGER.log("TEST CASE: getLeafCount", LogLevel.DEBUG);
182   
183  1 buildTree();
184  1 assertEquals(5, treeWalker.getLeafs().size());
185    }
186   
 
187  1 toggle @Test
188    void isLeaf() throws Exception {
189  1 LOGGER.log("TEST CASE: isLeaf", LogLevel.DEBUG);
190   
191  1 buildTree();
192  1 assertTrue(treeWalker.isLeaf(
193    treeWalker.getElementByName("11").get(0))
194    );
195    }
196   
 
197  1 toggle @Test
198    void failIsLeaf() throws Exception {
199  1 LOGGER.log("TEST CASE: failIsLeaf", LogLevel.DEBUG);
200   
201  1 buildTree();
202  1 assertFalse(treeWalker.isLeaf(
203    treeWalker.getElementByName("01").get(0))
204    );
205    }
206   
 
207  1 toggle @Test
208    void getNodeByUuid() throws Exception {
209  1 LOGGER.log("TEST CASE: getNodeByUuid", LogLevel.DEBUG);
210   
211  1 buildTree();
212  1 String uuid = this.treeWalker.getTree().get(5).getUuid();
213  1 TreeNode<Boolean> fetched = treeWalker.getNodeByUuid(uuid);
214   
215  1 assertEquals(uuid, fetched.getUuid());
216  1 assertEquals("05", fetched.getNodeName());
217    }
218   
 
219  1 toggle @Test
220    void failIsLeafByEmptyTree() {
221  1 LOGGER.log("TEST CASE: failIsLeafByEmptyTree", LogLevel.DEBUG);
222   
223  1 TreeWalker<Boolean> emptyTree = new ListTree<Boolean>();
224  1 assertFalse(emptyTree.isLeaf(new TreeNode<Boolean>("mock")));
225    }
226   
 
227  1 toggle @Test
228    void failGetNodeByUuidByEmptyTree() {
229  1 LOGGER.log("TEST CASE: failGetNodeByUuidByEmptyTree", LogLevel.DEBUG);
230   
231  1 TreeWalker<Boolean> emptyTree = new ListTree<Boolean>();
232  1 assertNull(emptyTree.getNodeByUuid("uuid"));
233    }
234   
 
235  1 toggle @Test
236    void failGetNodeByUuidByUuidNotExist() throws Exception {
237  1 LOGGER.log("TEST CASE: failGetNodeByUuidByUuidNotExist", LogLevel.DEBUG);
238   
239  1 buildTree();
240  1 assertNull(treeWalker.getNodeByUuid("NotExist"));
241    }
242   
 
243  1 toggle @Test
244    void isNodeElementOfTree() throws Exception {
245  1 LOGGER.log("TEST CASE: isNodeElementOfTree", LogLevel.DEBUG);
246   
247  1 buildTree();
248  1 TreeNode<Boolean> node = treeWalker.getElementByName("07").get(0);
249  1 assertTrue(treeWalker.isElementOfTree(node));
250    }
251   
 
252  1 toggle @Test
253    void failNodeIsElementOfTree() {
254  1 LOGGER.log("TEST CASE: failNodeIsElementOfTree", LogLevel.DEBUG);
255   
256  1 assertFalse(new ListTree<Boolean>().isElementOfTree(new TreeNode<>("mock")));
257    }
258   
 
259  1 toggle @Test
260    void failRemoveNode() throws Exception {
261  1 LOGGER.log("TEST CASE: failRemoveNode", LogLevel.DEBUG);
262   
263  1 buildTree();
264  1 assertFalse(treeWalker.removeNode(treeWalker.getTree().get(0)));
265    }
266   
 
267  1 toggle @Test
268    void isNameUnique() throws Exception {
269  1 LOGGER.log("TEST CASE: isNameUnique", LogLevel.DEBUG);
270   
271  1 buildTree();
272  1 assertEquals(1, treeWalker.isNameUnique("05"));
273  1 assertEquals(0, treeWalker.isNameUnique("00"));
274   
275  1 TreeNode<Boolean> node = new TreeNode<>("05");
276  1 node.setParent(treeWalker.getTree().get(3).getUuid());
277  1 treeWalker.addNode(node);
278   
279  1 assertEquals(2, treeWalker.isNameUnique("05"));
280    }
281   
 
282  1 toggle @Test
283    void failIsNameUniqueByEmptyTree() {
284  1 LOGGER.log("TEST CASE: failIsNameUniqueByEmptyTree", LogLevel.DEBUG);
285   
286  1 TreeWalker<Boolean> emptyTree = new ListTree<Boolean>();
287  1 assertEquals(0, emptyTree.isNameUnique("node"));
288    }
289   
 
290  1 toggle @Test
291    void getElementsByName() throws Exception {
292  1 LOGGER.log("TEST CASE: getElementsByName", LogLevel.DEBUG);
293   
294  1 buildTree();
295   
296  1 TreeNode<Boolean> nodeA = new TreeNode<>("05");
297  1 nodeA.setParent(treeWalker.getTree().get(3).getUuid());
298  1 treeWalker.addNode(nodeA);
299  1 TreeNode<Boolean> nodeB = new TreeNode<>("05");
300  1 nodeB.setParent(treeWalker.getTree().get(8).getUuid());
301  1 treeWalker.addNode(nodeB);
302  1 TreeNode<Boolean> nodeC = new TreeNode<>("05");
303  1 nodeC.setParent(treeWalker.getTree().get(2).getUuid());
304  1 treeWalker.addNode(nodeC);
305   
306  1 List<TreeNode<Boolean>> elements = treeWalker.getElementByName("05");
307  1 assertEquals(4, elements.size());
308   
309  1 assertEquals("05", elements.get(0).getNodeName());
310  1 assertEquals("05", elements.get(1).getNodeName());
311  1 assertEquals("05", elements.get(2).getNodeName());
312  1 assertEquals("05", elements.get(3).getNodeName());
313    }
314   
 
315  1 toggle @Test
316    void getElementByNameNotExist() throws Exception {
317  1 LOGGER.log("TEST CASE: getElementsByNameNotExist", LogLevel.DEBUG);
318   
319  1 buildTree();
320  1 assertTrue(treeWalker.getElementByName("foo").isEmpty());
321    }
322   
 
323  1 toggle @Test
324    void getElementByNameInEmptyTree() {
325  1 LOGGER.log("TEST CASE: getElementsByNameInEmptyTree", LogLevel.DEBUG);
326   
327  1 TreeWalker<Boolean> emptyTree = new ListTree<Boolean>();
328  1 assertTrue(emptyTree.getElementByName("foo").isEmpty());
329    }
330   
 
331  1 toggle @Test
332    void pruneRoot() throws Exception {
333  1 LOGGER.log("TEST CASE: pruneRoot", LogLevel.DEBUG);
334   
335  1 buildTree();
336  1 treeWalker.prune(treeWalker.getRoot());
337   
338  1 assertEquals(0, treeWalker.countNodes());
339    }
340   
 
341  1 toggle @Test
342    void pruneLeaf() throws Exception {
343  1 LOGGER.log("TEST CASE: pruneLeaf", LogLevel.DEBUG);
344   
345  1 buildTree();
346   
347  1 TreeNode<Boolean> cuttingNode = treeWalker.getElementByName("11").get(0);
348  1 assertTrue(treeWalker.isLeaf(cuttingNode));
349  1 assertEquals(12, treeWalker.countNodes());
350   
351  1 treeWalker.prune(cuttingNode);
352  1 assertEquals(11, treeWalker.countNodes());
353    }
354   
 
355  1 toggle @Test
356    void pruneElementIsNotInTree() throws Exception {
357  1 LOGGER.log("TEST CASE: pruneElementIsNotInTree", LogLevel.DEBUG);
358   
359  1 buildTree();
360  1 assertEquals(12, treeWalker.countNodes());
361   
362  1 treeWalker.addNode(new TreeNode<Boolean>("the lonley outsider"));
363  1 assertEquals(13, treeWalker.countNodes());
364  1 assertFalse(treeWalker.validateTree(treeWalker.getTree()));
365   
366  1 treeWalker.prune(treeWalker.getElementByName("the lonley outsider").get(0));
367  1 assertEquals(12, treeWalker.countNodes());
368    }
369   
 
370  1 toggle @Test
371    void prune() throws Exception {
372  1 LOGGER.log("TEST CASE: prune", LogLevel.DEBUG);
373   
374  1 buildTree();
375   
376  1 treeWalker.prune(treeWalker.getElementByName("01").get(0));
377  1 assertEquals(8, treeWalker.countNodes());
378  1 LOGGER.log("\n" + treeWalker.toString(), LogLevel.TRACE);
379    }
380   
 
381  1 toggle @Test
382    void failPruneByEmptyTree() throws Exception {
383  1 LOGGER.log("TEST CASE: failPruneByEmptyTree", LogLevel.DEBUG);
384   
385  1 TreeWalker<Boolean> emptyTree = new ListTree<Boolean>();
386  1 assertEquals(0, emptyTree.countNodes());
387  1 assertThrows(Exception.class, () -> {
388  1 emptyTree.prune(new TreeNode<Boolean>("cut me"));
389    });
390    }
391   
 
392  1 toggle @Test
393    void failPruneByEmptyNode() throws Exception {
394  1 LOGGER.log("TEST CASE: failPruneByEmptyNode", LogLevel.DEBUG);
395   
396  1 buildTree();
397  1 assertThrows(Exception.class, () -> {
398  1 treeWalker.prune(null);
399    });
400    }
401   
 
402  1 toggle @Test
403    void merge() throws Exception {
404  1 LOGGER.log("TEST CASE: merge", LogLevel.DEBUG);
405   
406  1 buildTree();
407   
408  1 TreeNode<Boolean> mergeID = treeWalker.getElementByName("03").get(0);
409  1 treeWalker.merge(mergeID.getUuid(), appendTree());
410  1 LOGGER.log("\n" + treeWalker.toString(), LogLevel.TRACE);
411   
412  1 assertEquals(16, treeWalker.countNodes());
413    }
414   
 
415  1 toggle @Test
416    void failMerge() throws Exception {
417  1 LOGGER.log("TEST CASE: failMerge", LogLevel.DEBUG);
418   
419  1 buildTree();
420   
421  1 treeWalker.merge("node", null);
422  1 assertEquals(12, treeWalker.countNodes());
423   
424  1 treeWalker.merge("node", new ListTree<Boolean>());
425  1 assertEquals(12, treeWalker.countNodes());
426    }
427   
 
428  1 toggle @Test
429    void passValidateTree() throws Exception {
430  1 LOGGER.log("TEST CASE: passValidateTree", LogLevel.DEBUG);
431   
432  1 buildTree();
433   
434  1 List<TreeNode<Boolean>> tree = treeWalker.getTree();
435  1 assertTrue(treeWalker.validateTree(tree));
436    }
437   
 
438  1 toggle @Test
439    void failValidateByEmptyTree() throws Exception {
440  1 LOGGER.log("TEST CASE: failValidateByTreeRemoveNode", LogLevel.DEBUG);
441   
442  1 TreeWalker<Boolean> emptyTree = new ListTree<Boolean>();
443  1 assertFalse(emptyTree.validateTree(emptyTree.getTree()));
444    }
445   
 
446  1 toggle @Test
447    void failValidateTreeRemoveNode() throws Exception {
448  1 LOGGER.log("TEST CASE: failValidateTreeRemoveNode", LogLevel.DEBUG);
449   
450  1 buildTree();
451  1 assertFalse(treeWalker.removeNode(treeWalker.getElementByName("05").get(0)));
452  1 assertTrue(treeWalker.validateTree(treeWalker.getTree()));
453    }
454   
 
455  1 toggle @Test
456    void failValidateTreeNodeWithEmptyParent() throws Exception {
457  1 LOGGER.log("TEST CASE: failValidateTreeNodeWithEmptyParent", LogLevel.DEBUG);
458   
459  1 buildTree();
460  1 TreeNode<Boolean> lost_01 = new TreeNode<>("lost");
461  1 treeWalker.addNode(lost_01);
462   
463  1 assertFalse(treeWalker.validateTree(treeWalker.getTree()));
464    }
465   
 
466  1 toggle @Test
467    void failValidateTreeNodeWithDisconnectedParent() throws Exception {
468  1 LOGGER.log("TEST CASE: failValidateTreeNodeWithDisconnectedParent", LogLevel.DEBUG);
469   
470  1 buildTree();
471  1 TreeNode<Boolean> lost_01 = new TreeNode<>("diconnected");
472  1 lost_01.setParent(StringUtils.generateUUID());
473  1 treeWalker.addNode(lost_01);
474   
475  1 TreeNode<Boolean> lost_02 = new TreeNode<>("sub node 01");
476  1 lost_02.setParent(lost_01.getUuid());
477  1 treeWalker.addNode(lost_02);
478  1 TreeNode<Boolean> lost_03 = new TreeNode<>("sub node 02");
479  1 lost_03.setParent(lost_01.getUuid());
480  1 treeWalker.addNode(lost_03);
481   
482  1 assertFalse(treeWalker.validateTree(treeWalker.getTree()));
483    }
484   
 
485  1 toggle @Test
486    void failValidateTreeHasNoRoot() throws Exception {
487  1 LOGGER.log("TEST CASE: failValidateTreeHasNoRoot", LogLevel.DEBUG);
488   
489  1 treeWalker.clear();
490   
491  1 TreeWalker<Boolean> tree = new ListTree<Boolean>();
492  1 TreeNode<Boolean> n_01 = new TreeNode<>("01");
493  1 tree.addNode(n_01);
494  1 TreeNode<Boolean> n_04 = new TreeNode<>("04");
495  1 n_04.setParent(n_01.getUuid());
496  1 tree.addNode(n_04);
497  1 TreeNode<Boolean> n_05 = new TreeNode<>("05");
498  1 n_05.setParent(n_01.getUuid());
499  1 tree.addNode(n_05);
500   
501  1 assertFalse(treeWalker.validateTree(tree.getTree()));
502    }
503   
 
504  1 toggle @Test
505    void failValidateTreeHasMulitpleRoot() throws Exception {
506  1 LOGGER.log("TEST CASE: failValidateTreeHasMulitpleRoot", LogLevel.DEBUG);
507   
508  1 TreeNode<Boolean> node = new TreeNode<>("second ROOT");
509  1 node.setParent("-1");
510  1 treeWalker.addNode(node);
511   
512  1 assertFalse(treeWalker.validateTree(treeWalker.getTree()));
513    }
514   
 
515  24 toggle private void buildTree() throws Exception {
516    //P:0
517  24 TreeNode<Boolean> n_01 = new TreeNode<>("01");
518  24 n_01.setParent(treeWalker.getRoot().getUuid());
519  24 treeWalker.addNode(n_01);
520  24 TreeNode<Boolean> n_02 = new TreeNode<>("02");
521  24 n_02.setParent(treeWalker.getRoot().getUuid());
522  24 treeWalker.addNode(n_02);
523  24 TreeNode<Boolean> n_03 = new TreeNode<>("03");
524  24 n_03.setParent(treeWalker.getRoot().getUuid());
525  24 treeWalker.addNode(n_03);
526    //P:1
527  24 TreeNode<Boolean> n_04 = new TreeNode<>("04");
528  24 n_04.setParent(n_01.getUuid());
529  24 treeWalker.addNode(n_04);
530  24 TreeNode<Boolean> n_05 = new TreeNode<>("05");
531  24 n_05.setParent(n_01.getUuid());
532  24 treeWalker.addNode(n_05);
533    //P:2
534  24 TreeNode<Boolean> n_06 = new TreeNode<>("06");
535  24 n_06.setParent(n_02.getUuid());
536  24 treeWalker.addNode(n_06);
537    //P:3
538  24 TreeNode<Boolean> n_07 = new TreeNode<>("07");
539  24 n_07.setParent(n_03.getUuid());
540  24 treeWalker.addNode(n_07);
541    //P:5
542  24 TreeNode<Boolean> n_08 = new TreeNode<>("08");
543  24 n_08.setParent(n_05.getUuid());
544  24 treeWalker.addNode(n_08);
545    //P:7
546  24 TreeNode<Boolean> n_09 = new TreeNode<>("09");
547  24 n_09.setParent(n_07.getUuid());
548  24 treeWalker.addNode(n_09);
549  24 TreeNode<Boolean> n_10 = new TreeNode<>("10");
550  24 n_10.setParent(n_07.getUuid());
551  24 treeWalker.addNode(n_10);
552    //P:9
553  24 TreeNode<Boolean> n_11 = new TreeNode<>("11");
554  24 n_11.setParent(n_09.getUuid());
555  24 treeWalker.addNode(n_11);
556    }
557   
 
558  1 toggle private TreeWalker<Boolean> appendTree() throws Exception {
559  1 TreeWalker<Boolean> append = new ListTree<Boolean>(new TreeNode<>("sub tree"));
560    //P:0
561  1 TreeNode<Boolean> n_01 = new TreeNode<>("S-01");
562  1 n_01.setParent(append.getRoot().getUuid());
563  1 append.addNode(n_01);
564  1 TreeNode<Boolean> n_02 = new TreeNode<>("S-02");
565  1 n_02.setParent(append.getRoot().getUuid());
566  1 append.addNode(n_02);
567  1 TreeNode<Boolean> n_03 = new TreeNode<>("S-03");
568  1 n_03.setParent(append.getRoot().getUuid());
569  1 append.addNode(n_03);
570   
571  1 return append;
572    }
573    }
  • Report generated by OpenClover v 4.5.2 on Mon Dec 22 2025 15:00:28 CST using coverage data from Mon Dec 22 2025 15:00:14 CST.
  • OpenClover is free and open-source software.