View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.juneau.rest.annotation;
18  
19  import org.apache.juneau.*;
20  import org.apache.juneau.rest.*;
21  import org.apache.juneau.rest.config.*;
22  import org.apache.juneau.rest.logger.*;
23  import org.apache.juneau.rest.mock.*;
24  import org.apache.juneau.rest.servlet.*;
25  import org.junit.jupiter.api.*;
26  
27  public class Rest_Debug_Test extends TestBase {
28  
29  	public static final CaptureLogger LOGGER = new CaptureLogger();
30  
31  	public static class CaptureLogger extends BasicTestCaptureCallLogger {
32  		public static CaptureLogger getInstance() {
33  			return LOGGER;
34  		}
35  	}
36  
37  	private static void assertLogged() {
38  		LOGGER.assertMessageAndReset().isExists();
39  	}
40  
41  	private static void assertNotLogged() {
42  		LOGGER.assertMessageAndReset().isNull();
43  	}
44  
45  	private static void assertLogged(String msg) {
46  		LOGGER.assertMessageAndReset().isContains(msg);
47  	}
48  
49  	//------------------------------------------------------------------------------------------------------------------
50  	// @Rest(debug=""), various @RestOp(debug)
51  	//------------------------------------------------------------------------------------------------------------------
52  
53  	@Rest(callLogger=CaptureLogger.class)
54  	public static class A1_RestOp implements BasicUniversalConfig {
55  		@RestOp
56  		public boolean aa(RestRequest req) {
57  			return req.isDebug();
58  		}
59  		@RestOp(debug="false")
60  		public boolean ab(RestRequest req) {
61  			return req.isDebug();
62  		}
63  		@RestOp(debug="true")
64  		public boolean ac(RestRequest req) {
65  			return req.isDebug();
66  		}
67  		@RestOp(debug="conditional")
68  		public boolean ad(RestRequest req) {
69  			return req.isDebug();
70  		}
71  		@RestOp(debug="foo")
72  		public boolean ae(RestRequest req) {
73  			return req.isDebug();
74  		}
75  		@RestOp
76  		public boolean af(RestRequest req) throws Exception {
77  			req.setDebug();
78  			return req.isDebug();
79  		}
80  		@RestOp
81  		public boolean ag(RestRequest req) throws Exception {
82  			req.setDebug(false);
83  			return req.isDebug();
84  		}
85  		@RestGet
86  		public boolean ba(RestRequest req) {
87  			return req.isDebug();
88  		}
89  		@RestGet(debug="false")
90  		public boolean bb(RestRequest req) {
91  			return req.isDebug();
92  		}
93  		@RestGet(debug="true")
94  		public boolean bc(RestRequest req) {
95  			return req.isDebug();
96  		}
97  		@RestGet(debug="conditional")
98  		public boolean bd(RestRequest req) {
99  			return req.isDebug();
100 		}
101 		@RestGet(debug="foo")
102 		public boolean be(RestRequest req) {
103 			return req.isDebug();
104 		}
105 		@RestGet
106 		public boolean bf(RestRequest req) throws Exception {
107 			req.setDebug();
108 			return req.isDebug();
109 		}
110 		@RestGet
111 		public boolean bg(RestRequest req) throws Exception {
112 			req.setDebug(false);
113 			return req.isDebug();
114 		}
115 	}
116 
117 	@Test void a01_restOp_debugDefault() throws Exception {
118 		var a1 = MockRestClient.buildJson5(A1_RestOp.class);
119 		var a1d = MockRestClient.create(A1_RestOp.class).json5().debug().suppressLogging().build();
120 
121 		a1.get("/aa").run().assertContent("false");
122 		assertNotLogged();
123 		a1d.get("/aa").run().assertContent("true");
124 		assertLogged("[200] HTTP GET /aa");
125 
126 		a1.get("/ab").run().assertContent("false");
127 		assertNotLogged();
128 		a1d.get("/ab").run().assertContent("false");
129 		assertNotLogged();
130 
131 		a1.get("/ac").run().assertContent("true");
132 		assertLogged("[200] HTTP GET /ac");
133 		a1d.get("/ac").run().assertContent("true");
134 		assertLogged("[200] HTTP GET /ac");
135 
136 		a1.get("/ad").run().assertContent("false");
137 		assertNotLogged();
138 		a1d.get("/ad").run().assertContent("true");
139 		assertLogged("[200] HTTP GET /ad");
140 
141 		a1.get("/ae").run().assertContent("false");
142 		assertNotLogged();
143 		a1d.get("/ae").run().assertContent("true");
144 		assertLogged("[200] HTTP GET /ae");
145 
146 		a1.get("/af").run().assertContent("true");
147 		assertLogged("[200] HTTP GET /af");
148 		a1d.get("/af").run().assertContent("true");
149 		assertLogged("[200] HTTP GET /af");
150 
151 		a1.get("/ag").run().assertContent("false");
152 		assertNotLogged();
153 		a1d.get("/ag").run().assertContent("false");
154 		assertNotLogged();
155 
156 		a1.get("/ba").run().assertContent("false");
157 		assertNotLogged();
158 		a1d.get("/ba").run().assertContent("true");
159 		assertLogged("[200] HTTP GET /ba");
160 
161 		a1.get("/bb").run().assertContent("false");
162 		assertNotLogged();
163 		a1d.get("/bb").run().assertContent("false");
164 		assertNotLogged();
165 
166 		a1.get("/bc").run().assertContent("true");
167 		assertLogged("[200] HTTP GET /bc");
168 		a1d.get("/bc").run().assertContent("true");
169 		assertLogged("[200] HTTP GET /bc");
170 
171 		a1.get("/bd").run().assertContent("false");
172 		assertNotLogged();
173 		a1d.get("/bd").run().assertContent("true");
174 		assertLogged("[200] HTTP GET /bd");
175 
176 		a1.get("/be").run().assertContent("false");
177 		assertNotLogged();
178 		a1d.get("/be").run().assertContent("true");
179 		assertLogged("[200] HTTP GET /be");
180 
181 		a1.get("/bf").run().assertContent("true");
182 		assertLogged("[200] HTTP GET /bf");
183 		a1d.get("/bf").run().assertContent("true");
184 		assertLogged("[200] HTTP GET /bf");
185 
186 		a1.get("/bg").run().assertContent("false");
187 		assertNotLogged();
188 		a1d.get("/bg").run().assertContent("false");
189 		assertNotLogged();
190 	}
191 
192 	@Rest(callLogger=CaptureLogger.class)
193 	public static class A1_RestGet implements BasicUniversalConfig {
194 		@RestGet
195 		public boolean a(RestRequest req) {
196 			return req.isDebug();
197 		}
198 		@RestGet(debug="false")
199 		public boolean b(RestRequest req) {
200 			return req.isDebug();
201 		}
202 		@RestGet(debug="true")
203 		public boolean c(RestRequest req) {
204 			return req.isDebug();
205 		}
206 		@RestGet(debug="conditional")
207 		public boolean d(RestRequest req) {
208 			return req.isDebug();
209 		}
210 		@RestGet(debug="foo")
211 		public boolean e(RestRequest req) {
212 			return req.isDebug();
213 		}
214 		@RestGet
215 		public boolean f(RestRequest req) throws Exception {
216 			req.setDebug();
217 			return req.isDebug();
218 		}
219 		@RestGet
220 		public boolean g(RestRequest req) throws Exception {
221 			req.setDebug(false);
222 			return req.isDebug();
223 		}
224 	}
225 
226 	@Rest(callLogger=CaptureLogger.class)
227 	public static class A1a extends BasicRestObject {
228 		@RestOp
229 		public boolean a(RestRequest req) {
230 			return req.isDebug();
231 		}
232 		@RestOp(debug="false")
233 		public boolean b(RestRequest req) {
234 			return req.isDebug();
235 		}
236 		@RestOp(debug="true")
237 		public boolean c(RestRequest req) {
238 			return req.isDebug();
239 		}
240 		@RestOp(debug="conditional")
241 		public boolean d(RestRequest req) {
242 			return req.isDebug();
243 		}
244 		@RestOp(debug="foo")
245 		public boolean e(RestRequest req) {
246 			return req.isDebug();
247 		}
248 		@RestOp
249 		public boolean f(RestRequest req) throws Exception {
250 			req.setDebug();
251 			return req.isDebug();
252 		}
253 		@RestOp
254 		public boolean g(RestRequest req) throws Exception {
255 			req.setDebug(false);
256 			return req.isDebug();
257 		}
258 	}
259 
260 	@Test void a01a_debugDefault() throws Exception {
261 		var a1a = MockRestClient.buildJson5(A1a.class);
262 		var a1ad = MockRestClient.create(A1a.class).json5().debug().suppressLogging().build();
263 
264 		a1a.get("/a").run().assertContent("false");
265 		assertNotLogged();
266 		a1ad.get("/a").run().assertContent("true");
267 		assertLogged("[200] HTTP GET /a");
268 
269 		a1a.get("/b").run().assertContent("false");
270 		assertNotLogged();
271 		a1ad.get("/b").run().assertContent("false");
272 		assertNotLogged();
273 
274 		a1a.get("/c").run().assertContent("true");
275 		assertLogged("[200] HTTP GET /c");
276 		a1ad.get("/c").run().assertContent("true");
277 		assertLogged("[200] HTTP GET /c");
278 
279 		a1a.get("/d").run().assertContent("false");
280 		assertNotLogged();
281 		a1ad.get("/d").run().assertContent("true");
282 		assertLogged("[200] HTTP GET /d");
283 
284 		a1a.get("/e").run().assertContent("false");
285 		assertNotLogged();
286 		a1ad.get("/e").run().assertContent("true");
287 		assertLogged("[200] HTTP GET /e");
288 
289 		a1a.get("/f").run().assertContent("true");
290 		assertLogged();
291 		a1ad.get("/f").run().assertContent("true");
292 		assertLogged();
293 
294 		a1a.get("/g").run().assertContent("false");
295 		assertNotLogged();
296 		a1ad.get("/g").run().assertContent("false");
297 		assertNotLogged();
298 	}
299 
300 	//------------------------------------------------------------------------------------------------------------------
301 	// @Rest(debug="true"), various @RestOp(debug)
302 	//------------------------------------------------------------------------------------------------------------------
303 
304 	@Rest(callLogger=CaptureLogger.class, debug="true")
305 	public static class A2 implements BasicUniversalConfig {
306 		@RestOp
307 		public boolean a(RestRequest req) {
308 			return req.isDebug();
309 		}
310 		@RestOp(debug="false")
311 		public boolean b(RestRequest req) {
312 			return req.isDebug();
313 		}
314 		@RestOp(debug="true")
315 		public boolean c(RestRequest req) {
316 			return req.isDebug();
317 		}
318 		@RestOp(debug="conditional")
319 		public boolean d(RestRequest req) {
320 			return req.isDebug();
321 		}
322 		@RestOp(debug="foo")
323 		public boolean e(RestRequest req) {
324 			return req.isDebug();
325 		}
326 		@RestOp
327 		public boolean f(RestRequest req) throws Exception {
328 			req.setDebug();
329 			return req.isDebug();
330 		}
331 		@RestOp
332 		public boolean g(RestRequest req) throws Exception {
333 			req.setDebug(false);
334 			return req.isDebug();
335 		}
336 	}
337 
338 	@Test void a02_debugTrue() throws Exception {
339 		var a2 = MockRestClient.buildJson5(A2.class);
340 		var a2d = MockRestClient.create(A2.class).json5().debug().suppressLogging().build();
341 
342 		a2.get("/a").run().assertContent("true");
343 		assertLogged();
344 		a2d.get("/a").run().assertContent("true");
345 		assertLogged();
346 
347 		a2.get("/b").run().assertContent("false");
348 		assertNotLogged();
349 		a2d.get("/b").run().assertContent("false");
350 		assertNotLogged();
351 
352 		a2.get("/c").run().assertContent("true");
353 		assertLogged();
354 		a2d.get("/c").run().assertContent("true");
355 		assertLogged();
356 
357 		a2.get("/d").run().assertContent("false");
358 		assertNotLogged();
359 		a2d.get("/d").run().assertContent("true");
360 		assertLogged();
361 
362 		a2.get("/e").run().assertContent("true");
363 		assertLogged();
364 		a2d.get("/e").run().assertContent("true");
365 		assertLogged();
366 
367 		a2.get("/f").run().assertContent("true");
368 		assertLogged();
369 		a2d.get("/f").run().assertContent("true");
370 		assertLogged();
371 
372 		a2.get("/g").run().assertContent("false");
373 		assertNotLogged();
374 		a2d.get("/g").run().assertContent("false");
375 		assertNotLogged();
376 	}
377 
378 	//------------------------------------------------------------------------------------------------------------------
379 	// @Rest(debug="false"), various @RestOp(debug)
380 	//------------------------------------------------------------------------------------------------------------------
381 
382 	@Rest(callLogger=CaptureLogger.class,debug="false")
383 	public static class A3 implements BasicUniversalConfig {
384 		@RestOp
385 		public boolean a(RestRequest req) {
386 			return req.isDebug();
387 		}
388 		@RestOp(debug="false")
389 		public boolean b(RestRequest req) {
390 			return req.isDebug();
391 		}
392 		@RestOp(debug="true")
393 		public boolean c(RestRequest req) {
394 			return req.isDebug();
395 		}
396 		@RestOp(debug="conditional")
397 		public boolean d(RestRequest req) {
398 			return req.isDebug();
399 		}
400 		@RestOp(debug="foo")
401 		public boolean e(RestRequest req) {
402 			return req.isDebug();
403 		}
404 		@RestOp
405 		public boolean f(RestRequest req) throws Exception {
406 			req.setDebug();
407 			return req.isDebug();
408 		}
409 		@RestOp
410 		public boolean g(RestRequest req) throws Exception {
411 			req.setDebug(false);
412 			return req.isDebug();
413 		}
414 	}
415 
416 	@Test void a03_restDebugFalse() throws Exception {
417 		var a3 = MockRestClient.buildJson5(A3.class);
418 		var a3d = MockRestClient.create(A3.class).json5().debug().suppressLogging().build();
419 
420 		a3.get("/a").run().assertContent("false");
421 		assertNotLogged();
422 		a3d.get("/a").run().assertContent("false");
423 		assertNotLogged();
424 
425 		a3.get("/b").run().assertContent("false");
426 		assertNotLogged();
427 		a3d.get("/b").run().assertContent("false");
428 		assertNotLogged();
429 
430 		a3.get("/c").run().assertContent("true");
431 		assertLogged("[200] HTTP GET /c");
432 		a3d.get("/c").run().assertContent("true");
433 		assertLogged("[200] HTTP GET /c");
434 
435 		a3.get("/d").run().assertContent("false");
436 		assertNotLogged();
437 		a3d.get("/d").run().assertContent("true");
438 		assertLogged("[200] HTTP GET /d");
439 
440 		a3.get("/e").run().assertContent("false");
441 		assertNotLogged();
442 		a3d.get("/e").run().assertContent("false");
443 		assertNotLogged();
444 
445 		a3.get("/f").run().assertContent("true");
446 		assertLogged();
447 		a3d.get("/f").run().assertContent("true");
448 		assertLogged();
449 
450 		a3.get("/g").run().assertContent("false");
451 		assertNotLogged();
452 		a3d.get("/g").run().assertContent("false");
453 		assertNotLogged();
454 	}
455 
456 	//------------------------------------------------------------------------------------------------------------------
457 	// @Rest(debug="conditional"), various @RestOp(debug)
458 	//------------------------------------------------------------------------------------------------------------------
459 
460 	@Rest(callLogger=CaptureLogger.class,debug="conditional")
461 	public static class A4 implements BasicUniversalConfig {
462 		@RestOp
463 		public boolean a(RestRequest req) {
464 			return req.isDebug();
465 		}
466 		@RestOp(debug="false")
467 		public boolean b(RestRequest req) {
468 			return req.isDebug();
469 		}
470 		@RestOp(debug="true")
471 		public boolean c(RestRequest req) {
472 			return req.isDebug();
473 		}
474 		@RestOp(debug="conditional")
475 		public boolean d(RestRequest req) {
476 			return req.isDebug();
477 		}
478 		@RestOp(debug="foo")
479 		public boolean e(RestRequest req) {
480 			return req.isDebug();
481 		}
482 		@RestOp
483 		public boolean f(RestRequest req) throws Exception {
484 			req.setDebug();
485 			return req.isDebug();
486 		}
487 		@RestOp
488 		public boolean g(RestRequest req) throws Exception {
489 			req.setDebug(false);
490 			return req.isDebug();
491 		}
492 	}
493 
494 	@Test void a04_debugPerRequest() throws Exception {
495 		var a4 = MockRestClient.buildJson5(A4.class);
496 		var a4d = MockRestClient.create(A4.class).json5().debug().suppressLogging().build();
497 
498 		a4.get("/a").run().assertContent("false");
499 		assertNotLogged();
500 		a4d.get("/a").run().assertContent("true");
501 		assertLogged();
502 
503 		a4.get("/b").run().assertContent("false");
504 		assertNotLogged();
505 		a4d.get("/b").run().assertContent("false");
506 		assertNotLogged();
507 
508 		a4.get("/c").run().assertContent("true");
509 		assertLogged("[200] HTTP GET /c");
510 		a4d.get("/c").run().assertContent("true");
511 		assertLogged("[200] HTTP GET /c");
512 
513 		a4.get("/d").run().assertContent("false");
514 		assertNotLogged();
515 		a4d.get("/d").run().assertContent("true");
516 		assertLogged("[200] HTTP GET /d");
517 
518 		a4.get("/e").run().assertContent("false");
519 		assertNotLogged();
520 		a4d.get("/e").run().assertContent("true");
521 		assertLogged();
522 
523 		a4.get("/f").run().assertContent("true");
524 		assertLogged();
525 		a4d.get("/f").run().assertContent("true");
526 		assertLogged();
527 
528 		a4.get("/g").run().assertContent("false");
529 		assertNotLogged();
530 		a4d.get("/g").run().assertContent("false");
531 		assertNotLogged();
532 	}
533 
534 	//------------------------------------------------------------------------------------------------------------------
535 	// @Rest(debugOn=""), various @RestOp(debug)
536 	//------------------------------------------------------------------------------------------------------------------
537 
538 	@Rest(
539 		callLogger=CaptureLogger.class,
540 		debugOn="""
541 			C1.b1=false,C1.b2=false,C1.b3=FALSE,C1.b4=FALSE,C1.b5=FALSE,C1.b6=FALSE,\
542 			 C1.c1 , C1.c2 = true , C1.c3 = TRUE , C1.c4 = TRUE , C1.c5 = TRUE , C1.c6 = TRUE , \
543 			C1.d1=conditional,C1.d2=conditional,C1.d3=CONDITIONAL,C1.d4=CONDITIONAL,C1.d5=CONDITIONAL,C1.d6=CONDITIONAL,\
544 			C1.e1=foo,C1.e2,C1.e3=foo,C1.e4=foo,C1.e5=foo,C1.e6=foo,"""
545 	)
546 	public static class C1 implements BasicUniversalConfig {
547 
548 		@RestOp
549 		public boolean a1(RestRequest req) {
550 			return req.isDebug();
551 		}
552 		@RestOp(debug="false")
553 		public boolean a2(RestRequest req) {
554 			return req.isDebug();
555 		}
556 		@RestOp(debug="true")
557 		public boolean a3(RestRequest req) {
558 			return req.isDebug();
559 		}
560 		@RestOp(debug="conditional")
561 		public boolean a4(RestRequest req) {
562 			return req.isDebug();
563 		}
564 
565 		// debug=false
566 		@RestOp
567 		public boolean b1(RestRequest req) {
568 			return req.isDebug();
569 		}
570 		@RestOp
571 		public boolean b2(RestRequest req) {
572 			return req.isDebug();
573 		}
574 		@RestOp
575 		public boolean b3(RestRequest req) {
576 			return req.isDebug();
577 		}
578 		@RestOp(debug="false")
579 		public boolean b4(RestRequest req) {
580 			return req.isDebug();
581 		}
582 		@RestOp(debug="true")
583 		public boolean b5(RestRequest req) {
584 			return req.isDebug();
585 		}
586 		@RestOp(debug="conditional")
587 		public boolean b6(RestRequest req) {
588 			return req.isDebug();
589 		}
590 
591 		// debug=true
592 		@RestOp
593 		public boolean c1(RestRequest req) {
594 			return req.isDebug();
595 		}
596 		@RestOp
597 		public boolean c2(RestRequest req) {
598 			return req.isDebug();
599 		}
600 		@RestOp
601 		public boolean c3(RestRequest req) {
602 			return req.isDebug();
603 		}
604 		@RestOp(debug="false")
605 		public boolean c4(RestRequest req) {
606 			return req.isDebug();
607 		}
608 		@RestOp(debug="true")
609 		public boolean c5(RestRequest req) {
610 			return req.isDebug();
611 		}
612 		@RestOp(debug="conditional")
613 		public boolean c6(RestRequest req) {
614 			return req.isDebug();
615 		}
616 
617 		// debug=conditional
618 		@RestOp
619 		public boolean d1(RestRequest req) {
620 			return req.isDebug();
621 		}
622 		@RestOp
623 		public boolean d2(RestRequest req) {
624 			return req.isDebug();
625 		}
626 		@RestOp
627 		public boolean d3(RestRequest req) {
628 			return req.isDebug();
629 		}
630 		@RestOp(debug="false")
631 		public boolean d4(RestRequest req) {
632 			return req.isDebug();
633 		}
634 		@RestOp(debug="true")
635 		public boolean d5(RestRequest req) {
636 			return req.isDebug();
637 		}
638 		@RestOp(debug="conditional")
639 		public boolean d6(RestRequest req) {
640 			return req.isDebug();
641 		}
642 
643 		// debug=foo
644 		@RestOp
645 		public boolean e1(RestRequest req) {
646 			return req.isDebug();
647 		}
648 		@RestOp
649 		public boolean e2(RestRequest req) {
650 			return req.isDebug();
651 		}
652 		@RestOp
653 		public boolean e3(RestRequest req) {
654 			return req.isDebug();
655 		}
656 		@RestOp(debug="false")
657 		public boolean e4(RestRequest req) {
658 			return req.isDebug();
659 		}
660 		@RestOp(debug="true")
661 		public boolean e5(RestRequest req) {
662 			return req.isDebug();
663 		}
664 		@RestOp(debug="conditional")
665 		public boolean e6(RestRequest req) {
666 			return req.isDebug();
667 		}
668 
669 		@RestOp
670 		public boolean f1(RestRequest req) throws Exception {
671 			req.setDebug();
672 			return req.isDebug();
673 		}
674 		@RestOp(debug="false")
675 		public boolean f2(RestRequest req) throws Exception {
676 			req.setDebug();
677 			return req.isDebug();
678 		}
679 		@RestOp(debug="true")
680 		public boolean f3(RestRequest req) throws Exception {
681 			req.setDebug();
682 			return req.isDebug();
683 		}
684 		@RestOp(debug="conditional")
685 		public boolean f4(RestRequest req) throws Exception {
686 			req.setDebug();
687 			return req.isDebug();
688 		}
689 
690 		@RestOp
691 		public boolean g1(RestRequest req) throws Exception {
692 			req.setDebug(false);
693 			return req.isDebug();
694 		}
695 		@RestOp(debug="false")
696 		public boolean g2(RestRequest req) throws Exception {
697 			req.setDebug(false);
698 			return req.isDebug();
699 		}
700 		@RestOp(debug="true")
701 		public boolean g3(RestRequest req) throws Exception {
702 			req.setDebug(false);
703 			return req.isDebug();
704 		}
705 		@RestOp(debug="conditional")
706 		public boolean g4(RestRequest req) throws Exception {
707 			req.setDebug(false);
708 			return req.isDebug();
709 		}
710 	}
711 
712 	@Test void c01_debugDefault() throws Exception {
713 		var c1 = MockRestClient.buildJson5(C1.class);
714 		var c1d = MockRestClient.create(C1.class).json5().debug().suppressLogging().build();
715 
716 		c1.get("/a1").run().assertContent("false");
717 		assertNotLogged();
718 		c1d.get("/a1").run().assertContent("true");
719 		assertLogged("[200] HTTP GET /a1");
720 		c1.get("/a2").run().assertContent("false");
721 		assertNotLogged();
722 		c1d.get("/a2").run().assertContent("false");
723 		assertNotLogged();
724 		c1.get("/a3").run().assertContent("true");
725 		assertLogged();
726 		c1d.get("/a3").run().assertContent("true");
727 		assertLogged();
728 		c1.get("/a4").run().assertContent("false");
729 		assertNotLogged();
730 		c1d.get("/a4").run().assertContent("true");
731 		assertLogged();
732 
733 		c1.get("/b1").run().assertContent("false");
734 		assertNotLogged();
735 		c1d.get("/b1").run().assertContent("false");
736 		assertNotLogged();
737 		c1.get("/b2").run().assertContent("false");
738 		assertNotLogged();
739 		c1d.get("/b2").run().assertContent("false");
740 		assertNotLogged();
741 		c1.get("/b3").run().assertContent("false");
742 		assertNotLogged();
743 		c1d.get("/b3").run().assertContent("false");
744 		assertNotLogged();
745 		c1.get("/b4").run().assertContent("false");
746 		assertNotLogged();
747 		c1d.get("/b4").run().assertContent("false");
748 		assertNotLogged();
749 		c1.get("/b5").run().assertContent("true");
750 		assertLogged();
751 		c1d.get("/b5").run().assertContent("true");
752 		assertLogged();
753 		c1.get("/b6").run().assertContent("false");
754 		assertNotLogged();
755 		c1d.get("/b6").run().assertContent("true");
756 		assertLogged();
757 
758 		c1.get("/c1").run().assertContent("true");
759 		assertLogged("[200] HTTP GET /c1");
760 		c1d.get("/c1").run().assertContent("true");
761 		assertLogged("[200] HTTP GET /c1");
762 		c1.get("/c2").run().assertContent("true");
763 		assertLogged("[200] HTTP GET /c2");
764 		c1d.get("/c2").run().assertContent("true");
765 		assertLogged("[200] HTTP GET /c2");
766 		c1.get("/c3").run().assertContent("true");
767 		assertLogged("[200] HTTP GET /c3");
768 		c1d.get("/c3").run().assertContent("true");
769 		assertLogged("[200] HTTP GET /c3");
770 		c1.get("/c4").run().assertContent("false");
771 		assertNotLogged();
772 		c1d.get("/c4").run().assertContent("false");
773 		assertNotLogged();
774 		c1.get("/c5").run().assertContent("true");
775 		assertLogged("[200] HTTP GET /c5");
776 		c1d.get("/c5").run().assertContent("true");
777 		assertLogged("[200] HTTP GET /c5");
778 		c1.get("/c6").run().assertContent("false");
779 		assertNotLogged();
780 		c1d.get("/c6").run().assertContent("true");
781 		assertLogged("[200] HTTP GET /c6");
782 
783 		c1.get("/d1").run().assertContent("false");
784 		assertNotLogged();
785 		c1d.get("/d1").run().assertContent("true");
786 		assertLogged("[200] HTTP GET /d1");
787 		c1.get("/d2").run().assertContent("false");
788 		assertNotLogged();
789 		c1d.get("/d2").run().assertContent("true");
790 		assertLogged("[200] HTTP GET /d2");
791 		c1.get("/d3").run().assertContent("false");
792 		assertNotLogged();
793 		c1d.get("/d3").run().assertContent("true");
794 		assertLogged("[200] HTTP GET /d3");
795 		c1.get("/d4").run().assertContent("false");
796 		assertNotLogged();
797 		c1d.get("/d4").run().assertContent("false");
798 		assertNotLogged();
799 		c1.get("/d5").run().assertContent("true");
800 		assertLogged("[200] HTTP GET /d5");
801 		c1d.get("/d5").run().assertContent("true");
802 		assertLogged("[200] HTTP GET /d5");
803 		c1.get("/d6").run().assertContent("false");
804 		assertNotLogged();
805 		c1d.get("/d6").run().assertContent("true");
806 		assertLogged("[200] HTTP GET /d6");
807 
808 		c1.get("/e1").run().assertContent("false");
809 		assertNotLogged();
810 		c1d.get("/e1").run().assertContent("true");
811 		assertLogged("[200] HTTP GET /e1");
812 		c1.get("/e2").run().assertContent("true");
813 		assertLogged("[200] HTTP GET /e2");
814 		c1d.get("/e2").run().assertContent("true");
815 		assertLogged("[200] HTTP GET /e2");
816 		c1.get("/e3").run().assertContent("false");
817 		assertNotLogged();
818 		c1d.get("/e3").run().assertContent("true");
819 		assertLogged("[200] HTTP GET /e3");
820 		c1.get("/e4").run().assertContent("false");
821 		assertNotLogged();
822 		c1d.get("/e4").run().assertContent("false");
823 		assertNotLogged();
824 		c1.get("/e5").run().assertContent("true");
825 		assertLogged("[200] HTTP GET /e5");
826 		c1d.get("/e5").run().assertContent("true");
827 		assertLogged("[200] HTTP GET /e5");
828 		c1.get("/e6").run().assertContent("false");
829 		assertNotLogged();
830 		c1d.get("/e6").run().assertContent("true");
831 		assertLogged("[200] HTTP GET /e6");
832 
833 		c1.get("/f1").run().assertContent("true");
834 		assertLogged();
835 		c1d.get("/f1").run().assertContent("true");
836 		assertLogged();
837 		c1.get("/f2").run().assertContent("true");
838 		assertLogged();
839 		c1d.get("/f2").run().assertContent("true");
840 		assertLogged();
841 		c1.get("/f3").run().assertContent("true");
842 		assertLogged();
843 		c1d.get("/f3").run().assertContent("true");
844 		assertLogged();
845 		c1.get("/f4").run().assertContent("true");
846 		assertLogged();
847 		c1d.get("/f4").run().assertContent("true");
848 		assertLogged();
849 
850 		c1.get("/g1").run().assertContent("false");
851 		assertNotLogged();
852 		c1d.get("/g1").run().assertContent("false");
853 		assertNotLogged();
854 		c1.get("/g2").run().assertContent("false");
855 		assertNotLogged();
856 		c1d.get("/g2").run().assertContent("false");
857 		assertNotLogged();
858 		c1.get("/g3").run().assertContent("false");
859 		assertNotLogged();
860 		c1d.get("/g3").run().assertContent("false");
861 		assertNotLogged();
862 		c1.get("/g4").run().assertContent("false");
863 		assertNotLogged();
864 		c1d.get("/g4").run().assertContent("false");
865 		assertNotLogged();
866 	}
867 
868 	static {
869 		System.setProperty("C2DebugEnabled", "C2=true");
870 	}
871 	@Rest(
872 		callLogger=CaptureLogger.class,
873 		debugOn="""
874 			$S{C2DebugEnabled},\
875 			C2.b1=false,C2.b2=false,C2.b3=FALSE,C2.b4=FALSE,C2.b5=FALSE,C2.b6=FALSE,\
876 			 C2.c1 , C2.c2 = true , C2.c3 = TRUE , C2.c4 = TRUE , C2.c5 = TRUE , C2.c6 = TRUE , \
877 			C2.d1=conditional,C2.d2=conditional,C2.d3=CONDITIONAL,C2.d4=CONDITIONAL,C2.d5=CONDITIONAL,C2.d6=CONDITIONAL,\
878 			C2.e1=foo,C2.e2=,C2.e3=foo,C2.e4=foo,C2.e5=foo,C2.e6=foo,"""
879 	)
880 	public static class C2 implements BasicUniversalConfig {
881 
882 		@RestOp
883 		public boolean a1(RestRequest req) {
884 			return req.isDebug();
885 		}
886 		@RestOp(debug="false")
887 		public boolean a2(RestRequest req) {
888 			return req.isDebug();
889 		}
890 		@RestOp(debug="true")
891 		public boolean a3(RestRequest req) {
892 			return req.isDebug();
893 		}
894 		@RestOp(debug="conditional")
895 		public boolean a4(RestRequest req) {
896 			return req.isDebug();
897 		}
898 
899 		// debug=false
900 		@RestOp
901 		public boolean b1(RestRequest req) {
902 			return req.isDebug();
903 		}
904 		@RestOp
905 		public boolean b2(RestRequest req) {
906 			return req.isDebug();
907 		}
908 		@RestOp
909 		public boolean b3(RestRequest req) {
910 			return req.isDebug();
911 		}
912 		@RestOp(debug="false")
913 		public boolean b4(RestRequest req) {
914 			return req.isDebug();
915 		}
916 		@RestOp(debug="true")
917 		public boolean b5(RestRequest req) {
918 			return req.isDebug();
919 		}
920 		@RestOp(debug="conditional")
921 		public boolean b6(RestRequest req) {
922 			return req.isDebug();
923 		}
924 
925 		// debug=true
926 		@RestOp
927 		public boolean c1(RestRequest req) {
928 			return req.isDebug();
929 		}
930 		@RestOp
931 		public boolean c2(RestRequest req) {
932 			return req.isDebug();
933 		}
934 		@RestOp
935 		public boolean c3(RestRequest req) {
936 			return req.isDebug();
937 		}
938 		@RestOp(debug="false")
939 		public boolean c4(RestRequest req) {
940 			return req.isDebug();
941 		}
942 		@RestOp(debug="true")
943 		public boolean c5(RestRequest req) {
944 			return req.isDebug();
945 		}
946 		@RestOp(debug="conditional")
947 		public boolean c6(RestRequest req) {
948 			return req.isDebug();
949 		}
950 
951 		// debug=conditional
952 		@RestOp
953 		public boolean d1(RestRequest req) {
954 			return req.isDebug();
955 		}
956 		@RestOp
957 		public boolean d2(RestRequest req) {
958 			return req.isDebug();
959 		}
960 		@RestOp
961 		public boolean d3(RestRequest req) {
962 			return req.isDebug();
963 		}
964 		@RestOp(debug="false")
965 		public boolean d4(RestRequest req) {
966 			return req.isDebug();
967 		}
968 		@RestOp(debug="true")
969 		public boolean d5(RestRequest req) {
970 			return req.isDebug();
971 		}
972 		@RestOp(debug="conditional")
973 		public boolean d6(RestRequest req) {
974 			return req.isDebug();
975 		}
976 
977 		// debug=foo
978 		@RestOp
979 		public boolean e1(RestRequest req) {
980 			return req.isDebug();
981 		}
982 		@RestOp
983 		public boolean e2(RestRequest req) {
984 			return req.isDebug();
985 		}
986 		@RestOp
987 		public boolean e3(RestRequest req) {
988 			return req.isDebug();
989 		}
990 		@RestOp(debug="false")
991 		public boolean e4(RestRequest req) {
992 			return req.isDebug();
993 		}
994 		@RestOp(debug="true")
995 		public boolean e5(RestRequest req) {
996 			return req.isDebug();
997 		}
998 		@RestOp(debug="conditional")
999 		public boolean e6(RestRequest req) {
1000 			return req.isDebug();
1001 		}
1002 
1003 		@RestOp
1004 		public boolean f1(RestRequest req) throws Exception {
1005 			req.setDebug();
1006 			return req.isDebug();
1007 		}
1008 		@RestOp(debug="false")
1009 		public boolean f2(RestRequest req) throws Exception {
1010 			req.setDebug();
1011 			return req.isDebug();
1012 		}
1013 		@RestOp(debug="true")
1014 		public boolean f3(RestRequest req) throws Exception {
1015 			req.setDebug();
1016 			return req.isDebug();
1017 		}
1018 		@RestOp(debug="conditional")
1019 		public boolean f4(RestRequest req) throws Exception {
1020 			req.setDebug();
1021 			return req.isDebug();
1022 		}
1023 
1024 		@RestOp
1025 		public boolean g1(RestRequest req) throws Exception {
1026 			req.setDebug(false);
1027 			return req.isDebug();
1028 		}
1029 		@RestOp(debug="false")
1030 		public boolean g2(RestRequest req) throws Exception {
1031 			req.setDebug(false);
1032 			return req.isDebug();
1033 		}
1034 		@RestOp(debug="true")
1035 		public boolean g3(RestRequest req) throws Exception {
1036 			req.setDebug(false);
1037 			return req.isDebug();
1038 		}
1039 		@RestOp(debug="conditional")
1040 		public boolean g4(RestRequest req) throws Exception {
1041 			req.setDebug(false);
1042 			return req.isDebug();
1043 		}
1044 	}
1045 
1046 	@Test void c02_debugTrue() throws Exception {
1047 		var c2 = MockRestClient.buildJson5(C2.class);
1048 		var c2d = MockRestClient.create(C2.class).json5().debug().suppressLogging().build();
1049 
1050 		c2.get("/a1").run().assertContent("true");
1051 		assertLogged();
1052 		c2d.get("/a1").run().assertContent("true");
1053 		assertLogged();
1054 		c2.get("/a2").run().assertContent("false");
1055 		assertNotLogged();
1056 		c2d.get("/a2").run().assertContent("false");
1057 		assertNotLogged();
1058 		c2.get("/a3").run().assertContent("true");
1059 		assertLogged();
1060 		c2d.get("/a3").run().assertContent("true");
1061 		assertLogged();
1062 		c2.get("/a4").run().assertContent("false");
1063 		assertNotLogged();
1064 		c2d.get("/a4").run().assertContent("true");
1065 		assertLogged();
1066 
1067 		c2.get("/b1").run().assertContent("false");
1068 		assertNotLogged();
1069 		c2d.get("/b1").run().assertContent("false");
1070 		assertNotLogged();
1071 		c2.get("/b2").run().assertContent("false");
1072 		assertNotLogged();
1073 		c2d.get("/b2").run().assertContent("false");
1074 		assertNotLogged();
1075 		c2.get("/b3").run().assertContent("false");
1076 		assertNotLogged();
1077 		c2d.get("/b3").run().assertContent("false");
1078 		assertNotLogged();
1079 		c2.get("/b4").run().assertContent("false");
1080 		assertNotLogged();
1081 		c2d.get("/b4").run().assertContent("false");
1082 		assertNotLogged();
1083 		c2.get("/b5").run().assertContent("true");
1084 		assertLogged();
1085 		c2d.get("/b5").run().assertContent("true");
1086 		assertLogged();
1087 		c2.get("/b6").run().assertContent("false");
1088 		assertNotLogged();
1089 		c2d.get("/b6").run().assertContent("true");
1090 		assertLogged();
1091 
1092 		c2.get("/c1").run().assertContent("true");
1093 		assertLogged("[200] HTTP GET /c1");
1094 		c2d.get("/c1").run().assertContent("true");
1095 		assertLogged("[200] HTTP GET /c1");
1096 		c2.get("/c2").run().assertContent("true");
1097 		assertLogged("[200] HTTP GET /c2");
1098 		c2d.get("/c2").run().assertContent("true");
1099 		assertLogged("[200] HTTP GET /c2");
1100 		c2.get("/c3").run().assertContent("true");
1101 		assertLogged("[200] HTTP GET /c3");
1102 		c2d.get("/c3").run().assertContent("true");
1103 		assertLogged("[200] HTTP GET /c3");
1104 		c2.get("/c4").run().assertContent("false");
1105 		assertNotLogged();
1106 		c2d.get("/c4").run().assertContent("false");
1107 		assertNotLogged();
1108 		c2.get("/c5").run().assertContent("true");
1109 		assertLogged("[200] HTTP GET /c5");
1110 		c2d.get("/c5").run().assertContent("true");
1111 		assertLogged("[200] HTTP GET /c5");
1112 		c2.get("/c6").run().assertContent("false");
1113 		assertNotLogged();
1114 		c2d.get("/c6").run().assertContent("true");
1115 		assertLogged("[200] HTTP GET /c6");
1116 
1117 		c2.get("/d1").run().assertContent("false");
1118 		assertNotLogged();
1119 		c2d.get("/d1").run().assertContent("true");
1120 		assertLogged("[200] HTTP GET /d1");
1121 		c2.get("/d2").run().assertContent("false");
1122 		assertNotLogged();
1123 		c2d.get("/d2").run().assertContent("true");
1124 		assertLogged("[200] HTTP GET /d2");
1125 		c2.get("/d3").run().assertContent("false");
1126 		assertNotLogged();
1127 		c2d.get("/d3").run().assertContent("true");
1128 		assertLogged("[200] HTTP GET /d3");
1129 		c2.get("/d4").run().assertContent("false");
1130 		assertNotLogged();
1131 		c2d.get("/d4").run().assertContent("false");
1132 		assertNotLogged();
1133 		c2.get("/d5").run().assertContent("true");
1134 		assertLogged("[200] HTTP GET /d5");
1135 		c2d.get("/d5").run().assertContent("true");
1136 		assertLogged("[200] HTTP GET /d5");
1137 		c2.get("/d6").run().assertContent("false");
1138 		assertNotLogged();
1139 		c2d.get("/d6").run().assertContent("true");
1140 		assertLogged("[200] HTTP GET /d6");
1141 
1142 		c2.get("/e1").run().assertContent("true");
1143 		assertLogged();
1144 		c2d.get("/d1").run().assertContent("true");
1145 		assertLogged();
1146 		c2.get("/e2").run().assertContent("true");
1147 		assertLogged();
1148 		c2d.get("/e2").run().assertContent("true");
1149 		assertLogged();
1150 		c2.get("/e3").run().assertContent("true");
1151 		assertLogged();
1152 		c2d.get("/e3").run().assertContent("true");
1153 		assertLogged();
1154 		c2.get("/e4").run().assertContent("false");
1155 		assertNotLogged();
1156 		c2d.get("/e4").run().assertContent("false");
1157 		assertNotLogged();
1158 		c2.get("/e5").run().assertContent("true");
1159 		assertLogged();
1160 		c2d.get("/e5").run().assertContent("true");
1161 		assertLogged();
1162 		c2.get("/e6").run().assertContent("false");
1163 		assertNotLogged();
1164 		c2d.get("/e6").run().assertContent("true");
1165 		assertLogged();
1166 
1167 		c2.get("/f1").run().assertContent("true");
1168 		assertLogged();
1169 		c2d.get("/f1").run().assertContent("true");
1170 		assertLogged();
1171 		c2.get("/f2").run().assertContent("true");
1172 		assertLogged();
1173 		c2d.get("/f2").run().assertContent("true");
1174 		assertLogged();
1175 		c2.get("/f3").run().assertContent("true");
1176 		assertLogged();
1177 		c2d.get("/f3").run().assertContent("true");
1178 		assertLogged();
1179 		c2.get("/f4").run().assertContent("true");
1180 		assertLogged();
1181 		c2d.get("/f4").run().assertContent("true");
1182 		assertLogged();
1183 
1184 		c2.get("/g1").run().assertContent("false");
1185 		assertNotLogged();
1186 		c2d.get("/g1").run().assertContent("false");
1187 		assertNotLogged();
1188 		c2.get("/g2").run().assertContent("false");
1189 		assertNotLogged();
1190 		c2d.get("/g2").run().assertContent("false");
1191 		assertNotLogged();
1192 		c2.get("/g3").run().assertContent("false");
1193 		assertNotLogged();
1194 		c2d.get("/g3").run().assertContent("false");
1195 		assertNotLogged();
1196 		c2.get("/g4").run().assertContent("false");
1197 		assertNotLogged();
1198 		c2d.get("/g4").run().assertContent("false");
1199 		assertNotLogged();
1200 	}
1201 }