1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.juneau.http.annotation;
18
19 import static java.lang.annotation.ElementType.*;
20 import static java.lang.annotation.RetentionPolicy.*;
21 import static org.apache.juneau.junit.bct.BctAssertions.*;
22 import static org.junit.jupiter.api.Assertions.*;
23
24 import java.lang.annotation.*;
25
26 import org.apache.juneau.*;
27 import org.apache.juneau.annotation.*;
28 import org.apache.juneau.commons.utils.*;
29 import org.apache.juneau.oapi.*;
30 import org.junit.jupiter.api.*;
31
32 class AnnotationUtils_Test extends TestBase {
33
34
35
36
37
38 @Target(TYPE)
39 @Retention(RUNTIME)
40 public @interface X1 {
41 Contact contact() default @Contact;
42 ExternalDocs externalDocs() default @ExternalDocs;
43 License license() default @License;
44 Schema schema() default @Schema;
45 SubItems subItems() default @SubItems;
46 Items items() default @Items;
47 }
48
49 @Content
50 @Response
51 @Header
52 @X1
53 public static class A1 {
54 @Query @Header @FormData @Path @Schema
55 public int f1;
56 }
57
58 public static class A2 {
59 public int f1;
60 }
61
62 @Test void a01_Body() {
63 assertBean(body().build().annotationType(), "simpleName", "Content");
64
65 assertTrue(ContentAnnotation.empty(A1.class.getAnnotation(Content.class)));
66 assertTrue(ContentAnnotation.empty(A2.class.getAnnotation(Content.class)));
67 assertTrue(ContentAnnotation.empty(body().build()));
68 assertTrue(ContentAnnotation.empty((Content)null));
69 }
70
71 @Test void a02_Contact() {
72 var x1 = A1.class.getAnnotation(X1.class);
73
74 assertBean(contact().build().annotationType(), "simpleName", "Contact");
75
76 assertTrue(ContactAnnotation.empty(x1.contact()));
77 assertTrue(ContactAnnotation.empty(contact().build()));
78 assertTrue(ContactAnnotation.empty((Contact)null));
79
80 assertFalse(ContactAnnotation.empty(contact().email("foo").build()));
81 assertFalse(ContactAnnotation.empty(contact().name("foo").build()));
82 assertFalse(ContactAnnotation.empty(contact().url("foo").build()));
83 }
84
85 @Test void a03_FormData() throws Exception {
86 var f1 = A1.class.getField("f1");
87 var f2 = A2.class.getField("f1");
88
89 assertBean(formData().build().annotationType(), "simpleName", "FormData");
90
91 assertTrue(FormDataAnnotation.empty(f1.getAnnotation(FormData.class)));
92 assertTrue(FormDataAnnotation.empty(f2.getAnnotation(FormData.class)));
93 assertTrue(FormDataAnnotation.empty((FormData)null));
94 assertTrue(FormDataAnnotation.empty(formData().build()));
95
96 assertFalse(FormDataAnnotation.empty(formData().name("foo").build()));
97 assertFalse(FormDataAnnotation.empty(formData().parser(OpenApiParser.class).build()));
98 assertFalse(FormDataAnnotation.empty(formData().serializer(OpenApiSerializer.class).build()));
99 assertFalse(FormDataAnnotation.empty(formData().value("foo").build()));
100 }
101
102 @Test void a04_HasFormData() {
103 assertBean(hasFormData().build().annotationType(), "simpleName", "HasFormData");
104
105 assertEquals("foo", hasFormData().name("foo").build().name());
106 assertEquals("foo", hasFormData().value("foo").build().value());
107 }
108
109 @Test void a05_Query() throws Exception {
110 var f1 = A1.class.getField("f1");
111 var f2 = A2.class.getField("f1");
112
113 assertBean(query().build().annotationType(), "simpleName", "Query");
114
115 assertTrue(QueryAnnotation.empty(f1.getAnnotation(Query.class)));
116 assertTrue(QueryAnnotation.empty(f2.getAnnotation(Query.class)));
117 assertTrue(QueryAnnotation.empty((Query)null));
118 assertTrue(QueryAnnotation.empty(query().build()));
119
120 assertFalse(QueryAnnotation.empty(query().name("foo").build()));
121 assertFalse(QueryAnnotation.empty(query().parser(OpenApiParser.class).build()));
122 assertFalse(QueryAnnotation.empty(query().serializer(OpenApiSerializer.class).build()));
123 assertFalse(QueryAnnotation.empty(query().value("foo").build()));
124 }
125
126 @Test void a06_HasQuery() {
127 assertBean(hasQuery().build().annotationType(), "simpleName", "HasQuery");
128
129 assertEquals("foo", hasQuery().name("foo").build().name());
130 assertEquals("foo", hasQuery().value("foo").build().value());
131 }
132
133 @Test void a07_Header() throws Exception {
134 var f1 = A1.class.getField("f1");
135 var f2 = A2.class.getField("f1");
136
137 assertBean(header().build().annotationType(), "simpleName", "Header");
138
139 assertTrue(HeaderAnnotation.empty(f1.getAnnotation(Header.class)));
140 assertTrue(HeaderAnnotation.empty(f2.getAnnotation(Header.class)));
141 assertTrue(HeaderAnnotation.empty((Header)null));
142 assertTrue(HeaderAnnotation.empty(header().build()));
143
144 assertFalse(HeaderAnnotation.empty(header().name("foo").build()));
145 assertFalse(HeaderAnnotation.empty(header().parser(OpenApiParser.class).build()));
146 assertFalse(HeaderAnnotation.empty(header().serializer(OpenApiSerializer.class).build()));
147 assertFalse(HeaderAnnotation.empty(header().value("foo").build()));
148 }
149
150 @Test void a08_License() {
151 var x = A1.class.getAnnotation(X1.class);
152
153 assertBean(license().build().annotationType(), "simpleName", "License");
154
155 assertTrue(LicenseAnnotation.empty(x.license()));
156 assertTrue(LicenseAnnotation.empty((License)null));
157 assertTrue(LicenseAnnotation.empty(license().build()));
158
159 assertFalse(LicenseAnnotation.empty(license().name("foo").build()));
160 assertFalse(LicenseAnnotation.empty(license().url("foo").build()));
161 }
162
163 @Test void a09_Path() throws Exception {
164 var f1 = A1.class.getField("f1");
165 var f2 = A2.class.getField("f1");
166
167 assertBean(path().build().annotationType(), "simpleName", "Path");
168
169 assertTrue(PathAnnotation.empty(f1.getAnnotation(Path.class)));
170 assertTrue(PathAnnotation.empty(f2.getAnnotation(Path.class)));
171 assertTrue(PathAnnotation.empty((Path)null));
172 assertTrue(PathAnnotation.empty(path().build()));
173
174 assertFalse(PathAnnotation.empty(path().name("foo").build()));
175 assertFalse(PathAnnotation.empty(path().parser(OpenApiParser.class).build()));
176 assertFalse(PathAnnotation.empty(path().serializer(OpenApiSerializer.class).build()));
177 assertFalse(PathAnnotation.empty(path().value("foo").build()));
178 }
179
180 @Test void a10_Request() {
181 assertBean(request().build().annotationType(), "simpleName", "Request");
182
183 assertString("org.apache.juneau.oapi.OpenApiParser", request().parser(OpenApiParser.class).build().parser().getName());
184 assertString("org.apache.juneau.oapi.OpenApiSerializer", request().serializer(OpenApiSerializer.class).build().serializer().getName());
185 }
186
187 @Test void a11_Response() {
188 assertBean(response().build().annotationType(), "simpleName", "Response");
189
190 assertTrue(ResponseAnnotation.empty(A1.class.getAnnotation(Response.class)));
191 assertTrue(ResponseAnnotation.empty(A2.class.getAnnotation(Response.class)));
192 assertTrue(ResponseAnnotation.empty(response().build()));
193 assertTrue(ResponseAnnotation.empty((Response)null));
194
195 assertFalse(ResponseAnnotation.empty(response().examples(a("foo")).build()));
196 assertFalse(ResponseAnnotation.empty(response().headers(CollectionUtils.a(header().name("foo").build())).build()));
197 assertFalse(ResponseAnnotation.empty(response().parser(OpenApiParser.class).build()));
198 assertFalse(ResponseAnnotation.empty(response().schema(schema().$ref("foo").build()).build()));
199 assertFalse(ResponseAnnotation.empty(response().serializer(OpenApiSerializer.class).build()));
200 }
201
202 @Test void a14_ResponseStatus() {
203 assertBean(responseCode().build().annotationType(), "simpleName", "StatusCode");
204 }
205
206 @Test void a15_Tag() {
207 assertBean(tag().build().annotationType(), "simpleName", "Tag");
208 assertList(tag().description(a("foo")).build().description(), "foo");
209 assertEquals("foo", tag().externalDocs(externalDocs().url("foo").build()).build().externalDocs().url());
210 assertEquals("foo", tag().name("foo").build().name());
211 }
212
213 @Test void a16_ExternalDocs() {
214 var x = A1.class.getAnnotation(X1.class);
215
216 assertBean(externalDocs().build().annotationType(), "simpleName", "ExternalDocs");
217
218 assertTrue(ExternalDocsAnnotation.empty(x.externalDocs()));
219 assertTrue(ExternalDocsAnnotation.empty((ExternalDocs)null));
220
221 assertFalse(ExternalDocsAnnotation.empty(externalDocs().description(a("foo")).build()));
222 assertFalse(ExternalDocsAnnotation.empty(externalDocs().url("foo").build()));
223 }
224
225 @Test void a17_Schema() {
226 var x = A1.class.getAnnotation(X1.class);
227
228 assertBean(schema().build().annotationType(), "simpleName", "Schema");
229
230 assertTrue(SchemaAnnotation.empty(x.schema()));
231 assertTrue(SchemaAnnotation.empty((Schema)null));
232
233 assertFalse(SchemaAnnotation.empty(schema().default_(a("foo")).build()));
234 assertFalse(SchemaAnnotation.empty(schema().enum_(a("foo")).build()));
235 assertFalse(SchemaAnnotation.empty(schema().$ref("foo").build()));
236 assertFalse(SchemaAnnotation.empty(schema().additionalProperties(a("foo")).build()));
237 assertFalse(SchemaAnnotation.empty(schema().allOf(a("foo")).build()));
238 assertFalse(SchemaAnnotation.empty(schema().cf("foo").build()));
239 assertFalse(SchemaAnnotation.empty(schema().collectionFormat("foo").build()));
240 assertFalse(SchemaAnnotation.empty(schema().d(a("foo")).build()));
241 assertFalse(SchemaAnnotation.empty(schema().description(a("foo")).build()));
242 assertFalse(SchemaAnnotation.empty(schema().df(a("foo")).build()));
243 assertFalse(SchemaAnnotation.empty(schema().discriminator("foo").build()));
244 assertFalse(SchemaAnnotation.empty(schema().e(a("foo")).build()));
245 assertFalse(SchemaAnnotation.empty(schema().emax(true).build()));
246 assertFalse(SchemaAnnotation.empty(schema().emin(true).build()));
247 assertFalse(SchemaAnnotation.empty(schema().exclusiveMaximum(true).build()));
248 assertFalse(SchemaAnnotation.empty(schema().exclusiveMinimum(true).build()));
249 assertFalse(SchemaAnnotation.empty(schema().externalDocs(externalDocs().url("foo").build()).build()));
250 assertFalse(SchemaAnnotation.empty(schema().f("foo").build()));
251 assertFalse(SchemaAnnotation.empty(schema().format("foo").build()));
252 assertFalse(SchemaAnnotation.empty(schema().ignore(true).build()));
253 assertFalse(SchemaAnnotation.empty(schema().items(items().$ref("foo").build()).build()));
254 assertFalse(SchemaAnnotation.empty(schema().max("foo").build()));
255 assertFalse(SchemaAnnotation.empty(schema().maxi(0).build()));
256 assertFalse(SchemaAnnotation.empty(schema().maximum("foo").build()));
257 assertFalse(SchemaAnnotation.empty(schema().maxItems(0).build()));
258 assertFalse(SchemaAnnotation.empty(schema().maxl(0).build()));
259 assertFalse(SchemaAnnotation.empty(schema().maxLength(0).build()));
260 assertFalse(SchemaAnnotation.empty(schema().maxp(0).build()));
261 assertFalse(SchemaAnnotation.empty(schema().maxProperties(0).build()));
262 assertFalse(SchemaAnnotation.empty(schema().min("foo").build()));
263 assertFalse(SchemaAnnotation.empty(schema().mini(0).build()));
264 assertFalse(SchemaAnnotation.empty(schema().minimum("foo").build()));
265 assertFalse(SchemaAnnotation.empty(schema().minItems(0).build()));
266 assertFalse(SchemaAnnotation.empty(schema().minl(0).build()));
267 assertFalse(SchemaAnnotation.empty(schema().minLength(0).build()));
268 assertFalse(SchemaAnnotation.empty(schema().minp(0).build()));
269 assertFalse(SchemaAnnotation.empty(schema().minProperties(0).build()));
270 assertFalse(SchemaAnnotation.empty(schema().mo("foo").build()));
271 assertFalse(SchemaAnnotation.empty(schema().multipleOf("foo").build()));
272 assertFalse(SchemaAnnotation.empty(schema().p("foo").build()));
273 assertFalse(SchemaAnnotation.empty(schema().pattern("foo").build()));
274 assertFalse(SchemaAnnotation.empty(schema().properties(a("foo")).build()));
275 assertFalse(SchemaAnnotation.empty(schema().r(true).build()));
276 assertFalse(SchemaAnnotation.empty(schema().readOnly(true).build()));
277 assertFalse(SchemaAnnotation.empty(schema().required(true).build()));
278 assertFalse(SchemaAnnotation.empty(schema().ro(true).build()));
279 assertFalse(SchemaAnnotation.empty(schema().t("foo").build()));
280 assertFalse(SchemaAnnotation.empty(schema().title("foo").build()));
281 assertFalse(SchemaAnnotation.empty(schema().type("foo").build()));
282 assertFalse(SchemaAnnotation.empty(schema().ui(true).build()));
283 assertFalse(SchemaAnnotation.empty(schema().uniqueItems(true).build()));
284 assertFalse(SchemaAnnotation.empty(schema().xml(a("foo")).build()));
285 }
286
287 @Test void a18_SubItems() {
288 var x = A1.class.getAnnotation(X1.class);
289
290 assertBean(subItems().build().annotationType(), "simpleName", "SubItems");
291
292 assertTrue(SubItemsAnnotation.empty(x.subItems()));
293 assertTrue(SubItemsAnnotation.empty((SubItems)null));
294
295 assertFalse(SubItemsAnnotation.empty(subItems().default_(a("foo")).build()));
296 assertFalse(SubItemsAnnotation.empty(subItems().enum_(a("foo")).build()));
297 assertFalse(SubItemsAnnotation.empty(subItems().$ref("foo").build()));
298 assertFalse(SubItemsAnnotation.empty(subItems().cf("foo").build()));
299 assertFalse(SubItemsAnnotation.empty(subItems().collectionFormat("foo").build()));
300 assertFalse(SubItemsAnnotation.empty(subItems().df(a("foo")).build()));
301 assertFalse(SubItemsAnnotation.empty(subItems().e(a("foo")).build()));
302 assertFalse(SubItemsAnnotation.empty(subItems().emax(true).build()));
303 assertFalse(SubItemsAnnotation.empty(subItems().emin(true).build()));
304 assertFalse(SubItemsAnnotation.empty(subItems().exclusiveMaximum(true).build()));
305 assertFalse(SubItemsAnnotation.empty(subItems().exclusiveMinimum(true).build()));
306 assertFalse(SubItemsAnnotation.empty(subItems().f("foo").build()));
307 assertFalse(SubItemsAnnotation.empty(subItems().format("foo").build()));
308 assertFalse(SubItemsAnnotation.empty(subItems().items(a("foo")).build()));
309 assertFalse(SubItemsAnnotation.empty(subItems().max("foo").build()));
310 assertFalse(SubItemsAnnotation.empty(subItems().maxi(0).build()));
311 assertFalse(SubItemsAnnotation.empty(subItems().maximum("foo").build()));
312 assertFalse(SubItemsAnnotation.empty(subItems().maxItems(0).build()));
313 assertFalse(SubItemsAnnotation.empty(subItems().maxl(0).build()));
314 assertFalse(SubItemsAnnotation.empty(subItems().maxLength(0).build()));
315 assertFalse(SubItemsAnnotation.empty(subItems().min("foo").build()));
316 assertFalse(SubItemsAnnotation.empty(subItems().mini(0).build()));
317 assertFalse(SubItemsAnnotation.empty(subItems().minimum("foo").build()));
318 assertFalse(SubItemsAnnotation.empty(subItems().minItems(0).build()));
319 assertFalse(SubItemsAnnotation.empty(subItems().minl(0).build()));
320 assertFalse(SubItemsAnnotation.empty(subItems().minLength(0).build()));
321 assertFalse(SubItemsAnnotation.empty(subItems().mo("foo").build()));
322 assertFalse(SubItemsAnnotation.empty(subItems().multipleOf("foo").build()));
323 assertFalse(SubItemsAnnotation.empty(subItems().p("foo").build()));
324 assertFalse(SubItemsAnnotation.empty(subItems().pattern("foo").build()));
325 assertFalse(SubItemsAnnotation.empty(subItems().t("foo").build()));
326 assertFalse(SubItemsAnnotation.empty(subItems().type("foo").build()));
327 assertFalse(SubItemsAnnotation.empty(subItems().ui(true).build()));
328 assertFalse(SubItemsAnnotation.empty(subItems().uniqueItems(true).build()));
329 }
330
331 @Test void a19_Items() {
332 var x = A1.class.getAnnotation(X1.class);
333
334 assertBean(items().build().annotationType(), "simpleName", "Items");
335
336 assertTrue(ItemsAnnotation.empty(x.items()));
337 assertTrue(ItemsAnnotation.empty((Items)null));
338 assertFalse(ItemsAnnotation.empty(items().default_(a("foo")).build()));
339 assertFalse(ItemsAnnotation.empty(items().enum_(a("foo")).build()));
340 assertFalse(ItemsAnnotation.empty(items().$ref("foo").build()));
341 assertFalse(ItemsAnnotation.empty(items().cf("foo").build()));
342 assertFalse(ItemsAnnotation.empty(items().collectionFormat("foo").build()));
343 assertFalse(ItemsAnnotation.empty(items().df(a("foo")).build()));
344 assertFalse(ItemsAnnotation.empty(items().e(a("foo")).build()));
345 assertFalse(ItemsAnnotation.empty(items().emax(true).build()));
346 assertFalse(ItemsAnnotation.empty(items().emin(true).build()));
347 assertFalse(ItemsAnnotation.empty(items().exclusiveMaximum(true).build()));
348 assertFalse(ItemsAnnotation.empty(items().exclusiveMinimum(true).build()));
349 assertFalse(ItemsAnnotation.empty(items().f("foo").build()));
350 assertFalse(ItemsAnnotation.empty(items().format("foo").build()));
351 assertFalse(ItemsAnnotation.empty(items().items(subItems().$ref("foo").build()).build()));
352 assertFalse(ItemsAnnotation.empty(items().max("foo").build()));
353 assertFalse(ItemsAnnotation.empty(items().maxi(0).build()));
354 assertFalse(ItemsAnnotation.empty(items().maximum("foo").build()));
355 assertFalse(ItemsAnnotation.empty(items().maxItems(0).build()));
356 assertFalse(ItemsAnnotation.empty(items().maxl(0).build()));
357 assertFalse(ItemsAnnotation.empty(items().maxLength(0).build()));
358 assertFalse(ItemsAnnotation.empty(items().min("foo").build()));
359 assertFalse(ItemsAnnotation.empty(items().mini(0).build()));
360 assertFalse(ItemsAnnotation.empty(items().minimum("foo").build()));
361 assertFalse(ItemsAnnotation.empty(items().minItems(0).build()));
362 assertFalse(ItemsAnnotation.empty(items().minl(0).build()));
363 assertFalse(ItemsAnnotation.empty(items().minLength(0).build()));
364 assertFalse(ItemsAnnotation.empty(items().mo("foo").build()));
365 assertFalse(ItemsAnnotation.empty(items().multipleOf("foo").build()));
366 assertFalse(ItemsAnnotation.empty(items().p("foo").build()));
367 assertFalse(ItemsAnnotation.empty(items().pattern("foo").build()));
368 assertFalse(ItemsAnnotation.empty(items().t("foo").build()));
369 assertFalse(ItemsAnnotation.empty(items().type("foo").build()));
370 assertFalse(ItemsAnnotation.empty(items().ui(true).build()));
371 assertFalse(ItemsAnnotation.empty(items().uniqueItems(true).build()));
372 }
373
374
375
376
377
378 private static ContentAnnotation.Builder body() {
379 return ContentAnnotation.create();
380 }
381
382 private static ContactAnnotation.Builder contact() {
383 return ContactAnnotation.create();
384 }
385
386 private static FormDataAnnotation.Builder formData() {
387 return FormDataAnnotation.create();
388 }
389
390 private static HasFormDataAnnotation.Builder hasFormData() {
391 return HasFormDataAnnotation.create();
392 }
393
394 private static QueryAnnotation.Builder query() {
395 return QueryAnnotation.create();
396 }
397
398 private static HasQueryAnnotation.Builder hasQuery() {
399 return HasQueryAnnotation.create();
400 }
401
402 private static HeaderAnnotation.Builder header() {
403 return HeaderAnnotation.create();
404 }
405
406 private static LicenseAnnotation.Builder license() {
407 return LicenseAnnotation.create();
408 }
409
410 private static PathAnnotation.Builder path() {
411 return PathAnnotation.create();
412 }
413
414 private static RequestAnnotation.Builder request() {
415 return RequestAnnotation.create();
416 }
417
418 private static ResponseAnnotation.Builder response() {
419 return ResponseAnnotation.create();
420 }
421
422 private static StatusCodeAnnotation.Builder responseCode() {
423 return StatusCodeAnnotation.create();
424 }
425
426 private static TagAnnotation.Builder tag() {
427 return TagAnnotation.create();
428 }
429
430 private static SchemaAnnotation.Builder schema() {
431 return SchemaAnnotation.create();
432 }
433
434 private static ItemsAnnotation.Builder items() {
435 return ItemsAnnotation.create();
436 }
437
438 private static SubItemsAnnotation.Builder subItems() {
439 return SubItemsAnnotation.create();
440 }
441
442 private static ExternalDocsAnnotation.Builder externalDocs() {
443 return ExternalDocsAnnotation.create();
444 }
445
446 private static String[] a(String...s) {
447 return s;
448 }
449 }