Serge NOEL
1750 lines
126 KiB
Java
1750 lines
126 KiB
Java
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; }
|
|
}
|
|
|
|
}
|