  				public void remove() {
  					throw new UnsupportedOperationException("cannot remove");
  				}
-@@ -397,6 +403,169 @@
+@@ -397,6 +403,179 @@
  	}
  
  	/**

Index: src/main/java/de/odysseus/el/ExpressionFactoryImpl.java
===================================================================
--- src/main/java/de/odysseus/el/ExpressionFactoryImpl.java	(revision 63)

+				throw new MethodNotFoundException(e);
+			}
+		}
+		Method varArgsMethod = null;
+		for (Method method : base.getClass().getMethods()) {
+			if (method.getName().equals(name)) {
+				if (paramCount == method.getParameterTypes().length) {
+					return method;
+				} else if (method.isVarArgs() && paramCount >= method.getParameterTypes().length - 1) {
+					varArgsMethod = method;
+				}
+			}
+		}
+		if (varArgsMethod != null) {
+			return varArgsMethod;
+		}
+		throw new MethodNotFoundException("Cannot find matching method " + name + " on class " + base);
+	}
+
+	/**
+	 * Lookup an expression factory used to coerce method parameters in context under key
+	 * <code>"javax.el.ExpressionFactory"</code>.
+	 * If no expression factory can be found under that key, use a default instance created with
+	 * {@link ExpressionFactory#newInstance()}.
+	 * @param context
+	 *            The context of this evaluation.
+	 * @return expression factory instance
+	 */
+	private ExpressionFactory getExpressionFactory(ELContext context) {
+		Object obj = context.getContext(ExpressionFactory.class);
+		return obj instanceof ExpressionFactory ? (ExpressionFactory)obj : DEFAULT_FACTORY;
+	}
+	
+	private Object[] coerceParams(ExpressionFactory factory, Method method, Object[] params) {
+		Class<?>[] types = method.getParameterTypes();
+		Object[] args = new Object[types.length];
+		if (method.isVarArgs()) {
+			int varargIndex = types.length - 1;
+			if (params.length < varargIndex) {
+				throw new ELException("Bad argument count");
+			}
+			for (int i = 0; i < varargIndex; i++) {
+				coerceValue(args[i], i, factory, params[i], types[i]);
+			}
+			Class<?> varargType = types[varargIndex].getComponentType();
+			int length = params.length - varargIndex;
+			Object array = null;
+			if (length == 1) {
+				Object source = params[varargIndex];
+				if (source != null && source.getClass().isArray()) {
+					if (types[varargIndex].isInstance(source)) { // use source array as is
+						array = source;
+					} else { // coerce array elements
+						length = Array.getLength(source);
+						array = Array.newInstance(varargType, length);
+						for (int i = 0; i < length; i++) {
+							coerceValue(array, i, factory, Array.get(source, i), varargType);
+						}
+					}
+				} else { // single element array
+					array = Array.newInstance(varargType, 1);
+					coerceValue(array, 0, factory, source, varargType);
+				}
+			} else {
+				array = Array.newInstance(varargType, length);
+				for (int i = 0; i < length; i++) {
+					coerceValue(array, i, factory, params[varargIndex + i], varargType);
+				}
+			}
+			args[varargIndex] = array;
+		} else {
+			if (params.length != args.length) {
+				throw new ELException("Bad argument count");
+			}
+			for (int i = 0; i < args.length; i++) {
+				coerceValue(args, i, factory, params[i], types[i]);
+			}
+		}
+		return args;
+	}
+
+	private void coerceValue(Object array, int index, ExpressionFactory factory, Object value, Class<?> type) {
+		if (value != null || type.isPrimitive()) {
+			Array.set(array, index, factory.coerceToType(value, type));
+		}
