fix bug

hutool-core/src/main/java/org/dromara/hutool/core/collection/CollUtil.java

@@ -409,11 +409,18 @@ public class CollUtil {
 		}
 
 		Collection<T> result = ObjUtil.clone(coll1);
-		if (null == result) {
+		try {
-			result = CollUtil.create(coll1.getClass());
+			if (null == result) {
+				result = CollUtil.create(coll1.getClass());
+				result.addAll(coll1);
+			}
+			result.removeAll(coll2);
+		} catch (UnsupportedOperationException e) {
+			// 针对 coll1 为只读集合的补偿
+			result = CollUtil.create(AbstractCollection.class);
 			result.addAll(coll1);
+			result.removeAll(coll2);
 		}
-		result.removeAll(coll2);
 		return result;
 	}
 

hutool-core/src/test/java/org/dromara/hutool/core/collection/CollUtilTest.java

@@ -31,8 +31,7 @@ import org.junit.jupiter.api.Test;
 import java.util.*;
 import java.util.function.Function;
 
-import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.*;
-import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
  * 集合工具类单元测试
@@ -46,11 +45,11 @@ public class CollUtilTest {
 	public void emptyIfNullTest() {
 		final Set<?> set = null;
 		final Set<?> set1 = CollUtil.emptyIfNull(set);
-		Assertions.assertEquals(SetUtil.empty(), set1);
+		assertEquals(SetUtil.empty(), set1);
 
 		final List<?> list = null;
 		final List<?> list1 = CollUtil.emptyIfNull(list);
-		Assertions.assertEquals(ListUtil.empty(), list1);
+		assertEquals(ListUtil.empty(), list1);
 	}
 
 	@SuppressWarnings("ConstantConditions")
@@ -72,16 +71,16 @@ public class CollUtilTest {
 	@Test
 	public void defaultIfEmpty() {
 		List<String> strings = CollUtil.defaultIfEmpty(ListUtil.of(), ListUtil.of("1"));
-		Assertions.assertEquals(ListUtil.of("1"), strings);
+		assertEquals(ListUtil.of("1"), strings);
 
 		strings = CollUtil.defaultIfEmpty(null, ListUtil.of("1"));
-		Assertions.assertEquals(ListUtil.of("1"), strings);
+		assertEquals(ListUtil.of("1"), strings);
 	}
 
 	@Test
 	public void defaultIfEmpty2() {
 		final List<String> strings = CollUtil.defaultIfEmpty(ListUtil.of(), Function.identity(), () -> ListUtil.of("1"));
-		Assertions.assertEquals(ListUtil.of("1"), strings);
+		assertEquals(ListUtil.of("1"), strings);
 	}
 
 	@Test
@@ -98,14 +97,14 @@ public class CollUtilTest {
 		final List<Integer> exceptResultList = ListUtil.of(1);
 
 		List<Integer> resultList = CollUtil.removeWithAddIf(list, ele -> 1 == ele);
-		Assertions.assertEquals(list, exceptRemovedList);
+		assertEquals(list, exceptRemovedList);
-		Assertions.assertEquals(resultList, exceptResultList);
+		assertEquals(resultList, exceptResultList);
 
 		list = ListUtil.of(1, 2, 3);
 		resultList = new ArrayList<>();
 		CollUtil.removeWithAddIf(list, resultList, ele -> 1 == ele);
-		Assertions.assertEquals(list, exceptRemovedList);
+		assertEquals(list, exceptRemovedList);
-		Assertions.assertEquals(resultList, exceptResultList);
+		assertEquals(resultList, exceptResultList);
 	}
 
 	@Test
@@ -114,17 +113,17 @@ public class CollUtilTest {
 		List<String> answerList = ListUtil.of("a", "b");
 		CollUtil.padLeft(srcList, 1, "b");
 		CollUtil.padLeft(srcList, 2, "a");
-		Assertions.assertEquals(srcList, answerList);
+		assertEquals(srcList, answerList);
 
 		srcList = ListUtil.of("a", "b");
 		answerList = ListUtil.of("a", "b");
 		CollUtil.padLeft(srcList, 2, "a");
-		Assertions.assertEquals(srcList, answerList);
+		assertEquals(srcList, answerList);
 
 		srcList = ListUtil.of("c");
 		answerList = ListUtil.of("a", "a", "c");
 		CollUtil.padLeft(srcList, 3, "a");
-		Assertions.assertEquals(srcList, answerList);
+		assertEquals(srcList, answerList);
 	}
 
 	@Test
@@ -132,7 +131,7 @@ public class CollUtilTest {
 		final List<String> srcList = ListUtil.of("a");
 		final List<String> answerList = ListUtil.of("a", "b", "b", "b", "b");
 		CollUtil.padRight(srcList, 5, "b");
-		Assertions.assertEquals(srcList, answerList);
+		assertEquals(srcList, answerList);
 	}
 
 	@SuppressWarnings("ConstantValue")
@@ -154,7 +153,7 @@ public class CollUtilTest {
 
 		final Collection<String> union = CollUtil.union(list1, list2);
 
-		Assertions.assertEquals(3, CollUtil.count(union, "b"::equals));
+		assertEquals(3, CollUtil.count(union, "b"::equals));
 	}
 
 	@Test
@@ -163,8 +162,8 @@ public class CollUtilTest {
 		final List<String> list2 = ListUtil.of("a", "b", "b", "b", "c", "d");
 
 		final Collection<String> intersection = CollUtil.intersection(list1, list2);
-		Assertions.assertEquals(2, CollUtil.count(intersection, "b"::equals));
+		assertEquals(2, CollUtil.count(intersection, "b"::equals));
-		Assertions.assertEquals(0, CollUtil.count(intersection, "x"::equals));
+		assertEquals(0, CollUtil.count(intersection, "x"::equals));
 	}
 
 	@Test
@@ -174,7 +173,7 @@ public class CollUtilTest {
 		final List<String> list3 = ListUtil.of();
 
 		final Collection<String> intersectionDistinct = CollUtil.intersectionDistinct(list1, list2);
-		Assertions.assertEquals(SetUtil.ofLinked("a", "b", "c", "d"), intersectionDistinct);
+		assertEquals(SetUtil.ofLinked("a", "b", "c", "d"), intersectionDistinct);
 
 		final Collection<String> intersectionDistinct2 = CollUtil.intersectionDistinct(list1, list2, list3);
 		Console.log(intersectionDistinct2);
@@ -204,9 +203,9 @@ public class CollUtilTest {
 		final List<String> list2 = ListUtil.of("a", "b", "b", "b", "c", "d", "x2");
 
 		final Collection<String> disjunction = CollUtil.disjunction(list1, list2);
-		Assertions.assertEquals(list2, disjunction);
+		assertEquals(list2, disjunction);
 		final Collection<String> disjunction2 = CollUtil.disjunction(list2, list1);
-		Assertions.assertEquals(list2, disjunction2);
+		assertEquals(list2, disjunction2);
 	}
 
 	@Test
@@ -236,8 +235,8 @@ public class CollUtilTest {
 		final List<String> list1 = ListUtil.of("a", "b", "b", "c", "d", "x");
 		final List<String> list2 = ListUtil.of("a", "b", "b", "b", "c", "d", "x2");
 		final Collection<String> subtract = CollUtil.subtract(list1, list2);
-		Assertions.assertEquals(1, subtract.size());
+		assertEquals(1, subtract.size());
-		Assertions.assertEquals("x", subtract.iterator().next());
+		assertEquals("x", subtract.iterator().next());
 	}
 
 	@Test
@@ -248,7 +247,7 @@ public class CollUtilTest {
 		map1.put("2", "v2");
 		map2.put("2", "v2");
 		final Collection<String> r2 = CollUtil.subtract(map1.keySet(), map2.keySet());
-		Assertions.assertEquals("[1]", r2.toString());
+		assertEquals("[1]", r2.toString());
 	}
 
 	@Test
@@ -259,7 +258,7 @@ public class CollUtilTest {
 		map1.put("2", "v2");
 		map2.put("2", "v2");
 		final List<String> r2 = CollUtil.subtractToList(map1.keySet(), map2.keySet());
-		Assertions.assertEquals("[1]", r2.toString());
+		assertEquals("[1]", r2.toString());
 	}
 
 	@Test
@@ -275,13 +274,13 @@ public class CollUtilTest {
 		// ----------------------------------------------------------------------------------------
 		final List<HashMap<String, String>> list = ListUtil.of(map1, map2);
 		final Map<String, List<String>> map = CollUtil.toListMap(list);
-		Assertions.assertEquals("值1", map.get("a").get(0));
+		assertEquals("值1", map.get("a").get(0));
-		Assertions.assertEquals("值2", map.get("a").get(1));
+		assertEquals("值2", map.get("a").get(1));
 
 		// ----------------------------------------------------------------------------------------
 		final List<Map<String, String>> listMap = CollUtil.toMapList(map);
-		Assertions.assertEquals("值1", listMap.get(0).get("a"));
+		assertEquals("值1", listMap.get(0).get("a"));
-		Assertions.assertEquals("值2", listMap.get(1).get("a"));
+		assertEquals("值2", listMap.get(1).get("a"));
 	}
 
 	@Test
@@ -292,24 +291,24 @@ public class CollUtilTest {
 
 		final List<Object> fieldValues = (List<Object>) CollUtil.getFieldValues(list, "name");
 
-		Assertions.assertEquals("张三", fieldValues.get(0));
+		assertEquals("张三", fieldValues.get(0));
-		Assertions.assertEquals("李四", fieldValues.get(1));
+		assertEquals("李四", fieldValues.get(1));
 	}
 
 	@Test
 	public void partitionTest() {
 		final List<Integer> list = ListUtil.of(1, 2, 3, 4, 5, 6, 7, 8, 9);
 		final List<List<Integer>> split = CollUtil.partition(list, 3);
-		Assertions.assertEquals(3, split.size());
+		assertEquals(3, split.size());
-		Assertions.assertEquals(3, split.get(0).size());
+		assertEquals(3, split.get(0).size());
 	}
 
 	@Test
 	public void partitionTest2() {
 		final ArrayList<Integer> list = ListUtil.of(1, 2, 3, 4, 5, 6, 7, 8, 9);
 		final List<List<Integer>> split = CollUtil.partition(list, Integer.MAX_VALUE);
-		Assertions.assertEquals(1, split.size());
+		assertEquals(1, split.size());
-		Assertions.assertEquals(9, split.get(0).size());
+		assertEquals(9, split.get(0).size());
 	}
 
 	@Test
@@ -326,7 +325,7 @@ public class CollUtilTest {
 				result[0] = value;
 			}
 		});
-		Assertions.assertEquals("1", result[0]);
+		assertEquals("1", result[0]);
 	}
 
 	@Test
@@ -335,7 +334,7 @@ public class CollUtilTest {
 
 		final Collection<String> filtered = CollUtil.edit(list, t -> t + 1);
 
-		Assertions.assertEquals(ListUtil.of("a1", "b1", "c1"), filtered);
+		assertEquals(ListUtil.of("a1", "b1", "c1"), filtered);
 	}
 
 	@Test
@@ -346,7 +345,7 @@ public class CollUtilTest {
 
 		// 原地过滤
 		Assertions.assertSame(list, filtered);
-		Assertions.assertEquals(ListUtil.of("b", "c"), filtered);
+		assertEquals(ListUtil.of("b", "c"), filtered);
 	}
 
 	@Test
@@ -354,7 +353,7 @@ public class CollUtilTest {
 		final Set<String> set = SetUtil.ofLinked("a", "b", "", "  ", "c");
 		final Set<String> filtered = CollUtil.remove(set, StrUtil::isBlank);
 
-		Assertions.assertEquals(SetUtil.ofLinked("a", "b", "c"), filtered);
+		assertEquals(SetUtil.ofLinked("a", "b", "c"), filtered);
 	}
 
 	@Test
@@ -370,12 +369,12 @@ public class CollUtilTest {
 			return false;
 		});
 
-		Assertions.assertEquals(1, removed.size());
+		assertEquals(1, removed.size());
-		Assertions.assertEquals("a", removed.get(0));
+		assertEquals("a", removed.get(0));
 
 		// 原地过滤
 		Assertions.assertSame(list, filtered);
-		Assertions.assertEquals(ListUtil.of("b", "c"), filtered);
+		assertEquals(ListUtil.of("b", "c"), filtered);
 	}
 
 	@Test
@@ -386,7 +385,7 @@ public class CollUtilTest {
 
 		// 原地过滤
 		Assertions.assertSame(list, filtered);
-		Assertions.assertEquals(ListUtil.of("a", "b", "c", "", "  "), filtered);
+		assertEquals(ListUtil.of("a", "b", "c", "", "  "), filtered);
 	}
 
 	@Test
@@ -397,7 +396,7 @@ public class CollUtilTest {
 
 		// 原地过滤
 		Assertions.assertSame(list, filtered);
-		Assertions.assertEquals(ListUtil.of("a", "b", "c", "  "), filtered);
+		assertEquals(ListUtil.of("a", "b", "c", "  "), filtered);
 	}
 
 	@Test
@@ -408,7 +407,7 @@ public class CollUtilTest {
 
 		// 原地过滤
 		Assertions.assertSame(list, filtered);
-		Assertions.assertEquals(ListUtil.of("a", "b", "c"), filtered);
+		assertEquals(ListUtil.of("a", "b", "c"), filtered);
 	}
 
 	@Test
@@ -421,38 +420,38 @@ public class CollUtilTest {
 			// 按照奇数偶数分类
 			return Integer.parseInt(t) % 2;
 		});
-		Assertions.assertEquals(ListUtil.of("2", "4", "6"), group2.get(0));
+		assertEquals(ListUtil.of("2", "4", "6"), group2.get(0));
-		Assertions.assertEquals(ListUtil.of("1", "3", "5"), group2.get(1));
+		assertEquals(ListUtil.of("1", "3", "5"), group2.get(1));
 	}
 
 	@Test
 	public void groupByFieldTest() {
 		final List<TestBean> list = ListUtil.of(new TestBean("张三", 12), new TestBean("李四", 13), new TestBean("王五", 12));
 		final List<List<TestBean>> groupByField = CollUtil.groupByField(list, "age");
-		Assertions.assertEquals("张三", groupByField.get(0).get(0).getName());
+		assertEquals("张三", groupByField.get(0).get(0).getName());
-		Assertions.assertEquals("王五", groupByField.get(0).get(1).getName());
+		assertEquals("王五", groupByField.get(0).get(1).getName());
 
-		Assertions.assertEquals("李四", groupByField.get(1).get(0).getName());
+		assertEquals("李四", groupByField.get(1).get(0).getName());
 	}
 
 	@Test
 	public void groupByFuncTest() {
 		final List<TestBean> list = ListUtil.of(new TestBean("张三", 12), new TestBean("李四", 13), new TestBean("王五", 12));
 		final List<List<TestBean>> groupByField = CollUtil.groupByFunc(list, TestBean::getAge);
-		Assertions.assertEquals("张三", groupByField.get(0).get(0).getName());
+		assertEquals("张三", groupByField.get(0).get(0).getName());
-		Assertions.assertEquals("王五", groupByField.get(0).get(1).getName());
+		assertEquals("王五", groupByField.get(0).get(1).getName());
 
-		Assertions.assertEquals("李四", groupByField.get(1).get(0).getName());
+		assertEquals("李四", groupByField.get(1).get(0).getName());
 	}
 
 	@Test
 	public void groupByFunc2Test() {
 		final List<TestBean> list = ListUtil.of(new TestBean("张三", 12), new TestBean("李四", 13), new TestBean("王五", 12));
 		final List<List<TestBean>> groupByField = CollUtil.groupByFunc(list, a -> a.getAge() > 12);
-		Assertions.assertEquals("张三", groupByField.get(0).get(0).getName());
+		assertEquals("张三", groupByField.get(0).get(0).getName());
-		Assertions.assertEquals("王五", groupByField.get(0).get(1).getName());
+		assertEquals("王五", groupByField.get(0).get(1).getName());
 
-		Assertions.assertEquals("李四", groupByField.get(1).get(0).getName());
+		assertEquals("李四", groupByField.get(1).get(0).getName());
 	}
 
 	@Test
@@ -464,9 +463,9 @@ public class CollUtilTest {
 		);
 
 		CollUtil.sortByProperty(list, "createTime");
-		Assertions.assertEquals("李四", list.get(0).getName());
+		assertEquals("李四", list.get(0).getName());
-		Assertions.assertEquals("王五", list.get(1).getName());
+		assertEquals("王五", list.get(1).getName());
-		Assertions.assertEquals("张三", list.get(2).getName());
+		assertEquals("张三", list.get(2).getName());
 	}
 
 	@Test
@@ -478,9 +477,9 @@ public class CollUtilTest {
 		);
 
 		CollUtil.sortByProperty(list, "age");
-		Assertions.assertEquals("李四", list.get(0).getName());
+		assertEquals("李四", list.get(0).getName());
-		Assertions.assertEquals("张三", list.get(1).getName());
+		assertEquals("张三", list.get(1).getName());
-		Assertions.assertEquals("王五", list.get(2).getName());
+		assertEquals("王五", list.get(2).getName());
 	}
 
 	@Test
@@ -491,9 +490,9 @@ public class CollUtilTest {
 		);
 
 		final Map<String, TestBean> map = CollUtil.fieldValueMap(list, "name");
-		Assertions.assertEquals("李四", map.get("李四").getName());
+		assertEquals("李四", map.get("李四").getName());
-		Assertions.assertEquals("王五", map.get("王五").getName());
+		assertEquals("王五", map.get("王五").getName());
-		Assertions.assertEquals("张三", map.get("张三").getName());
+		assertEquals("张三", map.get("张三").getName());
 	}
 
 	@Test
@@ -504,21 +503,21 @@ public class CollUtilTest {
 		);
 
 		final Map<String, Integer> map = CollUtil.fieldValueAsMap(list, "name", "age");
-		Assertions.assertEquals(Integer.valueOf(12), map.get("张三"));
+		assertEquals(Integer.valueOf(12), map.get("张三"));
-		Assertions.assertEquals(Integer.valueOf(13), map.get("李四"));
+		assertEquals(Integer.valueOf(13), map.get("李四"));
-		Assertions.assertEquals(Integer.valueOf(14), map.get("王五"));
+		assertEquals(Integer.valueOf(14), map.get("王五"));
 	}
 
 	@Test
 	public void emptyTest() {
 		final SortedSet<String> emptySortedSet = CollUtil.empty(SortedSet.class);
-		Assertions.assertEquals(Collections.emptySortedSet(), emptySortedSet);
+		assertEquals(Collections.emptySortedSet(), emptySortedSet);
 
 		final Set<String> emptySet = CollUtil.empty(Set.class);
-		Assertions.assertEquals(Collections.emptySet(), emptySet);
+		assertEquals(Collections.emptySet(), emptySet);
 
 		final List<String> emptyList = CollUtil.empty(List.class);
-		Assertions.assertEquals(Collections.emptyList(), emptyList);
+		assertEquals(Collections.emptyList(), emptyList);
 	}
 
 	@Data
@@ -547,8 +546,8 @@ public class CollUtilTest {
 	public void listTest2() {
 		final List<String> list1 = ListUtil.of("a", "b", "c");
 		final List<String> list2 = ListUtil.ofLinked("a", "b", "c");
-		Assertions.assertEquals("[a, b, c]", list1.toString());
+		assertEquals("[a, b, c]", list1.toString());
-		Assertions.assertEquals("[a, b, c]", list2.toString());
+		assertEquals("[a, b, c]", list2.toString());
 	}
 
 	@Test
@@ -560,18 +559,18 @@ public class CollUtilTest {
 
 		final List<String> list1 = ListUtil.of(false, set);
 		final List<String> list2 = ListUtil.of(true, set);
-		Assertions.assertEquals("[a, b, c]", list1.toString());
+		assertEquals("[a, b, c]", list1.toString());
-		Assertions.assertEquals("[a, b, c]", list2.toString());
+		assertEquals("[a, b, c]", list2.toString());
 	}
 
 	@Test
 	public void getTest() {
 		final HashSet<String> set = SetUtil.ofLinked("A", "B", "C", "D");
 		String str = CollUtil.get(set, 2);
-		Assertions.assertEquals("C", str);
+		assertEquals("C", str);
 
 		str = CollUtil.get(set, -1);
-		Assertions.assertEquals("D", str);
+		assertEquals("D", str);
 	}
 
 	@Test
@@ -587,7 +586,7 @@ public class CollUtilTest {
 		// Assert result
 		final List<Integer> arrayList = new ArrayList<>();
 		arrayList.add(null);
-		Assertions.assertEquals(arrayList, retval);
+		assertEquals(arrayList, retval);
 	}
 
 	@Test
@@ -604,7 +603,7 @@ public class CollUtilTest {
 		// Assert result
 		final List<Integer> arrayList = new ArrayList<>();
 		arrayList.add(null);
-		Assertions.assertEquals(arrayList, retval);
+		assertEquals(arrayList, retval);
 	}
 
 	@Test
@@ -619,7 +618,7 @@ public class CollUtilTest {
 
 		// Assert result
 		final List<Integer> arrayList = new ArrayList<>();
-		Assertions.assertEquals(arrayList, retval);
+		assertEquals(arrayList, retval);
 	}
 
 	@Test
@@ -647,7 +646,7 @@ public class CollUtilTest {
 		final List<Integer> retval = CollUtil.sub(list, start, end, step);
 		// Assert result
 		final List<Integer> arrayList = new ArrayList<>();
-		Assertions.assertEquals(arrayList, retval);
+		assertEquals(arrayList, retval);
 	}
 
 	@Test
@@ -662,7 +661,7 @@ public class CollUtilTest {
 		final List<Integer> retval = CollUtil.sub(list, start, end, step);
 		// Assert result
 		final List<Integer> arrayList = new ArrayList<>();
-		Assertions.assertEquals(arrayList, retval);
+		assertEquals(arrayList, retval);
 	}
 
 	@Test
@@ -706,7 +705,7 @@ public class CollUtilTest {
 		final List<Integer> retval = CollUtil.sub(list, start, end, step);
 		// Assert result
 		final List<Integer> arrayList = new ArrayList<>();
-		Assertions.assertEquals(arrayList, retval);
+		assertEquals(arrayList, retval);
 	}
 
 	@Test
@@ -721,7 +720,7 @@ public class CollUtilTest {
 		final List<Integer> retval = CollUtil.sub(list, start, end, step);
 		// Assert result
 		final List<Integer> arrayList = new ArrayList<>();
-		Assertions.assertEquals(arrayList, retval);
+		assertEquals(arrayList, retval);
 	}
 
 	@Test
@@ -736,7 +735,7 @@ public class CollUtilTest {
 		final List<Integer> retval = CollUtil.sub(list, start, end, step);
 		// Assert result
 		final List<Integer> arrayList = new ArrayList<>();
-		Assertions.assertEquals(arrayList, retval);
+		assertEquals(arrayList, retval);
 	}
 
 	@Test
@@ -756,7 +755,7 @@ public class CollUtilTest {
 		final List<Integer> list = ListUtil.of(1, 2, 3, 4, 5, 6, 7, 8, 9);
 		final List<Integer> sortPageAll = CollUtil.sortPageAll(1, 5, Comparator.reverseOrder(), list);
 
-		Assertions.assertEquals(ListUtil.of(4, 3, 2, 1), sortPageAll);
+		assertEquals(ListUtil.of(4, 3, 2, 1), sortPageAll);
 	}
 
 	@Test
@@ -793,22 +792,22 @@ public class CollUtilTest {
 
 		final Map<String, Integer> map = CollUtil.zip(keys, values);
 
-		Assertions.assertEquals(4, Objects.requireNonNull(map).size());
+		assertEquals(4, Objects.requireNonNull(map).size());
 
-		Assertions.assertEquals(1, map.get("a").intValue());
+		assertEquals(1, map.get("a").intValue());
-		Assertions.assertEquals(2, map.get("b").intValue());
+		assertEquals(2, map.get("b").intValue());
-		Assertions.assertEquals(3, map.get("c").intValue());
+		assertEquals(3, map.get("c").intValue());
-		Assertions.assertEquals(4, map.get("d").intValue());
+		assertEquals(4, map.get("d").intValue());
 	}
 
 	@Test
 	public void toMapTest() {
 		final Collection<String> keys = ListUtil.of("a", "b", "c", "d");
 		final Map<String, String> map = IterUtil.toMap(keys, (value) -> "key" + value);
-		Assertions.assertEquals("a", map.get("keya"));
+		assertEquals("a", map.get("keya"));
-		Assertions.assertEquals("b", map.get("keyb"));
+		assertEquals("b", map.get("keyb"));
-		Assertions.assertEquals("c", map.get("keyc"));
+		assertEquals("c", map.get("keyc"));
-		Assertions.assertEquals("d", map.get("keyd"));
+		assertEquals("d", map.get("keyd"));
 	}
 
 	@Test
@@ -822,9 +821,9 @@ public class CollUtilTest {
 			Map.Entry::getKey,
 			entry -> Long.parseLong(entry.getValue()));
 
-		Assertions.assertEquals(1L, (long) map.get("a"));
+		assertEquals(1L, (long) map.get("a"));
-		Assertions.assertEquals(12L, (long) map.get("b"));
+		assertEquals(12L, (long) map.get("b"));
-		Assertions.assertEquals(134L, (long) map.get("c"));
+		assertEquals(134L, (long) map.get("c"));
 	}
 
 	@Test
@@ -832,17 +831,17 @@ public class CollUtilTest {
 		final List<String> list = ListUtil.of("a", "b", "c", "c", "a", "b", "d");
 		final Map<String, Integer> countMap = CollUtil.countMap(list);
 
-		Assertions.assertEquals(Integer.valueOf(2), countMap.get("a"));
+		assertEquals(Integer.valueOf(2), countMap.get("a"));
-		Assertions.assertEquals(Integer.valueOf(2), countMap.get("b"));
+		assertEquals(Integer.valueOf(2), countMap.get("b"));
-		Assertions.assertEquals(Integer.valueOf(2), countMap.get("c"));
+		assertEquals(Integer.valueOf(2), countMap.get("c"));
-		Assertions.assertEquals(Integer.valueOf(1), countMap.get("d"));
+		assertEquals(Integer.valueOf(1), countMap.get("d"));
 	}
 
 	@Test
 	public void indexOfTest() {
 		final List<String> list = ListUtil.of("a", "b", "c", "c", "a", "b", "d");
 		final int i = CollUtil.indexOf(list, (str) -> str.charAt(0) == 'c');
-		Assertions.assertEquals(2, i);
+		assertEquals(2, i);
 	}
 
 	@Test
@@ -850,13 +849,13 @@ public class CollUtilTest {
 		// List有优化
 		final List<String> list = ListUtil.of("a", "b", "c", "c", "a", "b", "d");
 		final int i = CollUtil.lastIndexOf(list, (str) -> str.charAt(0) == 'a');
-		Assertions.assertEquals(4, i);
+		assertEquals(4, i);
 
 		final Queue<Integer> set = new ArrayDeque<>(Arrays.asList(1, 2, 3, 3, 2, 1));
-		Assertions.assertEquals(5, CollUtil.lastIndexOf(set, num -> num.equals(1)));
+		assertEquals(5, CollUtil.lastIndexOf(set, num -> num.equals(1)));
-		Assertions.assertEquals(4, CollUtil.lastIndexOf(set, num -> num.equals(2)));
+		assertEquals(4, CollUtil.lastIndexOf(set, num -> num.equals(2)));
-		Assertions.assertEquals(3, CollUtil.lastIndexOf(set, num -> num.equals(3)));
+		assertEquals(3, CollUtil.lastIndexOf(set, num -> num.equals(3)));
-		Assertions.assertEquals(-1, CollUtil.lastIndexOf(set, num -> num.equals(4)));
+		assertEquals(-1, CollUtil.lastIndexOf(set, num -> num.equals(4)));
 	}
 
 	@Test
@@ -864,7 +863,7 @@ public class CollUtilTest {
 		final Set<String> list = SetUtil.ofLinked("a", "b", "c", "c", "a", "b", "d");
 		// 去重后c排第三
 		final int i = CollUtil.lastIndexOf(list, (str) -> str.charAt(0) == 'c');
-		Assertions.assertEquals(2, i);
+		assertEquals(2, i);
 	}
 
 	@Test
@@ -874,7 +873,7 @@ public class CollUtilTest {
 			objects.add(Dict.of().set("name", "姓名：" + i));
 		}
 
-		Assertions.assertEquals(0, ListUtil.page(objects, 3, 5).size());
+		assertEquals(0, ListUtil.page(objects, 3, 5).size());
 	}
 
 	@Test
@@ -883,15 +882,15 @@ public class CollUtilTest {
 		final List<Long> list2 = Arrays.asList(2L, 3L);
 
 		final List<Long> result = CollUtil.subtractToList(list1, list2);
-		Assertions.assertEquals(1, result.size());
+		assertEquals(1, result.size());
-		Assertions.assertEquals(1L, (long) result.get(0));
+		assertEquals(1L, (long) result.get(0));
 	}
 
 	@Test
 	public void sortNaturalTest() {
 		final List<String> of = ListUtil.of("a", "c", "b");
 		final List<String> sort = CollUtil.sort(of, CompareUtil.natural());
-		Assertions.assertEquals("a,b,c", CollUtil.join(sort, ","));
+		assertEquals("a,b,c", CollUtil.join(sort, ","));
 	}
 
 	@Test
@@ -914,9 +913,9 @@ public class CollUtilTest {
 		genderMap.put(5, "小孩");
 		genderMap.put(6, "男");
 
-		Assertions.assertEquals(people.get(1).getGender(), "woman");
+		assertEquals("woman", people.get(1).getGender());
 		CollUtil.setValueByMap(people, genderMap, Person::getId, Person::setGender);
-		Assertions.assertEquals(people.get(1).getGender(), "妇女");
+		assertEquals("妇女", people.get(1).getGender());
 
 		final Map<Integer, Person> personMap = new HashMap<>();
 		personMap.put(1, new Person("AA", 21, "男", 1));
@@ -932,13 +931,13 @@ public class CollUtilTest {
 			x.setAge(y.getAge());
 		});
 
-		Assertions.assertEquals(people.get(1).getGender(), "小孩");
+		assertEquals("小孩", people.get(1).getGender());
 	}
 
 	@Test
 	public void distinctTest() {
 		final List<Integer> distinct = CollUtil.distinct(ListUtil.view(5, 3, 10, 9, 0, 5, 10, 9));
-		Assertions.assertEquals(ListUtil.view(5, 3, 10, 9, 0), distinct);
+		assertEquals(ListUtil.view(5, 3, 10, 9, 0), distinct);
 	}
 
 	@Test
@@ -954,15 +953,15 @@ public class CollUtilTest {
 
 		// 覆盖模式下ff覆盖了aa，ee覆盖了bb
 		List<Person> distinct = CollUtil.distinct(people, Person::getGender, true);
-		Assertions.assertEquals(2, distinct.size());
+		assertEquals(2, distinct.size());
-		Assertions.assertEquals("ff", distinct.get(0).getName());
+		assertEquals("ff", distinct.get(0).getName());
-		Assertions.assertEquals("ee", distinct.get(1).getName());
+		assertEquals("ee", distinct.get(1).getName());
 
 		// 非覆盖模式下，保留了最早加入的aa和bb
 		distinct = CollUtil.distinct(people, Person::getGender, false);
-		Assertions.assertEquals(2, distinct.size());
+		assertEquals(2, distinct.size());
-		Assertions.assertEquals("aa", distinct.get(0).getName());
+		assertEquals("aa", distinct.get(0).getName());
-		Assertions.assertEquals("bb", distinct.get(1).getName());
+		assertEquals("bb", distinct.get(1).getName());
 	}
 
 	@Data
@@ -978,7 +977,7 @@ public class CollUtilTest {
 	public void mapTest() {
 		final List<String> list = ListUtil.of("a", "b", "c");
 		final List<Object> extract = CollUtil.map(list, (e) -> e + "_1");
-		Assertions.assertEquals(ListUtil.of("a_1", "b_1", "c_1"), extract);
+		assertEquals(ListUtil.of("a_1", "b_1", "c_1"), extract);
 	}
 
 	@Test
@@ -991,7 +990,7 @@ public class CollUtilTest {
 		);
 
 		final List<Object> extract = CollUtil.map(people, Person::getName);
-		Assertions.assertEquals(ListUtil.of("aa", "bb", "cc", "dd"), extract);
+		assertEquals(ListUtil.of("aa", "bb", "cc", "dd"), extract);
 	}
 
 	@Test
@@ -1011,7 +1010,7 @@ public class CollUtilTest {
 		);
 
 		final Collection<String> trans = CollUtil.trans(people, Person::getName);
-		Assertions.assertEquals("[aa, bb, cc, dd]", trans.toString());
+		assertEquals("[aa, bb, cc, dd]", trans.toString());
 	}
 
 	@SuppressWarnings("ConstantConditions")
@@ -1043,7 +1042,7 @@ public class CollUtilTest {
 		final List<String> list = CollUtil.unionAll(list1, list2, list3);
 		Assertions.assertNotNull(list);
 
-		Assertions.assertEquals(
+		assertEquals(
 			ListUtil.of(1, 2, 3, 4),
 			CollUtil.unionAll(ListUtil.of(1), ListUtil.of(2), ListUtil.of(3), ListUtil.of(4))
 		);
@@ -1133,11 +1132,11 @@ public class CollUtilTest {
 		Assertions.assertNull(CollUtil.getFirst(null));
 		Assertions.assertNull(CollUtil.getFirst(ListUtil.of()));
 
-		Assertions.assertEquals("1", CollUtil.getFirst(ListUtil.of("1", "2", "3")));
+		assertEquals("1", CollUtil.getFirst(ListUtil.of("1", "2", "3")));
 		final ArrayDeque<String> deque = new ArrayDeque<>();
 		deque.add("3");
 		deque.add("4");
-		Assertions.assertEquals("3", CollUtil.getFirst(deque));
+		assertEquals("3", CollUtil.getFirst(deque));
 	}
 
 	@Test
@@ -1147,16 +1146,16 @@ public class CollUtilTest {
 			stack.push(i);
 		}
 		final List<Integer> popPart1 = CollUtil.popPart(stack, 3);
-		Assertions.assertEquals(ListUtil.of(9, 8, 7), popPart1);
+		assertEquals(ListUtil.of(9, 8, 7), popPart1);
-		Assertions.assertEquals(7, stack.size());
+		assertEquals(7, stack.size());
 
 		final ArrayDeque<Integer> queue = new ArrayDeque<>();
 		for (int i = 0; i < 10; i++) {
 			queue.push(i);
 		}
 		final List<Integer> popPart2 = CollUtil.popPart(queue, 3);
-		Assertions.assertEquals(ListUtil.of(9, 8, 7), popPart2);
+		assertEquals(ListUtil.of(9, 8, 7), popPart2);
-		Assertions.assertEquals(7, queue.size());
+		assertEquals(7, queue.size());
 	}
 
 	@Test
@@ -1185,7 +1184,7 @@ public class CollUtilTest {
 	@Test
 	public void maxTest() {
 		final List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
-		Assertions.assertEquals((Integer) 6, CollUtil.max(list));
+		assertEquals((Integer) 6, CollUtil.max(list));
 	}
 
 	@SuppressWarnings({"rawtypes", "unchecked"})
@@ -1204,7 +1203,7 @@ public class CollUtilTest {
 	public void unionExtendTest() {
 		final List<Dog> dog = Arrays.asList(new Dog("dog1", 12), new Dog("dog2", 12));
 		final List<Cat> cat = Arrays.asList(new Cat("cat1", 12), new Cat("cat2", 12));
-		Assertions.assertEquals(CollUtil.union(dog, cat).size(), dog.size() + cat.size());
+		assertEquals(CollUtil.union(dog, cat).size(), dog.size() + cat.size());
 	}
 
 	@Test
@@ -1212,7 +1211,7 @@ public class CollUtilTest {
 		final List<Dog> dog = Arrays.asList(new Dog("dog1", 12), new Dog("dog2", 12));
 		final List<Cat> cat = Arrays.asList(new Cat("cat1", 12), new Cat("cat2", 12));
 		final List<Pig> pig = Arrays.asList(new Pig("pig1", 12), new Pig("pig2", 12));
-		Assertions.assertEquals(CollUtil.unionAll(dog, cat, pig).size(), dog.size() + cat.size() + pig.size());
+		assertEquals(CollUtil.unionAll(dog, cat, pig).size(), dog.size() + cat.size() + pig.size());
 	}
 
 	@Test
@@ -1220,7 +1219,7 @@ public class CollUtilTest {
 		final List<Dog> dog = Arrays.asList(new Dog("dog1", 12), new Dog("dog1", 12)); // same
 		final List<Cat> cat = Arrays.asList(new Cat("cat1", 12), new Cat("cat2", 12));
 		final List<Pig> pig = Arrays.asList(new Pig("pig1", 12), new Pig("pig2", 12));
-		Assertions.assertEquals(CollUtil.unionDistinct(dog, cat, pig).size(), 5);
+		assertEquals(5, CollUtil.unionDistinct(dog, cat, pig).size());
 	}
 
 
@@ -1289,4 +1288,16 @@ public class CollUtilTest {
 
 		assertTrue(CollUtil.containsAll(coll1, coll2));
 	}
+
+	@Test
+	void issueIBHP68Test() {
+		final List<Integer> view1 = ListUtil.view(1, 2, 3);
+		final List<Integer> l3 = ListUtil.of(1);
+		final Collection<Integer> subtract = CollUtil.subtract(view1, l3);
+		assertEquals(2, subtract.size());
+		assertEquals(2, subtract.iterator().next());
+		assertFalse(subtract.contains(1));
+		assertTrue(subtract.contains(2));
+		assertTrue(subtract.contains(3));
+	}
 }