From a787796c74b2234f262ab840299a4142fdd91236 Mon Sep 17 00:00:00 2001 From: kensakurai Date: Thu, 26 Jan 2017 02:29:08 +0900 Subject: [PATCH 1/4] Add hook method for exception handling to StatelessChecker * Add hook method * Add test case to check behavior of hook method --- .../devutils/stateless/StatelessChecker.java | 71 +++++++++++++--- .../stateless/StatelessCheckerTest.java | 81 +++++++++++++++++-- 2 files changed, 135 insertions(+), 17 deletions(-) diff --git a/wicket-devutils/src/main/java/org/apache/wicket/devutils/stateless/StatelessChecker.java b/wicket-devutils/src/main/java/org/apache/wicket/devutils/stateless/StatelessChecker.java index ac115c29bfb..9b23cc263bb 100644 --- a/wicket-devutils/src/main/java/org/apache/wicket/devutils/stateless/StatelessChecker.java +++ b/wicket-devutils/src/main/java/org/apache/wicket/devutils/stateless/StatelessChecker.java @@ -31,10 +31,10 @@ * stateless. This is a utility that is intended for use primarily during development. If you add an * instance of this class to your application, it will check all components or pages marked with the * StatelessComponent annotation to make sure that they are stateless as you intended. - * + * * This is useful when trying to maintain stateless pages since it is very easy to inadvertently add * a component to a page that internally uses stateful links, etc. - * + * * @author Marat Radchenko * @see StatelessComponent */ @@ -43,7 +43,7 @@ public class StatelessChecker implements IComponentOnBeforeRenderListener /** * Returns true if checker must check given component, false * otherwise. - * + * * @param component * component to check. * @return true if checker must check given component. @@ -53,6 +53,58 @@ protected boolean mustCheck(final Component component) final StatelessComponent ann = component.getClass().getAnnotation(StatelessComponent.class); return (ann != null) && ann.enabled(); } + /** + * The given component claims to be stateless but isn't. + * + * @param component component failing stateless check + * @param reason explaining reason + */ + protected void fail(Component component, String reason) + { + throw new IllegalArgumentException(getMessage(component) + reason); + } + + /** + * The given page claims to be stateless but isn't. + * + * @param page page failing stateless check + * @param reason explaining reason + */ + protected void failPage(Page page, String reason) + { + fail(page, reason); + } + + /** + * The given markupContainer claims to be stateless but isn't. + * + * @param markupContainer MarkupContainer failing stateless check + * @param reason explaining reason + */ + protected void failMarkupContainer(MarkupContainer markupContainer, String reason) + { + fail(markupContainer, reason); + } + /** + * The given component claims to be stateless but isn't, because the holding behaviors are stateful. + * + * @param component component failing stateless check + * @param reason explaining reason + */ + protected void failBehaviors(Component component, String reason) + { + throw new IllegalStateException(getMessage(component) + reason); + } + /** + * return the message from the component + * + * @param component component failing stateless check + * @return message + */ + private String getMessage(Component component) + { + return "'" + component + "' claims to be stateless but isn't. "; + } /** * @see org.apache.wicket.application.IComponentOnBeforeRenderListener#onBeforeRender(org.apache.wicket.Component) @@ -91,7 +143,6 @@ else if (!comp.isStateless()) } }; - final String msg = "'" + component + "' claims to be stateless but isn't."; if (component.isStateless() == false) { StringList statefulBehaviors = new StringList(); @@ -111,16 +162,17 @@ else if (!comp.isStateless()) { reason = " Stateful behaviors: " + statefulBehaviors.join(); } - throw new IllegalStateException(msg + reason); + failBehaviors(component, reason); } if (component instanceof MarkupContainer) { + MarkupContainer container = ((MarkupContainer)component); // Traverse children - final Object o = ((MarkupContainer)component).visitChildren(visitor); + final Object o = container.visitChildren(visitor); if (o != null) { - throw new IllegalArgumentException(msg + " Offending component: " + o); + failMarkupContainer(container, " Offending component: " + o); } } @@ -129,12 +181,11 @@ else if (!comp.isStateless()) final Page p = (Page)component; if (!p.isBookmarkable()) { - throw new IllegalArgumentException(msg + - " Only bookmarkable pages can be stateless"); + failPage(p, " Only bookmarkable pages can be stateless"); } if (!p.isPageStateless()) { - throw new IllegalArgumentException(msg + " for unknown reason"); + failPage(p, " for unknown reason"); } } } diff --git a/wicket-devutils/src/test/java/org/apache/wicket/devutils/stateless/StatelessCheckerTest.java b/wicket-devutils/src/test/java/org/apache/wicket/devutils/stateless/StatelessCheckerTest.java index c02f9362bb6..707e7e0580f 100644 --- a/wicket-devutils/src/test/java/org/apache/wicket/devutils/stateless/StatelessCheckerTest.java +++ b/wicket-devutils/src/test/java/org/apache/wicket/devutils/stateless/StatelessCheckerTest.java @@ -16,6 +16,9 @@ */ package org.apache.wicket.devutils.stateless; +import org.apache.wicket.Component; +import org.apache.wicket.WicketRuntimeException; +import org.apache.wicket.behavior.Behavior; import org.apache.wicket.markup.html.basic.Label; import org.apache.wicket.util.tester.DummyHomePage; import org.apache.wicket.util.tester.WicketTester; @@ -52,7 +55,29 @@ public StatelessLabel(final String id) } } + private static class StatefulBehavior extends Behavior + { + private static final long serialVersionUID = 1L; + + @Override + public boolean getStatelessHint(Component component) + { + return false; + } + } + private final StatelessChecker checker = new StatelessChecker(); + private final StatelessChecker checkerQuietly = new StatelessChecker() { + protected void fail(Component component, String reason) + { + // Do Nothing... + } + protected void failBehaviors(Component component, String reason) { + // Do Nothing... + } + + }; + private WicketTester tester; /** @@ -76,6 +101,54 @@ public void tearDown() @Test public void testNonBookmarkablePage() { + boolean hit = isHitBookmarkablePage(checker); + assertTrue("Expected exception", hit); + } + + @Test + public void testNonBookmarkablePageQuietly() + { + boolean hit = isHitBookmarkablePage(checkerQuietly); + assertFalse("Expected exception", hit); + } + + @Test + public void testStatefulBehaviors() + { + boolean hit = isHitBehaviors(checker); + assertTrue("Expected exception", hit); + } + @Test + public void testStatefulBehaviorsQuietly() + { + boolean hit = isHitBehaviors(checkerQuietly); + assertFalse("Expected exception", hit); + } + + @Test + public void testPositive() + { + tester.getApplication().getComponentPostOnBeforeRenderListeners().add(checker); + tester.startComponentInPage(new StatelessLabel("foo")); + } + + private boolean isHitBehaviors(StatelessChecker checker) { + boolean hit = false; + try + { + tester.getApplication().getComponentPostOnBeforeRenderListeners().add(checker); + tester.startComponentInPage(new StatelessLabel("foo").add(new StatefulBehavior())); + } + catch (WicketRuntimeException ex) + { + if(ex.getCause() instanceof IllegalStateException) { + hit = true; + } + } + return hit; + } + + private boolean isHitBookmarkablePage(StatelessChecker checker) { boolean hit = false; try { @@ -86,13 +159,7 @@ public void testNonBookmarkablePage() { hit = true; } - assertTrue("Expected exception", hit); + return hit; } - @Test - public void testPositive() - { - tester.getApplication().getComponentPostOnBeforeRenderListeners().add(checker); - tester.startComponentInPage(new StatelessLabel("foo")); - } } From 20c2b8930d2fee27c809a70824a648cff17f700c Mon Sep 17 00:00:00 2001 From: kensakurai Date: Thu, 16 Feb 2017 02:10:29 +0900 Subject: [PATCH 2/4] Add StatelessCheckFailureException Add StatelessCheckFailureException --- .../StatelessCheckFailureException.java | 56 ++++++++++++ .../devutils/stateless/StatelessChecker.java | 57 ++---------- .../stateless/StatelessCheckerTest.java | 86 +++++++++++++++---- 3 files changed, 130 insertions(+), 69 deletions(-) create mode 100644 wicket-devutils/src/main/java/org/apache/wicket/devutils/stateless/StatelessCheckFailureException.java diff --git a/wicket-devutils/src/main/java/org/apache/wicket/devutils/stateless/StatelessCheckFailureException.java b/wicket-devutils/src/main/java/org/apache/wicket/devutils/stateless/StatelessCheckFailureException.java new file mode 100644 index 00000000000..b87e79adfce --- /dev/null +++ b/wicket-devutils/src/main/java/org/apache/wicket/devutils/stateless/StatelessCheckFailureException.java @@ -0,0 +1,56 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.wicket.devutils.stateless; + +import org.apache.wicket.Component; +import org.apache.wicket.Page; +import org.apache.wicket.WicketRuntimeException; + +/** + * + * Just an exception that can be thrown if a StatelessChecker is invoked, the component being checked is not stateless + * or the behavior held by the component is not stateless. + * + * Includes a method that to get check failure component. + * + * @author Ken Sakurai + */ +public class StatelessCheckFailureException extends WicketRuntimeException +{ + private static final long serialVersionUID = 1L; + + private Component component; + + /** + * Construct. + * @param component Failure component + * @param reason Reason for exception occurrence + */ + public StatelessCheckFailureException(Component component, String reason) + { + super("'" + component + "' claims to be stateless but isn't. "); + this.component = component; + } + + /** + * Get check failure component + * @return Failure component + */ + public Component getComponent() { + return component; + } +} diff --git a/wicket-devutils/src/main/java/org/apache/wicket/devutils/stateless/StatelessChecker.java b/wicket-devutils/src/main/java/org/apache/wicket/devutils/stateless/StatelessChecker.java index 9b23cc263bb..b2a7a32adaa 100644 --- a/wicket-devutils/src/main/java/org/apache/wicket/devutils/stateless/StatelessChecker.java +++ b/wicket-devutils/src/main/java/org/apache/wicket/devutils/stateless/StatelessChecker.java @@ -56,54 +56,11 @@ protected boolean mustCheck(final Component component) /** * The given component claims to be stateless but isn't. * - * @param component component failing stateless check - * @param reason explaining reason + * @param e StatelessCheckFailureException */ - protected void fail(Component component, String reason) + protected void fail(StatelessCheckFailureException e) { - throw new IllegalArgumentException(getMessage(component) + reason); - } - - /** - * The given page claims to be stateless but isn't. - * - * @param page page failing stateless check - * @param reason explaining reason - */ - protected void failPage(Page page, String reason) - { - fail(page, reason); - } - - /** - * The given markupContainer claims to be stateless but isn't. - * - * @param markupContainer MarkupContainer failing stateless check - * @param reason explaining reason - */ - protected void failMarkupContainer(MarkupContainer markupContainer, String reason) - { - fail(markupContainer, reason); - } - /** - * The given component claims to be stateless but isn't, because the holding behaviors are stateful. - * - * @param component component failing stateless check - * @param reason explaining reason - */ - protected void failBehaviors(Component component, String reason) - { - throw new IllegalStateException(getMessage(component) + reason); - } - /** - * return the message from the component - * - * @param component component failing stateless check - * @return message - */ - private String getMessage(Component component) - { - return "'" + component + "' claims to be stateless but isn't. "; + throw e; } /** @@ -162,7 +119,7 @@ else if (!comp.isStateless()) { reason = " Stateful behaviors: " + statefulBehaviors.join(); } - failBehaviors(component, reason); + fail(new StatelessCheckFailureException(component, reason)); } if (component instanceof MarkupContainer) @@ -172,7 +129,7 @@ else if (!comp.isStateless()) final Object o = container.visitChildren(visitor); if (o != null) { - failMarkupContainer(container, " Offending component: " + o); + fail(new StatelessCheckFailureException(container, " Offending component: " + o)); } } @@ -181,11 +138,11 @@ else if (!comp.isStateless()) final Page p = (Page)component; if (!p.isBookmarkable()) { - failPage(p, " Only bookmarkable pages can be stateless"); + fail(new StatelessCheckFailureException(p, " Only bookmarkable pages can be stateless")); } if (!p.isPageStateless()) { - failPage(p, " for unknown reason"); + fail(new StatelessCheckFailureException(p, " for unknown reason")); } } } diff --git a/wicket-devutils/src/test/java/org/apache/wicket/devutils/stateless/StatelessCheckerTest.java b/wicket-devutils/src/test/java/org/apache/wicket/devutils/stateless/StatelessCheckerTest.java index 707e7e0580f..41df859a973 100644 --- a/wicket-devutils/src/test/java/org/apache/wicket/devutils/stateless/StatelessCheckerTest.java +++ b/wicket-devutils/src/test/java/org/apache/wicket/devutils/stateless/StatelessCheckerTest.java @@ -17,7 +17,7 @@ package org.apache.wicket.devutils.stateless; import org.apache.wicket.Component; -import org.apache.wicket.WicketRuntimeException; +import org.apache.wicket.MarkupContainer; import org.apache.wicket.behavior.Behavior; import org.apache.wicket.markup.html.basic.Label; import org.apache.wicket.util.tester.DummyHomePage; @@ -33,7 +33,7 @@ public class StatelessCheckerTest extends Assert { /** - * + * StatelessPage */ @StatelessComponent public static class StatelessPage extends DummyHomePage @@ -42,7 +42,7 @@ public static class StatelessPage extends DummyHomePage } /** - * + * StatelessLabel */ @StatelessComponent private static class StatelessLabel extends Label @@ -55,6 +55,27 @@ public StatelessLabel(final String id) } } + /** + * StatefulMarkupContainer + */ + @StatelessComponent + private static class StatefulMarkupContainer extends MarkupContainer + { + private static final long serialVersionUID = 1L; + + public StatefulMarkupContainer(String id) { + super(id); + } + @Override + public boolean getStatelessHint() + { + return false; + } + } + + /** + * StatefulBehavior + */ private static class StatefulBehavior extends Behavior { private static final long serialVersionUID = 1L; @@ -67,15 +88,12 @@ public boolean getStatelessHint(Component component) } private final StatelessChecker checker = new StatelessChecker(); + private final StatelessChecker checkerQuietly = new StatelessChecker() { - protected void fail(Component component, String reason) + protected void fail(StatelessCheckFailureException e) { // Do Nothing... } - protected void failBehaviors(Component component, String reason) { - // Do Nothing... - } - }; private WicketTester tester; @@ -101,14 +119,34 @@ public void tearDown() @Test public void testNonBookmarkablePage() { - boolean hit = isHitBookmarkablePage(checker); + boolean hit1 = false; + try + { + tester.getApplication().getComponentPostOnBeforeRenderListeners().add(checker); + tester.startPage(StatelessPage.class); + } + catch (StatelessCheckFailureException ex) + { + hit1 = true; + } + boolean hit = hit1; assertTrue("Expected exception", hit); } @Test public void testNonBookmarkablePageQuietly() { - boolean hit = isHitBookmarkablePage(checkerQuietly); + boolean hit1 = false; + try + { + tester.getApplication().getComponentPostOnBeforeRenderListeners().add(checkerQuietly); + tester.startPage(StatelessPage.class); + } + catch (StatelessCheckFailureException ex) + { + hit1 = true; + } + boolean hit = hit1; assertFalse("Expected exception", hit); } @@ -132,30 +170,40 @@ public void testPositive() tester.startComponentInPage(new StatelessLabel("foo")); } - private boolean isHitBehaviors(StatelessChecker checker) { + @Test + public void testStatefulMarkupContainer() { + boolean hit = isHitMarkupContainer(checker); + assertTrue("Expected exception", hit); + } + + @Test + public void testStatefulMarkupContainerQuietly() { + boolean hit = isHitMarkupContainer(checkerQuietly); + assertFalse("Expected exception", hit); + } + + private boolean isHitMarkupContainer(StatelessChecker checker) { boolean hit = false; try { tester.getApplication().getComponentPostOnBeforeRenderListeners().add(checker); - tester.startComponentInPage(new StatelessLabel("foo").add(new StatefulBehavior())); + tester.startComponentInPage(new StatefulMarkupContainer("foo")); } - catch (WicketRuntimeException ex) + catch (StatelessCheckFailureException ex) { - if(ex.getCause() instanceof IllegalStateException) { - hit = true; - } + hit = true; } return hit; } - private boolean isHitBookmarkablePage(StatelessChecker checker) { + private boolean isHitBehaviors(StatelessChecker checker) { boolean hit = false; try { tester.getApplication().getComponentPostOnBeforeRenderListeners().add(checker); - tester.startPage(StatelessPage.class); + tester.startComponentInPage(new StatelessLabel("foo").add(new StatefulBehavior())); } - catch (IllegalArgumentException ex) + catch (StatelessCheckFailureException ex) { hit = true; } From c39fbdc99e142c6b2c27ea79c34fe6dda98c9ec2 Mon Sep 17 00:00:00 2001 From: kensakurai Date: Sat, 18 Feb 2017 19:48:33 +0900 Subject: [PATCH 3/4] Modify StatelessCheckerTest And fix bug. --- .../StatelessCheckFailureException.java | 2 +- .../devutils/stateless/StatelessChecker.java | 4 + .../stateless/StatelessCheckerTest.java | 126 ++++++++++-------- 3 files changed, 78 insertions(+), 54 deletions(-) diff --git a/wicket-devutils/src/main/java/org/apache/wicket/devutils/stateless/StatelessCheckFailureException.java b/wicket-devutils/src/main/java/org/apache/wicket/devutils/stateless/StatelessCheckFailureException.java index b87e79adfce..84def0aee5e 100644 --- a/wicket-devutils/src/main/java/org/apache/wicket/devutils/stateless/StatelessCheckFailureException.java +++ b/wicket-devutils/src/main/java/org/apache/wicket/devutils/stateless/StatelessCheckFailureException.java @@ -42,7 +42,7 @@ public class StatelessCheckFailureException extends WicketRuntimeException */ public StatelessCheckFailureException(Component component, String reason) { - super("'" + component + "' claims to be stateless but isn't. "); + super("'" + component + "' claims to be stateless but isn't." + reason); this.component = component; } diff --git a/wicket-devutils/src/main/java/org/apache/wicket/devutils/stateless/StatelessChecker.java b/wicket-devutils/src/main/java/org/apache/wicket/devutils/stateless/StatelessChecker.java index b2a7a32adaa..5312b2fddef 100644 --- a/wicket-devutils/src/main/java/org/apache/wicket/devutils/stateless/StatelessChecker.java +++ b/wicket-devutils/src/main/java/org/apache/wicket/devutils/stateless/StatelessChecker.java @@ -120,6 +120,7 @@ else if (!comp.isStateless()) reason = " Stateful behaviors: " + statefulBehaviors.join(); } fail(new StatelessCheckFailureException(component, reason)); + return; } if (component instanceof MarkupContainer) @@ -130,6 +131,7 @@ else if (!comp.isStateless()) if (o != null) { fail(new StatelessCheckFailureException(container, " Offending component: " + o)); + return; } } @@ -139,10 +141,12 @@ else if (!comp.isStateless()) if (!p.isBookmarkable()) { fail(new StatelessCheckFailureException(p, " Only bookmarkable pages can be stateless")); + return; } if (!p.isPageStateless()) { fail(new StatelessCheckFailureException(p, " for unknown reason")); + return; } } } diff --git a/wicket-devutils/src/test/java/org/apache/wicket/devutils/stateless/StatelessCheckerTest.java b/wicket-devutils/src/test/java/org/apache/wicket/devutils/stateless/StatelessCheckerTest.java index 41df859a973..0d16468a094 100644 --- a/wicket-devutils/src/test/java/org/apache/wicket/devutils/stateless/StatelessCheckerTest.java +++ b/wicket-devutils/src/test/java/org/apache/wicket/devutils/stateless/StatelessCheckerTest.java @@ -87,14 +87,27 @@ public boolean getStatelessHint(Component component) } } - private final StatelessChecker checker = new StatelessChecker(); + /** + * StatelessCheckerQuietly + */ + private static class StatelessCheckerQuietly extends StatelessChecker + { + private StatelessCheckFailureException ex; - private final StatelessChecker checkerQuietly = new StatelessChecker() { protected void fail(StatelessCheckFailureException e) { - // Do Nothing... + this.ex = e; } - }; + + public StatelessCheckFailureException getFailureException() + { + return ex; + } + } + + private StatelessChecker checker; + + private StatelessCheckerQuietly checkerQuietly; private WicketTester tester; @@ -105,6 +118,8 @@ protected void fail(StatelessCheckFailureException e) public void setUp() { tester = new WicketTester(); + checker = new StatelessChecker(); + checkerQuietly = new StatelessCheckerQuietly(); } /** @@ -119,95 +134,100 @@ public void tearDown() @Test public void testNonBookmarkablePage() { - boolean hit1 = false; try { - tester.getApplication().getComponentPostOnBeforeRenderListeners().add(checker); - tester.startPage(StatelessPage.class); + startNonBookmarkablePage(checker); + fail("Expected tester.startPage() to fail with StatelessCheckFailureException"); } catch (StatelessCheckFailureException ex) { - hit1 = true; + assertNonBookmarkablePage(ex); } - boolean hit = hit1; - assertTrue("Expected exception", hit); } @Test public void testNonBookmarkablePageQuietly() { - boolean hit1 = false; + startNonBookmarkablePage(checkerQuietly); + StatelessCheckFailureException ex = checkerQuietly.getFailureException(); + assertNonBookmarkablePage(ex); + } + + private void startNonBookmarkablePage(StatelessChecker checker) + { + tester.getApplication().getComponentPostOnBeforeRenderListeners().add(checker); + tester.startPage(StatelessPage.class); + } + + private void assertNonBookmarkablePage(StatelessCheckFailureException ex) { + assertEquals("'[Page class = org.apache.wicket.devutils.stateless.StatelessCheckerTest$StatelessPage, id = 0, render count = 1]' claims to be stateless but isn't. Offending component: [TestLink [Component id = testPage]]", ex.getMessage()); + assertEquals(StatelessPage.class, ex.getComponent().getClass()); + } + + @Test + public void testStatefulBehaviors() + { try { - tester.getApplication().getComponentPostOnBeforeRenderListeners().add(checkerQuietly); - tester.startPage(StatelessPage.class); + startComponentInPage(checker, new StatelessLabel("foo").add(new StatefulBehavior())); + fail("Expected tester.startComponentInPage() to fail with StatelessCheckFailureException"); } catch (StatelessCheckFailureException ex) { - hit1 = true; + assertStatefulBehaviors(ex); } - boolean hit = hit1; - assertFalse("Expected exception", hit); } - @Test - public void testStatefulBehaviors() - { - boolean hit = isHitBehaviors(checker); - assertTrue("Expected exception", hit); - } @Test public void testStatefulBehaviorsQuietly() { - boolean hit = isHitBehaviors(checkerQuietly); - assertFalse("Expected exception", hit); + startComponentInPage(checkerQuietly, new StatelessLabel("foo").add(new StatefulBehavior())); + StatelessCheckFailureException ex = checkerQuietly.getFailureException(); + assertStatefulBehaviors(ex); } - @Test - public void testPositive() - { + private void startComponentInPage(StatelessChecker checker, Component foo) { tester.getApplication().getComponentPostOnBeforeRenderListeners().add(checker); - tester.startComponentInPage(new StatelessLabel("foo")); + tester.startComponentInPage(foo); } - @Test - public void testStatefulMarkupContainer() { - boolean hit = isHitMarkupContainer(checker); - assertTrue("Expected exception", hit); + private void assertStatefulBehaviors(StatelessCheckFailureException ex) { + assertEquals("'[Component id = foo]' claims to be stateless but isn't. Stateful behaviors: org.apache.wicket.devutils.stateless.StatelessCheckerTest$StatefulBehavior", ex.getMessage()); + assertEquals(StatelessLabel.class, ex.getComponent().getClass()); } @Test - public void testStatefulMarkupContainerQuietly() { - boolean hit = isHitMarkupContainer(checkerQuietly); - assertFalse("Expected exception", hit); + public void testPositive() + { + startComponentInPage(checker, new StatelessLabel("foo")); } - private boolean isHitMarkupContainer(StatelessChecker checker) { - boolean hit = false; + @Test + public void testStatefulMarkupContainer() + { try { - tester.getApplication().getComponentPostOnBeforeRenderListeners().add(checker); - tester.startComponentInPage(new StatefulMarkupContainer("foo")); + startComponentInPage(checker, new StatefulMarkupContainer("foo")); + fail("Expected tester.startComponentInPage() to fail with StatelessCheckFailureException"); } catch (StatelessCheckFailureException ex) { - hit = true; + assertStatefulMarkupContainer(ex); } - return hit; } - private boolean isHitBehaviors(StatelessChecker checker) { - boolean hit = false; - try - { - tester.getApplication().getComponentPostOnBeforeRenderListeners().add(checker); - tester.startComponentInPage(new StatelessLabel("foo").add(new StatefulBehavior())); - } - catch (StatelessCheckFailureException ex) - { - hit = true; - } - return hit; + @Test + public void testStatefulMarkupContainerQuietly() + { + startComponentInPage(checkerQuietly, new StatefulMarkupContainer("foo")); + StatelessCheckFailureException ex = checkerQuietly.getFailureException(); + assertStatefulMarkupContainer(ex); + } + private void assertStatefulMarkupContainer(StatelessCheckFailureException ex) + { + assertEquals("'[StatefulMarkupContainer [Component id = foo]]' claims to be stateless but isn't. Possible reason: no stateless hint", ex.getMessage()); + assertEquals(StatefulMarkupContainer.class, ex.getComponent().getClass()); + } } From 1975bf852e6692ce1c8e3a75dac4c9aca95f87ac Mon Sep 17 00:00:00 2001 From: kensakurai Date: Sat, 18 Feb 2017 19:59:39 +0900 Subject: [PATCH 4/4] Change Indent --- .../stateless/StatelessCheckFailureException.java | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/wicket-devutils/src/main/java/org/apache/wicket/devutils/stateless/StatelessCheckFailureException.java b/wicket-devutils/src/main/java/org/apache/wicket/devutils/stateless/StatelessCheckFailureException.java index 84def0aee5e..1ba2ecaf8fc 100644 --- a/wicket-devutils/src/main/java/org/apache/wicket/devutils/stateless/StatelessCheckFailureException.java +++ b/wicket-devutils/src/main/java/org/apache/wicket/devutils/stateless/StatelessCheckFailureException.java @@ -31,9 +31,9 @@ */ public class StatelessCheckFailureException extends WicketRuntimeException { - private static final long serialVersionUID = 1L; + private static final long serialVersionUID = 1L; - private Component component; + private Component component; /** * Construct. @@ -41,16 +41,17 @@ public class StatelessCheckFailureException extends WicketRuntimeException * @param reason Reason for exception occurrence */ public StatelessCheckFailureException(Component component, String reason) - { - super("'" + component + "' claims to be stateless but isn't." + reason); - this.component = component; - } + { + super("'" + component + "' claims to be stateless but isn't." + reason); + this.component = component; + } /** * Get check failure component * @return Failure component */ - public Component getComponent() { + public Component getComponent() + { return component; } }