Clover icon

together Platform [Module:core] - Coverage Report

  1. Project Clover database Wed Jan 17 2024 23:40:18 CST
  2. Package org.europa.together.application

File ListTreeTest.java

 

Code metrics

0
259
47
1
574
437
47
0.18
5.51
47
1

Classes

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