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="$S{C2DebugEnabled},"
874 			+ "C2.b1=false,C2.b2=false,C2.b3=FALSE,C2.b4=FALSE,C2.b5=FALSE,C2.b6=FALSE,"
875 			+ " C2.c1 , C2.c2 = true , C2.c3 = TRUE , C2.c4 = TRUE , C2.c5 = TRUE , C2.c6 = TRUE , "
876 			+ "C2.d1=conditional,C2.d2=conditional,C2.d3=CONDITIONAL,C2.d4=CONDITIONAL,C2.d5=CONDITIONAL,C2.d6=CONDITIONAL,"
877 			+ "C2.e1=foo,C2.e2=,C2.e3=foo,C2.e4=foo,C2.e5=foo,C2.e6=foo,"
878 	)
879 	public static class C2 implements BasicUniversalConfig {
880 
881 		@RestOp
882 		public boolean a1(RestRequest req) {
883 			return req.isDebug();
884 		}
885 		@RestOp(debug="false")
886 		public boolean a2(RestRequest req) {
887 			return req.isDebug();
888 		}
889 		@RestOp(debug="true")
890 		public boolean a3(RestRequest req) {
891 			return req.isDebug();
892 		}
893 		@RestOp(debug="conditional")
894 		public boolean a4(RestRequest req) {
895 			return req.isDebug();
896 		}
897 
898 		// debug=false
899 		@RestOp
900 		public boolean b1(RestRequest req) {
901 			return req.isDebug();
902 		}
903 		@RestOp
904 		public boolean b2(RestRequest req) {
905 			return req.isDebug();
906 		}
907 		@RestOp
908 		public boolean b3(RestRequest req) {
909 			return req.isDebug();
910 		}
911 		@RestOp(debug="false")
912 		public boolean b4(RestRequest req) {
913 			return req.isDebug();
914 		}
915 		@RestOp(debug="true")
916 		public boolean b5(RestRequest req) {
917 			return req.isDebug();
918 		}
919 		@RestOp(debug="conditional")
920 		public boolean b6(RestRequest req) {
921 			return req.isDebug();
922 		}
923 
924 		// debug=true
925 		@RestOp
926 		public boolean c1(RestRequest req) {
927 			return req.isDebug();
928 		}
929 		@RestOp
930 		public boolean c2(RestRequest req) {
931 			return req.isDebug();
932 		}
933 		@RestOp
934 		public boolean c3(RestRequest req) {
935 			return req.isDebug();
936 		}
937 		@RestOp(debug="false")
938 		public boolean c4(RestRequest req) {
939 			return req.isDebug();
940 		}
941 		@RestOp(debug="true")
942 		public boolean c5(RestRequest req) {
943 			return req.isDebug();
944 		}
945 		@RestOp(debug="conditional")
946 		public boolean c6(RestRequest req) {
947 			return req.isDebug();
948 		}
949 
950 		// debug=conditional
951 		@RestOp
952 		public boolean d1(RestRequest req) {
953 			return req.isDebug();
954 		}
955 		@RestOp
956 		public boolean d2(RestRequest req) {
957 			return req.isDebug();
958 		}
959 		@RestOp
960 		public boolean d3(RestRequest req) {
961 			return req.isDebug();
962 		}
963 		@RestOp(debug="false")
964 		public boolean d4(RestRequest req) {
965 			return req.isDebug();
966 		}
967 		@RestOp(debug="true")
968 		public boolean d5(RestRequest req) {
969 			return req.isDebug();
970 		}
971 		@RestOp(debug="conditional")
972 		public boolean d6(RestRequest req) {
973 			return req.isDebug();
974 		}
975 
976 		// debug=foo
977 		@RestOp
978 		public boolean e1(RestRequest req) {
979 			return req.isDebug();
980 		}
981 		@RestOp
982 		public boolean e2(RestRequest req) {
983 			return req.isDebug();
984 		}
985 		@RestOp
986 		public boolean e3(RestRequest req) {
987 			return req.isDebug();
988 		}
989 		@RestOp(debug="false")
990 		public boolean e4(RestRequest req) {
991 			return req.isDebug();
992 		}
993 		@RestOp(debug="true")
994 		public boolean e5(RestRequest req) {
995 			return req.isDebug();
996 		}
997 		@RestOp(debug="conditional")
998 		public boolean e6(RestRequest req) {
999 			return req.isDebug();
1000 		}
1001 
1002 		@RestOp
1003 		public boolean f1(RestRequest req) throws Exception {
1004 			req.setDebug();
1005 			return req.isDebug();
1006 		}
1007 		@RestOp(debug="false")
1008 		public boolean f2(RestRequest req) throws Exception {
1009 			req.setDebug();
1010 			return req.isDebug();
1011 		}
1012 		@RestOp(debug="true")
1013 		public boolean f3(RestRequest req) throws Exception {
1014 			req.setDebug();
1015 			return req.isDebug();
1016 		}
1017 		@RestOp(debug="conditional")
1018 		public boolean f4(RestRequest req) throws Exception {
1019 			req.setDebug();
1020 			return req.isDebug();
1021 		}
1022 
1023 		@RestOp
1024 		public boolean g1(RestRequest req) throws Exception {
1025 			req.setDebug(false);
1026 			return req.isDebug();
1027 		}
1028 		@RestOp(debug="false")
1029 		public boolean g2(RestRequest req) throws Exception {
1030 			req.setDebug(false);
1031 			return req.isDebug();
1032 		}
1033 		@RestOp(debug="true")
1034 		public boolean g3(RestRequest req) throws Exception {
1035 			req.setDebug(false);
1036 			return req.isDebug();
1037 		}
1038 		@RestOp(debug="conditional")
1039 		public boolean g4(RestRequest req) throws Exception {
1040 			req.setDebug(false);
1041 			return req.isDebug();
1042 		}
1043 	}
1044 
1045 	@Test void c02_debugTrue() throws Exception {
1046 		var c2 = MockRestClient.buildJson5(C2.class);
1047 		var c2d = MockRestClient.create(C2.class).json5().debug().suppressLogging().build();
1048 
1049 		c2.get("/a1").run().assertContent("true");
1050 		assertLogged();
1051 		c2d.get("/a1").run().assertContent("true");
1052 		assertLogged();
1053 		c2.get("/a2").run().assertContent("false");
1054 		assertNotLogged();
1055 		c2d.get("/a2").run().assertContent("false");
1056 		assertNotLogged();
1057 		c2.get("/a3").run().assertContent("true");
1058 		assertLogged();
1059 		c2d.get("/a3").run().assertContent("true");
1060 		assertLogged();
1061 		c2.get("/a4").run().assertContent("false");
1062 		assertNotLogged();
1063 		c2d.get("/a4").run().assertContent("true");
1064 		assertLogged();
1065 
1066 		c2.get("/b1").run().assertContent("false");
1067 		assertNotLogged();
1068 		c2d.get("/b1").run().assertContent("false");
1069 		assertNotLogged();
1070 		c2.get("/b2").run().assertContent("false");
1071 		assertNotLogged();
1072 		c2d.get("/b2").run().assertContent("false");
1073 		assertNotLogged();
1074 		c2.get("/b3").run().assertContent("false");
1075 		assertNotLogged();
1076 		c2d.get("/b3").run().assertContent("false");
1077 		assertNotLogged();
1078 		c2.get("/b4").run().assertContent("false");
1079 		assertNotLogged();
1080 		c2d.get("/b4").run().assertContent("false");
1081 		assertNotLogged();
1082 		c2.get("/b5").run().assertContent("true");
1083 		assertLogged();
1084 		c2d.get("/b5").run().assertContent("true");
1085 		assertLogged();
1086 		c2.get("/b6").run().assertContent("false");
1087 		assertNotLogged();
1088 		c2d.get("/b6").run().assertContent("true");
1089 		assertLogged();
1090 
1091 		c2.get("/c1").run().assertContent("true");
1092 		assertLogged("[200] HTTP GET /c1");
1093 		c2d.get("/c1").run().assertContent("true");
1094 		assertLogged("[200] HTTP GET /c1");
1095 		c2.get("/c2").run().assertContent("true");
1096 		assertLogged("[200] HTTP GET /c2");
1097 		c2d.get("/c2").run().assertContent("true");
1098 		assertLogged("[200] HTTP GET /c2");
1099 		c2.get("/c3").run().assertContent("true");
1100 		assertLogged("[200] HTTP GET /c3");
1101 		c2d.get("/c3").run().assertContent("true");
1102 		assertLogged("[200] HTTP GET /c3");
1103 		c2.get("/c4").run().assertContent("false");
1104 		assertNotLogged();
1105 		c2d.get("/c4").run().assertContent("false");
1106 		assertNotLogged();
1107 		c2.get("/c5").run().assertContent("true");
1108 		assertLogged("[200] HTTP GET /c5");
1109 		c2d.get("/c5").run().assertContent("true");
1110 		assertLogged("[200] HTTP GET /c5");
1111 		c2.get("/c6").run().assertContent("false");
1112 		assertNotLogged();
1113 		c2d.get("/c6").run().assertContent("true");
1114 		assertLogged("[200] HTTP GET /c6");
1115 
1116 		c2.get("/d1").run().assertContent("false");
1117 		assertNotLogged();
1118 		c2d.get("/d1").run().assertContent("true");
1119 		assertLogged("[200] HTTP GET /d1");
1120 		c2.get("/d2").run().assertContent("false");
1121 		assertNotLogged();
1122 		c2d.get("/d2").run().assertContent("true");
1123 		assertLogged("[200] HTTP GET /d2");
1124 		c2.get("/d3").run().assertContent("false");
1125 		assertNotLogged();
1126 		c2d.get("/d3").run().assertContent("true");
1127 		assertLogged("[200] HTTP GET /d3");
1128 		c2.get("/d4").run().assertContent("false");
1129 		assertNotLogged();
1130 		c2d.get("/d4").run().assertContent("false");
1131 		assertNotLogged();
1132 		c2.get("/d5").run().assertContent("true");
1133 		assertLogged("[200] HTTP GET /d5");
1134 		c2d.get("/d5").run().assertContent("true");
1135 		assertLogged("[200] HTTP GET /d5");
1136 		c2.get("/d6").run().assertContent("false");
1137 		assertNotLogged();
1138 		c2d.get("/d6").run().assertContent("true");
1139 		assertLogged("[200] HTTP GET /d6");
1140 
1141 		c2.get("/e1").run().assertContent("true");
1142 		assertLogged();
1143 		c2d.get("/d1").run().assertContent("true");
1144 		assertLogged();
1145 		c2.get("/e2").run().assertContent("true");
1146 		assertLogged();
1147 		c2d.get("/e2").run().assertContent("true");
1148 		assertLogged();
1149 		c2.get("/e3").run().assertContent("true");
1150 		assertLogged();
1151 		c2d.get("/e3").run().assertContent("true");
1152 		assertLogged();
1153 		c2.get("/e4").run().assertContent("false");
1154 		assertNotLogged();
1155 		c2d.get("/e4").run().assertContent("false");
1156 		assertNotLogged();
1157 		c2.get("/e5").run().assertContent("true");
1158 		assertLogged();
1159 		c2d.get("/e5").run().assertContent("true");
1160 		assertLogged();
1161 		c2.get("/e6").run().assertContent("false");
1162 		assertNotLogged();
1163 		c2d.get("/e6").run().assertContent("true");
1164 		assertLogged();
1165 
1166 		c2.get("/f1").run().assertContent("true");
1167 		assertLogged();
1168 		c2d.get("/f1").run().assertContent("true");
1169 		assertLogged();
1170 		c2.get("/f2").run().assertContent("true");
1171 		assertLogged();
1172 		c2d.get("/f2").run().assertContent("true");
1173 		assertLogged();
1174 		c2.get("/f3").run().assertContent("true");
1175 		assertLogged();
1176 		c2d.get("/f3").run().assertContent("true");
1177 		assertLogged();
1178 		c2.get("/f4").run().assertContent("true");
1179 		assertLogged();
1180 		c2d.get("/f4").run().assertContent("true");
1181 		assertLogged();
1182 
1183 		c2.get("/g1").run().assertContent("false");
1184 		assertNotLogged();
1185 		c2d.get("/g1").run().assertContent("false");
1186 		assertNotLogged();
1187 		c2.get("/g2").run().assertContent("false");
1188 		assertNotLogged();
1189 		c2d.get("/g2").run().assertContent("false");
1190 		assertNotLogged();
1191 		c2.get("/g3").run().assertContent("false");
1192 		assertNotLogged();
1193 		c2d.get("/g3").run().assertContent("false");
1194 		assertNotLogged();
1195 		c2.get("/g4").run().assertContent("false");
1196 		assertNotLogged();
1197 		c2d.get("/g4").run().assertContent("false");
1198 		assertNotLogged();
1199 	}
1200 
1201 }