/**
 * Copyright (c) 2014 committers of YAKINDU and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     committers of YAKINDU - initial API and implementation
 */
package org.yakindu.sct.model.sexec.interpreter.test;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.yakindu.sct.simulation.core.sexec.interpreter.CoreFunction;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EcoreFactory;

/**
 * 
 * @author florian antony
 * 
 */
public class CoreFunctionTest {

	private CoreFunction cFunction;
	private double delta = 0.001;

	@Before
	public void setUp() throws Exception {
		cFunction = new CoreFunction();
	}

	@After
	public void tearDown() throws Exception {
		cFunction = null;
	}

	@Test
	public void testPlusIntegerInteger() {
		int expected = 10;
		int actual = cFunction.plus(5, 5);
		assertEquals(expected, actual);
	}

	@Test
	public void testPlusFloatFloat() {
		float expected = 10.6F;
		float actual = cFunction.plus(5.3F, 5.3F);
		assertEquals(expected, actual, delta);

	}

	@Test
	public void testPlusDoubleDouble() {
		double expected = 10.6;
		double actual = cFunction.plus(5.3, 5.3);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testPlusLongLong() {
		long expected = 10;
		long actual = cFunction.plus(5L, 5L);
		assertEquals(expected, actual);
	}

	@Test
	public void testPlusIntegerFloat() {
		float expected = 10.3F;
		float actual = cFunction.plus(5, 5.3F);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testPlusIntegerDouble() {
		double expected = 10.3;
		double actual = cFunction.plus(5, 5.3);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testPlusIntegerLong() {
		long expected = 10;
		long actual = cFunction.plus(5, 5L);
		assertEquals(expected, actual);
	}

	@Test
	public void testPlusFloatInteger() {
		float expected = 10.3F;
		float actual = cFunction.plus(5.3F, 5);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testPlusFloatDouble() {
		double expected = 10.6;
		double actual = cFunction.plus(5.3F, 5.3);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testPlusFloatLong() {
		double expected = 10.3;
		double actual = cFunction.plus(5.3F, 5L);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testPlusDoubleInteger() {
		double expected = 10.6;
		double actual = cFunction.plus(5.6, 5);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testPlusDoubleFloat() {
		double expected = 10.6;
		double actual = cFunction.plus(5.3D, 5.3F);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testPlusDoubleLong() {
		double expected = 10.3;
		double actual = cFunction.plus(5.3, 5L);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testPlusLongInteger() {
		long expected = 10;
		long actual = cFunction.plus(5L, 5);
		assertEquals(expected, actual);
	}

	@Test
	public void testPlusLongFloat() {
		float expected = 10;
		float actual = cFunction.plus(5L, 5.0f);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testPlusLongDouble() {
		double expected = 10;
		double actual = cFunction.plus(5L, 5.0d);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testPositiveInteger() {
		int expected = 10;
		int actual = cFunction.positive(10);
		assertEquals(expected, actual);
	}

	@Test
	public void testPositiveFloat() {
		float expected = 10.3F;
		float actual = cFunction.positive(10.3F);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testPositiveLong() {
		long expected = 10;
		long actual = cFunction.positive(10L);
		assertEquals(expected, actual);
	}

	@Test
	public void testPositiveDouble() {
		double expected = 10.3D;
		double actual = cFunction.positive(10.3D);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testPositiveBoolean() {
		boolean expected = true;
		boolean actual = cFunction.positive(true);
		assertEquals(expected, actual);
	}

	@Test
	public void testPositiveString() {
		String expected = "positive";
		String actual = cFunction.positive("positive");
		assertEquals(expected, actual);
	}

	@Test
	public void testNegativeInteger() {
		int expected = -10;
		int actual = cFunction.negative(10);
		assertEquals(expected, actual);
	}

	@Test
	public void testNegativeFloat() {
		float expected = -10.3F;
		float actual = cFunction.negative(10.3F);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testNegativeDouble() {
		double expected = -10.3;
		double actual = cFunction.negative(10.3);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testNegativeLong() {
		long expected = 10L;
		long actual = cFunction.negative(-10L);
		assertEquals(expected, actual);
	}

	@Test
	public void testMinusIntegerInteger() {
		int expected = 5;
		int actual = cFunction.minus(10, 5);
		assertEquals(expected, actual);
	}

	@Test
	public void testMinusFloatFloat() {
		float expected = 5.3F;
		float actual = cFunction.minus(10.3F, 5.0F);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testMinusDoubleDouble() {
		double expected = 5.3;
		double actual = cFunction.minus(10.6, 5.3);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testMinusLongLong() {
		long expected = 5L;
		long actual = cFunction.minus(10L, 5L);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testMinusIntegerFloat() {
		float expected = 4.7F;
		float actual = cFunction.minus(10, 5.3F);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testMinusIntegerDouble() {
		double expected = 4.7;
		double actual = cFunction.minus(10, 5.3D);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testMinusIntegerLong() {
		long expected = 5L;
		long actual = cFunction.minus(10, 5L);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testMinusFloatInteger() {
		float expected = 5.3F;
		float actual = cFunction.minus(10.3F, 5);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testMinusFloatDouble() {
		double expected = 5.0;
		double actual = cFunction.minus(10.3F, 5.3D);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testMinusFloatLong() {
		float expected = 5.3f;
		float actual = cFunction.minus(10.3f, 5L);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testMinusDoubleInteger() {
		double expected = 5.3;
		double actual = cFunction.minus(10.3, 5);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testMinusDoubleFloat() {
		double expected = 5.0;
		double actual = cFunction.minus(10.3, 5.3F);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testMinusDoubleLong() {
		double expected = 5.3;
		double actual = cFunction.minus(10.3, 5L);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testMinusLongInteger() {
		long expected = 5L;
		long actual = cFunction.minus(10L, 5);
		assertEquals(expected, actual);
	}

	@Test
	public void testMinusLongDouble() {
		double expected = 5L;
		double actual = cFunction.minus(10L, 5.0d);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testMinusLongFloat() {
		float expected = 5L;
		float actual = cFunction.minus(10L, 5.0f);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testMulIntegerInteger() {
		int expected = 25;
		int actual = cFunction.mul(5, 5);
		assertEquals(expected, actual);
	}

	@Test
	public void testMulFloatFloat() {
		float expected = 25.0F;
		float actual = cFunction.mul(5.0F, 5.0F);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testMulDoubleDouble() {
		double expected = 25.0;
		double actual = cFunction.mul(5.0, 5.0);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testMulLongLong() {
		long expected = 25L;
		long actual = cFunction.mul(5L, 5L);
		assertEquals(expected, actual);
	}

	@Test
	public void testMulIntegerFloat() {
		float expected = 25.0F;
		float actual = cFunction.mul(5, 5.0F);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testMulIntegerDouble() {
		double expected = 25.0;
		double actual = cFunction.mul(5, 5.0D);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testMulIntegerLong() {
		long expected = 25L;
		long actual = cFunction.mul(5, 5L);
		assertEquals(expected, actual);
	}

	@Test
	public void testMulFloatInteger() {
		float expected = 25.0F;
		float actual = cFunction.mul(5.0F, 5);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testMulFloatDouble() {
		double expected = 25.0;
		double actual = cFunction.mul(5.0F, 5.0);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testMulFloatLong() {
		double expected = 25.0;
		double actual = cFunction.mul(5.0F, 5L);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testMulDoubleInteger() {
		double expected = 25.0;
		double actual = cFunction.mul(5.0, 5);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testMulDoubleFloat() {
		double expected = 25.0;
		double actual = cFunction.mul(5.0, 5.0F);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testMulDoubleLong() {
		double expected = 25.0;
		double actual = cFunction.mul(5.0, 5L);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testMulLongInteger() {
		long expected = 25L;
		long actual = cFunction.mul(5L, 5);
		assertEquals(expected, actual);
	}

	@Test
	public void testMulLongFloat() {
		float expected = 25f;
		float actual = cFunction.mul(5L, 5.0f);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testMulLongDouble() {
		double expected = 25L;
		double actual = cFunction.mul(5L, 5.0d);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testDivIntegerInteger() {
		int expected = 5;
		int actual = cFunction.div(25, 5);
		assertEquals(expected, actual);
	}

	@Test
	public void testDivFloatFloat() {
		float expected = 5.0F;
		float actual = cFunction.div(25.0F, 5.0F);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testDivDoubleDouble() {
		double expected = 5.0;
		double actual = cFunction.div(25.0, 5.0);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testDivLongLong() {
		long expected = 5L;
		long actual = cFunction.div(25L, 5L);
		assertEquals(expected, actual);
	}

	@Test
	public void testDivIntegerFloat() {
		float expected = 5.0F;
		float actual = cFunction.div(25, 5.0F);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testDivIntegerDouble() {
		double expected = 5.0;
		double actual = cFunction.div(25, 5.0D);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testDivIntegerLong() {
		long expected = 5L;
		long actual = cFunction.div(25, 5L);
		assertEquals(expected, actual);
	}

	@Test
	public void testDivFloatInteger() {
		float expected = 5.0F;
		float actual = cFunction.div(25.0F, 5);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testDivFloatDouble() {
		double expected = 5.0d;
		double actual = cFunction.div(25.0F, 5.0);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testDivFloatLong() {
		float expected = 5.0f;
		float actual = cFunction.div(25.0F, 5L);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testDivDoubleInteger() {
		double expected = 5.0;
		double actual = cFunction.div(25.0, 5);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testDivDoubleFloat() {
		double expected = 5.0;
		double actual = cFunction.div(25.0, 5.0F);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testDivDoubleLong() {
		double expected = 5.0;
		double actual = cFunction.div(25.0, 5L);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testDivLongInteger() {
		long expected = 5L;
		long actual = cFunction.div(25L, 5);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testDivLongFloat() {
		float expected = 5f;
		float actual = cFunction.div(25L, 5.0f);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testDivLongDouble() {
		double expected = 5d;
		double actual = cFunction.div(25L, 5.0D);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testModIntegerInteger() {
		int expected = 0;
		int actual = cFunction.mod(5, 5);
		assertEquals(expected, actual);
	}

	@Test
	public void testModFloatFloat() {
		float expected = 0.0F;
		float actual = cFunction.mod(5.0F, 5.0F);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testModDoubleDouble() {
		double expected = 0.0;
		double actual = cFunction.mod(5.0, 5.0);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testModLongLong() {
		long expected = 0L;
		long actual = cFunction.mod(5L, 5L);
		assertEquals(expected, actual);
	}

	@Test
	public void testModIntegerFloat() {
		float expected = 0.0F;
		float actual = cFunction.mod(5, 5.0F);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testModIntegerDouble() {
		double expected = 0.0;
		double actual = cFunction.mod(5, 5.0);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testModIntegerLong() {
		long expected = 0L;
		long actual = cFunction.mod(5, 5L);
		assertEquals(expected, actual);
	}

	@Test
	public void testModFloatInteger() {
		float expected = 0.0F;
		float actual = cFunction.mod(5.0F, 5);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testModFloatDouble() {
		double expected = 0.0;
		double actual = cFunction.mod(5.0F, 5.0);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testModFloatLong() {
		float expected = 0.2f;
		float actual = cFunction.mod(5.2F, 5L);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testModDoubleInteger() {
		double expected = 0.0;
		double actual = cFunction.mod(5.0, 5);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testModDoubleFloat() {
		double expected = 0.0;
		double actual = cFunction.mod(5.0D, 5.0F);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testModDoubleLong() {
		double expected = 0.0;
		double actual = cFunction.mod(5.0, 5L);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testModLongInteger() {
		long expected = 0L;
		double actual = cFunction.mod(5L, 5);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testModLongFloat() {
		long expected = 0L;
		double actual = cFunction.mod(5L, 5.0f);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testModLongDouble() {
		long expected = 0L;
		double actual = cFunction.mod(5L, 5.0d);
		assertEquals(expected, actual, delta);
	}

	@Test
	public void testLeftIntegerInteger() {
		int expected = 20;
		int actual = cFunction.left(10, 1);
		assertEquals(expected, actual);
	}

	@Test
	public void testLeftLongLong() {
		long expected = 20;
		long actual = cFunction.left(10l, 1l);
		assertEquals(expected, actual);
	}

	@Test
	public void testLeftLongInteger() {
		long expected = 20;
		long actual = cFunction.left(10l, 1);
		assertEquals(expected, actual);
	}

	@Test
	public void testLeftIntegerLong() {
		int expected = 20;
		int actual = cFunction.left(10, 1l);
		assertEquals(expected, actual);
	}

	@Test
	public void testRightLongLong() {
		long expected = 5;
		long actual = cFunction.right(10L, 1L);
		assertEquals(expected, actual);
	}

	@Test
	public void testRightLongInteger() {
		long expected = 5;
		long actual = cFunction.right(10L, 1);
		assertEquals(expected, actual);
	}

	@Test
	public void testRightIntegerLong() {
		int expected = 5;
		int actual = cFunction.right(10, 1L);
		assertEquals(expected, actual);
	}
	
	@Test
	public void testRightIntegerInteger() {
		int expected = 5;
		int actual = cFunction.right(10, 1);
		assertEquals(expected, actual);
	}

	@Test
	public void testBitwiseAnd() {
		int expected = 0;
		int actual = cFunction.bitwiseAnd(5, 2);
		assertEquals(expected, actual);
	}
	
	@Test
	public void testBitwiseAndIntegerInteger() {
		int expected = 1;
		int actual = cFunction.bitwiseAnd(5, 3);
		assertEquals(expected, actual);
	}
	
	@Test
	public void testBitwiseAndLongLong() {
		long expected = 1L;
		long actual = cFunction.bitwiseAnd(5L, 3L);
		assertEquals(expected, actual);
	}
	
	@Test
	public void testBitwiseAndLongInteger() {
		long expected = 1L;
		long actual = cFunction.bitwiseAnd(5L, 3);
		assertEquals(expected, actual);
	}
	
	@Test
	public void testBitwiseAndIntegerLong() {
		long expected = 1L;
		long actual = cFunction.bitwiseAnd(5, 3L);
		assertEquals(expected, actual);
	}
	
	@Test
	public void testBitwiseOr() {
		int expected = 7;
		int actual = cFunction.bitwiseOr(5, 2);
		assertEquals(expected, actual);
	}
	
	@Test
	public void testBitwiseOrIntegerInteger() {
		int expected = 7;
		int actual = cFunction.bitwiseOr(5, 3);
		assertEquals(expected, actual);
	}

	@Test
	public void testBitwiseOrLongLong() {
		long expected = 7L;
		long actual = cFunction.bitwiseOr(5L, 3L);
		assertEquals(expected, actual);
	}
	
	@Test
	public void testBitwiseOrLongInteger() {
		long expected = 7L;
		long actual = cFunction.bitwiseOr(5L, 3);
		assertEquals(expected, actual);
	}
	
	@Test
	public void testBitwiseOrIntegerLong() {
		long expected = 7L;
		long actual = cFunction.bitwiseOr(5, 3L);
		assertEquals(expected, actual);
	}
	
	@Test
	public void testBitwiseXorIntegerInteger() {
		int expected = 6;
		int actual = cFunction.bitwiseXor(5, 3);
		assertEquals(expected, actual);
	}

	@Test
	public void testBitwiseXorLongLong() {
		long expected = 6L;
		long actual = cFunction.bitwiseXor(5L, 3L);
		assertEquals(expected, actual);
	}
	
	@Test
	public void testBitwiseXorLongInteger() {
		long expected = 6L;
		long actual = cFunction.bitwiseXor(5L, 3);
		assertEquals(expected, actual);
	}
	
	@Test
	public void testBitwiseXorIntegerLong() {
		long expected = 6L;
		long actual = cFunction.bitwiseXor(5, 3L);
		assertEquals(expected, actual);
	}

	@Test
	public void testEqualsBooleanBoolean() {
		assertFalse(cFunction.equals(true, false));
		assertTrue(cFunction.equals(true, true));
	}

	@Test
	public void testEqualsObjectObject() {
		Object obj1 = new Object();
		assertTrue(cFunction.equals(obj1, obj1));
		assertFalse(cFunction.equals(obj1, null));
		assertFalse(cFunction.equals(null, obj1));
		assertFalse(cFunction.equals(new Object(), new Object()));
	}
	
	@Test
	public void testEqualsEObjectEObject() {
		EObject obj1 = EcoreFactory.eINSTANCE.createEObject();
		assertTrue(cFunction.equals(obj1, obj1));
		assertFalse(cFunction.equals(obj1, null));
		assertFalse(cFunction.equals(null, obj1));
		assertTrue(cFunction.equals(EcoreFactory.eINSTANCE.createEObject(), EcoreFactory.eINSTANCE.createEObject()));
	}

	@Test
	public void testEqualsStringString() {
		String test = "test";
		assertTrue(cFunction.equals(test, "test"));
		assertFalse(cFunction.equals(test, "test2"));
	}

	@Test
	public void testEqualsIntegerInteger() {
		assertTrue(cFunction.equals(1, 1));
		assertFalse(cFunction.equals(1, 2));
	}

	@Test
	public void testEqualsFloatFloat() {
		assertTrue(cFunction.equals(1.3F, 1.3F));
		assertFalse(cFunction.equals(1.31F, 1.3F));
	}

	@Test
	public void testEqualsDoubleDouble() {
		assertTrue(cFunction.equals(1.5, 1.5));
		assertFalse(cFunction.equals(1.3, 1.31));
	}

	@Test
	public void testEqualsLongLong() {
		assertTrue(cFunction.equals(10L, 10L));
		assertFalse(cFunction.equals(11L, 10L));
	}

	@Test
	public void testEqualsIntegerFloat() {
		assertTrue(cFunction.equals(1, 1.0F));
		assertFalse(cFunction.equals(1, 1.1F));
	}

	@Test
	public void testEqualsIntegerDouble() {
		assertTrue(cFunction.equals(1, 1.0));
		assertFalse(cFunction.equals(1, 1.1));
	}

	@Test
	public void testEqualsIntegerLong() {
		assertTrue(cFunction.equals(1, 1L));
		assertFalse(cFunction.equals(1, 2L));
	}

	@Test
	public void testEqualsFloatInteger() {
		assertTrue(cFunction.equals(1.0F, 1));
		assertFalse(cFunction.equals(1.1F, 1));
	}

	@Test
	public void testEqualsLongFloat() {
		assertTrue(cFunction.equals(1L, 1F));
		assertFalse(cFunction.equals(1L, 1.01F));
	}

	@Test
	public void testEqualsLongDouble() {
		assertTrue(cFunction.equals(1L, 1D));
		assertFalse(cFunction.equals(1L, 1.01D));
	}

	@Test
	public void testEqualsFloatDouble() {
		assertTrue(cFunction.equals(1.0F, 1.0));
		assertTrue(cFunction.equals(1.5F, 1.5));
		// Since Java and C are not able to compare
		// float and double values with absolute precision -> 1.3F != 1.3
		assertFalse(cFunction.equals(1.3F, 1.3));
	}

	@Test
	public void testEqualsFloatLong() {
		assertTrue(cFunction.equals(1.0F, 1L));
		assertFalse(cFunction.equals(1.1F, 1L));
		// Since Java and C are not able to compare
		// float and double values with absolute precision -> 1.3F != 1.3
		assertFalse(cFunction.equals(1.3F, 1.3));
	}

	@Test
	public void testEqualsDoubleInteger() {
		assertTrue(cFunction.equals(1.0, 1));
		assertFalse(cFunction.equals(1.1, 1));
	}

	@Test
	public void testEqualsDoubleFloat() {
		// Since Java and C are not able to compare
		// float and double values with absolute precision -> 1.3 != 1.3F
		assertFalse(cFunction.equals(1.3, 1.3F));

		assertTrue(cFunction.equals(1.5, 1.5F));
	}

	@Test
	public void testEqualsDoubleLong() {
		assertTrue(cFunction.equals(1.0, 1L));
		assertFalse(cFunction.equals(1.1, 1L));
	}

	@Test
	public void testEqualsLongInteger() {
		assertTrue(cFunction.equals(1L, 1));
		assertFalse(cFunction.equals(1L, 2));
	}

	@Test
	public void testNotEqualsBooleanBoolean() {
		assertTrue(cFunction.notEquals(true, false));
		assertFalse(cFunction.notEquals(true, true));
	}

	@Test
	public void testNotEqualsStringString() {
		assertTrue(cFunction.notEquals("Hans", "Wurst"));
		assertFalse(cFunction.notEquals("Hans", "Hans"));
	}

	@Test
	public void testNotEqualsIntegerInteger() {
		assertTrue(cFunction.notEquals(1, 2));
		assertFalse(cFunction.notEquals(1, 1));
	}

	@Test
	public void testNotEqualsFloatFloat() {
		assertTrue(cFunction.notEquals(1.2F, 1.3F));
		assertFalse(cFunction.notEquals(1.1F, 1.1F));
	}

	@Test
	public void testNotEqualsDoubleDouble() {
		assertTrue(cFunction.notEquals(1.2, 1.3));
		assertFalse(cFunction.notEquals(1.2, 1.2));
	}

	@Test
	public void testNotEqualsLongLong() {
		assertTrue(cFunction.notEquals(1L, 2L));
		assertFalse(cFunction.notEquals(1L, 1L));
	}

	@Test
	public void testNotEqualsIntegerFloat() {
		assertTrue(cFunction.notEquals(1, 1.1F));
		assertFalse(cFunction.notEquals(1, 1.0F));
	}

	@Test
	public void testNotEqualsIntegerDouble() {
		assertTrue(cFunction.notEquals(1, 1.1));
		assertFalse(cFunction.notEquals(1, 1.0));
	}
	
	@Test
	public void testNotEqualsLongFloat() {
		assertTrue(cFunction.notEquals(1L, 1.1F));
		assertFalse(cFunction.notEquals(1L, 1.0F));
	}
	
	@Test
	public void testNotEqualsLongDouble() {
		assertTrue(cFunction.notEquals(1L, 1.1D));
		assertFalse(cFunction.notEquals(1L, 1.0D));
	}

	@Test
	public void testNotEqualsObjectObject() {
		Object obj1 = new Object();
		assertFalse(cFunction.notEquals(obj1, obj1));
		assertTrue(cFunction.notEquals(obj1, null));
		assertTrue(cFunction.notEquals(null, obj1));
		assertTrue(cFunction.notEquals(new Object(), new Object()));
	}
	
	@Test
	public void testNotEqualsEObjectEObject() {
		EObject obj1 = EcoreFactory.eINSTANCE.createEObject();
		assertFalse(cFunction.notEquals(obj1, obj1));
		assertTrue(cFunction.notEquals(obj1, null));
		assertTrue(cFunction.notEquals(null, obj1));
		assertFalse(cFunction.notEquals(EcoreFactory.eINSTANCE.createEObject(), EcoreFactory.eINSTANCE.createEObject()));
	}

	@Test
	public void testNotEqualsIntegerLong() {
		assertTrue(cFunction.notEquals(1, 2L));
		assertFalse(cFunction.notEquals(1, 1L));
	}

	@Test
	public void testNotEqualsFloatInteger() {
		assertTrue(cFunction.notEquals(1.1F, 1));
		assertFalse(cFunction.notEquals(1.0F, 1));
	}

	@Test
	public void testNotEqualsFloatDouble() {
		assertTrue(cFunction.notEquals(1.01F, 1.02));
		assertFalse(cFunction.notEquals(1.5F, 1.5));
	}

	@Test
	public void testNotEqualsFloatLong() {
		assertFalse(cFunction.notEquals(1.0F, 1L));
		assertTrue(cFunction.notEquals(1.5F, 1L));
	}

	@Test
	public void testNotEqualsDoubleInteger() {
		assertTrue(cFunction.notEquals(1.01, 1));
		assertFalse(cFunction.notEquals(1.0, 1));
	}

	@Test
	public void testNotEqualsDoubleFloat() {
		assertTrue(cFunction.notEquals(1.01, 1.02F));
		assertFalse(cFunction.notEquals(1.5, 1.5F));
	}

	@Test
	public void testNotEqualsDoubleLong() {
		assertTrue(cFunction.notEquals(1.01, 1L));
		assertFalse(cFunction.notEquals(1.0, 1L));
	}

	@Test
	public void testNotEqualsLongInteger() {
		assertTrue(cFunction.notEquals(1L, 2));
		assertFalse(cFunction.notEquals(1L, 1));
	}

	@Test
	public void testGreaterEqualIntegerInteger() {
		assertTrue(cFunction.greaterEqual(1, 1));
		assertTrue(cFunction.greaterEqual(2, 1));
		assertFalse(cFunction.greaterEqual(1, 2));
	}

	@Test
	public void testGreaterEqualFloatFloat() {
		assertTrue(cFunction.greaterEqual(1.0F, 1.0F));
		assertTrue(cFunction.greaterEqual(1.1F, 1F));
		assertFalse(cFunction.greaterEqual(1F, 1.1F));
	}

	@Test
	public void testGreaterEqualDoubleDouble() {
		assertTrue(cFunction.greaterEqual(1.0, 1.0));
		assertTrue(cFunction.greaterEqual(1.1, 1));
		assertFalse(cFunction.greaterEqual(1.0, 1.1));
	}

	@Test
	public void testGreaterEqualLongLong() {
		assertTrue(cFunction.greaterEqual(1L, 1L));
		assertTrue(cFunction.greaterEqual(2L, 1L));
		assertFalse(cFunction.greaterEqual(1L, 2L));
	}

	@Test
	public void testGreaterEqualIntegerFloat() {
		assertTrue(cFunction.greaterEqual(1, 1.0F));
		assertTrue(cFunction.greaterEqual(2, 1.0F));
		assertFalse(cFunction.greaterEqual(1, 1.1F));
	}

	@Test
	public void testGreaterEqualIntegerDouble() {
		assertTrue(cFunction.greaterEqual(1, 1.0));
		assertTrue(cFunction.greaterEqual(2, 1.0));
		assertFalse(cFunction.greaterEqual(1, 1.1));
	}

	@Test
	public void testGreaterEqualIntegerLong() {
		assertTrue(cFunction.greaterEqual(1, 1L));
		assertTrue(cFunction.greaterEqual(2, 1L));
		assertFalse(cFunction.greaterEqual(1, 2L));
	}

	@Test
	public void testGreaterEqualFloatInteger() {
		assertTrue(cFunction.greaterEqual(1.0F, 1));
		assertTrue(cFunction.greaterEqual(2.0F, 1));
		assertFalse(cFunction.greaterEqual(1.0F, 2));
	}

	@Test
	public void testGreaterEqualFloatDouble() {
		assertTrue(cFunction.greaterEqual(1.0f, 1.0D));
		assertTrue(cFunction.greaterEqual(2.0f, 1.0D));
		assertFalse(cFunction.greaterEqual(1.0f, 1.1D));
	}
	
	@Test
	public void testGreaterEqualFloatLong() {
		assertTrue(cFunction.greaterEqual(1.0f, 1L));
		assertTrue(cFunction.greaterEqual(2.0f, 1L));
		assertFalse(cFunction.greaterEqual(0.9f, 1L));
	}


	@Test
	public void testGreaterEqualDoubleInteger() {		
		assertTrue(cFunction.greaterEqual(1.0, 1));
		assertTrue(cFunction.greaterEqual(1.1, 1));
		assertFalse(cFunction.greaterEqual(1.0, 2));
	}

	@Test
	public void testGreaterEqualDoubleFloat() {
		assertTrue(cFunction.greaterEqual(1.0, 1.0F));
		assertTrue(cFunction.greaterEqual(1.1, 1.0F));
		assertFalse(cFunction.greaterEqual(1.0, 1.1F));
	}

	@Test
	public void testGreaterEqualDoubleLong() {
		assertTrue(cFunction.greaterEqual(1.0, 1L));
		assertTrue(cFunction.greaterEqual(1.1, 1L));
		assertFalse(cFunction.greaterEqual(1.9, 2L));
	}

	@Test
	public void testGreaterEqualLongInteger() {
		assertTrue(cFunction.greaterEqual(1L, 1));
		assertTrue(cFunction.greaterEqual(1L, 0));
		assertFalse(cFunction.greaterEqual(1L, 2));
	}
	
	@Test
	public void testGreaterEqualLongFloat() {
		assertTrue(cFunction.greaterEqual(1L, 1.0f));
		assertTrue(cFunction.greaterEqual(1L, 0.0f));
		assertFalse(cFunction.greaterEqual(1L, 2.0f));
	}
	
	@Test
	public void testGreaterEqualLongDouble() {
		assertTrue(cFunction.greaterEqual(1L, 1.0d));
		assertTrue(cFunction.greaterEqual(1L, 0.0d));
		assertFalse(cFunction.greaterEqual(1L, 2.0d));
	}

	@Test
	public void testSmallerEqualIntegerInteger() {
		assertTrue(cFunction.smallerEqual(1, 1));
		assertTrue(cFunction.smallerEqual(1, 2));
		assertFalse(cFunction.smallerEqual(2, 1));
	}

	@Test
	public void testSmallerEqualFloatFloat() {
		assertTrue(cFunction.smallerEqual(1.0F, 1.0F));
		assertTrue(cFunction.smallerEqual(1.0F, 1.1F));
		assertFalse(cFunction.smallerEqual(1.1F, 1.0F));
	}

	@Test
	public void testSmallerEqualDoubleDouble() {
		assertTrue(cFunction.smallerEqual(1.0, 1.0));
		assertTrue(cFunction.smallerEqual(1.0, 1.1));
		assertFalse(cFunction.smallerEqual(1.1, 1.0));
	}

	@Test
	public void testSmallerEqualLongLong() {
		assertTrue(cFunction.smallerEqual(1L, 1L));
		assertTrue(cFunction.smallerEqual(1L, 2L));
		assertFalse(cFunction.smallerEqual(2l, 1L));
	}

	@Test
	public void testSmallerEqualIntegerFloat() {
		assertTrue(cFunction.smallerEqual(1, 1.1F));
		assertTrue(cFunction.smallerEqual(1, 1.1F));
		assertFalse(cFunction.smallerEqual(1, 0.9F));
	}

	@Test
	public void testSmallerEqualIntegerDouble() {
		assertTrue(cFunction.smallerEqual(1, 1.1));
		assertTrue(cFunction.smallerEqual(1, 1.1));
		assertFalse(cFunction.smallerEqual(2, 1.9));
	}

	@Test
	public void testSmallerEqualIntegerLong() {
		assertTrue(cFunction.smallerEqual(1, 1L));
		assertTrue(cFunction.smallerEqual(1, 2L));
		assertFalse(cFunction.smallerEqual(2, 1L));
	}

	@Test
	public void testSmallerEqualFloatInteger() {
		assertTrue(cFunction.smallerEqual(1.0F, 1));
		assertTrue(cFunction.smallerEqual(1.9F, 2));
		assertFalse(cFunction.smallerEqual(1.9F, 1));
	}
	
	@Test
	public void testSmallerEqualFloatLong() {
		assertTrue(cFunction.smallerEqual(1.0F, 1L));
		assertTrue(cFunction.smallerEqual(1.9F, 2L));
		assertFalse(cFunction.smallerEqual(1.9F, 1L));
	}

	@Test
	public void testSmallerEqualFloatDouble() {
		assertTrue(cFunction.smallerEqual(1.0F, 1.0));
		assertTrue(cFunction.smallerEqual(1.5F, 1.5));
		assertTrue(cFunction.smallerEqual(1.1F, 1.2));
		// Since Java and C are not able to compare
		// float and double values with absolute precision -> 1.2 ! <= 1.2F
		assertFalse(cFunction.smallerEqual(1.2F, 1.2));
		assertFalse(cFunction.smallerEqual(1.2F, 1.1));
	}

	@Test
	public void testSmallerEqualDoubleInteger() {
		assertTrue(cFunction.smallerEqual(1.0, 1));
		assertTrue(cFunction.smallerEqual(1.9, 2));
		assertFalse(cFunction.smallerEqual(1.9, 1));
	}

	@Test
	public void testSmallerEqualDoubleFloat() {
		assertTrue(cFunction.smallerEqual(1.0, 1.0F));
		assertTrue(cFunction.smallerEqual(1.9, 2.0F));
		assertFalse(cFunction.smallerEqual(1.9, 1.0F));
	}

	@Test
	public void testSmallerEqualDoubleLong() {
		assertTrue(cFunction.smallerEqual(1.0, 1L));
		assertTrue(cFunction.smallerEqual(1.9, 2L));
		assertFalse(cFunction.smallerEqual(1.9, 1L));
	}

	@Test
	public void testSmallerEqualLongInteger() {
		assertTrue(cFunction.smallerEqual(1L, 1));
		assertTrue(cFunction.smallerEqual(1L, 2));
		assertFalse(cFunction.smallerEqual(2L, 1));
	}
	
	@Test
	public void testSmallerEqualLongFloat() {
		assertTrue(cFunction.smallerEqual(1L, 1.0F));
		assertTrue(cFunction.smallerEqual(1L, 2.0F));
		assertFalse(cFunction.smallerEqual(2L, 1.0F));
	}
	
	@Test
	public void testSmallerEqualLongDouble() {
		assertTrue(cFunction.smallerEqual(1L, 1.0D));
		assertTrue(cFunction.smallerEqual(1L, 2.0D));
		assertFalse(cFunction.smallerEqual(2L, 1.0D));
	}

	@Test
	public void testGreaterIntegerInteger() {
		assertTrue(cFunction.greater(2, 1));
		assertFalse(cFunction.greater(1, 1));
		assertFalse(cFunction.greater(1, 2));
	}

	@Test
	public void testGreaterFloatFloat() {
		assertTrue(cFunction.greater(1.1F, 1.0F));
		assertFalse(cFunction.greater(1.0F, 1.0F));
		assertFalse(cFunction.greater(1.0F, 1.1F));
	}

	@Test
	public void testGreaterDoubleDouble() {
		assertTrue(cFunction.greater(1.1, 1.0));
		assertFalse(cFunction.greater(1.0, 1.0));
		assertFalse(cFunction.greater(1.0, 1.1));
	}

	@Test
	public void testGreaterLongLong() {
		assertTrue(cFunction.greater(2L, 1L));
		assertFalse(cFunction.greater(1L, 1L));
		assertFalse(cFunction.greater(1L, 2L));
	}

	@Test
	public void testGreaterIntegerFloat() {
		assertTrue(cFunction.greater(2, 1.9F));
		assertFalse(cFunction.greater(1, 1.0F));
		assertFalse(cFunction.greater(1, 1.1F));
	}

	@Test
	public void testGreaterIntegerDouble() {
		assertTrue(cFunction.greater(1, 0.9));
		assertFalse(cFunction.greater(1, 1.0));
		assertFalse(cFunction.greater(1, 1.1));
	}

	@Test
	public void testGreaterIntegerLong() {
		assertTrue(cFunction.greater(2, 1L));
		assertFalse(cFunction.greater(1, 1L));
		assertFalse(cFunction.greater(1, 2L));
	}

	@Test
	public void testGreaterFloatInteger() {
		assertTrue(cFunction.greater(1.1F, 1));
		assertFalse(cFunction.greater(1.0F, 1));
		assertFalse(cFunction.greater(1.9F, 2));
	}

	@Test
	public void testGreaterFloatDouble() {
		assertTrue(cFunction.greater(1.1F, 1.0));
		assertFalse(cFunction.greater(1.0F, 1.0));
		assertFalse(cFunction.greater(1.0F, 1.1));
	}
	
	@Test
	public void testGreaterFloatLong() {
		assertTrue(cFunction.greater(1.1F, 1L));
		assertFalse(cFunction.greater(1.0F, 1L));
		assertFalse(cFunction.greater(1.0F, 2L));
	}

	@Test
	public void testGreaterDoubleInteger() {
		assertTrue(cFunction.greater(1.1, 1));
		assertFalse(cFunction.greater(1.0, 1));
		assertFalse(cFunction.greater(0.9, 1));
	}

	@Test
	public void testGreaterDoubleFloat() {
		assertTrue(cFunction.greater(1.1, 1.0F));
		assertFalse(cFunction.greater(1.0, 1.0F));
		assertFalse(cFunction.greater(1.0, 1.1F));
	}

	@Test
	public void testGreaterDoubleLong() {
		assertTrue(cFunction.greater(1.1, 1L));
		assertFalse(cFunction.greater(1.0, 1L));
		assertFalse(cFunction.greater(0.9, 1L));
	}

	@Test
	public void testGreaterLongInteger() {
		assertTrue(cFunction.greater(1L, 0));
		assertFalse(cFunction.greater(1L, 1));
		assertFalse(cFunction.greater(1L, 2));
	}
	
	@Test
	public void testGreaterLongFloat() {
		assertTrue(cFunction.greater(1L, 0.0F));
		assertFalse(cFunction.greater(1L, 1.0F));
		assertFalse(cFunction.greater(1L, 1.2F));
	}
	
	@Test
	public void testGreaterLongDouble() {
		assertTrue(cFunction.greater(1L, 0.0D));
		assertFalse(cFunction.greater(1L, 1.0D));
		assertFalse(cFunction.greater(1L, 2.0D));
	}

	@Test
	public void testSmallerIntegerInteger() {
		assertTrue(cFunction.smaller(1, 2));
		assertFalse(cFunction.smaller(1, 1));
		assertFalse(cFunction.smaller(2, 1));
	}

	@Test
	public void testSmallerFloatFloat() {
		assertTrue(cFunction.smaller(1.9F, 2.0F));
		assertFalse(cFunction.smaller(1.0F, 1.0F));
		assertFalse(cFunction.smaller(2.0F, 1.9F));
	}

	@Test
	public void testSmallerDoubleDouble() {
		assertTrue(cFunction.smaller(1.9, 2.0));
		assertFalse(cFunction.smaller(1.0, 1.0));
		assertFalse(cFunction.smaller(2.0, 1.9));
	}

	@Test
	public void testSmallerLongLong() {
		assertTrue(cFunction.smaller(1L, 2L));
		assertFalse(cFunction.smaller(1L, 1L));
		assertFalse(cFunction.smaller(2L, 1L));
	}

	@Test
	public void testSmallerIntegerFloat() {
		assertTrue(cFunction.smaller(1, 1.1F));
		assertFalse(cFunction.smaller(1, 1.0F));
		assertFalse(cFunction.smaller(2, 1.9F));
	}

	@Test
	public void testSmallerIntegerDouble() {
		assertTrue(cFunction.smaller(1, 1.1));
		assertFalse(cFunction.smaller(1, 1.0));
		assertFalse(cFunction.smaller(1, 0.9));
	}

	@Test
	public void testSmallerIntegerLong() {
		assertTrue(cFunction.smaller(1, 2L));
		assertFalse(cFunction.smaller(1, 1L));
		assertFalse(cFunction.smaller(2, 1L));
	}

	@Test
	public void testSmallerFloatInteger() {
		assertTrue(cFunction.smaller(1.9F, 2));
		assertFalse(cFunction.smaller(1.0F, 1));
		assertFalse(cFunction.smaller(1.1F, 1));
	}
	
	@Test
	public void testSmallerFloatLong() {
		assertTrue(cFunction.smaller(1.9F, 2L));
		assertFalse(cFunction.smaller(1.0F, 1L));
		assertFalse(cFunction.smaller(1.1F, 1L));
	}

	@Test
	public void testSmallerFloatDouble() {
		assertFalse(cFunction.smaller(1.0F, 1.0));
		assertTrue(cFunction.smaller(0.9F, 1.0));
		assertFalse(cFunction.smaller(1.1F, 1.0));
	}

	@Test
	public void testSmallerDoubleInteger() {
		assertTrue(cFunction.smaller(1.9, 2));
		assertFalse(cFunction.smaller(1.0, 1));
		assertFalse(cFunction.smaller(2.0, 1));
	}

	@Test
	public void testSmallerDoubleFloat() {
		assertTrue(cFunction.smaller(1.9, 2.0F));
		assertFalse(cFunction.smaller(1.0, 1.0F));
		assertFalse(cFunction.smaller(2.0, 1.9F));
	}

	@Test
	public void testSmallerDoubleLong() {
		assertTrue(cFunction.smaller(1.9, 2L));
		assertFalse(cFunction.smaller(1.0, 1L));
		assertFalse(cFunction.smaller(1.1, 1L));
	}

	@Test
	public void testSmallerLongInteger() {
		assertTrue(cFunction.smaller(1L, 2));
		assertFalse(cFunction.smaller(1L, 1));
		assertFalse(cFunction.smaller(2L, 1));
	}
	
	@Test
	public void testSmallerLongFloat() {
		assertTrue(cFunction.smaller(1L, 2.0F));
		assertFalse(cFunction.smaller(1L, 1.0F));
		assertFalse(cFunction.smaller(2L, 1.0F));
	}
	
	@Test
	public void testSmallerLongDouble() {
		assertTrue(cFunction.smaller(1L, 2.0D));
		assertFalse(cFunction.smaller(1L, 1.0D));
		assertFalse(cFunction.smaller(2L, 1.0D));
	}

	@Test
	public void testNot() {
		assertTrue(cFunction.not(false));
		assertFalse(cFunction.not(true));
	}

	@Test
	public void testComplementInteger() {
		int expected = -3;
		int actual = cFunction.complement(2);
		assertEquals(expected, actual);
	}
	
	@Test
	public void testComplementLong() {
		long expected = -3;
		long actual = cFunction.complement(2L);
		assertEquals(expected, actual);
	}
}
