/
Assert.java
137 lines (114 loc) · 4.03 KB
/
Assert.java
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
package graphql;
import java.util.Collection;
import java.util.function.Supplier;
import java.util.regex.Pattern;
import static java.lang.String.format;
@SuppressWarnings("TypeParameterUnusedInFormals")
@Internal
public class Assert {
public static <T> T assertNotNull(T object, Supplier<String> msg) {
if (object != null) {
return object;
}
throw new AssertException(msg.get());
}
public static <T> T assertNotNullWithNPE(T object, Supplier<String> msg) {
if (object != null) {
return object;
}
throw new NullPointerException(msg.get());
}
public static <T> T assertNotNull(T object) {
if (object != null) {
return object;
}
throw new AssertException("Object required to be not null");
}
public static <T> void assertNull(T object, Supplier<String> msg) {
if (object == null) {
return;
}
throw new AssertException(msg.get());
}
public static <T> void assertNull(T object) {
if (object == null) {
return;
}
throw new AssertException("Object required to be null");
}
public static <T> T assertNeverCalled() {
throw new AssertException("Should never been called");
}
public static <T> T assertShouldNeverHappen(String format, Object... args) {
throw new AssertException("Internal error: should never happen: " + format(format, args));
}
public static <T> T assertShouldNeverHappen() {
throw new AssertException("Internal error: should never happen");
}
public static <T> Collection<T> assertNotEmpty(Collection<T> collection) {
if (collection == null || collection.isEmpty()) {
throw new AssertException("collection must be not null and not empty");
}
return collection;
}
public static <T> Collection<T> assertNotEmpty(Collection<T> collection, Supplier<String> msg) {
if (collection == null || collection.isEmpty()) {
throw new AssertException(msg.get());
}
return collection;
}
public static void assertTrue(boolean condition, Supplier<String> msg) {
if (condition) {
return;
}
throw new AssertException(msg.get());
}
public static void assertTrue(boolean condition) {
if (condition) {
return;
}
throw new AssertException("condition expected to be true");
}
public static void assertTrue(boolean condition, String constantMsg) {
if (condition) {
return;
}
throwAssert(constantMsg);
}
public static void assertTrue(boolean condition, String msgFmt, Object arg1) {
if (condition) {
return;
}
throwAssert(msgFmt, arg1);
}
public static void assertFalse(boolean condition, Supplier<String> msg) {
if (!condition) {
return;
}
throw new AssertException(msg.get());
}
public static void assertFalse(boolean condition) {
if (!condition) {
return;
}
throw new AssertException("condition expected to be false");
}
private static final String invalidNameErrorMessage = "Name must be non-null, non-empty and match [_A-Za-z][_0-9A-Za-z]* - was '%s'";
private static final Pattern validNamePattern = Pattern.compile("[_A-Za-z][_0-9A-Za-z]*");
/**
* Validates that the Lexical token name matches the current spec.
* currently non null, non empty,
*
* @param name - the name to be validated.
* @return the name if valid, or AssertException if invalid.
*/
public static String assertValidName(String name) {
if (name != null && !name.isEmpty() && validNamePattern.matcher(name).matches()) {
return name;
}
throw new AssertException(String.format(invalidNameErrorMessage, name));
}
private static <T> T throwAssert(String format, Object... args) {
throw new AssertException(format(format, args));
}
}