完成 IWithCode 相关接口和 TreeBuilder 的单元测试

Reviewed-on: #1

ProgressOfTesting.txt

@@ -1,7 +1,7 @@
 [x] 无需测试 - 6
 [ ] 未开始测试 - 34
-[-] 测试未完成 - 17
+[-] 测试未完成 - 14
-[Y] 测试完成 - 12
+[Y] 测试完成 - 16
 
 xyz.zhouxy.plusone.commons
     ├───annotation
@@ -17,9 +17,9 @@ xyz.zhouxy.plusone.commons
     │       CharRef.java                          [Y]
     │       DoubleRef.java                        [Y]
     │       IntRef.java                           [Y]
-    │       IWithCode.java                        [-]
+    │       IWithCode.java                        [Y]
-    │       IWithIntCode.java                     [-]
+    │       IWithIntCode.java                     [Y]
-    │       IWithLongCode.java                    [ ]
+    │       IWithLongCode.java                    [Y]
     │       JRE.java                              [ ]
     │       LongRef.java                          [Y]
     │       Ref.java                              [Y]
@@ -97,4 +97,4 @@ xyz.zhouxy.plusone.commons
             RegexTools.java                       [ ]
             SnowflakeIdGenerator.java             [ ]
             StringTools.java                      [Y]
-            TreeBuilder.java                      [-]
+            TreeBuilder.java                      [Y]

src/test/java/xyz/zhouxy/plusone/commons/base/IWithCodeTests.java

@@ -1,22 +1,80 @@
 package xyz.zhouxy.plusone.commons.base;
 
-import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.*;
-import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import javax.annotation.Nonnull;
 
-import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
 import xyz.zhouxy.plusone.commons.util.AssertTools;
 
 class IWithCodeTests {
 
-    private static class WithCodeImpl implements IWithCode<String> {
+    @Test
+    void equalsCode_SameCode_ReturnsTrue() {
+        assertTrue(WithCode.INSTANCE.equalsCode("testCode"));
+        Integer intCode = 0;
+        Long longCode = 0L;
+        assertTrue(WithIntCode.INSTANCE.equalsCode(intCode));
+        assertTrue(WithLongCode.INSTANCE.equalsCode(intCode));
+        assertTrue(WithLongCode.INSTANCE.equalsCode(longCode));
+
+        assertTrue(WithCode.INSTANCE.equalsCode(WithCode.SAME_CODE_INSTANCE));
+        assertTrue(WithIntCode.INSTANCE.equalsCode(WithIntCode.SAME_CODE_INSTANCE));
+        assertTrue(WithIntCode.INSTANCE.equalsCode(WithLongCode.SAME_CODE_INSTANCE));
+        assertTrue(WithLongCode.INSTANCE.equalsCode(WithLongCode.SAME_CODE_INSTANCE));
+        assertTrue(WithLongCode.INSTANCE.equalsCode(WithIntCode.SAME_CODE_INSTANCE));
+    }
+
+    @Test
+    void equalsCode_DifferentCode_ReturnsFalse() {
+        assertFalse(WithCode.INSTANCE.equalsCode("wrongCode"));
+        Integer intCode = 108;
+        Long longCode = 108L;
+        assertFalse(WithIntCode.INSTANCE.equalsCode(intCode));
+        assertFalse(WithLongCode.INSTANCE.equalsCode(intCode));
+        assertFalse(WithLongCode.INSTANCE.equalsCode(longCode));
+
+        assertFalse(WithCode.INSTANCE.equalsCode(WithCode.WRONG_CODE_INSTANCE));
+        assertFalse(WithIntCode.INSTANCE.equalsCode(WithIntCode.WRONG_CODE_INSTANCE));
+        assertFalse(WithIntCode.INSTANCE.equalsCode(WithLongCode.WRONG_CODE_INSTANCE));
+        assertFalse(WithLongCode.INSTANCE.equalsCode(WithLongCode.WRONG_CODE_INSTANCE));
+        assertFalse(WithLongCode.INSTANCE.equalsCode(WithIntCode.WRONG_CODE_INSTANCE));
+    }
+
+    @Test
+    @SuppressWarnings("null")
+    void equalsCode_NullCode_ReturnsFalse() {
+        assertFalse(WithCode.INSTANCE.equalsCode((WithCode) null));
+        assertFalse(WithCode.INSTANCE.equalsCode((WithIntCode) null));
+        assertFalse(WithCode.INSTANCE.equalsCode((WithLongCode) null));
+
+        assertFalse(WithIntCode.INSTANCE.equalsCode((WithCode) null));
+        assertFalse(WithIntCode.INSTANCE.equalsCode((WithIntCode) null));
+        assertFalse(WithIntCode.INSTANCE.equalsCode((WithLongCode) null));
+
+        assertFalse(WithLongCode.INSTANCE.equalsCode((WithCode) null));
+        assertFalse(WithLongCode.INSTANCE.equalsCode((WithIntCode) null));
+        assertFalse(WithLongCode.INSTANCE.equalsCode((WithLongCode) null));
+
+        assertFalse(WithCode.INSTANCE.equalsCode((String) null));
+        Integer intCode = null;
+        Long longCode = null;
+        assertThrows(NullPointerException.class, () -> WithIntCode.INSTANCE.equalsCode(intCode));
+        assertThrows(NullPointerException.class, () -> WithLongCode.INSTANCE.equalsCode(intCode));
+        assertThrows(NullPointerException.class, () -> WithLongCode.INSTANCE.equalsCode(longCode));
+    }
+
+    private static enum WithCode implements IWithCode<String> {
+        INSTANCE("testCode"),
+        SAME_CODE_INSTANCE("testCode"),
+        WRONG_CODE_INSTANCE("wrongCode"),
+        ;
+
         @Nonnull
         private final String code;
 
-        WithCodeImpl(String code) {
+        WithCode(String code) {
             AssertTools.checkNotNull(code);
             this.code = code;
         }
@@ -28,30 +86,39 @@ class IWithCodeTests {
         }
     }
 
-    private WithCodeImpl instance;
+    private static enum WithIntCode implements IWithIntCode {
+        INSTANCE(0),
+        SAME_CODE_INSTANCE(0),
+        WRONG_CODE_INSTANCE(1),
+        ;
 
-    @BeforeEach
+        private final int code;
-    void setUp() {
+
-        instance = new WithCodeImpl("testCode");
+        WithIntCode(int code) {
+            this.code = code;
         }
 
-    @Test
+        @Override
-    void equalsCode_SameCode_ReturnsTrue() {
+        public int getCode() {
-        assertTrue(instance.equalsCode("testCode"));
+            return code;
+        }
     }
 
-    @Test
+    private static enum WithLongCode implements IWithLongCode {
-    void equalsCode_DifferentCode_ReturnsFalse() {
+        INSTANCE(0L),
-        assertFalse(instance.equalsCode("wrongCode"));
+        SAME_CODE_INSTANCE(0L),
+        WRONG_CODE_INSTANCE(108L),
+        ;
+
+        private final long code;
+
+        WithLongCode(long code) {
+            this.code = code;
         }
 
-    @Test
+        @Override
-    void equalsCode_NullCode_ReturnsFalse() {
+        public long getCode() {
-        assertFalse(instance.equalsCode((String) null));
+            return code;
         }
-
-    @Test
-    void equalsCode_NullObject_ReturnsFalse() {
-        assertFalse(instance.equalsCode((String) null));
     }
 }

src/test/java/xyz/zhouxy/plusone/commons/base/IWithIntCodeTests.java

@@ -1,38 +0,0 @@
-package xyz.zhouxy.plusone.commons.base;
-
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-import org.junit.jupiter.api.Test;
-
-class IWithIntCodeTests {
-    @Test
-    void test() {
-        IWithIntCode instance1 = new WithIntCodeImpl(10);
-        IWithIntCode instance2 = new WithIntCodeImpl(20);
-        IWithIntCode instance3 = new WithIntCodeImpl(10);
-
-        // Test for equalsCode method
-        assertTrue(instance1.equalsCode(10));
-        assertFalse(instance1.equalsCode(20));
-        assertTrue(instance2.equalsCode(20));
-        assertTrue(instance3.equalsCode(10));
-
-        // Test for distinct instances with same code
-        assertTrue(instance1.equalsCode(instance3.getCode())); // because they have the same code
-        assertFalse(instance1.equalsCode(instance2.getCode())); // because they have different codes
-    }
-}
-
-class WithIntCodeImpl implements IWithIntCode {
-    private int code;
-
-    public WithIntCodeImpl(int code) {
-        this.code = code;
-    }
-
-    @Override
-    public int getCode() {
-        return code;
-    }
-}

src/test/java/xyz/zhouxy/plusone/commons/util/TreeBuilderTests.java

@@ -16,8 +16,14 @@
 
 package xyz.zhouxy.plusone.commons.util;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 import java.io.Serializable;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
 import java.util.stream.Collectors;
 
@@ -25,54 +31,107 @@ import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Lists;
 import com.google.gson.Gson;
 
 import cn.hutool.core.util.ObjectUtil;
+import lombok.EqualsAndHashCode;
 import lombok.ToString;
 
 class TreeBuilderTests {
 
     private static final Logger log = LoggerFactory.getLogger(TreeBuilderTests.class);
+
+    private final MenuItem A     = MenuItem.of("A", "首页", "/home", 1);
+    private final MenuList B     = MenuList.of("B", "系统管理", 3);
+    private final MenuItem B001  = /**/MenuItem.of("B", "B001", "功能管理", "/sys/function-mgmt", 4);
+    private final MenuItem B002  = /**/MenuItem.of("B", "B002", "角色管理", "/sys/role-mgmt", 3);
+    private final MenuItem B003  = /**/MenuItem.of("B", "B003", "账号管理", "/sys/account-mgmt", 2);
+    private final MenuItem B004  = /**/MenuItem.of("B", "B004", "系统参数管理", "/sys/param-mgmt", 1);
+    private final MenuList C     = MenuList.of("C", "一级菜单C", 2);
+    private final MenuList C1    = /**/MenuList.of("C", "C1", "二级菜单C1", 3);
+    private final MenuItem C1001 = /**//**/MenuItem.of("C1", "C1001", "三级菜单C1001", "/c/c1/c1001", 1);
+    private final MenuItem C1002 = /**//**/MenuItem.of("C1", "C1002", "三级菜单C1002", "/c/c1/c1002", 2);
+    private final MenuItem C2    = /**/MenuItem.of("C", "C2", "二级菜单C2", "/c/c2", 1);
+    private final MenuItem C3    = /**/MenuItem.of("C", "C3", "二级菜单C3", "/c/c3", 2);
+
+    private final List<Menu> menus = ImmutableList.of(B, C1002, A, B004, C3, B001, B003, C1, C1001, B002, C, C2);
+
     private final TreeBuilder<Menu, MenuList, String> treeBuilder = new TreeBuilder<>(
             Menu::getMenuCode,
             menu -> Optional.ofNullable(menu.parentMenuCode),
             MenuList::addChild,
-            (a, b) -> Integer.compare(a.getOrderNum(), b.getOrderNum()));
+            Menu.orderNumComparator);
 
     @Test
-    void testBuildTree() {
+    void testBuildTreeAndSortedByOrderNum() {
-        List<Menu> menus = Lists.newArrayList(
+        List<Menu> clonedMenus = menus.stream().map(ObjectUtil::clone).collect(Collectors.toList());
-                MenuList.of("B", "系统管理", 3),
-                MenuItem.of("A", "首页", "/home", 1),
-                /**/MenuItem.of("B", "B002", "角色管理", "/sys/role-mgmt", 3),
-                /**/MenuItem.of("B", "B001", "功能管理", "/sys/function-mgmt", 4),
-                /**/MenuItem.of("B", "B004", "系统参数管理", "/sys/param-mgmt", 1),
-                /**/MenuItem.of("B", "B003", "账号管理", "/sys/account-mgmt", 2),
-                MenuList.of("C", "一级菜单C", 2),
-                /**/MenuItem.of("C", "C3", "二级菜单C3", "/c/c3", 2),
-                /**/MenuList.of("C", "C1", "二级菜单C1", 2),
-                /**//**/MenuItem.of("C1", "C1001", "三级菜单C1001", "/c/c1/c1001", 1),
-                /**//**/MenuItem.of("C1", "C1002", "三级菜单C1002", "/c/c1/c1002", 2),
-                /**/MenuItem.of("C", "C2", "二级菜单C2", "/c/c2", 1));
-
-        List<Menu> clonedMenus;
-
-        clonedMenus = menus.stream().map(m -> ObjectUtil.clone(m)).collect(Collectors.toList());
         List<Menu> menuTreeSortedByOrderNum = treeBuilder.buildTree(clonedMenus);
         log.info("menuTreeSortedByOrderNum: {}", new Gson().toJson(menuTreeSortedByOrderNum));
 
-        clonedMenus = menus.stream().map(m -> ObjectUtil.clone(m)).collect(Collectors.toList());
+        assertEquals(clonedMenus.stream()
+                .filter(menu -> menu.getParentMenuCode() == null)
+                .sorted(Menu.orderNumComparator)
+                .collect(Collectors.toList()),
+                menuTreeSortedByOrderNum);
+
+        Map<String, Menu> menuMap = new HashMap<>();
+        for (Menu element : clonedMenus) {
+            menuMap.put(element.getMenuCode(), element);
+        }
+
+        assertEquals(Arrays.stream(new Menu[] { B001, B002, B003, B004 })
+                .sorted(Menu.orderNumComparator)
+                .collect(Collectors.toList()),
+                MenuList.class.cast(menuMap.get("B")).children);
+
+        assertEquals(Arrays.stream(new Menu[] { C1, C2, C3 })
+                .sorted(Menu.orderNumComparator)
+                .collect(Collectors.toList()),
+                MenuList.class.cast(menuMap.get("C")).children);
+
+        assertEquals(Arrays.stream(new Menu[] { C1001, C1002 })
+                .sorted(Menu.orderNumComparator)
+                .collect(Collectors.toList()),
+                MenuList.class.cast(menuMap.get("C1")).children);
+
+    }
+
+    @Test
+    void testBuildTreeAndSortedByMenuCode() {
+        List<Menu> clonedMenus;
+
+        clonedMenus = menus.stream().map(ObjectUtil::clone).collect(Collectors.toList());
         List<Menu> menuTreeSortedByMenuCode = treeBuilder.buildTree(
                 clonedMenus,
-                (a, b) -> a.getMenuCode().compareTo(b.getMenuCode())
+                (a, b) -> a.getMenuCode().compareTo(b.getMenuCode()));
-        );
         log.info("menuTreeSortedByMenuCode: {}", new Gson().toJson(menuTreeSortedByMenuCode));
-    }
-}
 
-@ToString
+        assertEquals(clonedMenus.stream()
-abstract class Menu implements Serializable {
+                .filter(menu -> menu.getParentMenuCode() == null)
+                .sorted((a, b) -> a.getMenuCode().compareTo(b.getMenuCode()))
+                .collect(Collectors.toList()),
+                menuTreeSortedByMenuCode);
+
+        Map<String, Menu> menuMap = new HashMap<>();
+        for (Menu element : clonedMenus) {
+            menuMap.put(element.getMenuCode(), element);
+        }
+
+        assertEquals(ImmutableList.of(B001, B002, B003, B004),
+                MenuList.class.cast(menuMap.get("B")).children);
+
+        assertEquals(ImmutableList.of(C1, C2, C3),
+                MenuList.class.cast(menuMap.get("C")).children);
+
+        assertEquals(ImmutableList.of(C1001, C1002),
+                MenuList.class.cast(menuMap.get("C1")).children);
+    }
+
+    @ToString
+    @EqualsAndHashCode
+    private static abstract class Menu implements Serializable { // NOSONAR
         protected final String parentMenuCode;
         protected final String menuCode;
         protected final String title;
@@ -101,11 +160,15 @@ abstract class Menu implements Serializable {
             return orderNum;
         }
 
-    private static final long serialVersionUID = 20240917181424L;
+        public static Comparator<Menu> orderNumComparator =
-}
+                (a, b) -> Integer.compare(a.getOrderNum(), b.getOrderNum());
 
-@ToString(callSuper = true)
+        private static final long serialVersionUID = 20240917181424L;
-class MenuItem extends Menu {
+    }
+
+    @ToString(callSuper = true)
+    @EqualsAndHashCode(callSuper = true)
+    private static final class MenuItem extends Menu {
 
         private final String url;
 
@@ -127,10 +190,10 @@ class MenuItem extends Menu {
         }
 
         private static final long serialVersionUID = 20240917181910L;
-}
+    }
 
-@ToString(callSuper = true)
+    @ToString(callSuper = true)
-class MenuList extends Menu {
+    private static final class MenuList extends Menu {
 
         private List<Menu> children;
 
@@ -146,11 +209,13 @@ class MenuList extends Menu {
             return new MenuList(null, menuCode, title, orderNum);
         }
 
+        @SuppressWarnings("unused")
         static MenuList of(String menuCode, String title, Iterable<Menu> children, int orderNum) {
             return of(null, menuCode, title, children, orderNum);
         }
 
-    static MenuList of(String parentMenuCode, String menuCode, String title, Iterable<Menu> children, int orderNum) {
+        static MenuList of(String parentMenuCode, String menuCode, String title, Iterable<Menu> children,
+                int orderNum) {
             final MenuList instance = of(parentMenuCode, menuCode, title, orderNum);
             children.forEach(instance::addChild);
             return instance;
@@ -164,4 +229,5 @@ class MenuList extends Menu {
         }
 
         private static final long serialVersionUID = 20240917181917L;
+    }
 }