You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@wicket.apache.org by mg...@apache.org on 2013/06/13 11:48:23 UTC
[11/11] git commit: WICKET-3347 Simplify somehow the code in
org.apache.wicket.request.handler.render.WebPageRenderer.respond(RequestCycle)
WICKET-3347 Simplify somehow the code in org.apache.wicket.request.handler.render.WebPageRenderer.respond(RequestCycle)
Merge branch 'Refactor-WebPageRenderer' of https://github.com/michaelmosmann/wicket into WebPageRendererRefactor
Project: http://git-wip-us.apache.org/repos/asf/wicket/repo
Commit: http://git-wip-us.apache.org/repos/asf/wicket/commit/22f1e048
Tree: http://git-wip-us.apache.org/repos/asf/wicket/tree/22f1e048
Diff: http://git-wip-us.apache.org/repos/asf/wicket/diff/22f1e048
Branch: refs/heads/master
Commit: 22f1e048923cf5b6e020a81b66e0a8512c24fe79
Parents: b5d53c5 d3055f7
Author: Martin Tzvetanov Grigorov <mg...@apache.org>
Authored: Thu Jun 13 12:46:09 2013 +0300
Committer: Martin Tzvetanov Grigorov <mg...@apache.org>
Committed: Thu Jun 13 12:46:09 2013 +0300
----------------------------------------------------------------------
.gitignore | 2 +-
.../request/handler/render/WebPageRenderer.java | 242 ++++++++------
.../handler/render/AbstractVariations.java | 37 +++
.../render/ShouldRedirectToTargetUrl.java | 57 ++++
...uldRenderPageAndWriteResponseVariations.java | 59 ++++
.../request/handler/render/TestVariations.java | 66 ++++
.../request/handler/render/Variation.java | 46 +++
.../handler/render/VariationIterator.java | 92 ++++++
.../handler/render/WebPageRendererTest.java | 324 ++++++++++++++++++-
9 files changed, 830 insertions(+), 95 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/wicket/blob/22f1e048/.gitignore
----------------------------------------------------------------------
diff --cc .gitignore
index b1d5e2c,bbefc81..83c0f7e
--- a/.gitignore
+++ b/.gitignore
@@@ -1,10 -1,9 +1,10 @@@
-target
+**target*
velocity.log
-.project
-.classpath
+**.project
+**.classpath
+**.settings
*velocity.log*
-.idea/
+*.idea/
*.iml
*~
- node_modules/
-
++node_modules/
http://git-wip-us.apache.org/repos/asf/wicket/blob/22f1e048/wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java
----------------------------------------------------------------------
diff --cc wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java
index 2f20845,5854ed4..6b95240
--- a/wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java
+++ b/wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java
@@@ -177,105 -177,97 +177,89 @@@ public class WebPageRenderer extends Pa
// if there is saved response for this URL render it
bufferedResponse.writeTo((WebResponse)requestCycle.getResponse());
}
- else if (getRedirectPolicy() == RedirectPolicy.NEVER_REDIRECT ||
- (isOnePassRender() && isAjax == false && getRedirectPolicy() != RedirectPolicy.ALWAYS_REDIRECT) //
- ||
- (!isAjax //
- &&
- (targetUrl.equals(currentUrl) && !getPageProvider().isNewPageInstance() && !getPage().isPageStateless()) //
- || (targetUrl.equals(currentUrl) && isRedirectToRender()) //
- ) //
- || shouldPreserveClientUrl) //
- {
- // if the policy is never to redirect
- // or one pass render mode is on
- // or the targetUrl matches current url and the page is not stateless
- // or the targetUrl matches current url, page is stateless but it's redirect-to-render
- // or the request determines that the current url should be preserved
- // just render the page
- BufferedWebResponse response = renderPage(currentUrl, requestCycle);
- if (response != null)
- {
- response.writeTo((WebResponse)requestCycle.getResponse());
- }
- }
- else if (getRedirectPolicy() == RedirectPolicy.ALWAYS_REDIRECT //
- ||
- isRedirectToRender() //
- || (isAjax && targetUrl.equals(currentUrl)))
- {
- // if target URL is different
- // and render policy is always-redirect or it's redirect-to-render
- redirectTo(targetUrl, requestCycle);
- }
- else if (!targetUrl.equals(currentUrl) //
- &&
- (getPageProvider().isNewPageInstance() || (isSessionTemporary() && getPage().isPageStateless())))
- {
- // if target URL is different and session is temporary and page is stateless
- // this is special case when page is stateless but there is no session so we can't
- // render it to buffer
-
- // alternatively if URLs are different and we have a page class and not an instance we
- // can redirect to the url which will instantiate the instance of us
-
- // note: if we had session here we would render the page to buffer and then redirect to
- // URL generated *after* page has been rendered (the statelessness may change during
- // render). this would save one redirect because now we have to render to URL generated
- // *before* page is rendered, render the page, get URL after render and if the URL is
- // different (meaning page is not stateless), save the buffer and redirect again (which
- // is pretty much what the next step does)
- redirectTo(targetUrl, requestCycle);
- }
- else
- {
- if (isRedirectToBuffer() == false && logger.isDebugEnabled())
+ else {
+ RedirectPolicy redirectPolicy = getRedirectPolicy();
+
+ boolean onePassRender = isOnePassRender();
+ boolean isRedirectToRender = isRedirectToRender();
+ boolean redirectToBuffer = isRedirectToBuffer();
+
+ boolean targetEqualsCurrentUrl = targetUrl.equals(currentUrl);
+ boolean isNewPageInstance = getPageProvider().isNewPageInstance();
+ boolean isPageStateless = getPage().isPageStateless();
+
+ if (shouldRenderPageAndWriteResponse(isAjax, onePassRender, isRedirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, isNewPageInstance, isPageStateless)) //
{
- String details = String.format("redirect strategy: '%s', isAjax: '%s', redirect policy: '%s', " +
- "current url: '%s', target url: '%s', is new: '%s', is stateless: '%s', is temporary: '%s'",
- Application.get().getRequestCycleSettings().getRenderStrategy(),
- isAjax, getRedirectPolicy(), currentUrl, targetUrl, getPageProvider().isNewPageInstance(),
- getPage().isPageStateless(), isSessionTemporary());
- logger.debug("Falling back to Redirect_To_Buffer render strategy because none of the conditions " +
- "matched. Details: " + details);
+ BufferedWebResponse response = renderPage(currentUrl, requestCycle);
+ if (response != null)
+ {
+ response.writeTo((WebResponse)requestCycle.getResponse());
+ }
}
+ else {
+ boolean sessionTemporary = isSessionTemporary();
+ if (shouldRedirectToTargetUrl(isAjax, redirectPolicy, isRedirectToRender, targetEqualsCurrentUrl, isNewPageInstance, isPageStateless, sessionTemporary))
+ {
+ redirectTo(targetUrl, requestCycle);
- // force creation of possible stateful page to get the final target url
- getPage();
+ // note: if we had session here we would render the page to buffer and then redirect to
+ // URL generated *after* page has been rendered (the statelessness may change during
+ // render). this would save one redirect because now we have to render to URL generated
+ // *before* page is rendered, render the page, get URL after render and if the URL is
+ // different (meaning page is not stateless), save the buffer and redirect again (which
+ // is pretty much what the next step does)
+ }
+ else
+ {
+ if (redirectToBuffer == false && logger.isDebugEnabled())
+ {
+ String details = String.format("redirect strategy: '%s', isAjax: '%s', redirect policy: '%s', " +
+ "current url: '%s', target url: '%s', is new: '%s', is stateless: '%s', is temporary: '%s'",
+ Application.get().getRequestCycleSettings().getRenderStrategy(),
+ isAjax, redirectPolicy, currentUrl, targetUrl, isNewPageInstance,
+ isPageStateless, sessionTemporary);
+ logger.debug("Falling back to Redirect_To_Buffer render strategy because none of the conditions " +
+ "matched. Details: " + details);
+ }
- Url renderTargetUrl = requestCycle.mapUrlFor(getRenderPageRequestHandler());
++ // force creation of possible stateful page to get the final target url
++ getPage();
+
- // redirect to buffer
- BufferedWebResponse response = renderPage(renderTargetUrl, requestCycle);
++ Url renderTargetUrl = requestCycle.mapUrlFor(getRenderPageRequestHandler());
+
- if (response == null)
- {
- return;
- }
+ // redirect to buffer
- BufferedWebResponse response = renderPage(targetUrl, requestCycle);
++ BufferedWebResponse response = renderPage(renderTargetUrl, requestCycle);
- if (currentUrl.equals(renderTargetUrl))
- {
- // no need to redirect when both urls are exactly the same
- response.writeTo((WebResponse)requestCycle.getResponse());
- }
- // if page is still stateless after render
- else if (getPage().isPageStateless() && !enableRedirectForStatelessPage())
- {
- // we don't want the redirect to happen for stateless page
- // example:
- // when a normal mounted stateful page is hit at /mount/point
- // wicket renders the page to buffer and redirects to /mount/point?12
- // but for stateless page the redirect is not necessary
- // also for listener interface on stateful page we want to redirect
- // after the listener is invoked, but on stateless page the user
- // must ask for redirect explicitly
- response.writeTo((WebResponse)requestCycle.getResponse());
- }
- else
- {
- storeBufferedResponse(renderTargetUrl, response);
+ if (response == null)
+ {
+ return;
+ }
+
- // check if the url hasn't changed after page has been rendered
- // (i.e. the stateless flag might have changed which could result in different page url)
- Url targetUrl2 = requestCycle.mapUrlFor(getRenderPageRequestHandler());
-
- if (targetUrl.getSegments().equals(targetUrl2.getSegments()) == false)
- {
- // the amount of segments is different - generated relative URLs will not work, we
- // need to rerender the page. This shouldn't happen, but in theory it can - with
- // RequestHandlerEncoders that produce different URLs with different amount of
- // segments for stateless and stateful pages
- response = renderPage(targetUrl2, requestCycle);
- }
-
- if (currentUrl.equals(targetUrl2))
++ if (currentUrl.equals(renderTargetUrl))
+ {
+ // no need to redirect when both urls are exactly the same
+ response.writeTo((WebResponse)requestCycle.getResponse());
+ }
+ // if page is still stateless after render
+ else if (isPageStateless && !enableRedirectForStatelessPage())
+ {
+ // we don't want the redirect to happen for stateless page
+ // example:
+ // when a normal mounted stateful page is hit at /mount/point
+ // wicket renders the page to buffer and redirects to /mount/point?12
+ // but for stateless page the redirect is not necessary
+ // also for listener interface on stateful page we want to redirect
+ // after the listener is invoked, but on stateless page the user
+ // must ask for redirect explicitly
+ response.writeTo((WebResponse)requestCycle.getResponse());
+ }
+ else
+ {
- storeBufferedResponse(targetUrl2, response);
++ storeBufferedResponse(renderTargetUrl, response);
- redirectTo(renderTargetUrl, requestCycle);
- redirectTo(targetUrl2, requestCycle);
++ redirectTo(renderTargetUrl, requestCycle);
+ }
+ }
}
}
}
http://git-wip-us.apache.org/repos/asf/wicket/blob/22f1e048/wicket-core/src/test/java/org/apache/wicket/request/handler/render/AbstractVariations.java
----------------------------------------------------------------------
diff --cc wicket-core/src/test/java/org/apache/wicket/request/handler/render/AbstractVariations.java
index 0000000,ddec3ca..b15b4e7
mode 000000,100644..100644
--- a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/AbstractVariations.java
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/AbstractVariations.java
@@@ -1,0 -1,37 +1,37 @@@
+ /*
+ * 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.request.handler.render;
+
+ public abstract class AbstractVariations {
+
+ protected abstract VariationIterator<?> last();
+
+ public abstract boolean getResult();
+
+ public boolean hasNextVariation() {
- return last().hasNextVariation();
++ return last().hasNext();
+ }
+
+ public void nextVariation() {
+ last().nextVariation();
+ }
+
+ protected static void toString(StringBuilder sb,String label, VariationIterator<?> iterator) {
- sb.append(label).append("=").append(iterator.value()).append(",");
++ sb.append(label).append('=').append(iterator.next()).append(',');
+ }
+
+ }
http://git-wip-us.apache.org/repos/asf/wicket/blob/22f1e048/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRedirectToTargetUrl.java
----------------------------------------------------------------------
diff --cc wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRedirectToTargetUrl.java
index 0000000,e54768c..4a6f389
mode 000000,100644..100644
--- a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRedirectToTargetUrl.java
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRedirectToTargetUrl.java
@@@ -1,0 -1,55 +1,57 @@@
+ /*
+ * 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.request.handler.render;
+
+ import org.apache.wicket.core.request.handler.RenderPageRequestHandler;
+
+ public class ShouldRedirectToTargetUrl extends AbstractVariations {
+
+ VariationIterator<Boolean> ajax=VariationIterator.of(Variation.ofBoolean());
+ VariationIterator<RenderPageRequestHandler.RedirectPolicy> redirectPolicy=VariationIterator.of(ajax,Variation.of(RenderPageRequestHandler.RedirectPolicy.class));
+ VariationIterator<Boolean> redirectToRender=VariationIterator.of(redirectPolicy,Variation.ofBoolean());
+ VariationIterator<Boolean> targetEqualsCurrentUrl=VariationIterator.of(redirectToRender,Variation.ofBoolean());
+ VariationIterator<Boolean> newPageInstance=VariationIterator.of(targetEqualsCurrentUrl,Variation.ofBoolean());
+ VariationIterator<Boolean> pageStateless=VariationIterator.of(newPageInstance,Variation.ofBoolean());
+ VariationIterator<Boolean> sessionTemporary=VariationIterator.of(pageStateless,Variation.ofBoolean());
+
+ VariationIterator<Boolean> last=sessionTemporary;
+
+
+ public String toString() {
+ StringBuilder sb=new StringBuilder();
+ toString(sb,"ajax",ajax);
+ toString(sb,"redirectPolicy",redirectPolicy);
+ toString(sb,"redirectToRender",redirectToRender);
+ toString(sb,"targetEqualsCurrentUrl",targetEqualsCurrentUrl);
+ toString(sb,"newPageInstance",newPageInstance);
+ toString(sb,"pageStateless",pageStateless);
+ toString(sb,"sessionTemporary",sessionTemporary);
+ return sb.toString();
+ }
+
+ @Override
+ protected VariationIterator<?> last() {
+ return last;
+ }
+
+ @Override
+ public boolean getResult() {
- return WebPageRenderer.shouldRedirectToTargetUrl(ajax.value(), redirectPolicy.value(), redirectToRender.value(), targetEqualsCurrentUrl.value(), newPageInstance.value(), pageStateless.value(),sessionTemporary.value());
++ return WebPageRenderer.shouldRedirectToTargetUrl(ajax.next(), redirectPolicy.next(),
++ redirectToRender.next(), targetEqualsCurrentUrl.next(), newPageInstance.next(),
++ pageStateless.next(), sessionTemporary.next());
+ }
+ }
http://git-wip-us.apache.org/repos/asf/wicket/blob/22f1e048/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRenderPageAndWriteResponseVariations.java
----------------------------------------------------------------------
diff --cc wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRenderPageAndWriteResponseVariations.java
index 0000000,213c395..3f7b5d6
mode 000000,100644..100644
--- a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRenderPageAndWriteResponseVariations.java
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRenderPageAndWriteResponseVariations.java
@@@ -1,0 -1,57 +1,59 @@@
+ /*
+ * 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.request.handler.render;
+
+ import org.apache.wicket.core.request.handler.RenderPageRequestHandler;
+
+ public class ShouldRenderPageAndWriteResponseVariations extends AbstractVariations {
+
+ VariationIterator<RenderPageRequestHandler.RedirectPolicy> redirectPolicy=VariationIterator.of(Variation.of(RenderPageRequestHandler.RedirectPolicy.class));
+ VariationIterator<Boolean> ajax=VariationIterator.of(redirectPolicy, Variation.ofBoolean());
+ VariationIterator<Boolean> onePassRender=VariationIterator.of(ajax,Variation.ofBoolean());
+ VariationIterator<Boolean> redirectToRender=VariationIterator.of(onePassRender,Variation.ofBoolean());
+ VariationIterator<Boolean> shouldPreserveClientUrl=VariationIterator.of(redirectToRender,Variation.ofBoolean());
+ VariationIterator<Boolean> targetEqualsCurrentUrl=VariationIterator.of(shouldPreserveClientUrl,Variation.ofBoolean());
+ VariationIterator<Boolean> newPageInstance=VariationIterator.of(targetEqualsCurrentUrl,Variation.ofBoolean());
+ VariationIterator<Boolean> pageStateless=VariationIterator.of(newPageInstance,Variation.ofBoolean());
+
+ VariationIterator<Boolean> last=pageStateless;
+
+ @Override
+ protected VariationIterator<?> last() {
+ return last;
+ }
+
+ public boolean getResult() {
- return WebPageRenderer.shouldRenderPageAndWriteResponse(ajax.value(),onePassRender.value(),redirectToRender.value(),redirectPolicy.value(),shouldPreserveClientUrl.value(),targetEqualsCurrentUrl.value(),newPageInstance.value(),pageStateless.value());
++ return WebPageRenderer.shouldRenderPageAndWriteResponse(ajax.next(), onePassRender.next(),
++ redirectToRender.next(), redirectPolicy.next(), shouldPreserveClientUrl.next(),
++ targetEqualsCurrentUrl.next(), newPageInstance.next(), pageStateless.next());
+ }
+
+ public String toString() {
+ StringBuilder sb=new StringBuilder();
+ toString(sb,"ajax",ajax);
+ toString(sb,"onePassRender",onePassRender);
+ toString(sb,"redirectToRender",redirectToRender);
+ toString(sb,"redirectPolicy",redirectPolicy);
+ toString(sb,"shouldPreserveClientUrl",shouldPreserveClientUrl);
+ toString(sb,"targetEqualsCurrentUrl",targetEqualsCurrentUrl);
+ toString(sb,"newPageInstance",newPageInstance);
+ toString(sb,"pageStateless",pageStateless);
+ return sb.toString();
+ }
+
+
+ }
http://git-wip-us.apache.org/repos/asf/wicket/blob/22f1e048/wicket-core/src/test/java/org/apache/wicket/request/handler/render/TestVariations.java
----------------------------------------------------------------------
diff --cc wicket-core/src/test/java/org/apache/wicket/request/handler/render/TestVariations.java
index 0000000,b976e26..5a11266
mode 000000,100644..100644
--- a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/TestVariations.java
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/TestVariations.java
@@@ -1,0 -1,66 +1,66 @@@
+ /*
+ * 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.request.handler.render;
+
-import junit.framework.Assert;
++import org.junit.Assert;
+ import org.junit.Test;
+
+ public class TestVariations {
+
+ @Test
+ public void testSingle() {
+ VariationIterator<Boolean> single = VariationIterator.of(Variation.ofBoolean());
- Assert.assertTrue(single.hasNextVariation());
++ Assert.assertTrue(single.hasNext());
+ single.nextVariation();
- Assert.assertFalse(single.hasNextVariation());
++ Assert.assertFalse(single.hasNext());
+
- Exception ex=null;
++ Exception ex = null;
+ try {
+ single.nextVariation();
+ } catch (Exception e) {
- ex=e;
++ ex = e;
+ }
+ Assert.assertNotNull(ex);
+ }
+
+ @Test
+ public void testDouble() {
- VariationIterator<Integer> numbers = VariationIterator.of(new Variation<Integer>(1,2,3));
++ VariationIterator<Integer> numbers = VariationIterator.of(new Variation<>(1,2,3));
+ VariationIterator<Boolean> flag = VariationIterator.of(numbers,Variation.ofBoolean());
+ VariationIterator<?> last=flag;
+
- Assert.assertTrue(last.hasNextVariation());
++ Assert.assertTrue(last.hasNext());
+ last.nextVariation();
- Assert.assertTrue(last.hasNextVariation());
++ Assert.assertTrue(last.hasNext());
+ last.nextVariation();
- Assert.assertTrue(last.hasNextVariation());
++ Assert.assertTrue(last.hasNext());
+ last.nextVariation();
- Assert.assertTrue(last.hasNextVariation());
++ Assert.assertTrue(last.hasNext());
+ last.nextVariation();
- Assert.assertTrue(last.hasNextVariation());
++ Assert.assertTrue(last.hasNext());
+ last.nextVariation();
- Assert.assertFalse(last.hasNextVariation());
++ Assert.assertFalse(last.hasNext());
+
- Exception ex=null;
++ Exception ex = null;
+ try {
+ last.nextVariation();
+ } catch (Exception e) {
- ex=e;
++ ex = e;
+ }
+ Assert.assertNotNull(ex);
+ }
+ }
http://git-wip-us.apache.org/repos/asf/wicket/blob/22f1e048/wicket-core/src/test/java/org/apache/wicket/request/handler/render/Variation.java
----------------------------------------------------------------------
diff --cc wicket-core/src/test/java/org/apache/wicket/request/handler/render/Variation.java
index 0000000,c8b751d..d086c34
mode 000000,100644..100644
--- a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/Variation.java
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/Variation.java
@@@ -1,0 -1,45 +1,46 @@@
+ /*
+ * 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.request.handler.render;
+
+ import java.util.Arrays;
-import java.util.EnumSet;
+ import java.util.List;
+
+ /**
- * provides some value variations for tests
++ * Provides some value variations that can be used for tests
++ *
++ * Similar to <a href="https://github.com/rickynils/scalacheck">Scala Check</a>
+ */
+ public class Variation<T> {
+
- private List<T> value;
++ private final List<T> value;
+
+ public Variation(T...values) {
- this.value=Arrays.asList(values);
++ this.value = Arrays.asList(values);
+ }
+
+ public List<T> values() {
+ return value;
+ }
+
+ public static Variation<Boolean> ofBoolean() {
- return new Variation<Boolean>(Boolean.FALSE,Boolean.TRUE);
++ return new Variation<>(Boolean.FALSE,Boolean.TRUE);
+ }
+
+ public static <T extends Enum<T>> Variation<T> of(Class<T> enumType) {
- return new Variation<T>(enumType.getEnumConstants());
++ return new Variation<>(enumType.getEnumConstants());
+ }
+ }
http://git-wip-us.apache.org/repos/asf/wicket/blob/22f1e048/wicket-core/src/test/java/org/apache/wicket/request/handler/render/VariationIterator.java
----------------------------------------------------------------------
diff --cc wicket-core/src/test/java/org/apache/wicket/request/handler/render/VariationIterator.java
index 0000000,f552b7c..741d3d2
mode 000000,100644..100644
--- a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/VariationIterator.java
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/VariationIterator.java
@@@ -1,0 -1,70 +1,92 @@@
+ /*
+ * 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.request.handler.render;
+
-public class VariationIterator<T> {
++import java.util.Iterator;
++import java.util.NoSuchElementException;
++
++public class VariationIterator<T> implements Iterator<T>
++{
++ private final VariationIterator<?> prev;
+
- private VariationIterator<?> prev;
+ private final Variation<T> variation;
- int idx=0;
++
++ private int idx = 0;
+
+ public VariationIterator(Variation<T> variation) {
- this.variation = variation;
++ this(null, variation);
+ }
+
- public VariationIterator(VariationIterator<?> prev,Variation<T> variation) {
++ public VariationIterator(VariationIterator<?> prev, Variation<T> variation) {
+ this.prev = prev;
+ this.variation = variation;
+ }
+
+ public static <T> VariationIterator<T> of(Variation<T> variation) {
- return new VariationIterator<T>(variation);
++ return new VariationIterator<>(variation);
+ }
+
- public static <T> VariationIterator<T> of(VariationIterator<?> prev,Variation<T> variation) {
- return new VariationIterator<T>(prev,variation);
++ public static <T> VariationIterator<T> of(VariationIterator<?> prev, Variation<T> variation)
++ {
++ return new VariationIterator<>(prev,variation);
+ }
+
- public T value() {
++ @Override
++ public T next()
++ {
+ return variation.values().get(idx);
+ }
+
- public boolean hasNextVariation() {
++ @Override
++ public boolean hasNext()
++ {
+ return thisHasNextVariation() || prevHasNextVariation();
+ }
+
- private boolean prevHasNextVariation() {
- return (prev!=null ? prev.hasNextVariation() : false);
++ private boolean prevHasNextVariation()
++ {
++ return (prev != null && prev.hasNext());
+ }
+
- private boolean thisHasNextVariation() {
- return variation.values().size() > idx+1;
++ private boolean thisHasNextVariation()
++ {
++ return variation.values().size() > idx + 1;
+ }
+
+ public void nextVariation() {
- if (thisHasNextVariation()) {
++ if (thisHasNextVariation())
++ {
+ idx++;
- } else {
- if (prevHasNextVariation()) {
++ } else
++ {
++ if (prevHasNextVariation())
++ {
+ idx=0;
+ prev.nextVariation();
- } else {
- throw new IllegalArgumentException("no variation left, but next called");
++ }
++ else
++ {
++ throw new NoSuchElementException("no variation left, but next called");
+ }
+ }
+ }
++
++ @Override
++ public void remove()
++ {
++ }
+ }
http://git-wip-us.apache.org/repos/asf/wicket/blob/22f1e048/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
----------------------------------------------------------------------
diff --cc wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
index 3ce620c,bce93cb..0f32673
--- a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
@@@ -625,10 -625,328 +625,328 @@@ public class WebPageRendererTes
Assert.assertTrue(stored.get());
}
+ @Test
+ public void testShouldRenderPageAndWriteResponseCondition() {
+
+ RedirectPolicy redirectPolicy;
+ boolean ajax;
+ boolean onePassRender;
+ boolean redirectToRender;
+ boolean shouldPreserveClientUrl;
+ boolean targetEqualsCurrentUrl;
+ boolean newPageInstance;
+ boolean pageStateless;
+
+
+ // if
+ // the policy is never to redirect
+ redirectPolicy=RedirectPolicy.NEVER_REDIRECT;
+ ajax=true;
+ onePassRender=true;
+ redirectToRender=true;
+ shouldPreserveClientUrl=true;
+ targetEqualsCurrentUrl=true;
+ newPageInstance=true;
+ pageStateless=true;
+
+ Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+
+ ajax=false;
+ onePassRender=false;
+ redirectToRender=false;
+ shouldPreserveClientUrl=false;
+ targetEqualsCurrentUrl=false;
+ newPageInstance=false;
+ pageStateless=false;
+
+ Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+
+ // or
+ // its NOT ajax and
+ // one pass render mode is on and NOT forced to redirect
+ // or
+ // the targetUrl matches current url and page is NOT stateless and NOT a new instance
+ redirectPolicy=RedirectPolicy.AUTO_REDIRECT;
+ ajax=false;
+ onePassRender=true;
+
+ Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+
+ targetEqualsCurrentUrl=true;
+ redirectPolicy=RedirectPolicy.ALWAYS_REDIRECT;
+ onePassRender=false;
+
+ newPageInstance=false;
+ pageStateless=false;
+
+ Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+
+ // or
+ // the targetUrl matches current url and it's redirect-to-render
+ redirectToRender=true;
+ targetEqualsCurrentUrl=true;
+
+ Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+
+ targetEqualsCurrentUrl=true;
+ pageStateless=true;
+ newPageInstance=true;
+ redirectToRender=true;
+
+ Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+
+ // or
+ // the request determines that the current url should be preserved
+ // just render the page
+ shouldPreserveClientUrl=true;
+
+ redirectPolicy=RedirectPolicy.AUTO_REDIRECT;
+ ajax=true;
+ onePassRender=false;
+ redirectToRender=false;
+ targetEqualsCurrentUrl=false;
+ newPageInstance=true;
+ pageStateless=true;
+
+ Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+
+ }
+
+ @Test
+ public void testShouldNOTRenderPageAndWriteResponseCondition() {
+
+ RedirectPolicy redirectPolicy;
+ boolean ajax;
+ boolean onePassRender;
+ boolean redirectToRender;
+ boolean shouldPreserveClientUrl;
+ boolean targetEqualsCurrentUrl;
+ boolean newPageInstance;
+ boolean pageStateless;
+
+ // NOT if the policy is never to redirect
+ redirectPolicy=RedirectPolicy.AUTO_REDIRECT;
+
+ // NOT or one pass render mode is on
+ // -> or one pass render mode is on and its NOT ajax and its NOT always redirect
+ ajax=true;
+ onePassRender=false;
+
+ // NOT or the targetUrl matches current url and the page is not stateless
+ // or the targetUrl matches current url, page is stateless but it's redirect-to-render
+ // --> its NOT ajax and
+ // the targetUrl matches current url and the page is NOT stateless and its NOT a new instance
+ // or the targetUrl matches current url and it's redirect-to-render
+ targetEqualsCurrentUrl=false;
+
+ // or the request determines that the current url should be preserved
+ // just render the page
+ shouldPreserveClientUrl=false;
+
+ redirectToRender=true;
+ newPageInstance=true;
+ pageStateless=true;
+
+ Assert.assertFalse(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+
+ redirectToRender=false;
+ newPageInstance=false;
+ pageStateless=false;
+
+ Assert.assertFalse(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+ }
+
+ @Test
+ public void testShouldRenderPageAndWriteResponseVariationIntegrity() {
+ int count = countVariations(new ShouldRenderPageAndWriteResponseVariations());
+ Assert.assertEquals(2*2*2*2*2*2*2*3,count);
+ }
+
+ @Test
+ public void testShouldRenderPageAndWriteResponseVariation() {
+
+ String match =
+ " X XXXXXXXX" +
+ " XXXXXXXXXXXX" +
+ " X XXXXXXXX" +
+ " XXXXXXXXXXXX" +
+ " XXXXXXXX" +
+ " XXXXXXXXXXXX" +
+ " XXXXXXXX" +
+ " XXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ " X XXXXXXXX" +
+ " XXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ " XXXXXXXX" +
+ " XXXXXXXXXXXX" +
+ " XXXXXXXX" +
+ " XXXXXXXXXXX";
+
+ checkVariations(match,new ShouldRenderPageAndWriteResponseVariations());
+ }
+
+ @Test
+ public void testShouldRedirectToTargetUrlIntegrity() {
+ int count = countVariations(new ShouldRedirectToTargetUrl());
+ Assert.assertEquals(2*3*2*2*2*2*2,count);
+ }
+
+ @Test
+ public void testShouldRedirectToTargetUrl() {
+
+ String match =
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ " XXXXX " +
+ "XXXXXXXXXXXXXXXX" +
+ " XXXXX " +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ " XXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ " XXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXX";
+
+ checkVariations(match,new ShouldRedirectToTargetUrl());
+ }
+
+ public void testShouldRedirectToTargetUrlCondition() {
+
+ boolean ajax;
+ RedirectPolicy redirectPolicy;
+ boolean redirectToRender;
+ boolean targetEqualsCurrentUrl;
+ boolean newPageInstance;
+ boolean pageStateless;
+ boolean sessionTemporary;
+
+ // if
+ // render policy is always-redirect
+
+ ajax=false;
+ redirectPolicy=RedirectPolicy.ALWAYS_REDIRECT;
+ redirectToRender=false;
+ targetEqualsCurrentUrl=false;
+ newPageInstance=false;
+ pageStateless=false;
+ sessionTemporary=false;
+
+ Assert.assertTrue(WebPageRenderer.shouldRedirectToTargetUrl(ajax, redirectPolicy, redirectToRender, targetEqualsCurrentUrl, newPageInstance, pageStateless,sessionTemporary));
+
+ // or
+ // it's redirect-to-render
+ redirectPolicy=RedirectPolicy.AUTO_REDIRECT;
+ redirectToRender=true;
+
+ Assert.assertTrue(WebPageRenderer.shouldRedirectToTargetUrl(ajax, redirectPolicy, redirectToRender, targetEqualsCurrentUrl, newPageInstance, pageStateless,sessionTemporary));
+
+ // or
+ // its ajax and the targetUrl matches current url
+ redirectToRender=false;
+ ajax=true;
+ targetEqualsCurrentUrl=true;
+
+ Assert.assertTrue(WebPageRenderer.shouldRedirectToTargetUrl(ajax, redirectPolicy, redirectToRender, targetEqualsCurrentUrl, newPageInstance, pageStateless,sessionTemporary));
+
+ // or
+ // targetUrl DONT matches current url and
+ // is new page instance
+ // or
+ // session is temporary and page is stateless
+ ajax=false;
+ targetEqualsCurrentUrl=false;
+ newPageInstance=true;
+
+ Assert.assertTrue(WebPageRenderer.shouldRedirectToTargetUrl(ajax, redirectPolicy, redirectToRender, targetEqualsCurrentUrl, newPageInstance, pageStateless,sessionTemporary));
+
+ newPageInstance=false;
+ sessionTemporary=true;
+ pageStateless=true;
+
+ Assert.assertTrue(WebPageRenderer.shouldRedirectToTargetUrl(ajax, redirectPolicy, redirectToRender, targetEqualsCurrentUrl, newPageInstance, pageStateless,sessionTemporary));
+ // just redirect
+ }
+
+ public void testShouldNOTRedirectToTargetUrlCondition() {
+
+ boolean ajax;
+ RedirectPolicy redirectPolicy;
+ boolean redirectToRender;
+ boolean targetEqualsCurrentUrl;
+ boolean newPageInstance;
+ boolean pageStateless;
+ boolean sessionTemporary;
+
+ // NOT if
+ // render policy is always-redirect
+ // AND NOT
+ // it's redirect-to-render
+ // AND NOT
+ // its ajax and the targetUrl matches current url
+ // AND NOT
+ // targetUrl DONT matches current url and
+ // is new page instance
+ // or
+ // session is temporary and page is stateless
+
+ ajax=false;
+ redirectPolicy=RedirectPolicy.AUTO_REDIRECT;
+ redirectToRender=false;
+ targetEqualsCurrentUrl=false;
+ newPageInstance=false;
+ pageStateless=false;
+ sessionTemporary=false;
+
+ Assert.assertFalse(WebPageRenderer.shouldRedirectToTargetUrl(ajax, redirectPolicy, redirectToRender, targetEqualsCurrentUrl, newPageInstance, pageStateless,sessionTemporary));
+ }
+
+ private int countVariations(AbstractVariations variations) {
+ int count=1;
+ while (variations.hasNextVariation()) {
+ count++;
+ variations.nextVariation();
+ }
+ return count;
+ }
+
- private void checkVariations(String match,AbstractVariations variations) {
++ private void checkVariations(String match, AbstractVariations variations) {
+ int idx=0;
+ while (variations.hasNextVariation()) {
+ Assert.assertEquals(variations.toString(), match.charAt(idx) == 'X', variations.getResult());
+ variations.nextVariation();
+ idx++;
+ }
+ }
+
+ private void printVariations(AbstractVariations variations) {
+ int idx=0;
+ System.out.print("\"");
+ while (variations.hasNextVariation()) {
+ System.out.print(variations.getResult() ? 'X': ' ');
+ variations.nextVariation();
+ idx++;
+ if (idx>=16) {
+ System.out.print("\"+\n\"");
+ idx=0;
+ }
+ }
+ System.out.println("\";");
+ }
+
/**
- * Tests that when the page is stateful and the urls are the same then the response is written
- * directly
- */
+ * Tests that when the page is stateful and the urls are the same then the response is written
+ * directly
+ */
@Test
public void testRedirectToBufferStatefulPageAndSameUrls()
{