hotfix/source/openejb-core/src.original/test/java/org/apache/openejb/util/proxy/SampleLocalBean.java

/**
 * 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.openejb.util.proxy;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import javax.ejb.LocalBean;

@LocalBean
public class SampleLocalBean extends BaseLocalBean {
    
	public SampleLocalBean() {
		super();
	}
	
	int defaultMethod() {
	    return -1;
	}
	
	@Override
	public String overriddenMethod() {
	    return getClass().getName();
	}
	   
	/* 1. void return, no arg */
	public void doWork() {
		System.out.println("void doWork()");
	}
	
	/* 2. simple object */
	public String echo(String input) {
		return input;
	}
	
	/* 3a int primitive */
	public int add(int no1, int no2) {
		return no1 + no2;
	}

	/* 3b int object */
	public Integer add(Integer no1, Integer no2) {
		return no1 + no2;
	}
	
	/* 3c bool primitive */
	public boolean isTrue (boolean value) {
		return value;
	}

	/* 3d bool object */
	public Boolean isTrue (Boolean value) {
		return value;
	}
	
	/* 3e char primitive */
	public char nextChar (char value) {
		if (value > 'z') return 'A';
		char next = value;
		next++;
		return next;
	}
	
	/* 3f char object */
	public Character nextChar (Character value) {
		if (value > 'z') return 'A';
		char next = value;
		next++;
		return next;
	}
	
	/* 3g short primitive */
	public short add(short no1, short no2) {
		return (short) (no1 + no2);
	}
	
	/* 3h short object */
	public Short add(Short no1, Short no2) {
		return new Short((short) (no1 + no2));
	}

	/* 3i long primitive */
	public long add(long no1, long no2) {
		return (long) (no1 + no2);
	}

	/* 3j long object */
	public Long add(Long no1, Long no2) {
		return (long) (no1 + no2);
	}
	
	/* 3k double primitive */
	public double add(double no1, double no2) {
		return (double) (no1 + no2);
	}

	/* 3l double object */
	public Double add(Double no1, Double no2) {
		return (Double) (no1 + no2);
	}
	
	/* 3m float primitive */
	public float add(float no1, float no2) {
		return (float) (no1 + no2);
	}
	
	/* 3n float object*/
	public Float add(Float no1, Float no2) {
		return (Float) (no1 + no2);
	}
	
	/* 4a simple object array */
	public ProxyTestObject[] createSomeObjects() {
		ProxyTestObject object1 = new ProxyTestObject("object1");
		ProxyTestObject object2 = new ProxyTestObject("object2");
		
		return new ProxyTestObject[] { object1, object2 };
	}
	
	/* 4b simple object array */
	public ProxyTestObject returnFirst(ProxyTestObject[] objects) {
		if (objects == null || objects.length == 0) {
			return null;
		}
		
		return objects[0];
	}

	/* 5a int primitive */
	public int[] reverse(int[] value) {
		if (value == null || value.length == 0) {
			return value;
		}
		
		int[] result = new int[value.length];
		for (int i = 0; i < value.length; i++) {
			result[(value.length - 1) - i] = value[i];
		}
		
		return result;
	}

	/* 5b int object */
	public Integer[] reverse(Integer[] value) {
		if (value == null || value.length == 0) {
			return value;
		}
		
		Integer[] result = new Integer[value.length];
		for (int i = 0; i < value.length; i++) {
			result[(value.length - 1) - i] = value[i];
		}
		
		return result;
	}
	
	/* 5c bool primitive */
	public boolean[] reverse (boolean[] value) {
		if (value == null || value.length == 0) {
			return value;
		}
		
		boolean[] result = new boolean[value.length];
		for (int i = 0; i < value.length; i++) {
			result[(value.length - 1) - i] = value[i];
		}
		
		return result;
	}

	/* 5d bool object */
	public Boolean[] reverse (Boolean[] value) {
		if (value == null || value.length == 0) {
			return value;
		}
		
		Boolean[] result = new Boolean[value.length];
		for (int i = 0; i < value.length; i++) {
			result[(value.length - 1) - i] = value[i];
		}
		
		return result;
	}
	
	/* 5e char primitive */
	public char[] reverse (char[] value) {
		if (value == null || value.length == 0) {
			return value;
		}
		
		char[] result = new char[value.length];
		for (int i = 0; i < value.length; i++) {
			result[(value.length - 1) - i] = value[i];
		}
		
		return result;
	}
	
	/* 5f char object */
	public Character[] reverse (Character[] value) {
		if (value == null || value.length == 0) {
			return value;
		}
		
		Character[] result = new Character[value.length];
		for (int i = 0; i < value.length; i++) {
			result[(value.length - 1) - i] = value[i];
		}
		
		return result;
	}
	
	/* 5g short primitive */
	public short[] reverse(short[] value) {
		if (value == null || value.length == 0) {
			return value;
		}
		
		short[] result = new short[value.length];
		for (int i = 0; i < value.length; i++) {
			result[(value.length - 1) - i] = value[i];
		}
		
		return result;
	}
	
	/* 5h short object */
	public Short[] reverse(Short[] value) {
		if (value == null || value.length == 0) {
			return value;
		}
		
		Short[] result = new Short[value.length];
		for (int i = 0; i < value.length; i++) {
			result[(value.length - 1) - i] = value[i];
		}
		
		return result;
	}

	/* 5i long primitive */
	public long[] reverse(long[] value) {
		if (value == null || value.length == 0) {
			return value;
		}
		
		long[] result = new long[value.length];
		for (int i = 0; i < value.length; i++) {
			result[(value.length - 1) - i] = value[i];
		}
		
		return result;
	}

	/* 5j long object */
	public Long[] reverse(Long[] value) {
		if (value == null || value.length == 0) {
			return value;
		}
		
		Long[] result = new Long[value.length];
		for (int i = 0; i < value.length; i++) {
			result[(value.length - 1) - i] = value[i];
		}
		
		return result;
	}
	
	/* 5k double primitive */
	public double[] reverse(double[] value) {
		if (value == null || value.length == 0) {
			return value;
		}
		
		double[] result = new double[value.length];
		for (int i = 0; i < value.length; i++) {
			result[(value.length - 1) - i] = value[i];
		}
		
		return result;
	}

	/* 5l double object */
	public Double[] reverse(Double[] value) {
		if (value == null || value.length == 0) {
			return value;
		}
		
		Double[] result = new Double[value.length];
		for (int i = 0; i < value.length; i++) {
			result[(value.length - 1) - i] = value[i];
		}
		
		return result;
	}
	
	/* 5m float primitive */
	public float[] reverse(float[] value) {
		if (value == null || value.length == 0) {
			return value;
		}
		
		float[] result = new float[value.length];
		for (int i = 0; i < value.length; i++) {
			result[(value.length - 1) - i] = value[i];
		}
		
		return result;
	}
	
	/* 5n float object*/
	public Float[] reverse(Float[] value) {
		if (value == null || value.length == 0) {
			return value;
		}
		
		Float[] result = new Float[value.length];
		for (int i = 0; i < value.length; i++) {
			result[(value.length - 1) - i] = value[i];
		}
		
		return result;
	}

	/* 6 throw and exception */
	public String throwAnException() throws ProxyTestException {
		throw new ProxyTestException();
	}
	
	public String throwAnotherException() throws ProxyTestException, IOException {
		throw new IOException();
	}
	
	/* 7 test generics */
	public List<ProxyTestObject> reverseList(List<ProxyTestObject> objectList) {
		List<ProxyTestObject> result = new ArrayList<ProxyTestObject>();
		for (int i = objectList.size() - 1; i >= 0; i--) {
			result.add(objectList.get(i));
		}
		
		return result;
	}
	
	/* 8 test multi dimension array */
	public int[][] reverseAll(int[][] value) {
		int[][] result = new int[value.length][];
		for (int i = 0; i < value.length; i++) {
			result[i] = reverse(value[(value.length - 1) - i]);
		}
		
		return result;
	}
}