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