View Javadoc
1   ///////////////////////////////////////////////////////////////////////////////////////////////
2   // checkstyle: Checks Java source code and other text files for adherence to a set of rules.
3   // Copyright (C) 2001-2024 the original author or authors.
4   //
5   // This library is free software; you can redistribute it and/or
6   // modify it under the terms of the GNU Lesser General Public
7   // License as published by the Free Software Foundation; either
8   // version 2.1 of the License, or (at your option) any later version.
9   //
10  // This library is distributed in the hope that it will be useful,
11  // but WITHOUT ANY WARRANTY; without even the implied warranty of
12  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  // Lesser General Public License for more details.
14  //
15  // You should have received a copy of the GNU Lesser General Public
16  // License along with this library; if not, write to the Free Software
17  // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
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 }