1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package com.puppycrawl.tools.checkstyle.checks.imports;
21
22 import static com.google.common.truth.Truth.assertWithMessage;
23
24 import org.junit.jupiter.api.Test;
25
26 public class PkgImportRuleTest {
27
28 @Test
29 public void testPkgImportRule() {
30 final PkgImportRule rule = new PkgImportRule(true, false, "pkg", false, false);
31 assertWithMessage("Rule must not be null")
32 .that(rule)
33 .isNotNull();
34 assertWithMessage("Invalid access result")
35 .that(rule.verifyImport("asda"))
36 .isEqualTo(AccessResult.UNKNOWN);
37 assertWithMessage("Invalid access result")
38 .that(rule.verifyImport("p"))
39 .isEqualTo(AccessResult.UNKNOWN);
40 assertWithMessage("Invalid access result")
41 .that(rule.verifyImport("pkga"))
42 .isEqualTo(AccessResult.UNKNOWN);
43 assertWithMessage("Invalid access result")
44 .that(rule.verifyImport("pkg.a"))
45 .isEqualTo(AccessResult.ALLOWED);
46 assertWithMessage("Invalid access result")
47 .that(rule.verifyImport("pkg.a.b"))
48 .isEqualTo(AccessResult.ALLOWED);
49 assertWithMessage("Invalid access result")
50 .that(rule.verifyImport("pkg"))
51 .isEqualTo(AccessResult.UNKNOWN);
52 }
53
54 @Test
55 public void testPkgImportRuleExactMatch() {
56 final PkgImportRule rule = new PkgImportRule(true, false, "pkg", true, false);
57 assertWithMessage("Rule must not be null")
58 .that(rule)
59 .isNotNull();
60 assertWithMessage("Invalid access result")
61 .that(rule.verifyImport("asda"))
62 .isEqualTo(AccessResult.UNKNOWN);
63 assertWithMessage("Invalid access result")
64 .that(rule.verifyImport("p"))
65 .isEqualTo(AccessResult.UNKNOWN);
66 assertWithMessage("Invalid access result")
67 .that(rule.verifyImport("pkg.a"))
68 .isEqualTo(AccessResult.ALLOWED);
69 assertWithMessage("Invalid access result")
70 .that(rule.verifyImport("pkg.a.b"))
71 .isEqualTo(AccessResult.UNKNOWN);
72 assertWithMessage("Invalid access result")
73 .that(rule.verifyImport("pkg"))
74 .isEqualTo(AccessResult.UNKNOWN);
75 }
76
77 @Test
78 public void testPkgImportRuleRegexpSimple() {
79 final PkgImportRule rule = new PkgImportRule(true, false, "pkg", false, true);
80 assertWithMessage("Rule must not be null")
81 .that(rule)
82 .isNotNull();
83 assertWithMessage("Invalid access result")
84 .that(rule.verifyImport("asda"))
85 .isEqualTo(AccessResult.UNKNOWN);
86 assertWithMessage("Invalid access result")
87 .that(rule.verifyImport("p"))
88 .isEqualTo(AccessResult.UNKNOWN);
89 assertWithMessage("Invalid access result")
90 .that(rule.verifyImport("pkga"))
91 .isEqualTo(AccessResult.UNKNOWN);
92 assertWithMessage("Invalid access result")
93 .that(rule.verifyImport("pkg.a"))
94 .isEqualTo(AccessResult.ALLOWED);
95 assertWithMessage("Invalid access result")
96 .that(rule.verifyImport("pkg.a.b"))
97 .isEqualTo(AccessResult.ALLOWED);
98 assertWithMessage("Invalid access result")
99 .that(rule.verifyImport("pkg"))
100 .isEqualTo(AccessResult.UNKNOWN);
101 }
102
103 @Test
104 public void testPkgImportRuleExactMatchRegexpSimple() {
105 final PkgImportRule rule = new PkgImportRule(true, false, "pkg", true, true);
106 assertWithMessage("Rule must not be null")
107 .that(rule)
108 .isNotNull();
109 assertWithMessage("Invalid access result")
110 .that(rule.verifyImport("asda"))
111 .isEqualTo(AccessResult.UNKNOWN);
112 assertWithMessage("Invalid access result")
113 .that(rule.verifyImport("p"))
114 .isEqualTo(AccessResult.UNKNOWN);
115 assertWithMessage("Invalid access result")
116 .that(rule.verifyImport("pkg.a"))
117 .isEqualTo(AccessResult.ALLOWED);
118 assertWithMessage("Invalid access result")
119 .that(rule.verifyImport("pkg.a.b"))
120 .isEqualTo(AccessResult.UNKNOWN);
121 assertWithMessage("Invalid access result")
122 .that(rule.verifyImport("pkg"))
123 .isEqualTo(AccessResult.UNKNOWN);
124 }
125
126 @Test
127 public void testPkgImportRuleRegexp() {
128 final PkgImportRule rule = new PkgImportRule(true, false, "(pkg|hallo)", false, true);
129 assertWithMessage("Rule must not be null")
130 .that(rule)
131 .isNotNull();
132 assertWithMessage("Invalid access result")
133 .that(rule.verifyImport("asda"))
134 .isEqualTo(AccessResult.UNKNOWN);
135 assertWithMessage("Invalid access result")
136 .that(rule.verifyImport("p"))
137 .isEqualTo(AccessResult.UNKNOWN);
138 assertWithMessage("Invalid access result")
139 .that(rule.verifyImport("pkga"))
140 .isEqualTo(AccessResult.UNKNOWN);
141 assertWithMessage("Invalid access result")
142 .that(rule.verifyImport("pkg.a"))
143 .isEqualTo(AccessResult.ALLOWED);
144 assertWithMessage("Invalid access result")
145 .that(rule.verifyImport("pkg.a.b"))
146 .isEqualTo(AccessResult.ALLOWED);
147 assertWithMessage("Invalid access result")
148 .that(rule.verifyImport("pkg"))
149 .isEqualTo(AccessResult.UNKNOWN);
150 assertWithMessage("Invalid access result")
151 .that(rule.verifyImport("halloa"))
152 .isEqualTo(AccessResult.UNKNOWN);
153 assertWithMessage("Invalid access result")
154 .that(rule.verifyImport("hallo.a"))
155 .isEqualTo(AccessResult.ALLOWED);
156 assertWithMessage("Invalid access result")
157 .that(rule.verifyImport("hallo.a.b"))
158 .isEqualTo(AccessResult.ALLOWED);
159 assertWithMessage("Invalid access result")
160 .that(rule.verifyImport("hallo"))
161 .isEqualTo(AccessResult.UNKNOWN);
162 }
163
164 @Test
165 public void testPkgImportRuleNoRegexp() {
166 final PkgImportRule rule = new PkgImportRule(true, false, "(pkg|hallo)", false, false);
167 assertWithMessage("Rule must not be null")
168 .that(rule)
169 .isNotNull();
170 assertWithMessage("Invalid access result")
171 .that(rule.verifyImport("pkga"))
172 .isEqualTo(AccessResult.UNKNOWN);
173 assertWithMessage("Invalid access result")
174 .that(rule.verifyImport("pkg.a"))
175 .isEqualTo(AccessResult.UNKNOWN);
176 assertWithMessage("Invalid access result")
177 .that(rule.verifyImport("pkg.a.b"))
178 .isEqualTo(AccessResult.UNKNOWN);
179 assertWithMessage("Invalid access result")
180 .that(rule.verifyImport("pkg"))
181 .isEqualTo(AccessResult.UNKNOWN);
182 assertWithMessage("Invalid access result")
183 .that(rule.verifyImport("halloa"))
184 .isEqualTo(AccessResult.UNKNOWN);
185 assertWithMessage("Invalid access result")
186 .that(rule.verifyImport("hallo.a"))
187 .isEqualTo(AccessResult.UNKNOWN);
188 assertWithMessage("Invalid access result")
189 .that(rule.verifyImport("hallo.a.b"))
190 .isEqualTo(AccessResult.UNKNOWN);
191 assertWithMessage("Invalid access result")
192 .that(rule.verifyImport("hallo"))
193 .isEqualTo(AccessResult.UNKNOWN);
194 assertWithMessage("Invalid access result")
195 .that(rule.verifyImport("(pkg|hallo).a"))
196 .isEqualTo(AccessResult.ALLOWED);
197 }
198
199 @Test
200 public void testPkgImportRuleExactMatchRegexp() {
201 final PkgImportRule rule = new PkgImportRule(true, false, "(pkg|hallo)", true, true);
202 assertWithMessage("Rule must not be null")
203 .that(rule)
204 .isNotNull();
205 assertWithMessage("Invalid access result")
206 .that(rule.verifyImport("asda"))
207 .isEqualTo(AccessResult.UNKNOWN);
208 assertWithMessage("Invalid access result")
209 .that(rule.verifyImport("p"))
210 .isEqualTo(AccessResult.UNKNOWN);
211 assertWithMessage("Invalid access result")
212 .that(rule.verifyImport("pkg.a"))
213 .isEqualTo(AccessResult.ALLOWED);
214 assertWithMessage("Invalid access result")
215 .that(rule.verifyImport("pkg.a.b"))
216 .isEqualTo(AccessResult.UNKNOWN);
217 assertWithMessage("Invalid access result")
218 .that(rule.verifyImport("pkg"))
219 .isEqualTo(AccessResult.UNKNOWN);
220 assertWithMessage("Invalid access result")
221 .that(rule.verifyImport("hallo.a"))
222 .isEqualTo(AccessResult.ALLOWED);
223 assertWithMessage("Invalid access result")
224 .that(rule.verifyImport("hallo.a.b"))
225 .isEqualTo(AccessResult.UNKNOWN);
226 assertWithMessage("Invalid access result")
227 .that(rule.verifyImport("hallo"))
228 .isEqualTo(AccessResult.UNKNOWN);
229 }
230
231 }