Assert断言常用工具类

 

jdk自带的assert

jdk的内置断言 assert 默认关闭，可以用命令行参数 -ea 启用内置断言，ea即enable assertions，不推荐此种方式。

 

spring的断言Assert

不满足时都是抛出 IllegalArgumentException(msg)，msg可以用String或Supplier指定

//期待obj为null
Assert.isNull(Object obj, String msg);
Assert.isNull(Object obj, Supplier<String> msg);

//期待不为null
Assert.notNull(Object obj, String msg);
Assert.notNull(Object obj, Supplier<String> msg);



//期待数组|集合不为空
Assert.notEmpty(Object[] arr, String msg);
Assert.notEmpty(Object[] arr, Supplier<String> msg);

//期待数组、集合中没有为null的元素（允许数组、集合自身为null）
Assert.noNullElements(Object[] arr, String msg);
Assert.noNullElements(Object[] arr, Supplier<String> msg);



//期待str不包含指定子串substr，包含时抛出 IllegalArgumentException(msg)，msg可以用String或Supplier指定
Assert.doesNotContain(String str, String substr, String msg);
Assert.doesNotContain(String str, String substr, Supplier<String> msg);

//期待str非空（相当于isNotEmpty)
Assert.hasLength(String str, String msg);
Assert.hasLength(String str, Supplier<String> msg);

//期待str有内容（在str非空的基础上，要求字符串有空格之外的字符，相当于isNotBlank）
Assert.hasText(String str, String msg);
Assert.hasText(String str, Supplier<String> msg);



//期待superType是subType的父类（不要求是直接父类）
Assert.isAssignable(Class superType, Class subType);
Assert.isAssignable(Class superType, Class subType, String msg);
Assert.isAssignable(Class superType, Class subType, Supplier<String> msg);

//期待obj是指定类的实例
Assert.isInstanceOf(Class clazz, Object obj);
Assert.isInstanceOf(Class clazz, Object obj, String msg);
Assert.isInstanceOf(Class clazz, Object obj, Supplier<String> msg);



//期待expression为true
Assert.isTrue(boolean expression, String msg);
Assert.isTrue(boolean expression, Supplier<String> msg);
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

 

junit的断言Assert

不满足要求时，都是抛出 AssertionError

//期待condition为true|false
Assert.assertTrue(boolean condition);
Assert.assertTrue(String msg, boolean condition);

Assert.assertFalse(boolean condition);
Assert.assertFalse(String msg, boolean condition);



//期待obj为null、非null
Assert.assertNull(Object obj);
Assert.assertNull(String msg, Object obj);

Assert.assertNotNull(Object obj);
Assert.assertNotNull(String msg, Object obj);



//期待2个值相等、不等（直接使用==判断）
Assert.assertSame(Object expected, Object actual);
Assert.assertSame(String message, Object expected, Object actual);

Assert.assertNotSame(Object expected, Object actual);
Assert.assertNotSame(String message, Object expected, Object actual);



//期待同类型的2个值相等、不等。基本类型使用==判断，Object类型使用equals判断
Assert.assertEquals(long expected, long actual);
Assert.assertEquals(String msg, long expected, long actual);

Assert.assertEquals(Object expected, Object actual);
Assert.assertEquals(String message, Object expected, Object actual);

//assertNotEquals用法同上
Assert.assertNotEquals();



//期待同类型的2个数组相等
Assert.assertArrayEquals(int[], int[]);
Assert.assertArrayEquals(String msg, int[], int[]);

Assert.assertArrayEquals(Object[], Object[]);
Assert.assertArrayEquals(String msg, Object[], Object[]);



//期待执行runnable.run()时抛出指定类型的异常，会自动执行runnable.run()
Assert.assertThrows(Class expectedThrowable, ThrowingRunnable runnable);
Assert.assertThrows(String msg, Class expectedThrowable, ThrowingRunnable runnable);
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

 

common-lang3的Validate

不满足时也是抛异常，可以起到断言作用

//期待非null
Validate.notNull(Object obj);
Validate.notNull(Object obj, String msg, Object... values);

//期待非空，适用于字符串、数组、集合类型，非空指的是 非null + 元素数量>0
Validate.notEmpty(String str);
Validate.notEmpty(String str, String msg, Object... values);

//期待字符串不是blank
Validate.notBlank(String str);
Validate.notBlank(sString str, String msg, Object... values);



//期待不存在为null的元素，适用于数组、集合等可迭代对象
Validate.noNullElements(T[] arr);
//msg中可以使用%s、%d之类的占位符，obj...指定占位符对应的值
Validate.noNullElements(T[] arr, String msg, Object... values);



//期待布尔表达式的值为true
Validate.isTrue(boolean expression);
Validate.isTrue(boolean expression, String msg, Object... values);

//期待布尔表达式是否为true
Validate.validState(boolean expression);
Validate.validState(boolean expression, String msg, Object... values);



//期待obj是指定类的实例
Validate.isInstanceOf(Class clazz, Object obj);
Validate.isInstanceOf(Class clazz, Object obj, String msg, Object... values);

//期待2个Class相同，或第一个是第二个的基类
Validate.isAssignableFrom(Class superClazz,Class clazz);
Validate.isAssignableFrom(Class superClazz,Class clazz, String msg, Object... values);



//期待value在 [start,end] 范围上，支持long、double类型
Validate.inclusiveBetween(long start, long end, long value);
Validate.inclusiveBetween(long start, long end, long value, String msg, Object... values);

//支持自定义比较方式。value是待校验的值，需要实现Comparable接口，使用自身的compareTo()方法进行比较
Validate.inclusiveBetween(T start,T end, Comparable<T> value);
Validate.inclusiveBetween(T start,T end, Comparable<T> value, String msg, Object... values);

//期待value在 (start,end) 范围上，使用方式和 inclusiveBetween() 相同，区别在于是否包含边界（开、闭区间）
Validate.exclusiveBetween();



//期待字符串满足指定的正则表达式
Validate.matchesPattern(String str, String pattern);
Validate.matchesPattern(String str, String pattern, String msg, Object... values);
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

以上方法，当参数自身为null时，抛出NPE；当参数自身不为null、但不满足要求时，抛出 IllegalArgumentException。

 

//期待index在合法范围内，适用于字符串、数组、Collection类型
Validate.validIndex(T[] arr, int index);
Validate.validIndex(T[] arr, int index, String msg, Object... values);
1
2
3

以上方法，当参数自身为null时，抛出NPE；当参数自身不为null、但不满足要求时，抛出 IndexOutOfBoundsException。