2009/05/20 - Apache Shale has been retired.

   /*
    * 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.shale.test.el;
  
  import java.lang.reflect.Method;
  import java.util.ArrayList;
  import java.util.List;
  import javax.el.ELContext;
  import javax.el.ELException;
  import javax.el.ELResolver;
  import javax.el.MethodExpression;
  import javax.el.MethodInfo;
  import javax.faces.context.FacesContext;
  
  /***
   * <p>Mock implementation of <code>MethodExpression</code>.</p>
   */
  public class MockMethodExpression extends MethodExpression {
      
  
      // ------------------------------------------------------------ Constructors
  
  
      /***
       * Serial version UID.
       */
      private static final long serialVersionUID = 5694105394290316715L;
  
  
      /***
       * <p>Construct a new expression for the specified expression string.</p>
       *
       * @param expression Expression string to be evaluated
       * @param signature Parameter signature of the method to be called
       * @param expectedType Expected type of the result
       */
      public MockMethodExpression(String expression, Class[] signature, Class expectedType) {
  
          if (expression == null) {
              throw new NullPointerException("Expression string cannot be null");
          }
          this.expression = expression;
          this.signature = signature;
          this.expectedType = expectedType;
          parse();
  
      }
  
  
      // ------------------------------------------------------ Instance Variables
  
  
      /***
       * <p>The parsed elements of this expression.</p>
       */
      private String[] elements = null;
  
  
      /***
       * <p>The expected result type for <code>getValue()</code> calls.</p>
       */
      private Class expectedType = null;
  
  
      /***
       * <p>The original expression string used to create this expression.</p>
       */
      private String expression = null;
  
  
      /***
       * <p>The method signature of the method to be called.</p>
       */
      private Class[] signature = null;
  
  
      // ------------------------------------------------------ Expression Methods
  
  
      /***
       * <p>Return <code>true</code> if this expression is equal to the
       * specified expression.</p>
       *
       * @param obj Object to be compared
      */
     public boolean equals(Object obj) {
 
         if ((obj != null) & (obj instanceof MethodExpression)) {
             return expression.equals(((MethodExpression) obj).getExpressionString());
         } else {
             return false;
         }
 
     }
 
 
     /***
      * <p>Return the original String used to create this expression,
      * unmodified.</p>
      */
     public String getExpressionString() {
 
         return this.expression;
 
     }
 
 
     /***
      * <p>Return the hash code for this expression.</p>
      */
     public int hashCode() {
 
         return this.expression.hashCode();
 
     }
 
 
     /***
      * <p>Return <code>true</code> if the expression string for this expression
      * contains only literal text.</p>
      */
     public boolean isLiteralText() {
 
         return (expression.indexOf("${") < 0) && (expression.indexOf("#{") < 0);
 
     }
 
 
     // ------------------------------------------------ MethodExpression Methods
 
 
     /***
      * <p>Evaluate the expression relative to the specified context,
      * and return information about the actual implementation method.</p>
      *
      * @param context ELContext for this evaluation
      */
     public MethodInfo getMethodInfo(ELContext context) {
 
         if (context == null) {
             throw new NullPointerException();
         }
         return new MethodInfo(elements[elements.length - 1], expectedType, signature);
 
     }
 
 
     /***
      * <p>Evaluate the expression relative to the specified ocntext,
      * and return the result after coercion to the expected result type.</p>
      *
      * @param context ELContext for this evaluation
      * @param params Parameters for this method call
      */
     public Object invoke(ELContext context, Object[] params) {
 
         if (context == null) {
             throw new NullPointerException();
         }
         if (isLiteralText()) {
             return expression;
         }
 
         FacesContext fcontext = (FacesContext) context.getContext(FacesContext.class);
         ELResolver resolver = fcontext.getApplication().getELResolver();
         Object base = null;
         for (int i = 0; i < elements.length - 1; i++) {
             base = resolver.getValue(context, base, elements[i]);
         }
 
         try {
             Method method = base.getClass().getMethod(elements[elements.length - 1], signature);
             Object result = method.invoke(base, params);
             return fcontext.getApplication().getExpressionFactory().coerceToType(result, expectedType);
         } catch (RuntimeException e) {
             throw e;
         } catch (Exception e) {
             throw new ELException(e);
         }
 
     }
 
 
     // --------------------------------------------------------- Private Methods
 
 
     /***
      * <p>Parse the expression string into its constituent elemetns.</p>
      */
     private void parse() {
 
         if (isLiteralText()) {
             elements = new String[0];
             return;
         }
 
         if (expression.startsWith("${") || expression.startsWith("#{")) {
             if (expression.endsWith("}")) {
                 String temp = expression.substring(2, expression.length() - 1).replaceAll(" ", "");
                 List names = new ArrayList();
                 while (temp.length() > 0) {
                     int period= temp.indexOf(".");
                     if (period >= 0) {
                         names.add(temp.substring(0, period));
                         temp = temp.substring(period + 1);
                     } else {
                         names.add(temp);
                         temp = "";
                     }
                 }
                 elements = (String[]) names.toArray(new String[names.size()]);
             } else {
                 throw new IllegalArgumentException(expression);
             }
         } else {
             throw new IllegalArgumentException(expression);
         }
 
     }
 
 
 }