package jmri.jmrit.logixng.util.parser;

/**
 * Important!!!
 * This file is created by ExpressionNodeMethodTest.testCreateTestMethods()
 * Comment out @Disabled if you want to regenerate this file.
 */

import static org.junit.jupiter.api.Assertions.assertEquals;

import java.util.*;

import jmri.JmriException;
import jmri.jmrit.logixng.SymbolTable;
import jmri.jmrit.logixng.implementation.DefaultConditionalNG;
import jmri.jmrit.logixng.implementation.DefaultSymbolTable;
import jmri.util.JUnitUtil;

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

/**
 * Test ParsedExpression
 *
 * @author Daniel Bergqvist 2024
 */
public class ExpressionNodeMethodPrimTest {

    private static final TestClass tc = new TestClass();

    public void testCall(Object object, String method, Object expectedResult, Object[] params)
            throws FunctionNotExistsException, JmriException {

        Map<String, Variable> variables = new HashMap<>();
        List<ExpressionNode> parameterList = new ArrayList<>();
        SymbolTable symbolTable = new DefaultSymbolTable(new DefaultConditionalNG("IQC1", null));

        for (Object p : params) {
            parameterList.add(new MyExpressionNode(p));
        }

        ExpressionNodeMethod t = new ExpressionNodeMethod(method, variables, parameterList);
        Object result = t.calculate(object, symbolTable);

        assertEquals(expectedResult, result);
    }

    @Test
    public void testByte() throws FunctionNotExistsException, JmriException {
        testCall(tc, "testByteByte", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testByteByteResult", 8L, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testByteByte", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testByteByteResult", 8L, new Object[]{(byte)2,(short)4});
        testCall(tc, "testByteByte", null, new Object[]{(byte)2,4});
        testCall(tc, "testByteByteResult", 8L, new Object[]{(byte)2,4});
        testCall(tc, "testByteByte", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testByteByteResult", 8L, new Object[]{(byte)2,(long)4});
        testCall(tc, "testByteByte", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testByteByteResult", 8L, new Object[]{(short)2,(byte)4});
        testCall(tc, "testByteByte", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testByteByteResult", 8L, new Object[]{(short)2,(short)4});
        testCall(tc, "testByteByte", null, new Object[]{(short)2,4});
        testCall(tc, "testByteByteResult", 8L, new Object[]{(short)2,4});
        testCall(tc, "testByteByte", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testByteByteResult", 8L, new Object[]{(short)2,(long)4});
        testCall(tc, "testByteByte", null, new Object[]{2,(byte)4});
        testCall(tc, "testByteByteResult", 8L, new Object[]{2,(byte)4});
        testCall(tc, "testByteByte", null, new Object[]{2,(short)4});
        testCall(tc, "testByteByteResult", 8L, new Object[]{2,(short)4});
        testCall(tc, "testByteByte", null, new Object[]{2,4});
        testCall(tc, "testByteByteResult", 8L, new Object[]{2,4});
        testCall(tc, "testByteByte", null, new Object[]{2,(long)4});
        testCall(tc, "testByteByteResult", 8L, new Object[]{2,(long)4});
        testCall(tc, "testByteByte", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testByteByteResult", 8L, new Object[]{(long)2,(byte)4});
        testCall(tc, "testByteByte", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testByteByteResult", 8L, new Object[]{(long)2,(short)4});
        testCall(tc, "testByteByte", null, new Object[]{(long)2,4});
        testCall(tc, "testByteByteResult", 8L, new Object[]{(long)2,4});
        testCall(tc, "testByteByte", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testByteByteResult", 8L, new Object[]{(long)2,(long)4});
        testCall(tc, "testByteShort", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testByteShortResult", 8L, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testByteShort", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testByteShortResult", 8L, new Object[]{(byte)2,(short)4});
        testCall(tc, "testByteShort", null, new Object[]{(byte)2,4});
        testCall(tc, "testByteShortResult", 8L, new Object[]{(byte)2,4});
        testCall(tc, "testByteShort", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testByteShortResult", 8L, new Object[]{(byte)2,(long)4});
        testCall(tc, "testByteShort", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testByteShortResult", 8L, new Object[]{(short)2,(byte)4});
        testCall(tc, "testByteShort", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testByteShortResult", 8L, new Object[]{(short)2,(short)4});
        testCall(tc, "testByteShort", null, new Object[]{(short)2,4});
        testCall(tc, "testByteShortResult", 8L, new Object[]{(short)2,4});
        testCall(tc, "testByteShort", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testByteShortResult", 8L, new Object[]{(short)2,(long)4});
        testCall(tc, "testByteShort", null, new Object[]{2,(byte)4});
        testCall(tc, "testByteShortResult", 8L, new Object[]{2,(byte)4});
        testCall(tc, "testByteShort", null, new Object[]{2,(short)4});
        testCall(tc, "testByteShortResult", 8L, new Object[]{2,(short)4});
        testCall(tc, "testByteShort", null, new Object[]{2,4});
        testCall(tc, "testByteShortResult", 8L, new Object[]{2,4});
        testCall(tc, "testByteShort", null, new Object[]{2,(long)4});
        testCall(tc, "testByteShortResult", 8L, new Object[]{2,(long)4});
        testCall(tc, "testByteShort", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testByteShortResult", 8L, new Object[]{(long)2,(byte)4});
        testCall(tc, "testByteShort", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testByteShortResult", 8L, new Object[]{(long)2,(short)4});
        testCall(tc, "testByteShort", null, new Object[]{(long)2,4});
        testCall(tc, "testByteShortResult", 8L, new Object[]{(long)2,4});
        testCall(tc, "testByteShort", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testByteShortResult", 8L, new Object[]{(long)2,(long)4});
        testCall(tc, "testByteInteger", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testByteIntegerResult", 8L, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testByteInteger", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testByteIntegerResult", 8L, new Object[]{(byte)2,(short)4});
        testCall(tc, "testByteInteger", null, new Object[]{(byte)2,4});
        testCall(tc, "testByteIntegerResult", 8L, new Object[]{(byte)2,4});
        testCall(tc, "testByteInteger", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testByteIntegerResult", 8L, new Object[]{(byte)2,(long)4});
        testCall(tc, "testByteInteger", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testByteIntegerResult", 8L, new Object[]{(short)2,(byte)4});
        testCall(tc, "testByteInteger", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testByteIntegerResult", 8L, new Object[]{(short)2,(short)4});
        testCall(tc, "testByteInteger", null, new Object[]{(short)2,4});
        testCall(tc, "testByteIntegerResult", 8L, new Object[]{(short)2,4});
        testCall(tc, "testByteInteger", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testByteIntegerResult", 8L, new Object[]{(short)2,(long)4});
        testCall(tc, "testByteInteger", null, new Object[]{2,(byte)4});
        testCall(tc, "testByteIntegerResult", 8L, new Object[]{2,(byte)4});
        testCall(tc, "testByteInteger", null, new Object[]{2,(short)4});
        testCall(tc, "testByteIntegerResult", 8L, new Object[]{2,(short)4});
        testCall(tc, "testByteInteger", null, new Object[]{2,4});
        testCall(tc, "testByteIntegerResult", 8L, new Object[]{2,4});
        testCall(tc, "testByteInteger", null, new Object[]{2,(long)4});
        testCall(tc, "testByteIntegerResult", 8L, new Object[]{2,(long)4});
        testCall(tc, "testByteInteger", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testByteIntegerResult", 8L, new Object[]{(long)2,(byte)4});
        testCall(tc, "testByteInteger", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testByteIntegerResult", 8L, new Object[]{(long)2,(short)4});
        testCall(tc, "testByteInteger", null, new Object[]{(long)2,4});
        testCall(tc, "testByteIntegerResult", 8L, new Object[]{(long)2,4});
        testCall(tc, "testByteInteger", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testByteIntegerResult", 8L, new Object[]{(long)2,(long)4});
        testCall(tc, "testByteLong", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testByteLongResult", 8L, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testByteLong", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testByteLongResult", 8L, new Object[]{(byte)2,(short)4});
        testCall(tc, "testByteLong", null, new Object[]{(byte)2,4});
        testCall(tc, "testByteLongResult", 8L, new Object[]{(byte)2,4});
        testCall(tc, "testByteLong", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testByteLongResult", 8L, new Object[]{(byte)2,(long)4});
        testCall(tc, "testByteLong", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testByteLongResult", 8L, new Object[]{(short)2,(byte)4});
        testCall(tc, "testByteLong", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testByteLongResult", 8L, new Object[]{(short)2,(short)4});
        testCall(tc, "testByteLong", null, new Object[]{(short)2,4});
        testCall(tc, "testByteLongResult", 8L, new Object[]{(short)2,4});
        testCall(tc, "testByteLong", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testByteLongResult", 8L, new Object[]{(short)2,(long)4});
        testCall(tc, "testByteLong", null, new Object[]{2,(byte)4});
        testCall(tc, "testByteLongResult", 8L, new Object[]{2,(byte)4});
        testCall(tc, "testByteLong", null, new Object[]{2,(short)4});
        testCall(tc, "testByteLongResult", 8L, new Object[]{2,(short)4});
        testCall(tc, "testByteLong", null, new Object[]{2,4});
        testCall(tc, "testByteLongResult", 8L, new Object[]{2,4});
        testCall(tc, "testByteLong", null, new Object[]{2,(long)4});
        testCall(tc, "testByteLongResult", 8L, new Object[]{2,(long)4});
        testCall(tc, "testByteLong", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testByteLongResult", 8L, new Object[]{(long)2,(byte)4});
        testCall(tc, "testByteLong", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testByteLongResult", 8L, new Object[]{(long)2,(short)4});
        testCall(tc, "testByteLong", null, new Object[]{(long)2,4});
        testCall(tc, "testByteLongResult", 8L, new Object[]{(long)2,4});
        testCall(tc, "testByteLong", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testByteLongResult", 8L, new Object[]{(long)2,(long)4});
        testCall(tc, "testByteFloat", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testByteFloatResult", 8D, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testByteFloat", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testByteFloatResult", 8D, new Object[]{(byte)2,(short)4});
        testCall(tc, "testByteFloat", null, new Object[]{(byte)2,4});
        testCall(tc, "testByteFloatResult", 8D, new Object[]{(byte)2,4});
        testCall(tc, "testByteFloat", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testByteFloatResult", 8D, new Object[]{(byte)2,(long)4});
        testCall(tc, "testByteFloat", null, new Object[]{(byte)2,(float)4});
        testCall(tc, "testByteFloatResult", 8D, new Object[]{(byte)2,(float)4});
        testCall(tc, "testByteFloat", null, new Object[]{(byte)2,(double)4});
        testCall(tc, "testByteFloatResult", 8D, new Object[]{(byte)2,(double)4});
        testCall(tc, "testByteFloat", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testByteFloatResult", 8D, new Object[]{(short)2,(byte)4});
        testCall(tc, "testByteFloat", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testByteFloatResult", 8D, new Object[]{(short)2,(short)4});
        testCall(tc, "testByteFloat", null, new Object[]{(short)2,4});
        testCall(tc, "testByteFloatResult", 8D, new Object[]{(short)2,4});
        testCall(tc, "testByteFloat", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testByteFloatResult", 8D, new Object[]{(short)2,(long)4});
        testCall(tc, "testByteFloat", null, new Object[]{(short)2,(float)4});
        testCall(tc, "testByteFloatResult", 8D, new Object[]{(short)2,(float)4});
        testCall(tc, "testByteFloat", null, new Object[]{(short)2,(double)4});
        testCall(tc, "testByteFloatResult", 8D, new Object[]{(short)2,(double)4});
        testCall(tc, "testByteFloat", null, new Object[]{2,(byte)4});
        testCall(tc, "testByteFloatResult", 8D, new Object[]{2,(byte)4});
        testCall(tc, "testByteFloat", null, new Object[]{2,(short)4});
        testCall(tc, "testByteFloatResult", 8D, new Object[]{2,(short)4});
        testCall(tc, "testByteFloat", null, new Object[]{2,4});
        testCall(tc, "testByteFloatResult", 8D, new Object[]{2,4});
        testCall(tc, "testByteFloat", null, new Object[]{2,(long)4});
        testCall(tc, "testByteFloatResult", 8D, new Object[]{2,(long)4});
        testCall(tc, "testByteFloat", null, new Object[]{2,(float)4});
        testCall(tc, "testByteFloatResult", 8D, new Object[]{2,(float)4});
        testCall(tc, "testByteFloat", null, new Object[]{2,(double)4});
        testCall(tc, "testByteFloatResult", 8D, new Object[]{2,(double)4});
        testCall(tc, "testByteFloat", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testByteFloatResult", 8D, new Object[]{(long)2,(byte)4});
        testCall(tc, "testByteFloat", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testByteFloatResult", 8D, new Object[]{(long)2,(short)4});
        testCall(tc, "testByteFloat", null, new Object[]{(long)2,4});
        testCall(tc, "testByteFloatResult", 8D, new Object[]{(long)2,4});
        testCall(tc, "testByteFloat", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testByteFloatResult", 8D, new Object[]{(long)2,(long)4});
        testCall(tc, "testByteFloat", null, new Object[]{(long)2,(float)4});
        testCall(tc, "testByteFloatResult", 8D, new Object[]{(long)2,(float)4});
        testCall(tc, "testByteFloat", null, new Object[]{(long)2,(double)4});
        testCall(tc, "testByteFloatResult", 8D, new Object[]{(long)2,(double)4});
        testCall(tc, "testByteDouble", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testByteDoubleResult", 8D, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testByteDouble", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testByteDoubleResult", 8D, new Object[]{(byte)2,(short)4});
        testCall(tc, "testByteDouble", null, new Object[]{(byte)2,4});
        testCall(tc, "testByteDoubleResult", 8D, new Object[]{(byte)2,4});
        testCall(tc, "testByteDouble", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testByteDoubleResult", 8D, new Object[]{(byte)2,(long)4});
        testCall(tc, "testByteDouble", null, new Object[]{(byte)2,(float)4});
        testCall(tc, "testByteDoubleResult", 8D, new Object[]{(byte)2,(float)4});
        testCall(tc, "testByteDouble", null, new Object[]{(byte)2,(double)4});
        testCall(tc, "testByteDoubleResult", 8D, new Object[]{(byte)2,(double)4});
        testCall(tc, "testByteDouble", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testByteDoubleResult", 8D, new Object[]{(short)2,(byte)4});
        testCall(tc, "testByteDouble", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testByteDoubleResult", 8D, new Object[]{(short)2,(short)4});
        testCall(tc, "testByteDouble", null, new Object[]{(short)2,4});
        testCall(tc, "testByteDoubleResult", 8D, new Object[]{(short)2,4});
        testCall(tc, "testByteDouble", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testByteDoubleResult", 8D, new Object[]{(short)2,(long)4});
        testCall(tc, "testByteDouble", null, new Object[]{(short)2,(float)4});
        testCall(tc, "testByteDoubleResult", 8D, new Object[]{(short)2,(float)4});
        testCall(tc, "testByteDouble", null, new Object[]{(short)2,(double)4});
        testCall(tc, "testByteDoubleResult", 8D, new Object[]{(short)2,(double)4});
        testCall(tc, "testByteDouble", null, new Object[]{2,(byte)4});
        testCall(tc, "testByteDoubleResult", 8D, new Object[]{2,(byte)4});
        testCall(tc, "testByteDouble", null, new Object[]{2,(short)4});
        testCall(tc, "testByteDoubleResult", 8D, new Object[]{2,(short)4});
        testCall(tc, "testByteDouble", null, new Object[]{2,4});
        testCall(tc, "testByteDoubleResult", 8D, new Object[]{2,4});
        testCall(tc, "testByteDouble", null, new Object[]{2,(long)4});
        testCall(tc, "testByteDoubleResult", 8D, new Object[]{2,(long)4});
        testCall(tc, "testByteDouble", null, new Object[]{2,(float)4});
        testCall(tc, "testByteDoubleResult", 8D, new Object[]{2,(float)4});
        testCall(tc, "testByteDouble", null, new Object[]{2,(double)4});
        testCall(tc, "testByteDoubleResult", 8D, new Object[]{2,(double)4});
        testCall(tc, "testByteDouble", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testByteDoubleResult", 8D, new Object[]{(long)2,(byte)4});
        testCall(tc, "testByteDouble", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testByteDoubleResult", 8D, new Object[]{(long)2,(short)4});
        testCall(tc, "testByteDouble", null, new Object[]{(long)2,4});
        testCall(tc, "testByteDoubleResult", 8D, new Object[]{(long)2,4});
        testCall(tc, "testByteDouble", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testByteDoubleResult", 8D, new Object[]{(long)2,(long)4});
        testCall(tc, "testByteDouble", null, new Object[]{(long)2,(float)4});
        testCall(tc, "testByteDoubleResult", 8D, new Object[]{(long)2,(float)4});
        testCall(tc, "testByteDouble", null, new Object[]{(long)2,(double)4});
        testCall(tc, "testByteDoubleResult", 8D, new Object[]{(long)2,(double)4});
    }

    @Test
    public void testShort() throws FunctionNotExistsException, JmriException {
        testCall(tc, "testShortByte", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testShortByteResult", 8L, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testShortByte", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testShortByteResult", 8L, new Object[]{(byte)2,(short)4});
        testCall(tc, "testShortByte", null, new Object[]{(byte)2,4});
        testCall(tc, "testShortByteResult", 8L, new Object[]{(byte)2,4});
        testCall(tc, "testShortByte", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testShortByteResult", 8L, new Object[]{(byte)2,(long)4});
        testCall(tc, "testShortByte", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testShortByteResult", 8L, new Object[]{(short)2,(byte)4});
        testCall(tc, "testShortByte", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testShortByteResult", 8L, new Object[]{(short)2,(short)4});
        testCall(tc, "testShortByte", null, new Object[]{(short)2,4});
        testCall(tc, "testShortByteResult", 8L, new Object[]{(short)2,4});
        testCall(tc, "testShortByte", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testShortByteResult", 8L, new Object[]{(short)2,(long)4});
        testCall(tc, "testShortByte", null, new Object[]{2,(byte)4});
        testCall(tc, "testShortByteResult", 8L, new Object[]{2,(byte)4});
        testCall(tc, "testShortByte", null, new Object[]{2,(short)4});
        testCall(tc, "testShortByteResult", 8L, new Object[]{2,(short)4});
        testCall(tc, "testShortByte", null, new Object[]{2,4});
        testCall(tc, "testShortByteResult", 8L, new Object[]{2,4});
        testCall(tc, "testShortByte", null, new Object[]{2,(long)4});
        testCall(tc, "testShortByteResult", 8L, new Object[]{2,(long)4});
        testCall(tc, "testShortByte", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testShortByteResult", 8L, new Object[]{(long)2,(byte)4});
        testCall(tc, "testShortByte", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testShortByteResult", 8L, new Object[]{(long)2,(short)4});
        testCall(tc, "testShortByte", null, new Object[]{(long)2,4});
        testCall(tc, "testShortByteResult", 8L, new Object[]{(long)2,4});
        testCall(tc, "testShortByte", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testShortByteResult", 8L, new Object[]{(long)2,(long)4});
        testCall(tc, "testShortShort", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testShortShortResult", 8L, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testShortShort", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testShortShortResult", 8L, new Object[]{(byte)2,(short)4});
        testCall(tc, "testShortShort", null, new Object[]{(byte)2,4});
        testCall(tc, "testShortShortResult", 8L, new Object[]{(byte)2,4});
        testCall(tc, "testShortShort", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testShortShortResult", 8L, new Object[]{(byte)2,(long)4});
        testCall(tc, "testShortShort", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testShortShortResult", 8L, new Object[]{(short)2,(byte)4});
        testCall(tc, "testShortShort", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testShortShortResult", 8L, new Object[]{(short)2,(short)4});
        testCall(tc, "testShortShort", null, new Object[]{(short)2,4});
        testCall(tc, "testShortShortResult", 8L, new Object[]{(short)2,4});
        testCall(tc, "testShortShort", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testShortShortResult", 8L, new Object[]{(short)2,(long)4});
        testCall(tc, "testShortShort", null, new Object[]{2,(byte)4});
        testCall(tc, "testShortShortResult", 8L, new Object[]{2,(byte)4});
        testCall(tc, "testShortShort", null, new Object[]{2,(short)4});
        testCall(tc, "testShortShortResult", 8L, new Object[]{2,(short)4});
        testCall(tc, "testShortShort", null, new Object[]{2,4});
        testCall(tc, "testShortShortResult", 8L, new Object[]{2,4});
        testCall(tc, "testShortShort", null, new Object[]{2,(long)4});
        testCall(tc, "testShortShortResult", 8L, new Object[]{2,(long)4});
        testCall(tc, "testShortShort", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testShortShortResult", 8L, new Object[]{(long)2,(byte)4});
        testCall(tc, "testShortShort", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testShortShortResult", 8L, new Object[]{(long)2,(short)4});
        testCall(tc, "testShortShort", null, new Object[]{(long)2,4});
        testCall(tc, "testShortShortResult", 8L, new Object[]{(long)2,4});
        testCall(tc, "testShortShort", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testShortShortResult", 8L, new Object[]{(long)2,(long)4});
        testCall(tc, "testShortInteger", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testShortIntegerResult", 8L, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testShortInteger", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testShortIntegerResult", 8L, new Object[]{(byte)2,(short)4});
        testCall(tc, "testShortInteger", null, new Object[]{(byte)2,4});
        testCall(tc, "testShortIntegerResult", 8L, new Object[]{(byte)2,4});
        testCall(tc, "testShortInteger", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testShortIntegerResult", 8L, new Object[]{(byte)2,(long)4});
        testCall(tc, "testShortInteger", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testShortIntegerResult", 8L, new Object[]{(short)2,(byte)4});
        testCall(tc, "testShortInteger", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testShortIntegerResult", 8L, new Object[]{(short)2,(short)4});
        testCall(tc, "testShortInteger", null, new Object[]{(short)2,4});
        testCall(tc, "testShortIntegerResult", 8L, new Object[]{(short)2,4});
        testCall(tc, "testShortInteger", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testShortIntegerResult", 8L, new Object[]{(short)2,(long)4});
        testCall(tc, "testShortInteger", null, new Object[]{2,(byte)4});
        testCall(tc, "testShortIntegerResult", 8L, new Object[]{2,(byte)4});
        testCall(tc, "testShortInteger", null, new Object[]{2,(short)4});
        testCall(tc, "testShortIntegerResult", 8L, new Object[]{2,(short)4});
        testCall(tc, "testShortInteger", null, new Object[]{2,4});
        testCall(tc, "testShortIntegerResult", 8L, new Object[]{2,4});
        testCall(tc, "testShortInteger", null, new Object[]{2,(long)4});
        testCall(tc, "testShortIntegerResult", 8L, new Object[]{2,(long)4});
        testCall(tc, "testShortInteger", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testShortIntegerResult", 8L, new Object[]{(long)2,(byte)4});
        testCall(tc, "testShortInteger", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testShortIntegerResult", 8L, new Object[]{(long)2,(short)4});
        testCall(tc, "testShortInteger", null, new Object[]{(long)2,4});
        testCall(tc, "testShortIntegerResult", 8L, new Object[]{(long)2,4});
        testCall(tc, "testShortInteger", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testShortIntegerResult", 8L, new Object[]{(long)2,(long)4});
        testCall(tc, "testShortLong", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testShortLongResult", 8L, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testShortLong", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testShortLongResult", 8L, new Object[]{(byte)2,(short)4});
        testCall(tc, "testShortLong", null, new Object[]{(byte)2,4});
        testCall(tc, "testShortLongResult", 8L, new Object[]{(byte)2,4});
        testCall(tc, "testShortLong", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testShortLongResult", 8L, new Object[]{(byte)2,(long)4});
        testCall(tc, "testShortLong", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testShortLongResult", 8L, new Object[]{(short)2,(byte)4});
        testCall(tc, "testShortLong", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testShortLongResult", 8L, new Object[]{(short)2,(short)4});
        testCall(tc, "testShortLong", null, new Object[]{(short)2,4});
        testCall(tc, "testShortLongResult", 8L, new Object[]{(short)2,4});
        testCall(tc, "testShortLong", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testShortLongResult", 8L, new Object[]{(short)2,(long)4});
        testCall(tc, "testShortLong", null, new Object[]{2,(byte)4});
        testCall(tc, "testShortLongResult", 8L, new Object[]{2,(byte)4});
        testCall(tc, "testShortLong", null, new Object[]{2,(short)4});
        testCall(tc, "testShortLongResult", 8L, new Object[]{2,(short)4});
        testCall(tc, "testShortLong", null, new Object[]{2,4});
        testCall(tc, "testShortLongResult", 8L, new Object[]{2,4});
        testCall(tc, "testShortLong", null, new Object[]{2,(long)4});
        testCall(tc, "testShortLongResult", 8L, new Object[]{2,(long)4});
        testCall(tc, "testShortLong", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testShortLongResult", 8L, new Object[]{(long)2,(byte)4});
        testCall(tc, "testShortLong", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testShortLongResult", 8L, new Object[]{(long)2,(short)4});
        testCall(tc, "testShortLong", null, new Object[]{(long)2,4});
        testCall(tc, "testShortLongResult", 8L, new Object[]{(long)2,4});
        testCall(tc, "testShortLong", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testShortLongResult", 8L, new Object[]{(long)2,(long)4});
        testCall(tc, "testShortFloat", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testShortFloatResult", 8D, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testShortFloat", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testShortFloatResult", 8D, new Object[]{(byte)2,(short)4});
        testCall(tc, "testShortFloat", null, new Object[]{(byte)2,4});
        testCall(tc, "testShortFloatResult", 8D, new Object[]{(byte)2,4});
        testCall(tc, "testShortFloat", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testShortFloatResult", 8D, new Object[]{(byte)2,(long)4});
        testCall(tc, "testShortFloat", null, new Object[]{(byte)2,(float)4});
        testCall(tc, "testShortFloatResult", 8D, new Object[]{(byte)2,(float)4});
        testCall(tc, "testShortFloat", null, new Object[]{(byte)2,(double)4});
        testCall(tc, "testShortFloatResult", 8D, new Object[]{(byte)2,(double)4});
        testCall(tc, "testShortFloat", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testShortFloatResult", 8D, new Object[]{(short)2,(byte)4});
        testCall(tc, "testShortFloat", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testShortFloatResult", 8D, new Object[]{(short)2,(short)4});
        testCall(tc, "testShortFloat", null, new Object[]{(short)2,4});
        testCall(tc, "testShortFloatResult", 8D, new Object[]{(short)2,4});
        testCall(tc, "testShortFloat", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testShortFloatResult", 8D, new Object[]{(short)2,(long)4});
        testCall(tc, "testShortFloat", null, new Object[]{(short)2,(float)4});
        testCall(tc, "testShortFloatResult", 8D, new Object[]{(short)2,(float)4});
        testCall(tc, "testShortFloat", null, new Object[]{(short)2,(double)4});
        testCall(tc, "testShortFloatResult", 8D, new Object[]{(short)2,(double)4});
        testCall(tc, "testShortFloat", null, new Object[]{2,(byte)4});
        testCall(tc, "testShortFloatResult", 8D, new Object[]{2,(byte)4});
        testCall(tc, "testShortFloat", null, new Object[]{2,(short)4});
        testCall(tc, "testShortFloatResult", 8D, new Object[]{2,(short)4});
        testCall(tc, "testShortFloat", null, new Object[]{2,4});
        testCall(tc, "testShortFloatResult", 8D, new Object[]{2,4});
        testCall(tc, "testShortFloat", null, new Object[]{2,(long)4});
        testCall(tc, "testShortFloatResult", 8D, new Object[]{2,(long)4});
        testCall(tc, "testShortFloat", null, new Object[]{2,(float)4});
        testCall(tc, "testShortFloatResult", 8D, new Object[]{2,(float)4});
        testCall(tc, "testShortFloat", null, new Object[]{2,(double)4});
        testCall(tc, "testShortFloatResult", 8D, new Object[]{2,(double)4});
        testCall(tc, "testShortFloat", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testShortFloatResult", 8D, new Object[]{(long)2,(byte)4});
        testCall(tc, "testShortFloat", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testShortFloatResult", 8D, new Object[]{(long)2,(short)4});
        testCall(tc, "testShortFloat", null, new Object[]{(long)2,4});
        testCall(tc, "testShortFloatResult", 8D, new Object[]{(long)2,4});
        testCall(tc, "testShortFloat", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testShortFloatResult", 8D, new Object[]{(long)2,(long)4});
        testCall(tc, "testShortFloat", null, new Object[]{(long)2,(float)4});
        testCall(tc, "testShortFloatResult", 8D, new Object[]{(long)2,(float)4});
        testCall(tc, "testShortFloat", null, new Object[]{(long)2,(double)4});
        testCall(tc, "testShortFloatResult", 8D, new Object[]{(long)2,(double)4});
        testCall(tc, "testShortDouble", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testShortDoubleResult", 8D, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testShortDouble", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testShortDoubleResult", 8D, new Object[]{(byte)2,(short)4});
        testCall(tc, "testShortDouble", null, new Object[]{(byte)2,4});
        testCall(tc, "testShortDoubleResult", 8D, new Object[]{(byte)2,4});
        testCall(tc, "testShortDouble", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testShortDoubleResult", 8D, new Object[]{(byte)2,(long)4});
        testCall(tc, "testShortDouble", null, new Object[]{(byte)2,(float)4});
        testCall(tc, "testShortDoubleResult", 8D, new Object[]{(byte)2,(float)4});
        testCall(tc, "testShortDouble", null, new Object[]{(byte)2,(double)4});
        testCall(tc, "testShortDoubleResult", 8D, new Object[]{(byte)2,(double)4});
        testCall(tc, "testShortDouble", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testShortDoubleResult", 8D, new Object[]{(short)2,(byte)4});
        testCall(tc, "testShortDouble", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testShortDoubleResult", 8D, new Object[]{(short)2,(short)4});
        testCall(tc, "testShortDouble", null, new Object[]{(short)2,4});
        testCall(tc, "testShortDoubleResult", 8D, new Object[]{(short)2,4});
        testCall(tc, "testShortDouble", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testShortDoubleResult", 8D, new Object[]{(short)2,(long)4});
        testCall(tc, "testShortDouble", null, new Object[]{(short)2,(float)4});
        testCall(tc, "testShortDoubleResult", 8D, new Object[]{(short)2,(float)4});
        testCall(tc, "testShortDouble", null, new Object[]{(short)2,(double)4});
        testCall(tc, "testShortDoubleResult", 8D, new Object[]{(short)2,(double)4});
        testCall(tc, "testShortDouble", null, new Object[]{2,(byte)4});
        testCall(tc, "testShortDoubleResult", 8D, new Object[]{2,(byte)4});
        testCall(tc, "testShortDouble", null, new Object[]{2,(short)4});
        testCall(tc, "testShortDoubleResult", 8D, new Object[]{2,(short)4});
        testCall(tc, "testShortDouble", null, new Object[]{2,4});
        testCall(tc, "testShortDoubleResult", 8D, new Object[]{2,4});
        testCall(tc, "testShortDouble", null, new Object[]{2,(long)4});
        testCall(tc, "testShortDoubleResult", 8D, new Object[]{2,(long)4});
        testCall(tc, "testShortDouble", null, new Object[]{2,(float)4});
        testCall(tc, "testShortDoubleResult", 8D, new Object[]{2,(float)4});
        testCall(tc, "testShortDouble", null, new Object[]{2,(double)4});
        testCall(tc, "testShortDoubleResult", 8D, new Object[]{2,(double)4});
        testCall(tc, "testShortDouble", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testShortDoubleResult", 8D, new Object[]{(long)2,(byte)4});
        testCall(tc, "testShortDouble", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testShortDoubleResult", 8D, new Object[]{(long)2,(short)4});
        testCall(tc, "testShortDouble", null, new Object[]{(long)2,4});
        testCall(tc, "testShortDoubleResult", 8D, new Object[]{(long)2,4});
        testCall(tc, "testShortDouble", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testShortDoubleResult", 8D, new Object[]{(long)2,(long)4});
        testCall(tc, "testShortDouble", null, new Object[]{(long)2,(float)4});
        testCall(tc, "testShortDoubleResult", 8D, new Object[]{(long)2,(float)4});
        testCall(tc, "testShortDouble", null, new Object[]{(long)2,(double)4});
        testCall(tc, "testShortDoubleResult", 8D, new Object[]{(long)2,(double)4});
    }

    @Test
    public void testInteger() throws FunctionNotExistsException, JmriException {
        testCall(tc, "testIntegerByte", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testIntegerByteResult", 8L, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testIntegerByte", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testIntegerByteResult", 8L, new Object[]{(byte)2,(short)4});
        testCall(tc, "testIntegerByte", null, new Object[]{(byte)2,4});
        testCall(tc, "testIntegerByteResult", 8L, new Object[]{(byte)2,4});
        testCall(tc, "testIntegerByte", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testIntegerByteResult", 8L, new Object[]{(byte)2,(long)4});
        testCall(tc, "testIntegerByte", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testIntegerByteResult", 8L, new Object[]{(short)2,(byte)4});
        testCall(tc, "testIntegerByte", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testIntegerByteResult", 8L, new Object[]{(short)2,(short)4});
        testCall(tc, "testIntegerByte", null, new Object[]{(short)2,4});
        testCall(tc, "testIntegerByteResult", 8L, new Object[]{(short)2,4});
        testCall(tc, "testIntegerByte", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testIntegerByteResult", 8L, new Object[]{(short)2,(long)4});
        testCall(tc, "testIntegerByte", null, new Object[]{2,(byte)4});
        testCall(tc, "testIntegerByteResult", 8L, new Object[]{2,(byte)4});
        testCall(tc, "testIntegerByte", null, new Object[]{2,(short)4});
        testCall(tc, "testIntegerByteResult", 8L, new Object[]{2,(short)4});
        testCall(tc, "testIntegerByte", null, new Object[]{2,4});
        testCall(tc, "testIntegerByteResult", 8L, new Object[]{2,4});
        testCall(tc, "testIntegerByte", null, new Object[]{2,(long)4});
        testCall(tc, "testIntegerByteResult", 8L, new Object[]{2,(long)4});
        testCall(tc, "testIntegerByte", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testIntegerByteResult", 8L, new Object[]{(long)2,(byte)4});
        testCall(tc, "testIntegerByte", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testIntegerByteResult", 8L, new Object[]{(long)2,(short)4});
        testCall(tc, "testIntegerByte", null, new Object[]{(long)2,4});
        testCall(tc, "testIntegerByteResult", 8L, new Object[]{(long)2,4});
        testCall(tc, "testIntegerByte", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testIntegerByteResult", 8L, new Object[]{(long)2,(long)4});
        testCall(tc, "testIntegerShort", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testIntegerShortResult", 8L, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testIntegerShort", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testIntegerShortResult", 8L, new Object[]{(byte)2,(short)4});
        testCall(tc, "testIntegerShort", null, new Object[]{(byte)2,4});
        testCall(tc, "testIntegerShortResult", 8L, new Object[]{(byte)2,4});
        testCall(tc, "testIntegerShort", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testIntegerShortResult", 8L, new Object[]{(byte)2,(long)4});
        testCall(tc, "testIntegerShort", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testIntegerShortResult", 8L, new Object[]{(short)2,(byte)4});
        testCall(tc, "testIntegerShort", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testIntegerShortResult", 8L, new Object[]{(short)2,(short)4});
        testCall(tc, "testIntegerShort", null, new Object[]{(short)2,4});
        testCall(tc, "testIntegerShortResult", 8L, new Object[]{(short)2,4});
        testCall(tc, "testIntegerShort", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testIntegerShortResult", 8L, new Object[]{(short)2,(long)4});
        testCall(tc, "testIntegerShort", null, new Object[]{2,(byte)4});
        testCall(tc, "testIntegerShortResult", 8L, new Object[]{2,(byte)4});
        testCall(tc, "testIntegerShort", null, new Object[]{2,(short)4});
        testCall(tc, "testIntegerShortResult", 8L, new Object[]{2,(short)4});
        testCall(tc, "testIntegerShort", null, new Object[]{2,4});
        testCall(tc, "testIntegerShortResult", 8L, new Object[]{2,4});
        testCall(tc, "testIntegerShort", null, new Object[]{2,(long)4});
        testCall(tc, "testIntegerShortResult", 8L, new Object[]{2,(long)4});
        testCall(tc, "testIntegerShort", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testIntegerShortResult", 8L, new Object[]{(long)2,(byte)4});
        testCall(tc, "testIntegerShort", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testIntegerShortResult", 8L, new Object[]{(long)2,(short)4});
        testCall(tc, "testIntegerShort", null, new Object[]{(long)2,4});
        testCall(tc, "testIntegerShortResult", 8L, new Object[]{(long)2,4});
        testCall(tc, "testIntegerShort", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testIntegerShortResult", 8L, new Object[]{(long)2,(long)4});
        testCall(tc, "testIntegerInteger", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testIntegerIntegerResult", 8L, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testIntegerInteger", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testIntegerIntegerResult", 8L, new Object[]{(byte)2,(short)4});
        testCall(tc, "testIntegerInteger", null, new Object[]{(byte)2,4});
        testCall(tc, "testIntegerIntegerResult", 8L, new Object[]{(byte)2,4});
        testCall(tc, "testIntegerInteger", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testIntegerIntegerResult", 8L, new Object[]{(byte)2,(long)4});
        testCall(tc, "testIntegerInteger", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testIntegerIntegerResult", 8L, new Object[]{(short)2,(byte)4});
        testCall(tc, "testIntegerInteger", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testIntegerIntegerResult", 8L, new Object[]{(short)2,(short)4});
        testCall(tc, "testIntegerInteger", null, new Object[]{(short)2,4});
        testCall(tc, "testIntegerIntegerResult", 8L, new Object[]{(short)2,4});
        testCall(tc, "testIntegerInteger", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testIntegerIntegerResult", 8L, new Object[]{(short)2,(long)4});
        testCall(tc, "testIntegerInteger", null, new Object[]{2,(byte)4});
        testCall(tc, "testIntegerIntegerResult", 8L, new Object[]{2,(byte)4});
        testCall(tc, "testIntegerInteger", null, new Object[]{2,(short)4});
        testCall(tc, "testIntegerIntegerResult", 8L, new Object[]{2,(short)4});
        testCall(tc, "testIntegerInteger", null, new Object[]{2,4});
        testCall(tc, "testIntegerIntegerResult", 8L, new Object[]{2,4});
        testCall(tc, "testIntegerInteger", null, new Object[]{2,(long)4});
        testCall(tc, "testIntegerIntegerResult", 8L, new Object[]{2,(long)4});
        testCall(tc, "testIntegerInteger", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testIntegerIntegerResult", 8L, new Object[]{(long)2,(byte)4});
        testCall(tc, "testIntegerInteger", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testIntegerIntegerResult", 8L, new Object[]{(long)2,(short)4});
        testCall(tc, "testIntegerInteger", null, new Object[]{(long)2,4});
        testCall(tc, "testIntegerIntegerResult", 8L, new Object[]{(long)2,4});
        testCall(tc, "testIntegerInteger", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testIntegerIntegerResult", 8L, new Object[]{(long)2,(long)4});
        testCall(tc, "testIntegerLong", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testIntegerLongResult", 8L, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testIntegerLong", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testIntegerLongResult", 8L, new Object[]{(byte)2,(short)4});
        testCall(tc, "testIntegerLong", null, new Object[]{(byte)2,4});
        testCall(tc, "testIntegerLongResult", 8L, new Object[]{(byte)2,4});
        testCall(tc, "testIntegerLong", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testIntegerLongResult", 8L, new Object[]{(byte)2,(long)4});
        testCall(tc, "testIntegerLong", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testIntegerLongResult", 8L, new Object[]{(short)2,(byte)4});
        testCall(tc, "testIntegerLong", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testIntegerLongResult", 8L, new Object[]{(short)2,(short)4});
        testCall(tc, "testIntegerLong", null, new Object[]{(short)2,4});
        testCall(tc, "testIntegerLongResult", 8L, new Object[]{(short)2,4});
        testCall(tc, "testIntegerLong", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testIntegerLongResult", 8L, new Object[]{(short)2,(long)4});
        testCall(tc, "testIntegerLong", null, new Object[]{2,(byte)4});
        testCall(tc, "testIntegerLongResult", 8L, new Object[]{2,(byte)4});
        testCall(tc, "testIntegerLong", null, new Object[]{2,(short)4});
        testCall(tc, "testIntegerLongResult", 8L, new Object[]{2,(short)4});
        testCall(tc, "testIntegerLong", null, new Object[]{2,4});
        testCall(tc, "testIntegerLongResult", 8L, new Object[]{2,4});
        testCall(tc, "testIntegerLong", null, new Object[]{2,(long)4});
        testCall(tc, "testIntegerLongResult", 8L, new Object[]{2,(long)4});
        testCall(tc, "testIntegerLong", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testIntegerLongResult", 8L, new Object[]{(long)2,(byte)4});
        testCall(tc, "testIntegerLong", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testIntegerLongResult", 8L, new Object[]{(long)2,(short)4});
        testCall(tc, "testIntegerLong", null, new Object[]{(long)2,4});
        testCall(tc, "testIntegerLongResult", 8L, new Object[]{(long)2,4});
        testCall(tc, "testIntegerLong", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testIntegerLongResult", 8L, new Object[]{(long)2,(long)4});
        testCall(tc, "testIntegerFloat", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testIntegerFloatResult", 8D, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testIntegerFloat", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testIntegerFloatResult", 8D, new Object[]{(byte)2,(short)4});
        testCall(tc, "testIntegerFloat", null, new Object[]{(byte)2,4});
        testCall(tc, "testIntegerFloatResult", 8D, new Object[]{(byte)2,4});
        testCall(tc, "testIntegerFloat", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testIntegerFloatResult", 8D, new Object[]{(byte)2,(long)4});
        testCall(tc, "testIntegerFloat", null, new Object[]{(byte)2,(float)4});
        testCall(tc, "testIntegerFloatResult", 8D, new Object[]{(byte)2,(float)4});
        testCall(tc, "testIntegerFloat", null, new Object[]{(byte)2,(double)4});
        testCall(tc, "testIntegerFloatResult", 8D, new Object[]{(byte)2,(double)4});
        testCall(tc, "testIntegerFloat", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testIntegerFloatResult", 8D, new Object[]{(short)2,(byte)4});
        testCall(tc, "testIntegerFloat", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testIntegerFloatResult", 8D, new Object[]{(short)2,(short)4});
        testCall(tc, "testIntegerFloat", null, new Object[]{(short)2,4});
        testCall(tc, "testIntegerFloatResult", 8D, new Object[]{(short)2,4});
        testCall(tc, "testIntegerFloat", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testIntegerFloatResult", 8D, new Object[]{(short)2,(long)4});
        testCall(tc, "testIntegerFloat", null, new Object[]{(short)2,(float)4});
        testCall(tc, "testIntegerFloatResult", 8D, new Object[]{(short)2,(float)4});
        testCall(tc, "testIntegerFloat", null, new Object[]{(short)2,(double)4});
        testCall(tc, "testIntegerFloatResult", 8D, new Object[]{(short)2,(double)4});
        testCall(tc, "testIntegerFloat", null, new Object[]{2,(byte)4});
        testCall(tc, "testIntegerFloatResult", 8D, new Object[]{2,(byte)4});
        testCall(tc, "testIntegerFloat", null, new Object[]{2,(short)4});
        testCall(tc, "testIntegerFloatResult", 8D, new Object[]{2,(short)4});
        testCall(tc, "testIntegerFloat", null, new Object[]{2,4});
        testCall(tc, "testIntegerFloatResult", 8D, new Object[]{2,4});
        testCall(tc, "testIntegerFloat", null, new Object[]{2,(long)4});
        testCall(tc, "testIntegerFloatResult", 8D, new Object[]{2,(long)4});
        testCall(tc, "testIntegerFloat", null, new Object[]{2,(float)4});
        testCall(tc, "testIntegerFloatResult", 8D, new Object[]{2,(float)4});
        testCall(tc, "testIntegerFloat", null, new Object[]{2,(double)4});
        testCall(tc, "testIntegerFloatResult", 8D, new Object[]{2,(double)4});
        testCall(tc, "testIntegerFloat", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testIntegerFloatResult", 8D, new Object[]{(long)2,(byte)4});
        testCall(tc, "testIntegerFloat", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testIntegerFloatResult", 8D, new Object[]{(long)2,(short)4});
        testCall(tc, "testIntegerFloat", null, new Object[]{(long)2,4});
        testCall(tc, "testIntegerFloatResult", 8D, new Object[]{(long)2,4});
        testCall(tc, "testIntegerFloat", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testIntegerFloatResult", 8D, new Object[]{(long)2,(long)4});
        testCall(tc, "testIntegerFloat", null, new Object[]{(long)2,(float)4});
        testCall(tc, "testIntegerFloatResult", 8D, new Object[]{(long)2,(float)4});
        testCall(tc, "testIntegerFloat", null, new Object[]{(long)2,(double)4});
        testCall(tc, "testIntegerFloatResult", 8D, new Object[]{(long)2,(double)4});
        testCall(tc, "testIntegerDouble", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testIntegerDoubleResult", 8D, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testIntegerDouble", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testIntegerDoubleResult", 8D, new Object[]{(byte)2,(short)4});
        testCall(tc, "testIntegerDouble", null, new Object[]{(byte)2,4});
        testCall(tc, "testIntegerDoubleResult", 8D, new Object[]{(byte)2,4});
        testCall(tc, "testIntegerDouble", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testIntegerDoubleResult", 8D, new Object[]{(byte)2,(long)4});
        testCall(tc, "testIntegerDouble", null, new Object[]{(byte)2,(float)4});
        testCall(tc, "testIntegerDoubleResult", 8D, new Object[]{(byte)2,(float)4});
        testCall(tc, "testIntegerDouble", null, new Object[]{(byte)2,(double)4});
        testCall(tc, "testIntegerDoubleResult", 8D, new Object[]{(byte)2,(double)4});
        testCall(tc, "testIntegerDouble", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testIntegerDoubleResult", 8D, new Object[]{(short)2,(byte)4});
        testCall(tc, "testIntegerDouble", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testIntegerDoubleResult", 8D, new Object[]{(short)2,(short)4});
        testCall(tc, "testIntegerDouble", null, new Object[]{(short)2,4});
        testCall(tc, "testIntegerDoubleResult", 8D, new Object[]{(short)2,4});
        testCall(tc, "testIntegerDouble", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testIntegerDoubleResult", 8D, new Object[]{(short)2,(long)4});
        testCall(tc, "testIntegerDouble", null, new Object[]{(short)2,(float)4});
        testCall(tc, "testIntegerDoubleResult", 8D, new Object[]{(short)2,(float)4});
        testCall(tc, "testIntegerDouble", null, new Object[]{(short)2,(double)4});
        testCall(tc, "testIntegerDoubleResult", 8D, new Object[]{(short)2,(double)4});
        testCall(tc, "testIntegerDouble", null, new Object[]{2,(byte)4});
        testCall(tc, "testIntegerDoubleResult", 8D, new Object[]{2,(byte)4});
        testCall(tc, "testIntegerDouble", null, new Object[]{2,(short)4});
        testCall(tc, "testIntegerDoubleResult", 8D, new Object[]{2,(short)4});
        testCall(tc, "testIntegerDouble", null, new Object[]{2,4});
        testCall(tc, "testIntegerDoubleResult", 8D, new Object[]{2,4});
        testCall(tc, "testIntegerDouble", null, new Object[]{2,(long)4});
        testCall(tc, "testIntegerDoubleResult", 8D, new Object[]{2,(long)4});
        testCall(tc, "testIntegerDouble", null, new Object[]{2,(float)4});
        testCall(tc, "testIntegerDoubleResult", 8D, new Object[]{2,(float)4});
        testCall(tc, "testIntegerDouble", null, new Object[]{2,(double)4});
        testCall(tc, "testIntegerDoubleResult", 8D, new Object[]{2,(double)4});
        testCall(tc, "testIntegerDouble", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testIntegerDoubleResult", 8D, new Object[]{(long)2,(byte)4});
        testCall(tc, "testIntegerDouble", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testIntegerDoubleResult", 8D, new Object[]{(long)2,(short)4});
        testCall(tc, "testIntegerDouble", null, new Object[]{(long)2,4});
        testCall(tc, "testIntegerDoubleResult", 8D, new Object[]{(long)2,4});
        testCall(tc, "testIntegerDouble", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testIntegerDoubleResult", 8D, new Object[]{(long)2,(long)4});
        testCall(tc, "testIntegerDouble", null, new Object[]{(long)2,(float)4});
        testCall(tc, "testIntegerDoubleResult", 8D, new Object[]{(long)2,(float)4});
        testCall(tc, "testIntegerDouble", null, new Object[]{(long)2,(double)4});
        testCall(tc, "testIntegerDoubleResult", 8D, new Object[]{(long)2,(double)4});
    }

    @Test
    public void testLong() throws FunctionNotExistsException, JmriException {
        testCall(tc, "testLongByte", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testLongByteResult", 8L, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testLongByte", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testLongByteResult", 8L, new Object[]{(byte)2,(short)4});
        testCall(tc, "testLongByte", null, new Object[]{(byte)2,4});
        testCall(tc, "testLongByteResult", 8L, new Object[]{(byte)2,4});
        testCall(tc, "testLongByte", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testLongByteResult", 8L, new Object[]{(byte)2,(long)4});
        testCall(tc, "testLongByte", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testLongByteResult", 8L, new Object[]{(short)2,(byte)4});
        testCall(tc, "testLongByte", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testLongByteResult", 8L, new Object[]{(short)2,(short)4});
        testCall(tc, "testLongByte", null, new Object[]{(short)2,4});
        testCall(tc, "testLongByteResult", 8L, new Object[]{(short)2,4});
        testCall(tc, "testLongByte", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testLongByteResult", 8L, new Object[]{(short)2,(long)4});
        testCall(tc, "testLongByte", null, new Object[]{2,(byte)4});
        testCall(tc, "testLongByteResult", 8L, new Object[]{2,(byte)4});
        testCall(tc, "testLongByte", null, new Object[]{2,(short)4});
        testCall(tc, "testLongByteResult", 8L, new Object[]{2,(short)4});
        testCall(tc, "testLongByte", null, new Object[]{2,4});
        testCall(tc, "testLongByteResult", 8L, new Object[]{2,4});
        testCall(tc, "testLongByte", null, new Object[]{2,(long)4});
        testCall(tc, "testLongByteResult", 8L, new Object[]{2,(long)4});
        testCall(tc, "testLongByte", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testLongByteResult", 8L, new Object[]{(long)2,(byte)4});
        testCall(tc, "testLongByte", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testLongByteResult", 8L, new Object[]{(long)2,(short)4});
        testCall(tc, "testLongByte", null, new Object[]{(long)2,4});
        testCall(tc, "testLongByteResult", 8L, new Object[]{(long)2,4});
        testCall(tc, "testLongByte", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testLongByteResult", 8L, new Object[]{(long)2,(long)4});
        testCall(tc, "testLongShort", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testLongShortResult", 8L, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testLongShort", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testLongShortResult", 8L, new Object[]{(byte)2,(short)4});
        testCall(tc, "testLongShort", null, new Object[]{(byte)2,4});
        testCall(tc, "testLongShortResult", 8L, new Object[]{(byte)2,4});
        testCall(tc, "testLongShort", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testLongShortResult", 8L, new Object[]{(byte)2,(long)4});
        testCall(tc, "testLongShort", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testLongShortResult", 8L, new Object[]{(short)2,(byte)4});
        testCall(tc, "testLongShort", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testLongShortResult", 8L, new Object[]{(short)2,(short)4});
        testCall(tc, "testLongShort", null, new Object[]{(short)2,4});
        testCall(tc, "testLongShortResult", 8L, new Object[]{(short)2,4});
        testCall(tc, "testLongShort", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testLongShortResult", 8L, new Object[]{(short)2,(long)4});
        testCall(tc, "testLongShort", null, new Object[]{2,(byte)4});
        testCall(tc, "testLongShortResult", 8L, new Object[]{2,(byte)4});
        testCall(tc, "testLongShort", null, new Object[]{2,(short)4});
        testCall(tc, "testLongShortResult", 8L, new Object[]{2,(short)4});
        testCall(tc, "testLongShort", null, new Object[]{2,4});
        testCall(tc, "testLongShortResult", 8L, new Object[]{2,4});
        testCall(tc, "testLongShort", null, new Object[]{2,(long)4});
        testCall(tc, "testLongShortResult", 8L, new Object[]{2,(long)4});
        testCall(tc, "testLongShort", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testLongShortResult", 8L, new Object[]{(long)2,(byte)4});
        testCall(tc, "testLongShort", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testLongShortResult", 8L, new Object[]{(long)2,(short)4});
        testCall(tc, "testLongShort", null, new Object[]{(long)2,4});
        testCall(tc, "testLongShortResult", 8L, new Object[]{(long)2,4});
        testCall(tc, "testLongShort", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testLongShortResult", 8L, new Object[]{(long)2,(long)4});
        testCall(tc, "testLongInteger", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testLongIntegerResult", 8L, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testLongInteger", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testLongIntegerResult", 8L, new Object[]{(byte)2,(short)4});
        testCall(tc, "testLongInteger", null, new Object[]{(byte)2,4});
        testCall(tc, "testLongIntegerResult", 8L, new Object[]{(byte)2,4});
        testCall(tc, "testLongInteger", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testLongIntegerResult", 8L, new Object[]{(byte)2,(long)4});
        testCall(tc, "testLongInteger", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testLongIntegerResult", 8L, new Object[]{(short)2,(byte)4});
        testCall(tc, "testLongInteger", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testLongIntegerResult", 8L, new Object[]{(short)2,(short)4});
        testCall(tc, "testLongInteger", null, new Object[]{(short)2,4});
        testCall(tc, "testLongIntegerResult", 8L, new Object[]{(short)2,4});
        testCall(tc, "testLongInteger", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testLongIntegerResult", 8L, new Object[]{(short)2,(long)4});
        testCall(tc, "testLongInteger", null, new Object[]{2,(byte)4});
        testCall(tc, "testLongIntegerResult", 8L, new Object[]{2,(byte)4});
        testCall(tc, "testLongInteger", null, new Object[]{2,(short)4});
        testCall(tc, "testLongIntegerResult", 8L, new Object[]{2,(short)4});
        testCall(tc, "testLongInteger", null, new Object[]{2,4});
        testCall(tc, "testLongIntegerResult", 8L, new Object[]{2,4});
        testCall(tc, "testLongInteger", null, new Object[]{2,(long)4});
        testCall(tc, "testLongIntegerResult", 8L, new Object[]{2,(long)4});
        testCall(tc, "testLongInteger", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testLongIntegerResult", 8L, new Object[]{(long)2,(byte)4});
        testCall(tc, "testLongInteger", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testLongIntegerResult", 8L, new Object[]{(long)2,(short)4});
        testCall(tc, "testLongInteger", null, new Object[]{(long)2,4});
        testCall(tc, "testLongIntegerResult", 8L, new Object[]{(long)2,4});
        testCall(tc, "testLongInteger", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testLongIntegerResult", 8L, new Object[]{(long)2,(long)4});
        testCall(tc, "testLongLong", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testLongLongResult", 8L, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testLongLong", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testLongLongResult", 8L, new Object[]{(byte)2,(short)4});
        testCall(tc, "testLongLong", null, new Object[]{(byte)2,4});
        testCall(tc, "testLongLongResult", 8L, new Object[]{(byte)2,4});
        testCall(tc, "testLongLong", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testLongLongResult", 8L, new Object[]{(byte)2,(long)4});
        testCall(tc, "testLongLong", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testLongLongResult", 8L, new Object[]{(short)2,(byte)4});
        testCall(tc, "testLongLong", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testLongLongResult", 8L, new Object[]{(short)2,(short)4});
        testCall(tc, "testLongLong", null, new Object[]{(short)2,4});
        testCall(tc, "testLongLongResult", 8L, new Object[]{(short)2,4});
        testCall(tc, "testLongLong", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testLongLongResult", 8L, new Object[]{(short)2,(long)4});
        testCall(tc, "testLongLong", null, new Object[]{2,(byte)4});
        testCall(tc, "testLongLongResult", 8L, new Object[]{2,(byte)4});
        testCall(tc, "testLongLong", null, new Object[]{2,(short)4});
        testCall(tc, "testLongLongResult", 8L, new Object[]{2,(short)4});
        testCall(tc, "testLongLong", null, new Object[]{2,4});
        testCall(tc, "testLongLongResult", 8L, new Object[]{2,4});
        testCall(tc, "testLongLong", null, new Object[]{2,(long)4});
        testCall(tc, "testLongLongResult", 8L, new Object[]{2,(long)4});
        testCall(tc, "testLongLong", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testLongLongResult", 8L, new Object[]{(long)2,(byte)4});
        testCall(tc, "testLongLong", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testLongLongResult", 8L, new Object[]{(long)2,(short)4});
        testCall(tc, "testLongLong", null, new Object[]{(long)2,4});
        testCall(tc, "testLongLongResult", 8L, new Object[]{(long)2,4});
        testCall(tc, "testLongLong", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testLongLongResult", 8L, new Object[]{(long)2,(long)4});
        testCall(tc, "testLongFloat", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testLongFloatResult", 8D, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testLongFloat", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testLongFloatResult", 8D, new Object[]{(byte)2,(short)4});
        testCall(tc, "testLongFloat", null, new Object[]{(byte)2,4});
        testCall(tc, "testLongFloatResult", 8D, new Object[]{(byte)2,4});
        testCall(tc, "testLongFloat", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testLongFloatResult", 8D, new Object[]{(byte)2,(long)4});
        testCall(tc, "testLongFloat", null, new Object[]{(byte)2,(float)4});
        testCall(tc, "testLongFloatResult", 8D, new Object[]{(byte)2,(float)4});
        testCall(tc, "testLongFloat", null, new Object[]{(byte)2,(double)4});
        testCall(tc, "testLongFloatResult", 8D, new Object[]{(byte)2,(double)4});
        testCall(tc, "testLongFloat", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testLongFloatResult", 8D, new Object[]{(short)2,(byte)4});
        testCall(tc, "testLongFloat", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testLongFloatResult", 8D, new Object[]{(short)2,(short)4});
        testCall(tc, "testLongFloat", null, new Object[]{(short)2,4});
        testCall(tc, "testLongFloatResult", 8D, new Object[]{(short)2,4});
        testCall(tc, "testLongFloat", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testLongFloatResult", 8D, new Object[]{(short)2,(long)4});
        testCall(tc, "testLongFloat", null, new Object[]{(short)2,(float)4});
        testCall(tc, "testLongFloatResult", 8D, new Object[]{(short)2,(float)4});
        testCall(tc, "testLongFloat", null, new Object[]{(short)2,(double)4});
        testCall(tc, "testLongFloatResult", 8D, new Object[]{(short)2,(double)4});
        testCall(tc, "testLongFloat", null, new Object[]{2,(byte)4});
        testCall(tc, "testLongFloatResult", 8D, new Object[]{2,(byte)4});
        testCall(tc, "testLongFloat", null, new Object[]{2,(short)4});
        testCall(tc, "testLongFloatResult", 8D, new Object[]{2,(short)4});
        testCall(tc, "testLongFloat", null, new Object[]{2,4});
        testCall(tc, "testLongFloatResult", 8D, new Object[]{2,4});
        testCall(tc, "testLongFloat", null, new Object[]{2,(long)4});
        testCall(tc, "testLongFloatResult", 8D, new Object[]{2,(long)4});
        testCall(tc, "testLongFloat", null, new Object[]{2,(float)4});
        testCall(tc, "testLongFloatResult", 8D, new Object[]{2,(float)4});
        testCall(tc, "testLongFloat", null, new Object[]{2,(double)4});
        testCall(tc, "testLongFloatResult", 8D, new Object[]{2,(double)4});
        testCall(tc, "testLongFloat", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testLongFloatResult", 8D, new Object[]{(long)2,(byte)4});
        testCall(tc, "testLongFloat", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testLongFloatResult", 8D, new Object[]{(long)2,(short)4});
        testCall(tc, "testLongFloat", null, new Object[]{(long)2,4});
        testCall(tc, "testLongFloatResult", 8D, new Object[]{(long)2,4});
        testCall(tc, "testLongFloat", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testLongFloatResult", 8D, new Object[]{(long)2,(long)4});
        testCall(tc, "testLongFloat", null, new Object[]{(long)2,(float)4});
        testCall(tc, "testLongFloatResult", 8D, new Object[]{(long)2,(float)4});
        testCall(tc, "testLongFloat", null, new Object[]{(long)2,(double)4});
        testCall(tc, "testLongFloatResult", 8D, new Object[]{(long)2,(double)4});
        testCall(tc, "testLongDouble", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testLongDoubleResult", 8D, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testLongDouble", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testLongDoubleResult", 8D, new Object[]{(byte)2,(short)4});
        testCall(tc, "testLongDouble", null, new Object[]{(byte)2,4});
        testCall(tc, "testLongDoubleResult", 8D, new Object[]{(byte)2,4});
        testCall(tc, "testLongDouble", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testLongDoubleResult", 8D, new Object[]{(byte)2,(long)4});
        testCall(tc, "testLongDouble", null, new Object[]{(byte)2,(float)4});
        testCall(tc, "testLongDoubleResult", 8D, new Object[]{(byte)2,(float)4});
        testCall(tc, "testLongDouble", null, new Object[]{(byte)2,(double)4});
        testCall(tc, "testLongDoubleResult", 8D, new Object[]{(byte)2,(double)4});
        testCall(tc, "testLongDouble", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testLongDoubleResult", 8D, new Object[]{(short)2,(byte)4});
        testCall(tc, "testLongDouble", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testLongDoubleResult", 8D, new Object[]{(short)2,(short)4});
        testCall(tc, "testLongDouble", null, new Object[]{(short)2,4});
        testCall(tc, "testLongDoubleResult", 8D, new Object[]{(short)2,4});
        testCall(tc, "testLongDouble", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testLongDoubleResult", 8D, new Object[]{(short)2,(long)4});
        testCall(tc, "testLongDouble", null, new Object[]{(short)2,(float)4});
        testCall(tc, "testLongDoubleResult", 8D, new Object[]{(short)2,(float)4});
        testCall(tc, "testLongDouble", null, new Object[]{(short)2,(double)4});
        testCall(tc, "testLongDoubleResult", 8D, new Object[]{(short)2,(double)4});
        testCall(tc, "testLongDouble", null, new Object[]{2,(byte)4});
        testCall(tc, "testLongDoubleResult", 8D, new Object[]{2,(byte)4});
        testCall(tc, "testLongDouble", null, new Object[]{2,(short)4});
        testCall(tc, "testLongDoubleResult", 8D, new Object[]{2,(short)4});
        testCall(tc, "testLongDouble", null, new Object[]{2,4});
        testCall(tc, "testLongDoubleResult", 8D, new Object[]{2,4});
        testCall(tc, "testLongDouble", null, new Object[]{2,(long)4});
        testCall(tc, "testLongDoubleResult", 8D, new Object[]{2,(long)4});
        testCall(tc, "testLongDouble", null, new Object[]{2,(float)4});
        testCall(tc, "testLongDoubleResult", 8D, new Object[]{2,(float)4});
        testCall(tc, "testLongDouble", null, new Object[]{2,(double)4});
        testCall(tc, "testLongDoubleResult", 8D, new Object[]{2,(double)4});
        testCall(tc, "testLongDouble", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testLongDoubleResult", 8D, new Object[]{(long)2,(byte)4});
        testCall(tc, "testLongDouble", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testLongDoubleResult", 8D, new Object[]{(long)2,(short)4});
        testCall(tc, "testLongDouble", null, new Object[]{(long)2,4});
        testCall(tc, "testLongDoubleResult", 8D, new Object[]{(long)2,4});
        testCall(tc, "testLongDouble", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testLongDoubleResult", 8D, new Object[]{(long)2,(long)4});
        testCall(tc, "testLongDouble", null, new Object[]{(long)2,(float)4});
        testCall(tc, "testLongDoubleResult", 8D, new Object[]{(long)2,(float)4});
        testCall(tc, "testLongDouble", null, new Object[]{(long)2,(double)4});
        testCall(tc, "testLongDoubleResult", 8D, new Object[]{(long)2,(double)4});
    }

    @Test
    public void testFloat() throws FunctionNotExistsException, JmriException {
        testCall(tc, "testFloatByte", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testFloatByteResult", 8D, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testFloatByte", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testFloatByteResult", 8D, new Object[]{(byte)2,(short)4});
        testCall(tc, "testFloatByte", null, new Object[]{(byte)2,4});
        testCall(tc, "testFloatByteResult", 8D, new Object[]{(byte)2,4});
        testCall(tc, "testFloatByte", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testFloatByteResult", 8D, new Object[]{(byte)2,(long)4});
        testCall(tc, "testFloatByte", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testFloatByteResult", 8D, new Object[]{(short)2,(byte)4});
        testCall(tc, "testFloatByte", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testFloatByteResult", 8D, new Object[]{(short)2,(short)4});
        testCall(tc, "testFloatByte", null, new Object[]{(short)2,4});
        testCall(tc, "testFloatByteResult", 8D, new Object[]{(short)2,4});
        testCall(tc, "testFloatByte", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testFloatByteResult", 8D, new Object[]{(short)2,(long)4});
        testCall(tc, "testFloatByte", null, new Object[]{2,(byte)4});
        testCall(tc, "testFloatByteResult", 8D, new Object[]{2,(byte)4});
        testCall(tc, "testFloatByte", null, new Object[]{2,(short)4});
        testCall(tc, "testFloatByteResult", 8D, new Object[]{2,(short)4});
        testCall(tc, "testFloatByte", null, new Object[]{2,4});
        testCall(tc, "testFloatByteResult", 8D, new Object[]{2,4});
        testCall(tc, "testFloatByte", null, new Object[]{2,(long)4});
        testCall(tc, "testFloatByteResult", 8D, new Object[]{2,(long)4});
        testCall(tc, "testFloatByte", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testFloatByteResult", 8D, new Object[]{(long)2,(byte)4});
        testCall(tc, "testFloatByte", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testFloatByteResult", 8D, new Object[]{(long)2,(short)4});
        testCall(tc, "testFloatByte", null, new Object[]{(long)2,4});
        testCall(tc, "testFloatByteResult", 8D, new Object[]{(long)2,4});
        testCall(tc, "testFloatByte", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testFloatByteResult", 8D, new Object[]{(long)2,(long)4});
        testCall(tc, "testFloatByte", null, new Object[]{(float)2,(byte)4});
        testCall(tc, "testFloatByteResult", 8D, new Object[]{(float)2,(byte)4});
        testCall(tc, "testFloatByte", null, new Object[]{(float)2,(short)4});
        testCall(tc, "testFloatByteResult", 8D, new Object[]{(float)2,(short)4});
        testCall(tc, "testFloatByte", null, new Object[]{(float)2,4});
        testCall(tc, "testFloatByteResult", 8D, new Object[]{(float)2,4});
        testCall(tc, "testFloatByte", null, new Object[]{(float)2,(long)4});
        testCall(tc, "testFloatByteResult", 8D, new Object[]{(float)2,(long)4});
        testCall(tc, "testFloatByte", null, new Object[]{(double)2,(byte)4});
        testCall(tc, "testFloatByteResult", 8D, new Object[]{(double)2,(byte)4});
        testCall(tc, "testFloatByte", null, new Object[]{(double)2,(short)4});
        testCall(tc, "testFloatByteResult", 8D, new Object[]{(double)2,(short)4});
        testCall(tc, "testFloatByte", null, new Object[]{(double)2,4});
        testCall(tc, "testFloatByteResult", 8D, new Object[]{(double)2,4});
        testCall(tc, "testFloatByte", null, new Object[]{(double)2,(long)4});
        testCall(tc, "testFloatByteResult", 8D, new Object[]{(double)2,(long)4});
        testCall(tc, "testFloatShort", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testFloatShortResult", 8D, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testFloatShort", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testFloatShortResult", 8D, new Object[]{(byte)2,(short)4});
        testCall(tc, "testFloatShort", null, new Object[]{(byte)2,4});
        testCall(tc, "testFloatShortResult", 8D, new Object[]{(byte)2,4});
        testCall(tc, "testFloatShort", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testFloatShortResult", 8D, new Object[]{(byte)2,(long)4});
        testCall(tc, "testFloatShort", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testFloatShortResult", 8D, new Object[]{(short)2,(byte)4});
        testCall(tc, "testFloatShort", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testFloatShortResult", 8D, new Object[]{(short)2,(short)4});
        testCall(tc, "testFloatShort", null, new Object[]{(short)2,4});
        testCall(tc, "testFloatShortResult", 8D, new Object[]{(short)2,4});
        testCall(tc, "testFloatShort", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testFloatShortResult", 8D, new Object[]{(short)2,(long)4});
        testCall(tc, "testFloatShort", null, new Object[]{2,(byte)4});
        testCall(tc, "testFloatShortResult", 8D, new Object[]{2,(byte)4});
        testCall(tc, "testFloatShort", null, new Object[]{2,(short)4});
        testCall(tc, "testFloatShortResult", 8D, new Object[]{2,(short)4});
        testCall(tc, "testFloatShort", null, new Object[]{2,4});
        testCall(tc, "testFloatShortResult", 8D, new Object[]{2,4});
        testCall(tc, "testFloatShort", null, new Object[]{2,(long)4});
        testCall(tc, "testFloatShortResult", 8D, new Object[]{2,(long)4});
        testCall(tc, "testFloatShort", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testFloatShortResult", 8D, new Object[]{(long)2,(byte)4});
        testCall(tc, "testFloatShort", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testFloatShortResult", 8D, new Object[]{(long)2,(short)4});
        testCall(tc, "testFloatShort", null, new Object[]{(long)2,4});
        testCall(tc, "testFloatShortResult", 8D, new Object[]{(long)2,4});
        testCall(tc, "testFloatShort", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testFloatShortResult", 8D, new Object[]{(long)2,(long)4});
        testCall(tc, "testFloatShort", null, new Object[]{(float)2,(byte)4});
        testCall(tc, "testFloatShortResult", 8D, new Object[]{(float)2,(byte)4});
        testCall(tc, "testFloatShort", null, new Object[]{(float)2,(short)4});
        testCall(tc, "testFloatShortResult", 8D, new Object[]{(float)2,(short)4});
        testCall(tc, "testFloatShort", null, new Object[]{(float)2,4});
        testCall(tc, "testFloatShortResult", 8D, new Object[]{(float)2,4});
        testCall(tc, "testFloatShort", null, new Object[]{(float)2,(long)4});
        testCall(tc, "testFloatShortResult", 8D, new Object[]{(float)2,(long)4});
        testCall(tc, "testFloatShort", null, new Object[]{(double)2,(byte)4});
        testCall(tc, "testFloatShortResult", 8D, new Object[]{(double)2,(byte)4});
        testCall(tc, "testFloatShort", null, new Object[]{(double)2,(short)4});
        testCall(tc, "testFloatShortResult", 8D, new Object[]{(double)2,(short)4});
        testCall(tc, "testFloatShort", null, new Object[]{(double)2,4});
        testCall(tc, "testFloatShortResult", 8D, new Object[]{(double)2,4});
        testCall(tc, "testFloatShort", null, new Object[]{(double)2,(long)4});
        testCall(tc, "testFloatShortResult", 8D, new Object[]{(double)2,(long)4});
        testCall(tc, "testFloatInteger", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testFloatIntegerResult", 8D, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testFloatInteger", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testFloatIntegerResult", 8D, new Object[]{(byte)2,(short)4});
        testCall(tc, "testFloatInteger", null, new Object[]{(byte)2,4});
        testCall(tc, "testFloatIntegerResult", 8D, new Object[]{(byte)2,4});
        testCall(tc, "testFloatInteger", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testFloatIntegerResult", 8D, new Object[]{(byte)2,(long)4});
        testCall(tc, "testFloatInteger", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testFloatIntegerResult", 8D, new Object[]{(short)2,(byte)4});
        testCall(tc, "testFloatInteger", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testFloatIntegerResult", 8D, new Object[]{(short)2,(short)4});
        testCall(tc, "testFloatInteger", null, new Object[]{(short)2,4});
        testCall(tc, "testFloatIntegerResult", 8D, new Object[]{(short)2,4});
        testCall(tc, "testFloatInteger", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testFloatIntegerResult", 8D, new Object[]{(short)2,(long)4});
        testCall(tc, "testFloatInteger", null, new Object[]{2,(byte)4});
        testCall(tc, "testFloatIntegerResult", 8D, new Object[]{2,(byte)4});
        testCall(tc, "testFloatInteger", null, new Object[]{2,(short)4});
        testCall(tc, "testFloatIntegerResult", 8D, new Object[]{2,(short)4});
        testCall(tc, "testFloatInteger", null, new Object[]{2,4});
        testCall(tc, "testFloatIntegerResult", 8D, new Object[]{2,4});
        testCall(tc, "testFloatInteger", null, new Object[]{2,(long)4});
        testCall(tc, "testFloatIntegerResult", 8D, new Object[]{2,(long)4});
        testCall(tc, "testFloatInteger", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testFloatIntegerResult", 8D, new Object[]{(long)2,(byte)4});
        testCall(tc, "testFloatInteger", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testFloatIntegerResult", 8D, new Object[]{(long)2,(short)4});
        testCall(tc, "testFloatInteger", null, new Object[]{(long)2,4});
        testCall(tc, "testFloatIntegerResult", 8D, new Object[]{(long)2,4});
        testCall(tc, "testFloatInteger", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testFloatIntegerResult", 8D, new Object[]{(long)2,(long)4});
        testCall(tc, "testFloatInteger", null, new Object[]{(float)2,(byte)4});
        testCall(tc, "testFloatIntegerResult", 8D, new Object[]{(float)2,(byte)4});
        testCall(tc, "testFloatInteger", null, new Object[]{(float)2,(short)4});
        testCall(tc, "testFloatIntegerResult", 8D, new Object[]{(float)2,(short)4});
        testCall(tc, "testFloatInteger", null, new Object[]{(float)2,4});
        testCall(tc, "testFloatIntegerResult", 8D, new Object[]{(float)2,4});
        testCall(tc, "testFloatInteger", null, new Object[]{(float)2,(long)4});
        testCall(tc, "testFloatIntegerResult", 8D, new Object[]{(float)2,(long)4});
        testCall(tc, "testFloatInteger", null, new Object[]{(double)2,(byte)4});
        testCall(tc, "testFloatIntegerResult", 8D, new Object[]{(double)2,(byte)4});
        testCall(tc, "testFloatInteger", null, new Object[]{(double)2,(short)4});
        testCall(tc, "testFloatIntegerResult", 8D, new Object[]{(double)2,(short)4});
        testCall(tc, "testFloatInteger", null, new Object[]{(double)2,4});
        testCall(tc, "testFloatIntegerResult", 8D, new Object[]{(double)2,4});
        testCall(tc, "testFloatInteger", null, new Object[]{(double)2,(long)4});
        testCall(tc, "testFloatIntegerResult", 8D, new Object[]{(double)2,(long)4});
        testCall(tc, "testFloatLong", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testFloatLongResult", 8D, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testFloatLong", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testFloatLongResult", 8D, new Object[]{(byte)2,(short)4});
        testCall(tc, "testFloatLong", null, new Object[]{(byte)2,4});
        testCall(tc, "testFloatLongResult", 8D, new Object[]{(byte)2,4});
        testCall(tc, "testFloatLong", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testFloatLongResult", 8D, new Object[]{(byte)2,(long)4});
        testCall(tc, "testFloatLong", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testFloatLongResult", 8D, new Object[]{(short)2,(byte)4});
        testCall(tc, "testFloatLong", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testFloatLongResult", 8D, new Object[]{(short)2,(short)4});
        testCall(tc, "testFloatLong", null, new Object[]{(short)2,4});
        testCall(tc, "testFloatLongResult", 8D, new Object[]{(short)2,4});
        testCall(tc, "testFloatLong", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testFloatLongResult", 8D, new Object[]{(short)2,(long)4});
        testCall(tc, "testFloatLong", null, new Object[]{2,(byte)4});
        testCall(tc, "testFloatLongResult", 8D, new Object[]{2,(byte)4});
        testCall(tc, "testFloatLong", null, new Object[]{2,(short)4});
        testCall(tc, "testFloatLongResult", 8D, new Object[]{2,(short)4});
        testCall(tc, "testFloatLong", null, new Object[]{2,4});
        testCall(tc, "testFloatLongResult", 8D, new Object[]{2,4});
        testCall(tc, "testFloatLong", null, new Object[]{2,(long)4});
        testCall(tc, "testFloatLongResult", 8D, new Object[]{2,(long)4});
        testCall(tc, "testFloatLong", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testFloatLongResult", 8D, new Object[]{(long)2,(byte)4});
        testCall(tc, "testFloatLong", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testFloatLongResult", 8D, new Object[]{(long)2,(short)4});
        testCall(tc, "testFloatLong", null, new Object[]{(long)2,4});
        testCall(tc, "testFloatLongResult", 8D, new Object[]{(long)2,4});
        testCall(tc, "testFloatLong", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testFloatLongResult", 8D, new Object[]{(long)2,(long)4});
        testCall(tc, "testFloatLong", null, new Object[]{(float)2,(byte)4});
        testCall(tc, "testFloatLongResult", 8D, new Object[]{(float)2,(byte)4});
        testCall(tc, "testFloatLong", null, new Object[]{(float)2,(short)4});
        testCall(tc, "testFloatLongResult", 8D, new Object[]{(float)2,(short)4});
        testCall(tc, "testFloatLong", null, new Object[]{(float)2,4});
        testCall(tc, "testFloatLongResult", 8D, new Object[]{(float)2,4});
        testCall(tc, "testFloatLong", null, new Object[]{(float)2,(long)4});
        testCall(tc, "testFloatLongResult", 8D, new Object[]{(float)2,(long)4});
        testCall(tc, "testFloatLong", null, new Object[]{(double)2,(byte)4});
        testCall(tc, "testFloatLongResult", 8D, new Object[]{(double)2,(byte)4});
        testCall(tc, "testFloatLong", null, new Object[]{(double)2,(short)4});
        testCall(tc, "testFloatLongResult", 8D, new Object[]{(double)2,(short)4});
        testCall(tc, "testFloatLong", null, new Object[]{(double)2,4});
        testCall(tc, "testFloatLongResult", 8D, new Object[]{(double)2,4});
        testCall(tc, "testFloatLong", null, new Object[]{(double)2,(long)4});
        testCall(tc, "testFloatLongResult", 8D, new Object[]{(double)2,(long)4});
        testCall(tc, "testFloatFloat", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testFloatFloat", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(byte)2,(short)4});
        testCall(tc, "testFloatFloat", null, new Object[]{(byte)2,4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(byte)2,4});
        testCall(tc, "testFloatFloat", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(byte)2,(long)4});
        testCall(tc, "testFloatFloat", null, new Object[]{(byte)2,(float)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(byte)2,(float)4});
        testCall(tc, "testFloatFloat", null, new Object[]{(byte)2,(double)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(byte)2,(double)4});
        testCall(tc, "testFloatFloat", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(short)2,(byte)4});
        testCall(tc, "testFloatFloat", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(short)2,(short)4});
        testCall(tc, "testFloatFloat", null, new Object[]{(short)2,4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(short)2,4});
        testCall(tc, "testFloatFloat", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(short)2,(long)4});
        testCall(tc, "testFloatFloat", null, new Object[]{(short)2,(float)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(short)2,(float)4});
        testCall(tc, "testFloatFloat", null, new Object[]{(short)2,(double)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(short)2,(double)4});
        testCall(tc, "testFloatFloat", null, new Object[]{2,(byte)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{2,(byte)4});
        testCall(tc, "testFloatFloat", null, new Object[]{2,(short)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{2,(short)4});
        testCall(tc, "testFloatFloat", null, new Object[]{2,4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{2,4});
        testCall(tc, "testFloatFloat", null, new Object[]{2,(long)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{2,(long)4});
        testCall(tc, "testFloatFloat", null, new Object[]{2,(float)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{2,(float)4});
        testCall(tc, "testFloatFloat", null, new Object[]{2,(double)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{2,(double)4});
        testCall(tc, "testFloatFloat", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(long)2,(byte)4});
        testCall(tc, "testFloatFloat", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(long)2,(short)4});
        testCall(tc, "testFloatFloat", null, new Object[]{(long)2,4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(long)2,4});
        testCall(tc, "testFloatFloat", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(long)2,(long)4});
        testCall(tc, "testFloatFloat", null, new Object[]{(long)2,(float)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(long)2,(float)4});
        testCall(tc, "testFloatFloat", null, new Object[]{(long)2,(double)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(long)2,(double)4});
        testCall(tc, "testFloatFloat", null, new Object[]{(float)2,(byte)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(float)2,(byte)4});
        testCall(tc, "testFloatFloat", null, new Object[]{(float)2,(short)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(float)2,(short)4});
        testCall(tc, "testFloatFloat", null, new Object[]{(float)2,4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(float)2,4});
        testCall(tc, "testFloatFloat", null, new Object[]{(float)2,(long)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(float)2,(long)4});
        testCall(tc, "testFloatFloat", null, new Object[]{(float)2,(float)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(float)2,(float)4});
        testCall(tc, "testFloatFloat", null, new Object[]{(float)2,(double)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(float)2,(double)4});
        testCall(tc, "testFloatFloat", null, new Object[]{(double)2,(byte)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(double)2,(byte)4});
        testCall(tc, "testFloatFloat", null, new Object[]{(double)2,(short)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(double)2,(short)4});
        testCall(tc, "testFloatFloat", null, new Object[]{(double)2,4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(double)2,4});
        testCall(tc, "testFloatFloat", null, new Object[]{(double)2,(long)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(double)2,(long)4});
        testCall(tc, "testFloatFloat", null, new Object[]{(double)2,(float)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(double)2,(float)4});
        testCall(tc, "testFloatFloat", null, new Object[]{(double)2,(double)4});
        testCall(tc, "testFloatFloatResult", 8D, new Object[]{(double)2,(double)4});
        testCall(tc, "testFloatDouble", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testFloatDouble", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(byte)2,(short)4});
        testCall(tc, "testFloatDouble", null, new Object[]{(byte)2,4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(byte)2,4});
        testCall(tc, "testFloatDouble", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(byte)2,(long)4});
        testCall(tc, "testFloatDouble", null, new Object[]{(byte)2,(float)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(byte)2,(float)4});
        testCall(tc, "testFloatDouble", null, new Object[]{(byte)2,(double)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(byte)2,(double)4});
        testCall(tc, "testFloatDouble", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(short)2,(byte)4});
        testCall(tc, "testFloatDouble", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(short)2,(short)4});
        testCall(tc, "testFloatDouble", null, new Object[]{(short)2,4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(short)2,4});
        testCall(tc, "testFloatDouble", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(short)2,(long)4});
        testCall(tc, "testFloatDouble", null, new Object[]{(short)2,(float)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(short)2,(float)4});
        testCall(tc, "testFloatDouble", null, new Object[]{(short)2,(double)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(short)2,(double)4});
        testCall(tc, "testFloatDouble", null, new Object[]{2,(byte)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{2,(byte)4});
        testCall(tc, "testFloatDouble", null, new Object[]{2,(short)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{2,(short)4});
        testCall(tc, "testFloatDouble", null, new Object[]{2,4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{2,4});
        testCall(tc, "testFloatDouble", null, new Object[]{2,(long)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{2,(long)4});
        testCall(tc, "testFloatDouble", null, new Object[]{2,(float)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{2,(float)4});
        testCall(tc, "testFloatDouble", null, new Object[]{2,(double)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{2,(double)4});
        testCall(tc, "testFloatDouble", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(long)2,(byte)4});
        testCall(tc, "testFloatDouble", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(long)2,(short)4});
        testCall(tc, "testFloatDouble", null, new Object[]{(long)2,4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(long)2,4});
        testCall(tc, "testFloatDouble", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(long)2,(long)4});
        testCall(tc, "testFloatDouble", null, new Object[]{(long)2,(float)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(long)2,(float)4});
        testCall(tc, "testFloatDouble", null, new Object[]{(long)2,(double)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(long)2,(double)4});
        testCall(tc, "testFloatDouble", null, new Object[]{(float)2,(byte)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(float)2,(byte)4});
        testCall(tc, "testFloatDouble", null, new Object[]{(float)2,(short)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(float)2,(short)4});
        testCall(tc, "testFloatDouble", null, new Object[]{(float)2,4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(float)2,4});
        testCall(tc, "testFloatDouble", null, new Object[]{(float)2,(long)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(float)2,(long)4});
        testCall(tc, "testFloatDouble", null, new Object[]{(float)2,(float)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(float)2,(float)4});
        testCall(tc, "testFloatDouble", null, new Object[]{(float)2,(double)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(float)2,(double)4});
        testCall(tc, "testFloatDouble", null, new Object[]{(double)2,(byte)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(double)2,(byte)4});
        testCall(tc, "testFloatDouble", null, new Object[]{(double)2,(short)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(double)2,(short)4});
        testCall(tc, "testFloatDouble", null, new Object[]{(double)2,4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(double)2,4});
        testCall(tc, "testFloatDouble", null, new Object[]{(double)2,(long)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(double)2,(long)4});
        testCall(tc, "testFloatDouble", null, new Object[]{(double)2,(float)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(double)2,(float)4});
        testCall(tc, "testFloatDouble", null, new Object[]{(double)2,(double)4});
        testCall(tc, "testFloatDoubleResult", 8D, new Object[]{(double)2,(double)4});
    }

    @Test
    public void testDouble() throws FunctionNotExistsException, JmriException {
        testCall(tc, "testDoubleByte", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testDoubleByteResult", 8D, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testDoubleByte", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testDoubleByteResult", 8D, new Object[]{(byte)2,(short)4});
        testCall(tc, "testDoubleByte", null, new Object[]{(byte)2,4});
        testCall(tc, "testDoubleByteResult", 8D, new Object[]{(byte)2,4});
        testCall(tc, "testDoubleByte", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testDoubleByteResult", 8D, new Object[]{(byte)2,(long)4});
        testCall(tc, "testDoubleByte", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testDoubleByteResult", 8D, new Object[]{(short)2,(byte)4});
        testCall(tc, "testDoubleByte", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testDoubleByteResult", 8D, new Object[]{(short)2,(short)4});
        testCall(tc, "testDoubleByte", null, new Object[]{(short)2,4});
        testCall(tc, "testDoubleByteResult", 8D, new Object[]{(short)2,4});
        testCall(tc, "testDoubleByte", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testDoubleByteResult", 8D, new Object[]{(short)2,(long)4});
        testCall(tc, "testDoubleByte", null, new Object[]{2,(byte)4});
        testCall(tc, "testDoubleByteResult", 8D, new Object[]{2,(byte)4});
        testCall(tc, "testDoubleByte", null, new Object[]{2,(short)4});
        testCall(tc, "testDoubleByteResult", 8D, new Object[]{2,(short)4});
        testCall(tc, "testDoubleByte", null, new Object[]{2,4});
        testCall(tc, "testDoubleByteResult", 8D, new Object[]{2,4});
        testCall(tc, "testDoubleByte", null, new Object[]{2,(long)4});
        testCall(tc, "testDoubleByteResult", 8D, new Object[]{2,(long)4});
        testCall(tc, "testDoubleByte", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testDoubleByteResult", 8D, new Object[]{(long)2,(byte)4});
        testCall(tc, "testDoubleByte", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testDoubleByteResult", 8D, new Object[]{(long)2,(short)4});
        testCall(tc, "testDoubleByte", null, new Object[]{(long)2,4});
        testCall(tc, "testDoubleByteResult", 8D, new Object[]{(long)2,4});
        testCall(tc, "testDoubleByte", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testDoubleByteResult", 8D, new Object[]{(long)2,(long)4});
        testCall(tc, "testDoubleByte", null, new Object[]{(float)2,(byte)4});
        testCall(tc, "testDoubleByteResult", 8D, new Object[]{(float)2,(byte)4});
        testCall(tc, "testDoubleByte", null, new Object[]{(float)2,(short)4});
        testCall(tc, "testDoubleByteResult", 8D, new Object[]{(float)2,(short)4});
        testCall(tc, "testDoubleByte", null, new Object[]{(float)2,4});
        testCall(tc, "testDoubleByteResult", 8D, new Object[]{(float)2,4});
        testCall(tc, "testDoubleByte", null, new Object[]{(float)2,(long)4});
        testCall(tc, "testDoubleByteResult", 8D, new Object[]{(float)2,(long)4});
        testCall(tc, "testDoubleByte", null, new Object[]{(double)2,(byte)4});
        testCall(tc, "testDoubleByteResult", 8D, new Object[]{(double)2,(byte)4});
        testCall(tc, "testDoubleByte", null, new Object[]{(double)2,(short)4});
        testCall(tc, "testDoubleByteResult", 8D, new Object[]{(double)2,(short)4});
        testCall(tc, "testDoubleByte", null, new Object[]{(double)2,4});
        testCall(tc, "testDoubleByteResult", 8D, new Object[]{(double)2,4});
        testCall(tc, "testDoubleByte", null, new Object[]{(double)2,(long)4});
        testCall(tc, "testDoubleByteResult", 8D, new Object[]{(double)2,(long)4});
        testCall(tc, "testDoubleShort", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testDoubleShortResult", 8D, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testDoubleShort", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testDoubleShortResult", 8D, new Object[]{(byte)2,(short)4});
        testCall(tc, "testDoubleShort", null, new Object[]{(byte)2,4});
        testCall(tc, "testDoubleShortResult", 8D, new Object[]{(byte)2,4});
        testCall(tc, "testDoubleShort", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testDoubleShortResult", 8D, new Object[]{(byte)2,(long)4});
        testCall(tc, "testDoubleShort", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testDoubleShortResult", 8D, new Object[]{(short)2,(byte)4});
        testCall(tc, "testDoubleShort", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testDoubleShortResult", 8D, new Object[]{(short)2,(short)4});
        testCall(tc, "testDoubleShort", null, new Object[]{(short)2,4});
        testCall(tc, "testDoubleShortResult", 8D, new Object[]{(short)2,4});
        testCall(tc, "testDoubleShort", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testDoubleShortResult", 8D, new Object[]{(short)2,(long)4});
        testCall(tc, "testDoubleShort", null, new Object[]{2,(byte)4});
        testCall(tc, "testDoubleShortResult", 8D, new Object[]{2,(byte)4});
        testCall(tc, "testDoubleShort", null, new Object[]{2,(short)4});
        testCall(tc, "testDoubleShortResult", 8D, new Object[]{2,(short)4});
        testCall(tc, "testDoubleShort", null, new Object[]{2,4});
        testCall(tc, "testDoubleShortResult", 8D, new Object[]{2,4});
        testCall(tc, "testDoubleShort", null, new Object[]{2,(long)4});
        testCall(tc, "testDoubleShortResult", 8D, new Object[]{2,(long)4});
        testCall(tc, "testDoubleShort", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testDoubleShortResult", 8D, new Object[]{(long)2,(byte)4});
        testCall(tc, "testDoubleShort", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testDoubleShortResult", 8D, new Object[]{(long)2,(short)4});
        testCall(tc, "testDoubleShort", null, new Object[]{(long)2,4});
        testCall(tc, "testDoubleShortResult", 8D, new Object[]{(long)2,4});
        testCall(tc, "testDoubleShort", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testDoubleShortResult", 8D, new Object[]{(long)2,(long)4});
        testCall(tc, "testDoubleShort", null, new Object[]{(float)2,(byte)4});
        testCall(tc, "testDoubleShortResult", 8D, new Object[]{(float)2,(byte)4});
        testCall(tc, "testDoubleShort", null, new Object[]{(float)2,(short)4});
        testCall(tc, "testDoubleShortResult", 8D, new Object[]{(float)2,(short)4});
        testCall(tc, "testDoubleShort", null, new Object[]{(float)2,4});
        testCall(tc, "testDoubleShortResult", 8D, new Object[]{(float)2,4});
        testCall(tc, "testDoubleShort", null, new Object[]{(float)2,(long)4});
        testCall(tc, "testDoubleShortResult", 8D, new Object[]{(float)2,(long)4});
        testCall(tc, "testDoubleShort", null, new Object[]{(double)2,(byte)4});
        testCall(tc, "testDoubleShortResult", 8D, new Object[]{(double)2,(byte)4});
        testCall(tc, "testDoubleShort", null, new Object[]{(double)2,(short)4});
        testCall(tc, "testDoubleShortResult", 8D, new Object[]{(double)2,(short)4});
        testCall(tc, "testDoubleShort", null, new Object[]{(double)2,4});
        testCall(tc, "testDoubleShortResult", 8D, new Object[]{(double)2,4});
        testCall(tc, "testDoubleShort", null, new Object[]{(double)2,(long)4});
        testCall(tc, "testDoubleShortResult", 8D, new Object[]{(double)2,(long)4});
        testCall(tc, "testDoubleInteger", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testDoubleIntegerResult", 8D, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testDoubleInteger", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testDoubleIntegerResult", 8D, new Object[]{(byte)2,(short)4});
        testCall(tc, "testDoubleInteger", null, new Object[]{(byte)2,4});
        testCall(tc, "testDoubleIntegerResult", 8D, new Object[]{(byte)2,4});
        testCall(tc, "testDoubleInteger", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testDoubleIntegerResult", 8D, new Object[]{(byte)2,(long)4});
        testCall(tc, "testDoubleInteger", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testDoubleIntegerResult", 8D, new Object[]{(short)2,(byte)4});
        testCall(tc, "testDoubleInteger", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testDoubleIntegerResult", 8D, new Object[]{(short)2,(short)4});
        testCall(tc, "testDoubleInteger", null, new Object[]{(short)2,4});
        testCall(tc, "testDoubleIntegerResult", 8D, new Object[]{(short)2,4});
        testCall(tc, "testDoubleInteger", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testDoubleIntegerResult", 8D, new Object[]{(short)2,(long)4});
        testCall(tc, "testDoubleInteger", null, new Object[]{2,(byte)4});
        testCall(tc, "testDoubleIntegerResult", 8D, new Object[]{2,(byte)4});
        testCall(tc, "testDoubleInteger", null, new Object[]{2,(short)4});
        testCall(tc, "testDoubleIntegerResult", 8D, new Object[]{2,(short)4});
        testCall(tc, "testDoubleInteger", null, new Object[]{2,4});
        testCall(tc, "testDoubleIntegerResult", 8D, new Object[]{2,4});
        testCall(tc, "testDoubleInteger", null, new Object[]{2,(long)4});
        testCall(tc, "testDoubleIntegerResult", 8D, new Object[]{2,(long)4});
        testCall(tc, "testDoubleInteger", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testDoubleIntegerResult", 8D, new Object[]{(long)2,(byte)4});
        testCall(tc, "testDoubleInteger", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testDoubleIntegerResult", 8D, new Object[]{(long)2,(short)4});
        testCall(tc, "testDoubleInteger", null, new Object[]{(long)2,4});
        testCall(tc, "testDoubleIntegerResult", 8D, new Object[]{(long)2,4});
        testCall(tc, "testDoubleInteger", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testDoubleIntegerResult", 8D, new Object[]{(long)2,(long)4});
        testCall(tc, "testDoubleInteger", null, new Object[]{(float)2,(byte)4});
        testCall(tc, "testDoubleIntegerResult", 8D, new Object[]{(float)2,(byte)4});
        testCall(tc, "testDoubleInteger", null, new Object[]{(float)2,(short)4});
        testCall(tc, "testDoubleIntegerResult", 8D, new Object[]{(float)2,(short)4});
        testCall(tc, "testDoubleInteger", null, new Object[]{(float)2,4});
        testCall(tc, "testDoubleIntegerResult", 8D, new Object[]{(float)2,4});
        testCall(tc, "testDoubleInteger", null, new Object[]{(float)2,(long)4});
        testCall(tc, "testDoubleIntegerResult", 8D, new Object[]{(float)2,(long)4});
        testCall(tc, "testDoubleInteger", null, new Object[]{(double)2,(byte)4});
        testCall(tc, "testDoubleIntegerResult", 8D, new Object[]{(double)2,(byte)4});
        testCall(tc, "testDoubleInteger", null, new Object[]{(double)2,(short)4});
        testCall(tc, "testDoubleIntegerResult", 8D, new Object[]{(double)2,(short)4});
        testCall(tc, "testDoubleInteger", null, new Object[]{(double)2,4});
        testCall(tc, "testDoubleIntegerResult", 8D, new Object[]{(double)2,4});
        testCall(tc, "testDoubleInteger", null, new Object[]{(double)2,(long)4});
        testCall(tc, "testDoubleIntegerResult", 8D, new Object[]{(double)2,(long)4});
        testCall(tc, "testDoubleLong", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testDoubleLongResult", 8D, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testDoubleLong", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testDoubleLongResult", 8D, new Object[]{(byte)2,(short)4});
        testCall(tc, "testDoubleLong", null, new Object[]{(byte)2,4});
        testCall(tc, "testDoubleLongResult", 8D, new Object[]{(byte)2,4});
        testCall(tc, "testDoubleLong", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testDoubleLongResult", 8D, new Object[]{(byte)2,(long)4});
        testCall(tc, "testDoubleLong", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testDoubleLongResult", 8D, new Object[]{(short)2,(byte)4});
        testCall(tc, "testDoubleLong", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testDoubleLongResult", 8D, new Object[]{(short)2,(short)4});
        testCall(tc, "testDoubleLong", null, new Object[]{(short)2,4});
        testCall(tc, "testDoubleLongResult", 8D, new Object[]{(short)2,4});
        testCall(tc, "testDoubleLong", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testDoubleLongResult", 8D, new Object[]{(short)2,(long)4});
        testCall(tc, "testDoubleLong", null, new Object[]{2,(byte)4});
        testCall(tc, "testDoubleLongResult", 8D, new Object[]{2,(byte)4});
        testCall(tc, "testDoubleLong", null, new Object[]{2,(short)4});
        testCall(tc, "testDoubleLongResult", 8D, new Object[]{2,(short)4});
        testCall(tc, "testDoubleLong", null, new Object[]{2,4});
        testCall(tc, "testDoubleLongResult", 8D, new Object[]{2,4});
        testCall(tc, "testDoubleLong", null, new Object[]{2,(long)4});
        testCall(tc, "testDoubleLongResult", 8D, new Object[]{2,(long)4});
        testCall(tc, "testDoubleLong", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testDoubleLongResult", 8D, new Object[]{(long)2,(byte)4});
        testCall(tc, "testDoubleLong", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testDoubleLongResult", 8D, new Object[]{(long)2,(short)4});
        testCall(tc, "testDoubleLong", null, new Object[]{(long)2,4});
        testCall(tc, "testDoubleLongResult", 8D, new Object[]{(long)2,4});
        testCall(tc, "testDoubleLong", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testDoubleLongResult", 8D, new Object[]{(long)2,(long)4});
        testCall(tc, "testDoubleLong", null, new Object[]{(float)2,(byte)4});
        testCall(tc, "testDoubleLongResult", 8D, new Object[]{(float)2,(byte)4});
        testCall(tc, "testDoubleLong", null, new Object[]{(float)2,(short)4});
        testCall(tc, "testDoubleLongResult", 8D, new Object[]{(float)2,(short)4});
        testCall(tc, "testDoubleLong", null, new Object[]{(float)2,4});
        testCall(tc, "testDoubleLongResult", 8D, new Object[]{(float)2,4});
        testCall(tc, "testDoubleLong", null, new Object[]{(float)2,(long)4});
        testCall(tc, "testDoubleLongResult", 8D, new Object[]{(float)2,(long)4});
        testCall(tc, "testDoubleLong", null, new Object[]{(double)2,(byte)4});
        testCall(tc, "testDoubleLongResult", 8D, new Object[]{(double)2,(byte)4});
        testCall(tc, "testDoubleLong", null, new Object[]{(double)2,(short)4});
        testCall(tc, "testDoubleLongResult", 8D, new Object[]{(double)2,(short)4});
        testCall(tc, "testDoubleLong", null, new Object[]{(double)2,4});
        testCall(tc, "testDoubleLongResult", 8D, new Object[]{(double)2,4});
        testCall(tc, "testDoubleLong", null, new Object[]{(double)2,(long)4});
        testCall(tc, "testDoubleLongResult", 8D, new Object[]{(double)2,(long)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(byte)2,(short)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(byte)2,4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(byte)2,4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(byte)2,(long)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(byte)2,(float)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(byte)2,(float)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(byte)2,(double)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(byte)2,(double)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(short)2,(byte)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(short)2,(short)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(short)2,4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(short)2,4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(short)2,(long)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(short)2,(float)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(short)2,(float)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(short)2,(double)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(short)2,(double)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{2,(byte)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{2,(byte)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{2,(short)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{2,(short)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{2,4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{2,4});
        testCall(tc, "testDoubleFloat", null, new Object[]{2,(long)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{2,(long)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{2,(float)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{2,(float)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{2,(double)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{2,(double)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(long)2,(byte)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(long)2,(short)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(long)2,4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(long)2,4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(long)2,(long)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(long)2,(float)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(long)2,(float)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(long)2,(double)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(long)2,(double)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(float)2,(byte)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(float)2,(byte)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(float)2,(short)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(float)2,(short)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(float)2,4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(float)2,4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(float)2,(long)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(float)2,(long)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(float)2,(float)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(float)2,(float)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(float)2,(double)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(float)2,(double)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(double)2,(byte)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(double)2,(byte)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(double)2,(short)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(double)2,(short)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(double)2,4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(double)2,4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(double)2,(long)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(double)2,(long)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(double)2,(float)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(double)2,(float)4});
        testCall(tc, "testDoubleFloat", null, new Object[]{(double)2,(double)4});
        testCall(tc, "testDoubleFloatResult", 8D, new Object[]{(double)2,(double)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(byte)2,(byte)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(byte)2,(short)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(byte)2,(short)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(byte)2,4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(byte)2,4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(byte)2,(long)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(byte)2,(long)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(byte)2,(float)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(byte)2,(float)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(byte)2,(double)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(byte)2,(double)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(short)2,(byte)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(short)2,(byte)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(short)2,(short)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(short)2,(short)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(short)2,4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(short)2,4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(short)2,(long)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(short)2,(long)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(short)2,(float)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(short)2,(float)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(short)2,(double)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(short)2,(double)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{2,(byte)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{2,(byte)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{2,(short)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{2,(short)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{2,4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{2,4});
        testCall(tc, "testDoubleDouble", null, new Object[]{2,(long)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{2,(long)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{2,(float)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{2,(float)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{2,(double)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{2,(double)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(long)2,(byte)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(long)2,(byte)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(long)2,(short)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(long)2,(short)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(long)2,4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(long)2,4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(long)2,(long)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(long)2,(long)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(long)2,(float)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(long)2,(float)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(long)2,(double)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(long)2,(double)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(float)2,(byte)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(float)2,(byte)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(float)2,(short)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(float)2,(short)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(float)2,4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(float)2,4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(float)2,(long)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(float)2,(long)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(float)2,(float)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(float)2,(float)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(float)2,(double)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(float)2,(double)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(double)2,(byte)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(double)2,(byte)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(double)2,(short)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(double)2,(short)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(double)2,4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(double)2,4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(double)2,(long)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(double)2,(long)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(double)2,(float)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(double)2,(float)4});
        testCall(tc, "testDoubleDouble", null, new Object[]{(double)2,(double)4});
        testCall(tc, "testDoubleDoubleResult", 8D, new Object[]{(double)2,(double)4});
    }

    @BeforeEach
    public void setUp() {
        JUnitUtil.setUp();
    }

    @AfterEach
    public void tearDown() {
        JUnitUtil.tearDown();
    }


    private static class MyExpressionNode implements ExpressionNode {

        private final Object _value;

        private MyExpressionNode(Object value) {
            _value = value;
        }

        @Override
        public Object calculate(SymbolTable symbolTable) throws JmriException {
            return _value;
        }

        @Override
        public String getDefinitionString() {
            throw new UnsupportedOperationException("Not supported yet.");
        }

    }


    public static class TestClass {

        public void testByteByte(byte a, byte b) { }
        public long testByteByteResult(byte a, byte b) { return 1L * a*b; }
        public void testByteShort(byte a, short b) { }
        public long testByteShortResult(byte a, short b) { return 1L * a*b; }
        public void testByteInteger(byte a, int b) { }
        public long testByteIntegerResult(byte a, int b) { return 1L * a*b; }
        public void testByteLong(byte a, long b) { }
        public long testByteLongResult(byte a, long b) { return 1L * a*b; }
        public void testByteFloat(byte a, float b) { }
        public double testByteFloatResult(byte a, float b) { return a*b; }
        public void testByteDouble(byte a, double b) { }
        public double testByteDoubleResult(byte a, double b) { return a*b; }
        public void testShortByte(short a, byte b) { }
        public long testShortByteResult(short a, byte b) { return 1L * a*b; }
        public void testShortShort(short a, short b) { }
        public long testShortShortResult(short a, short b) { return 1L * a*b; }
        public void testShortInteger(short a, int b) { }
        public long testShortIntegerResult(short a, int b) { return 1L * a*b; }
        public void testShortLong(short a, long b) { }
        public long testShortLongResult(short a, long b) { return 1L * a*b; }
        public void testShortFloat(short a, float b) { }
        public double testShortFloatResult(short a, float b) { return a*b; }
        public void testShortDouble(short a, double b) { }
        public double testShortDoubleResult(short a, double b) { return a*b; }
        public void testIntegerByte(int a, byte b) { }
        public long testIntegerByteResult(int a, byte b) { return 1L * a*b; }
        public void testIntegerShort(int a, short b) { }
        public long testIntegerShortResult(int a, short b) { return 1L * a*b; }
        public void testIntegerInteger(int a, int b) { }
        public long testIntegerIntegerResult(int a, int b) { return 1L * a*b; }
        public void testIntegerLong(int a, long b) { }
        public long testIntegerLongResult(int a, long b) { return 1L * a*b; }
        public void testIntegerFloat(int a, float b) { }
        public double testIntegerFloatResult(int a, float b) { return a*b; }
        public void testIntegerDouble(int a, double b) { }
        public double testIntegerDoubleResult(int a, double b) { return a*b; }
        public void testLongByte(long a, byte b) { }
        public long testLongByteResult(long a, byte b) { return 1L * a*b; }
        public void testLongShort(long a, short b) { }
        public long testLongShortResult(long a, short b) { return 1L * a*b; }
        public void testLongInteger(long a, int b) { }
        public long testLongIntegerResult(long a, int b) { return 1L * a*b; }
        public void testLongLong(long a, long b) { }
        public long testLongLongResult(long a, long b) { return 1L * a*b; }
        public void testLongFloat(long a, float b) { }
        public double testLongFloatResult(long a, float b) { return a*b; }
        public void testLongDouble(long a, double b) { }
        public double testLongDoubleResult(long a, double b) { return a*b; }
        public void testFloatByte(float a, byte b) { }
        public double testFloatByteResult(float a, byte b) { return a*b; }
        public void testFloatShort(float a, short b) { }
        public double testFloatShortResult(float a, short b) { return a*b; }
        public void testFloatInteger(float a, int b) { }
        public double testFloatIntegerResult(float a, int b) { return a*b; }
        public void testFloatLong(float a, long b) { }
        public double testFloatLongResult(float a, long b) { return a*b; }
        public void testFloatFloat(float a, float b) { }
        public double testFloatFloatResult(float a, float b) { return a*b; }
        public void testFloatDouble(float a, double b) { }
        public double testFloatDoubleResult(float a, double b) { return a*b; }
        public void testDoubleByte(double a, byte b) { }
        public double testDoubleByteResult(double a, byte b) { return a*b; }
        public void testDoubleShort(double a, short b) { }
        public double testDoubleShortResult(double a, short b) { return a*b; }
        public void testDoubleInteger(double a, int b) { }
        public double testDoubleIntegerResult(double a, int b) { return a*b; }
        public void testDoubleLong(double a, long b) { }
        public double testDoubleLongResult(double a, long b) { return a*b; }
        public void testDoubleFloat(double a, float b) { }
        public double testDoubleFloatResult(double a, float b) { return a*b; }
        public void testDoubleDouble(double a, double b) { }
        public double testDoubleDoubleResult(double a, double b) { return a*b; }
    }

}