myfaces-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mfreed...@apache.org
Subject svn commit: r889475 [1/2] - in /myfaces/portlet-bridge/testsuite/trunk/src: main/java/org/apache/myfaces/portlet/faces/testsuite/tests/chapter_6/section_6_1_1/ main/java/org/apache/myfaces/portlet/faces/testsuite/tests/chapter_6/section_6_1_3_2/ main/w...
Date Fri, 11 Dec 2009 00:05:39 GMT
Author: mfreedman
Date: Fri Dec 11 00:05:38 2009
New Revision: 889475

URL: http://svn.apache.org/viewvc?rev=889475&view=rev
Log:
Added tests for section 6.1.3.2.  Also fixed up the JSE 6 dependency.

Added:
    myfaces/portlet-bridge/testsuite/trunk/src/main/java/org/apache/myfaces/portlet/faces/testsuite/tests/chapter_6/section_6_1_3_2/
    myfaces/portlet-bridge/testsuite/trunk/src/main/java/org/apache/myfaces/portlet/faces/testsuite/tests/chapter_6/section_6_1_3_2/Tests.java
Modified:
    myfaces/portlet-bridge/testsuite/trunk/src/main/java/org/apache/myfaces/portlet/faces/testsuite/tests/chapter_6/section_6_1_1/Tests.java
    myfaces/portlet-bridge/testsuite/trunk/src/main/webapp/WEB-INF/faces-config.xml
    myfaces/portlet-bridge/testsuite/trunk/src/main/webapp/WEB-INF/portlet.xml
    myfaces/portlet-bridge/testsuite/trunk/src/test/java/org/apache/myfaces/portlet/faces/tckharness/TckTestCase.java

Modified: myfaces/portlet-bridge/testsuite/trunk/src/main/java/org/apache/myfaces/portlet/faces/testsuite/tests/chapter_6/section_6_1_1/Tests.java
URL: http://svn.apache.org/viewvc/myfaces/portlet-bridge/testsuite/trunk/src/main/java/org/apache/myfaces/portlet/faces/testsuite/tests/chapter_6/section_6_1_1/Tests.java?rev=889475&r1=889474&r2=889475&view=diff
==============================================================================
--- myfaces/portlet-bridge/testsuite/trunk/src/main/java/org/apache/myfaces/portlet/faces/testsuite/tests/chapter_6/section_6_1_1/Tests.java
(original)
+++ myfaces/portlet-bridge/testsuite/trunk/src/main/java/org/apache/myfaces/portlet/faces/testsuite/tests/chapter_6/section_6_1_1/Tests.java
Fri Dec 11 00:05:38 2009
@@ -77,11 +77,20 @@
   @BridgeTest(test = "wrappedFacesContextTest")
   public String wrappedFacesContextTest(TestRunnerBean testRunner)
   { 
-    testRunner.setTestComplete(true);
+    // done by navigation rule.
+    if (BridgeUtil.getPortletRequestPhase() ==
+        Bridge.PortletPhase.ACTION_PHASE)
+    {
+      return "wrappedFacesContextTest"; // action Navigation result
+    }
+    else
+    {
+      testRunner.setTestComplete(true);
 
-    testRunner.setTestResult(true,  
+      testRunner.setTestResult(true,  
                              "Successfully rendered and performed an action with a wrapped
FacesContext indicating the bridge implementation doesn't depend on casting directly to its
FacesContext class.");
-    return Constants.TEST_SUCCESS;
+      return Constants.TEST_SUCCESS;
+    }
   }
 
 }

Added: myfaces/portlet-bridge/testsuite/trunk/src/main/java/org/apache/myfaces/portlet/faces/testsuite/tests/chapter_6/section_6_1_3_2/Tests.java
URL: http://svn.apache.org/viewvc/myfaces/portlet-bridge/testsuite/trunk/src/main/java/org/apache/myfaces/portlet/faces/testsuite/tests/chapter_6/section_6_1_3_2/Tests.java?rev=889475&view=auto
==============================================================================
--- myfaces/portlet-bridge/testsuite/trunk/src/main/java/org/apache/myfaces/portlet/faces/testsuite/tests/chapter_6/section_6_1_3_2/Tests.java
(added)
+++ myfaces/portlet-bridge/testsuite/trunk/src/main/java/org/apache/myfaces/portlet/faces/testsuite/tests/chapter_6/section_6_1_3_2/Tests.java
Fri Dec 11 00:05:38 2009
@@ -0,0 +1,1006 @@
+/* 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.myfaces.portlet.faces.testsuite.tests.chapter_6.section_6_1_3_2;
+
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+
+import java.util.Arrays;
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.Locale;
+import java.util.Map;
+
+import java.util.Set;
+
+import javax.el.ELContext;
+import javax.el.ExpressionFactory;
+
+import javax.el.ValueExpression;
+
+import javax.faces.application.Application;
+import javax.faces.application.FacesMessage;
+import javax.faces.application.ViewHandler;
+import javax.faces.context.ExternalContext;
+import javax.faces.context.FacesContext;
+import javax.faces.render.ResponseStateManager;
+
+import javax.portlet.ActionRequest;
+import javax.portlet.PortletContext;
+import javax.portlet.PortletMode;
+import javax.portlet.PortletRequest;
+import javax.portlet.PortletResponse;
+import javax.portlet.PortletSession;
+import javax.portlet.PortletURL;
+import javax.portlet.RenderRequest;
+import javax.portlet.RenderResponse;
+
+import javax.portlet.WindowState;
+import javax.portlet.faces.Bridge;
+import javax.portlet.faces.BridgeUtil;
+
+import javax.servlet.ServletRequest;
+import javax.servlet.http.HttpServletRequest;
+
+import javax.servlet.jsp.JspContext;
+
+import org.apache.myfaces.portlet.faces.testsuite.annotation.BridgeTest;
+import org.apache.myfaces.portlet.faces.testsuite.beans.TestRunnerBean;
+import org.apache.myfaces.portlet.faces.testsuite.common.Constants;
+import org.apache.myfaces.portlet.faces.testsuite.common.portlet.wrapper.ActionRequestDecorator;
+import org.apache.myfaces.portlet.faces.testsuite.common.portlet.wrapper.RenderRequestDecorator;
+
+
+public class Tests
+  extends Object
+{
+
+  // Test is SingleRequest -- Render only
+
+  @BridgeTest(test = "encodeNamespaceTest")
+  public String encodeNamespaceTest(TestRunnerBean testRunner)
+  {
+    testRunner.setTestComplete(true);
+
+    FacesContext ctx = FacesContext.getCurrentInstance();
+    ExternalContext extCtx = ctx.getExternalContext();
+    RenderResponse response = (RenderResponse) extCtx.getResponse();
+
+    String encodedNamespace = extCtx.encodeNamespace("");
+    if (encodedNamespace == null)
+    {
+      testRunner.setTestResult(false,
+                               "extCtx.encodeNamespace() failed:  it returned a null value");
+    }
+    else if (encodedNamespace.equals(response.getNamespace()))
+    {
+      testRunner.setTestResult(true,
+                               "extCtx.encodeNamespace() correctly returned the same value
as response.encodeNamespace when encoding the empty string.");
+    }
+    else
+    {
+      testRunner.setTestResult(false,
+                               "extCtx.encodeNamespace() failed:  it returned a different
value than response.encodeNamespace when encoding the empty string: it returned: " +
+                               encodedNamespace + " but we expected: " +
+                               response.getNamespace());
+    }
+
+    if (testRunner.getTestStatus())
+    {
+      return Constants.TEST_SUCCESS;
+    }
+    else
+    {
+      return Constants.TEST_FAILED;
+
+    }
+  }
+
+  /******************** getApplicationMap Tests ***************/
+  @BridgeTest(test = "getApplicationMapTest")
+  public String getApplicationMapTest(TestRunnerBean testRunner)
+  {
+    testRunner.setTestComplete(true);
+
+    FacesContext ctx = FacesContext.getCurrentInstance();
+    ExternalContext extCtx = ctx.getExternalContext();
+
+    // Test the following:
+    //   1. Map is mutable
+    //   2. Map contains attributes in the underlying portlet context
+    //         a) set on portlet context -- get via map
+    //         b) set on map -- get via app context
+    //   3. Remove in request -- gone from Map
+    //   4. Remove from Map -- gone in portlet context
+
+    PortletContext portletCtx = (PortletContext) extCtx.getContext();
+    Map<String, Object> extCtxAppMap = extCtx.getApplicationMap();
+
+    // ensure they start out identical
+    if (!containsIdenticalAttributeEntries(extCtxAppMap,
+                                           (Enumeration<String>) portletCtx.getAttributeNames(),
+                                           portletCtx))
+    {
+      testRunner.setTestResult(false,
+                               "Failed: Portlet context attributes and the externalContext
applicationMap entries aren't identical.");
+      return Constants.TEST_FAILED;
+    }
+
+    // Test for mutability
+    try
+    {
+      extCtxAppMap.put("Test0Key", "Test0Value");
+      portletCtx.setAttribute("Test1Key", "Test1Value");
+    }
+    catch (Exception e)
+    {
+      testRunner.setTestResult(false,
+                               "Failed: Putting an attribute on the ExternalContext's applicationMap
threw an exception: " +
+                               e.toString());
+      return Constants.TEST_FAILED;
+    }
+
+    // test that we can read an attribute set on the portlet request via this Map
+    // and vice-versa -- as we have just written an attribute on the extCtx and
+    // the test portlet wrote one on the portlet request -- the act of verifying
+    // the Maps contain the same keys/values should do the trick.
+    if (!containsIdenticalAttributeEntries(extCtxAppMap,
+                                           (Enumeration<String>) portletCtx.getAttributeNames(),
+                                           portletCtx))
+    {
+      testRunner.setTestResult(false,
+                               "Failed: After setting an attribute on the portlet context
and the externalContext applicationMap they no longer contain identical entries.");
+      return Constants.TEST_FAILED;
+    }
+
+    // Now remove the attribute we put in the  -- do the remove on the opposite object
+    extCtxAppMap.remove("Test1Key");
+    portletCtx.removeAttribute("Test0Key");
+
+    if (!containsIdenticalAttributeEntries(extCtxAppMap,
+                                           (Enumeration<String>) portletCtx.getAttributeNames(),
+                                           portletCtx))
+    {
+      testRunner.setTestResult(false,
+                               "Failed: After removing an attribute on the portlet context
and the externalContext applicationMap they no longer contain identical entries.");
+      return Constants.TEST_FAILED;
+    }
+
+
+    // Otherwise all out tests passed:
+
+    testRunner.setTestResult(true,
+                             "The Map returned from getApplicationMap is mutable.");
+    testRunner.appendTestDetail("The getApplicationMap Map correctly expresses attributes
in the underlying portletContext that have been added there.");
+    testRunner.appendTestDetail("The getApplicationMap Map correctly reflects attrbiutes
into the underlying portletContext that have been added to it.");
+    testRunner.appendTestDetail("The getApplicationMap Map correctly doesn't express attrbiutes
that have been removed from the underlying portletContext");
+    testRunner.appendTestDetail("The getApplicationMap Map correctly cause the underlying
portletContext to remove any attributes removed from it");
+
+    return Constants.TEST_SUCCESS;
+
+  }
+
+  private boolean containsIdenticalAttributeEntries(Map<String, Object> m,
+                                                    Enumeration<String> eNames,
+                                                    PortletContext ctx)
+  {
+    // For each entry in m ensure there is an identical one in the context
+    for (Iterator<Map.Entry<String, Object>> entries =
+         m.entrySet().iterator(); entries.hasNext(); )
+    {
+      Map.Entry<String, Object> e = entries.next();
+      Object attrValue = ctx.getAttribute(e.getKey());
+      Object mapObj = e.getValue();
+      if (mapObj == null && attrValue == null)
+        continue; // technically shouldn't have this but some container do
+      if (mapObj == null || attrValue == null || !mapObj.equals(attrValue))
+      {
+        return false;
+      }
+    }
+
+    // For each entry in the context -- ensure there is an identical one in the map
+    while (eNames.hasMoreElements())
+    {
+      String key = eNames.nextElement();
+      Object attrValue = ctx.getAttribute(key);
+      Object mapObj = m.get(key);
+      if (mapObj == null && attrValue == null)
+        continue; // technically shouldn't have this but some container do
+      if (mapObj == null || attrValue == null || !mapObj.equals(attrValue))
+      {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  @BridgeTest(test = "getAuthTypeTest")
+  public String getAuthTypeTest(TestRunnerBean testRunner)
+  {
+    testRunner.setTestComplete(true);
+
+    FacesContext ctx = FacesContext.getCurrentInstance();
+    ExternalContext extCtx = ctx.getExternalContext();
+    RenderRequest request = (RenderRequest) extCtx.getRequest();
+
+    String authType = extCtx.getAuthType();
+    String requestAuthType = request.getAuthType();
+
+    if ((authType == null && requestAuthType == null) ||
+        authType.equals(requestAuthType))
+    {
+      testRunner.setTestResult(true,
+                               "extCtx.getAuthType() correctly returned the same value as
request.getAuthType()");
+    }
+    else
+    {
+      testRunner.setTestResult(false,
+                               "extCtx.getAuthType() failed:  it returned a different value
than request.getAuthType(): it returned: " +
+                               authType + " but we expected: " +
+                               requestAuthType);
+    }
+
+    if (testRunner.getTestStatus())
+    {
+      return Constants.TEST_SUCCESS;
+    }
+    else
+    {
+      return Constants.TEST_FAILED;
+
+    }
+  }
+
+  @BridgeTest(test = "getContextTest")
+  public String getContextTest(TestRunnerBean testRunner)
+  {
+    testRunner.setTestComplete(true);
+
+    FacesContext ctx = FacesContext.getCurrentInstance();
+    ExternalContext extCtx = ctx.getExternalContext();
+    Object portletContext = extCtx.getContext();
+
+    if (portletContext != null && portletContext instanceof PortletContext)
+    {
+      testRunner.setTestResult(true,
+                               "extCtx.getContext() correctly returned an object of type
PortletContext.");
+    }
+    else
+    {
+      testRunner.setTestResult(false,
+                               "extCtx.getContext() didn't return an object of type PortletContext.");
+    }
+
+    if (testRunner.getTestStatus())
+    {
+      return Constants.TEST_SUCCESS;
+    }
+    else
+    {
+      return Constants.TEST_FAILED;
+
+    }
+  }
+
+  @BridgeTest(test = "getInitParameterTest")
+  public String getInitParameterTest(TestRunnerBean testRunner)
+  {
+    testRunner.setTestComplete(true);
+
+    FacesContext ctx = FacesContext.getCurrentInstance();
+    ExternalContext extCtx = ctx.getExternalContext();
+    PortletContext portletContext = (PortletContext) extCtx.getContext();
+
+    // Get the enum of initparameter names -- then get one of the parameters
+    // and make sure the same object is returned.
+    Enumeration<String> e = portletContext.getInitParameterNames();
+
+    if (!e.hasMoreElements())
+    {
+      testRunner.setTestResult(false,
+                               "extCtx.getInitParameter() failed: there are no initParameters");
+    }
+    else
+    {
+      String name = e.nextElement();
+      String extCtxParam = extCtx.getInitParameter(name);
+      String ctxParam = portletContext.getInitParameter(name);
+
+      if (extCtxParam.equals(ctxParam))
+      {
+        testRunner.setTestResult(true,
+                                 "extCtx.getInitParameter() correctly returned the same value
as PortletContext.getInitParameter.");
+      }
+      else
+      {
+        testRunner.setTestResult(false,
+                                 "extCtx.getInitParameter() failed: it returned a different
value than PortletContext.getInitParameter.  Expected: " +
+                                 ctxParam + " but received: " +
+                                 extCtxParam);
+      }
+    }
+
+
+    if (testRunner.getTestStatus())
+    {
+      return Constants.TEST_SUCCESS;
+    }
+    else
+    {
+      return Constants.TEST_FAILED;
+
+    }
+  }
+
+  /******************** getInitParameterMap Tests ***************/
+  @BridgeTest(test = "getInitParameterMapTest")
+  public String getInitParameterMapTest(TestRunnerBean testRunner)
+  {
+    testRunner.setTestComplete(true);
+
+    FacesContext ctx = FacesContext.getCurrentInstance();
+    ExternalContext extCtx = ctx.getExternalContext();
+
+    // Test the following:
+    //   1. Map is immutable
+    //   2. Map contains attributes in the underlying portlet context
+
+
+    PortletContext portletCtx = (PortletContext) extCtx.getContext();
+    Map<String, String> extCtxInitParamMap = extCtx.getInitParameterMap();
+
+    // ensure they start out identical
+    if (!containsIdenticalInitParamEntries(extCtxInitParamMap,
+                                           (Enumeration<String>) portletCtx.getInitParameterNames(),
+                                           portletCtx))
+    {
+      testRunner.setTestResult(false,
+                               "Failed: Portlet context initParams and the externalContext
initParameterMap entries aren't identical.");
+      return Constants.TEST_FAILED;
+    }
+
+    // Test for immutability
+    try
+    {
+      extCtxInitParamMap.put("Test0Key", "Test0Value");
+      testRunner.setTestResult(false,
+                               "Failed: ExternalContext's initParameterMap isn't immutable
-- a put() suceeded.");
+      return Constants.TEST_FAILED;
+    }
+    catch (Exception e)
+    {
+      // this is what we expect -- just forge ahead;
+    }
+
+
+    // Otherwise all out tests passed:
+
+    testRunner.setTestResult(true,
+                             "The Map returned from initParameterMap is immutable.");
+    testRunner.appendTestDetail("The initParameterMap Map correctly expresses attributes
in the underlying context.");
+
+
+    return Constants.TEST_SUCCESS;
+
+  }
+
+  private boolean containsIdenticalInitParamEntries(Map<String, String> m,
+                                                    Enumeration<String> eNames,
+                                                    PortletContext ctx)
+  {
+    // For each entry in m ensure there is an identical one in the context
+    for (Iterator<Map.Entry<String, String>> entries =
+         m.entrySet().iterator(); entries.hasNext(); )
+    {
+      Map.Entry<String, String> e = entries.next();
+      String value = ctx.getInitParameter(e.getKey());
+      String mapObj = e.getValue();
+      if (mapObj == null && value == null)
+        continue; // technically shouldn't have this but some container do
+      if (mapObj == null || value == null || !mapObj.equals(value))
+      {
+        return false;
+      }
+    }
+
+    // For each entry in the context -- ensure there is an identical one in the map
+    while (eNames.hasMoreElements())
+    {
+      String key = eNames.nextElement();
+      Object value = ctx.getInitParameter(key);
+      Object mapObj = m.get(key);
+      if (mapObj == null && value == null)
+        continue; // technically shouldn't have this but some container do
+      if (mapObj == null || value == null || !mapObj.equals(value))
+      {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  @BridgeTest(test = "getRemoteUserTest")
+  public String getRemoteUserTest(TestRunnerBean testRunner)
+  {
+    testRunner.setTestComplete(true);
+
+    FacesContext ctx = FacesContext.getCurrentInstance();
+    ExternalContext extCtx = ctx.getExternalContext();
+    RenderRequest request = (RenderRequest) extCtx.getRequest();
+
+    String remoteUser = extCtx.getRemoteUser();
+    String requestRemoteUser = request.getRemoteUser();
+
+    if ((remoteUser == null && requestRemoteUser == null) ||
+        remoteUser.equals(requestRemoteUser))
+    {
+      testRunner.setTestResult(true,
+                               "extCtx.getRemoteUser() correctly returned the same value
as request.getRemoteUser()");
+    }
+    else
+    {
+      testRunner.setTestResult(false,
+                               "extCtx.getRemoteUser() failed:  it returned a different value
than request.getRemoteUser(): it returned: " +
+                               remoteUser + " but we expected: " +
+                               requestRemoteUser);
+    }
+
+    if (testRunner.getTestStatus())
+    {
+      return Constants.TEST_SUCCESS;
+    }
+    else
+    {
+      return Constants.TEST_FAILED;
+
+    }
+  }
+
+  @BridgeTest(test = "getRequestContextPathTest")
+  public String getRequestContextPathTest(TestRunnerBean testRunner)
+  {
+    testRunner.setTestComplete(true);
+
+    FacesContext ctx = FacesContext.getCurrentInstance();
+    ExternalContext extCtx = ctx.getExternalContext();
+    RenderRequest request = (RenderRequest) extCtx.getRequest();
+
+    String contextPath = extCtx.getRequestContextPath();
+    String requestContextPath = request.getContextPath();
+
+    if (contextPath.equals(requestContextPath))
+    {
+      testRunner.setTestResult(true,
+                               "extCtx.getRequestContextPath() correctly returned the same
value as request.getRequestContextPath()");
+    }
+    else
+    {
+      testRunner.setTestResult(false,
+                               "extCtx.getRequestContextPath() failed:  it returned a different
value than request.getRequestContextPath(): it returned: " +
+                               contextPath + " but we expected: " +
+                               requestContextPath);
+    }
+
+    if (testRunner.getTestStatus())
+    {
+      return Constants.TEST_SUCCESS;
+    }
+    else
+    {
+      return Constants.TEST_FAILED;
+
+    }
+  }
+
+  /******************** getRequestCookieMap Tests ***************/
+  @BridgeTest(test = "getRequestCookieMapTest")
+  public String getRequestCookieMapTest(TestRunnerBean testRunner)
+  {
+    testRunner.setTestComplete(true);
+
+    FacesContext ctx = FacesContext.getCurrentInstance();
+    ExternalContext extCtx = ctx.getExternalContext();
+
+    // Test the following:
+    //   1. Map is immutable
+    //   2. We don't expect the Map to contain anything as cookies are hidden in JSR 168
+
+
+    Map<String, Object> cookieMap = extCtx.getRequestCookieMap();
+
+    // ensure they start out identical
+    if (cookieMap == null)
+    {
+      testRunner.setTestResult(false,
+                               "Failed: extCtx.getRequestCookieMap() returned null.");
+      return Constants.TEST_FAILED;
+    }
+
+    // Test for immutability
+    try
+    {
+      cookieMap.put("Test0Key", "Test0Value");
+      testRunner.setTestResult(false,
+                               "Failed: ExternalContext's getRequestCookieMap isn't immutable
-- a put() suceeded.");
+      return Constants.TEST_FAILED;
+    }
+    catch (Exception e)
+    {
+      // this is what we expect -- just forge ahead;
+    }
+
+
+    // Otherwise all out tests passed:
+
+    testRunner.setTestResult(true,
+                             "The Map returned from getRequestCookieMap is immutable.");
+
+    return Constants.TEST_SUCCESS;
+
+  }
+
+  @BridgeTest(test = "getRequestLocaleTest")
+  public String getRequestLocaleTest(TestRunnerBean testRunner)
+  {
+    testRunner.setTestComplete(true);
+
+    FacesContext ctx = FacesContext.getCurrentInstance();
+    ExternalContext extCtx = ctx.getExternalContext();
+    RenderRequest request = (RenderRequest) extCtx.getRequest();
+
+    Locale locale = extCtx.getRequestLocale();
+    Locale requestLocale = request.getLocale();
+
+    if (locale.equals(requestLocale))
+    {
+      testRunner.setTestResult(true,
+                               "extCtx.getRequestLocale() correctly returned the same Locale
as request.getLocale()");
+    }
+    else
+    {
+      testRunner.setTestResult(false,
+                               "extCtx.getRequestLocale() failed:  it returned a different
value than request.getRequestLocale(): it returned: " +
+                               locale + " but we expected: " +
+                               requestLocale);
+    }
+
+    if (testRunner.getTestStatus())
+    {
+      return Constants.TEST_SUCCESS;
+    }
+    else
+    {
+      return Constants.TEST_FAILED;
+
+    }
+  }
+
+  @BridgeTest(test = "getRequestLocalesTest")
+  public String getRequestLocalesTest(TestRunnerBean testRunner)
+  {
+    testRunner.setTestComplete(true);
+
+    FacesContext ctx = FacesContext.getCurrentInstance();
+    ExternalContext extCtx = ctx.getExternalContext();
+
+
+    RenderRequest request = (RenderRequest) extCtx.getRequest();
+    Iterator<Locale> locales = extCtx.getRequestLocales();
+    Enumeration<Locale> requestLocales = request.getLocales();
+
+    while (requestLocales.hasMoreElements() && locales.hasNext())
+    {
+      Locale requestLocale = requestLocales.nextElement();
+      Locale locale = locales.next();
+      if (!locale.equals(requestLocale))
+      {
+        testRunner.setTestResult(false,
+                                 "Failed: Portlet request locales and the externalContext
getRequestLocales entries aren't identical.");
+        return Constants.TEST_FAILED;
+      }
+    }
+
+    if (requestLocales.hasMoreElements() || locales.hasNext())
+    {
+      testRunner.setTestResult(false,
+                               "Failed: Size of Portlet request locales enumeration and the
externalContext getRequestLocales Iterator aren't identical.");
+      return Constants.TEST_FAILED;
+    }
+
+    // Otherwise all out tests passed:
+
+    testRunner.setTestResult(true,
+                             "The Iterator returned from extCtx.getRequestLocales contains
identical entries as the request.getLocales.");
+
+    return Constants.TEST_SUCCESS;
+
+  }
+
+  @BridgeTest(test = "getResourceTest")
+  public String getResourceTest(TestRunnerBean testRunner)
+  {
+    testRunner.setTestComplete(true);
+
+    FacesContext ctx = FacesContext.getCurrentInstance();
+    ExternalContext extCtx = ctx.getExternalContext();
+
+
+    PortletContext pCtx = (PortletContext) extCtx.getContext();
+
+    try
+    {
+      URL extCtxURL =
+        extCtx.getResource("/images/portlet_bridge_logo.png");
+      URL pCtxURL = pCtx.getResource("/images/portlet_bridge_logo.png");
+
+      if (extCtxURL == null || pCtxURL == null ||
+          !pCtxURL.equals(extCtxURL))
+      {
+        testRunner.setTestResult(false,
+                                 "Failed: extCtx.getResource failed:  URL returned from call
through externalContext isn't the same as the one returned by the portletContext.");
+        return Constants.TEST_FAILED;
+      }
+
+      // Otherwise all out tests passed:
+
+      testRunner.setTestResult(true,
+                               "URL returned from call through externalContext is the same
as the one returned by the portletContext.");
+
+      return Constants.TEST_SUCCESS;
+    }
+    catch (MalformedURLException e)
+    {
+      testRunner.setTestResult(false,
+                               "Failed: Unexpected MalformedURLException thrown when called
getResource().");
+      return Constants.TEST_FAILED;
+    }
+
+  }
+
+  @BridgeTest(test = "getResourceAsStreamTest")
+  public String getResourceAsStreamTest(TestRunnerBean testRunner)
+  {
+    testRunner.setTestComplete(true);
+
+    FacesContext ctx = FacesContext.getCurrentInstance();
+    ExternalContext extCtx = ctx.getExternalContext();
+
+
+    PortletContext pCtx = (PortletContext) extCtx.getContext();
+
+    InputStream extCtxStream =
+      extCtx.getResourceAsStream("/images/portlet_bridge_logo.png");
+    InputStream pCtxStream =
+      pCtx.getResourceAsStream("/images/portlet_bridge_logo.png");
+
+    if (extCtxStream == null || pCtxStream == null)
+    {
+      testRunner.setTestResult(false,
+                               "Failed: extCtx.getResourceAsStream failed:  returned InputStream
is unexpectedly null.");
+      return Constants.TEST_FAILED;
+    }
+
+    // compare the bytes in each stream
+    byte[] stream1 = new byte[1024];
+    byte[] stream2 = new byte[1024];
+    boolean done = false;
+    boolean success = true;
+    while (!done)
+    {
+      try
+      {
+        int c1 = extCtxStream.read(stream1);
+        int c2 = pCtxStream.read(stream2);
+        if (c1 < 1024)
+          done = true;
+        if (c1 != c2 || !Arrays.equals(stream1, stream2))
+        {
+          success = false;
+          done = true;
+        }
+      }
+      catch (IOException e)
+      {
+        testRunner.setTestResult(false,
+                                 "Failed: Unexpected IOException thrown when reading stream:
" + e.getMessage());
+        return Constants.TEST_FAILED;
+      }
+      catch (Throwable t)
+      {
+        testRunner.setTestResult(false,
+                                 "Failed: Unexpected Throwable thrown when reading stream:
" + t.getMessage());
+        return Constants.TEST_FAILED;
+      }
+      finally
+      {
+        try
+        {
+          extCtxStream.close();
+          pCtxStream.close();
+        }
+        catch (IOException e)
+        {
+          //ignore
+        }
+      }
+    }
+
+    if (success)
+    {
+      testRunner.setTestResult(true,
+                               "Stream returned from call through externalContext is the
same as the one returned by the portletContext.");
+
+      return Constants.TEST_SUCCESS;
+    }
+    else
+    {
+      testRunner.setTestResult(false,
+                               "Stream returned from call through externalContext is different
than the one returned by the portletContext.");
+
+      return Constants.TEST_FAILED;
+    }
+
+  }
+
+
+  @BridgeTest(test = "getResourcePathsTest")
+  public String getResourcePathsTest(TestRunnerBean testRunner)
+  {
+    testRunner.setTestComplete(true);
+
+    FacesContext ctx = FacesContext.getCurrentInstance();
+    ExternalContext extCtx = ctx.getExternalContext();
+
+
+    PortletContext pCtx = (PortletContext) extCtx.getContext();
+
+    Set<String> extCtxSet = extCtx.getResourcePaths("/tests/");
+    Set<String> pCtxSet = pCtx.getResourcePaths("/tests/");
+
+    if (pCtxSet == null || extCtxSet == null)
+    {
+      testRunner.setTestResult(false,
+                               "Failed: extCtx.getResourcePaths failed:  returned path Set
is unexpectedly null.");
+      return Constants.TEST_FAILED;
+    }
+    else if (pCtxSet.equals(extCtxSet))
+    {
+      testRunner.setTestResult(true,
+                               "Path set returned from call through externalContext is the
same as the one returned by the portletContext.");
+
+      return Constants.TEST_SUCCESS;
+    }
+    else
+    {
+      testRunner.setTestResult(false,
+                               "Path set returned from call through externalContext is different
than the one returned by the portletContext.");
+
+      return Constants.TEST_FAILED;
+    }
+  }
+
+  @BridgeTest(test = "setResponseCharacterEncodingTest")
+  public String setResponseCharacterEncodingTest(TestRunnerBean testRunner)
+  {
+    testRunner.setTestComplete(true);
+
+    FacesContext ctx = FacesContext.getCurrentInstance();
+    ExternalContext extCtx = ctx.getExternalContext();
+
+
+    PortletResponse response = (PortletResponse) extCtx.getResponse();
+
+    String curEncoding = extCtx.getResponseCharacterEncoding();
+
+    if (curEncoding.equalsIgnoreCase("utf-8"))
+    {
+      extCtx.setResponseCharacterEncoding("ISO-8859-1");
+    }
+    else
+    {
+      extCtx.setResponseCharacterEncoding("UTF-8");
+    }
+
+    if (curEncoding.equalsIgnoreCase(extCtx.getResponseCharacterEncoding()))
+    {
+      testRunner.setTestResult(true,
+                               "extCtx.setResponseCharacterEncoding() correctly had no effect.");
+
+      return Constants.TEST_SUCCESS;
+    }
+    else
+    {
+      testRunner.setTestResult(false,
+                               "extCtx.setResponseCharacterEncoding() unexpectedly changed
the response character encoding.");
+
+      return Constants.TEST_FAILED;
+    }
+  }
+
+  @BridgeTest(test = "getSessionTest")
+  public String getSessionTest(TestRunnerBean testRunner)
+  {
+    testRunner.setTestComplete(true);
+
+    FacesContext ctx = FacesContext.getCurrentInstance();
+    ExternalContext extCtx = ctx.getExternalContext();
+
+
+    PortletRequest request = (PortletRequest) extCtx.getRequest();
+
+
+    if (request.getPortletSession(true).equals(extCtx.getSession(true)))
+    {
+      testRunner.setTestResult(true,
+                               "extCtx.getSession() correctly returned the same session object
as the underlying request.");
+
+      return Constants.TEST_SUCCESS;
+    }
+    else
+    {
+      testRunner.setTestResult(false,
+                               "extCtx.getSession() incorrectly returned a different session
object than the underlying request.");
+
+      return Constants.TEST_FAILED;
+    }
+  }
+
+  @BridgeTest(test = "getSessionMapTest")
+  public String getSessionMapTest(TestRunnerBean testRunner)
+  {
+    testRunner.setTestComplete(true);
+
+    FacesContext ctx = FacesContext.getCurrentInstance();
+    ExternalContext extCtx = ctx.getExternalContext();
+
+    // Test the following:
+    //   1. Map is immutable
+    //   2. Map contains the same entries as in the underlying session
+
+    Map<String, Object> sessionMap = extCtx.getSessionMap();
+    PortletSession session =
+      ((PortletRequest) extCtx.getRequest()).getPortletSession();
+    Enumeration<String> requestSessionAttrNames =
+      session.getAttributeNames();
+
+    // Test for mutability
+    try
+    {
+      sessionMap.put("TestKey", "TestValue");
+    }
+    catch (Exception e)
+    {
+      testRunner.setTestResult(false,
+                               "The Map returned from getSessionMap is immutable.");
+      return "getSessionMapTest";
+    }
+
+    if (containsIdenticalSessionEntries(sessionMap,
+                                        requestSessionAttrNames, session))
+    {
+      testRunner.setTestResult(true,
+                               "extCtx.getSessionMap() correctly contains same attributes
as the underlying portlet session.");
+      return Constants.TEST_SUCCESS;
+    }
+    else
+    {
+      testRunner.setTestResult(false,
+                               "extCtx.getSessionMap() incorrectly contains different attributes
than the underlying portlet session.");
+      return Constants.TEST_FAILED;
+    }
+  }
+
+  private boolean containsIdenticalSessionEntries(Map<String, Object> m,
+                                                  Enumeration<String> eNames,
+                                                  PortletSession r)
+  {
+    // For each entry in m ensure there is an idenitcal one in the request
+    for (Iterator<Map.Entry<String, Object>> entries =
+         m.entrySet().iterator(); entries.hasNext(); )
+    {
+      Map.Entry<String, Object> e = entries.next();
+      Object requestObj = r.getAttribute(e.getKey());
+      Object mapObj = e.getValue();
+      if (mapObj == null && requestObj == null)
+        continue; // technically shouldn't have this but some container do
+      if (mapObj == null || requestObj == null ||
+          !mapObj.equals(requestObj))
+      {
+        return false;
+      }
+    }
+    return true;
+  }
+
+
+  @BridgeTest(test = "sessionMapPreDestroyRemoveTest")
+  public String sessionMapPreDestroyRemoveTest(TestRunnerBean testRunner)
+  {
+    testRunner.setTestComplete(true);
+
+
+    FacesContext ctx = FacesContext.getCurrentInstance();
+    ExternalContext extCtx = ctx.getExternalContext();
+    Application app = ctx.getApplication();
+
+    // ensure the managed beans come into existence
+    Boolean isIn =
+      (Boolean) app.evaluateExpressionGet(ctx, "#{predestroySessionBean.inBridgeRequestScope}",
+                                          Object.class);
+    Map<String, Object> m = extCtx.getRequestMap();
+    m.remove("predestroySessionBean");
+
+    // Now verify that things worked correctly
+    // We expect that the beans were not added to the bridge scope (yet) and hence only the
Predestroy was called
+    Boolean notifiedAddedToBridgeScope =
+      (Boolean) m.get("PreDestroyBean1.attributeAdded");
+    Boolean notifiedPreDestroy =
+      (Boolean) m.get("PreDestroyBean1.servletPreDestroy");
+    Boolean notifiedBridgePreDestroy =
+      (Boolean) m.get("PreDestroyBean1.bridgePreDestroy");
+
+    if (notifiedAddedToBridgeScope == null &&
+        notifiedBridgePreDestroy == null && notifiedPreDestroy != null &&
+        notifiedPreDestroy.equals(Boolean.TRUE))
+    {
+      // Only the regular PreDestroy was called and so it would have cleaned itself up
+      testRunner.setTestResult(true,
+                               "The bridge session scope behaved correctly in handling preDestroy
of a removed attribute prior to it being added to the bridge's scope in that:");
+      testRunner.appendTestDetail("     a) the bean wasn't notified it had been added to
the session scope.");
+      testRunner.appendTestDetail("     b) the bean didn't have its BridgePreDestroy called.");
+      testRunner.appendTestDetail("     c) the bean did have its Predestroy called.");
+    }
+    else
+    {
+      testRunner.setTestResult(false,
+                               "The bridge session scope didn't behave correctly in handling
preDestroy of a removed attribute:");
+      if (notifiedAddedToBridgeScope != null)
+        testRunner.appendTestDetail("::::: it notified the bean it was added to the bridge
session scope.");
+      if (notifiedBridgePreDestroy != null)
+        testRunner.appendTestDetail("::::: it notified the bean it was removed from the bridge
request scope.");
+      if (notifiedPreDestroy == null)
+        testRunner.appendTestDetail("::::: it didn't notify the bean's PreDestroy.");
+      if (notifiedPreDestroy != null &&
+          notifiedPreDestroy.equals(Boolean.FALSE))
+        testRunner.appendTestDetail("::::: the bean's Predestroy was called but it thought
it had been added to the bridge request scope.");
+    }
+
+
+    if (testRunner.getTestStatus())
+    {
+      return Constants.TEST_SUCCESS;
+    }
+    else
+    {
+      return Constants.TEST_FAILED;
+    }
+
+  }
+
+
+}

Modified: myfaces/portlet-bridge/testsuite/trunk/src/main/webapp/WEB-INF/faces-config.xml
URL: http://svn.apache.org/viewvc/myfaces/portlet-bridge/testsuite/trunk/src/main/webapp/WEB-INF/faces-config.xml?rev=889475&r1=889474&r2=889475&view=diff
==============================================================================
--- myfaces/portlet-bridge/testsuite/trunk/src/main/webapp/WEB-INF/faces-config.xml (original)
+++ myfaces/portlet-bridge/testsuite/trunk/src/main/webapp/WEB-INF/faces-config.xml Fri Dec
11 00:05:38 2009
@@ -171,6 +171,11 @@
     <managed-bean-scope>request</managed-bean-scope>
   </managed-bean>
   <managed-bean>
+    <managed-bean-name>chapter6_1_3_2Tests</managed-bean-name>
+    <managed-bean-class>org.apache.myfaces.portlet.faces.testsuite.tests.chapter_6.section_6_1_3_2.Tests</managed-bean-class>
+    <managed-bean-scope>request</managed-bean-scope>
+  </managed-bean>
+  <managed-bean>
     <managed-bean-name>predestroyBean1</managed-bean-name>
     <managed-bean-class>org.apache.myfaces.portlet.faces.testsuite.beans.PreDestroyBean1</managed-bean-class>
     <managed-bean-scope>request</managed-bean-scope>



Mime
View raw message