-
Notifications
You must be signed in to change notification settings - Fork 11
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
ctf.core: Remove dependency to o.e.tc.common.core
By removing this dependency this plug-in will be independent to other Eclipse plug-ins and can be deployed as maven artifact with less third-party dependencies. Note, that class SaturatedArithmetic is copied from plug-in org.eclipse.tracecompass.common.core. The original tests are refactored and a test suite was added in ctf.core.tests added so that the new class is tested, too. Signed-off-by: Bernd Hufmann <bernd.hufmann@ericsson.com>
- Loading branch information
Showing
9 changed files
with
561 additions
and
285 deletions.
There are no files selected for viewing
359 changes: 359 additions & 0 deletions
359
...ests/src/org/eclipse/tracecompass/common/core/tests/math/BaseSaturatedArithmeticTest.java
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,359 @@ | ||
/******************************************************************************* | ||
* Copyright (c) 2016 Ericsson | ||
* | ||
* All rights reserved. This program and the accompanying materials are | ||
* made available under the terms of the Eclipse Public License 2.0 which | ||
* accompanies this distribution, and is available at | ||
* https://www.eclipse.org/legal/epl-2.0/ | ||
* | ||
* SPDX-License-Identifier: EPL-2.0 | ||
*******************************************************************************/ | ||
|
||
package org.eclipse.tracecompass.common.core.tests.math; | ||
|
||
import static org.junit.Assert.assertEquals; | ||
import static org.junit.Assert.assertFalse; | ||
import static org.junit.Assert.assertTrue; | ||
|
||
import org.eclipse.tracecompass.common.core.math.SaturatedArithmetic; | ||
import org.junit.Test; | ||
|
||
/** | ||
* Test suite for the {@link SaturatedArithmetic} class. | ||
* <p> | ||
* All tests must test reciprocity as well as low and high limits. | ||
* | ||
* @author Matthew Khouzam | ||
*/ | ||
abstract public class BaseSaturatedArithmeticTest { | ||
|
||
/** | ||
* test multiplication absorption (int) | ||
*/ | ||
@Test | ||
public void testMult0() { | ||
assertEquals(0, multiply(0, 0)); | ||
assertEquals(0, multiply(0, 1)); | ||
assertEquals(0, multiply(1, 0)); | ||
assertEquals(0, multiply(42, 0)); | ||
assertEquals(0, multiply(0, 42)); | ||
assertEquals(0, multiply(-42, 0)); | ||
assertEquals(0, multiply(0, -42)); | ||
assertEquals(0, multiply(Integer.MAX_VALUE, 0)); | ||
assertEquals(0, multiply(0, Integer.MAX_VALUE)); | ||
assertEquals(0, multiply(Integer.MIN_VALUE, 0)); | ||
assertEquals(0, multiply(0, Integer.MIN_VALUE)); | ||
} | ||
|
||
/** | ||
* test multiplication identity (int) | ||
*/ | ||
@Test | ||
public void testMult1() { | ||
assertEquals(0, multiply(0, 1)); | ||
assertEquals(1, multiply(1, 1)); | ||
assertEquals(42, multiply(42, 1)); | ||
assertEquals(42, multiply(1, 42)); | ||
assertEquals(-42, multiply(-42, 1)); | ||
assertEquals(-42, multiply(1, -42)); | ||
assertEquals(Integer.MAX_VALUE, multiply(Integer.MAX_VALUE, 1)); | ||
assertEquals(Integer.MAX_VALUE, multiply(1, Integer.MAX_VALUE)); | ||
assertEquals(Integer.MIN_VALUE, multiply(Integer.MIN_VALUE, 1)); | ||
assertEquals(Integer.MIN_VALUE, multiply(1, Integer.MIN_VALUE)); | ||
} | ||
|
||
/** | ||
* test multiplication typical (int) | ||
*/ | ||
@Test | ||
public void testMult100() { | ||
assertEquals(10000, multiply(100, 100)); | ||
assertEquals(-10000, multiply(100, -100)); | ||
assertEquals(-10000, multiply(-100, 100)); | ||
assertEquals(10000, multiply(-100, -100)); | ||
|
||
assertEquals(Integer.MAX_VALUE, multiply(Integer.MAX_VALUE, 100)); | ||
assertEquals(Integer.MAX_VALUE, multiply(100, Integer.MAX_VALUE)); | ||
assertEquals(Integer.MIN_VALUE, multiply(Integer.MIN_VALUE, 100)); | ||
assertEquals(Integer.MIN_VALUE, multiply(100, Integer.MIN_VALUE)); | ||
|
||
assertEquals(Integer.MIN_VALUE, multiply(Integer.MAX_VALUE, -100)); | ||
assertEquals(Integer.MIN_VALUE, multiply(-100, Integer.MAX_VALUE)); | ||
assertEquals(Integer.MAX_VALUE, multiply(Integer.MIN_VALUE, -100)); | ||
assertEquals(Integer.MAX_VALUE, multiply(-100, Integer.MIN_VALUE)); | ||
} | ||
|
||
/** | ||
* test multiplication limit (int) | ||
*/ | ||
@Test | ||
public void testMultLimit() { | ||
assertEquals(Integer.MAX_VALUE, multiply(Integer.MAX_VALUE, Integer.MAX_VALUE)); | ||
assertEquals(Integer.MIN_VALUE, multiply(Integer.MAX_VALUE, Integer.MIN_VALUE)); | ||
assertEquals(Integer.MIN_VALUE, multiply(Integer.MIN_VALUE, Integer.MAX_VALUE)); | ||
assertEquals(Integer.MAX_VALUE, multiply(Integer.MIN_VALUE, Integer.MIN_VALUE)); | ||
} | ||
|
||
/** | ||
* test multiplication absorption (long) | ||
*/ | ||
@Test | ||
public void testMult0L() { | ||
assertEquals(0, multiply(0L, 0L)); | ||
assertEquals(0, multiply(0L, 1L)); | ||
assertEquals(0, multiply(1L, 0L)); | ||
assertEquals(0, multiply(42L, 0L)); | ||
assertEquals(0, multiply(0L, 42L)); | ||
assertEquals(0, multiply(-42L, 0L)); | ||
assertEquals(0, multiply(0L, -42L)); | ||
assertEquals(0, multiply(Long.MAX_VALUE, 0L)); | ||
assertEquals(0, multiply(0L, Long.MAX_VALUE)); | ||
assertEquals(0, multiply(Long.MIN_VALUE, 0L)); | ||
assertEquals(0, multiply(0L, Long.MIN_VALUE)); | ||
} | ||
|
||
/** | ||
* test multiplication identity (long) | ||
*/ | ||
@Test | ||
public void testMult1L() { | ||
assertEquals(0, multiply(0L, 1L)); | ||
assertEquals(1, multiply(1L, 1L)); | ||
assertEquals(42, multiply(42L, 1L)); | ||
assertEquals(42, multiply(1L, 42L)); | ||
assertEquals(-42, multiply(-42L, 1L)); | ||
assertEquals(-42, multiply(1L, -42L)); | ||
assertEquals(Long.MAX_VALUE, multiply(Long.MAX_VALUE, 1L)); | ||
assertEquals(Long.MAX_VALUE, multiply(1L, Long.MAX_VALUE)); | ||
assertEquals(Long.MIN_VALUE, multiply(Long.MIN_VALUE, 1L)); | ||
assertEquals(Long.MIN_VALUE, multiply(1L, Long.MIN_VALUE)); | ||
} | ||
|
||
/** | ||
* test multiplication typical (long) | ||
*/ | ||
@Test | ||
public void testMult100L() { | ||
assertEquals(10000, multiply(100L, 100L)); | ||
assertEquals(-10000, multiply(100L, -100L)); | ||
assertEquals(-10000, multiply(-100L, 100L)); | ||
assertEquals(10000, multiply(-100L, -100L)); | ||
|
||
assertEquals(Long.MAX_VALUE, multiply(Long.MAX_VALUE, 100L)); | ||
assertEquals(Long.MAX_VALUE, multiply(100L, Long.MAX_VALUE)); | ||
assertEquals(Long.MIN_VALUE, multiply(Long.MIN_VALUE, 100L)); | ||
assertEquals(Long.MIN_VALUE, multiply(100L, Long.MIN_VALUE)); | ||
|
||
assertEquals(Long.MIN_VALUE, multiply(Long.MAX_VALUE, -100L)); | ||
assertEquals(Long.MIN_VALUE, multiply(-100L, Long.MAX_VALUE)); | ||
assertEquals(Long.MAX_VALUE, multiply(Long.MIN_VALUE, -100L)); | ||
assertEquals(Long.MAX_VALUE, multiply(-100L, Long.MIN_VALUE)); | ||
} | ||
|
||
/** | ||
* test multiplication limit (long) | ||
*/ | ||
@Test | ||
public void testMultLimitL() { | ||
assertEquals(Long.MAX_VALUE, multiply(Long.MAX_VALUE, Long.MAX_VALUE)); | ||
assertEquals(Long.MIN_VALUE, multiply(Long.MAX_VALUE, Long.MIN_VALUE)); | ||
assertEquals(Long.MIN_VALUE, multiply(Long.MIN_VALUE, Long.MAX_VALUE)); | ||
assertEquals(Long.MAX_VALUE, multiply(Long.MIN_VALUE, Long.MIN_VALUE)); | ||
} | ||
|
||
/** | ||
* test addition identity (int) | ||
*/ | ||
@Test | ||
public void testAdd0() { | ||
assertEquals(0, add(0, 0)); | ||
assertEquals(1, add(0, 1)); | ||
assertEquals(1, add(1, 0)); | ||
|
||
assertEquals(42, add(42, 0)); | ||
assertEquals(42, add(0, 42)); | ||
assertEquals(-42, add(-42, 0)); | ||
assertEquals(-42, add(0, -42)); | ||
|
||
assertEquals(Integer.MAX_VALUE, add(Integer.MAX_VALUE, 0)); | ||
assertEquals(Integer.MAX_VALUE, add(0, Integer.MAX_VALUE)); | ||
assertEquals(Integer.MIN_VALUE, add(Integer.MIN_VALUE, 0)); | ||
assertEquals(Integer.MIN_VALUE, add(0, Integer.MIN_VALUE)); | ||
} | ||
|
||
/** | ||
* test addition typical (int) | ||
*/ | ||
@Test | ||
public void testAdd100() { | ||
assertEquals(200, add(100, 100)); | ||
assertEquals(0, add(100, -100)); | ||
assertEquals(0, add(-100, 100)); | ||
assertEquals(-200, add(-100, -100)); | ||
|
||
assertEquals(Integer.MAX_VALUE, add(Integer.MAX_VALUE, 100)); | ||
assertEquals(Integer.MAX_VALUE, add(100, Integer.MAX_VALUE)); | ||
assertEquals(Integer.MIN_VALUE + 100, add(Integer.MIN_VALUE, 100)); | ||
assertEquals(Integer.MIN_VALUE + 100, add(100, Integer.MIN_VALUE)); | ||
|
||
assertEquals(Integer.MAX_VALUE - 100, add(Integer.MAX_VALUE, -100)); | ||
assertEquals(Integer.MAX_VALUE - 100, add(-100, Integer.MAX_VALUE)); | ||
assertEquals(Integer.MIN_VALUE, add(Integer.MIN_VALUE, -100)); | ||
assertEquals(Integer.MIN_VALUE, add(-100, Integer.MIN_VALUE)); | ||
} | ||
|
||
/** | ||
* test addition limit (int) | ||
*/ | ||
@Test | ||
public void testAddLimit() { | ||
assertEquals(Integer.MAX_VALUE, add(Integer.MAX_VALUE, Integer.MAX_VALUE)); | ||
// min value is 1 larger than max value | ||
assertEquals(-1, add(Integer.MAX_VALUE, Integer.MIN_VALUE)); | ||
assertEquals(-1, add(Integer.MIN_VALUE, Integer.MAX_VALUE)); | ||
assertEquals(Integer.MIN_VALUE, add(Integer.MIN_VALUE, Integer.MIN_VALUE)); | ||
} | ||
|
||
/** | ||
* test addition identity (long) | ||
*/ | ||
@Test | ||
public void testAdd0L() { | ||
assertEquals(0, add(0L, 0L)); | ||
assertEquals(1, add(0L, 1L)); | ||
assertEquals(1, add(1L, 0L)); | ||
|
||
assertEquals(42, add(42L, 0L)); | ||
assertEquals(42, add(0L, 42L)); | ||
assertEquals(-42, add(-42L, 0L)); | ||
assertEquals(-42, add(0L, -42L)); | ||
|
||
assertEquals(Long.MAX_VALUE, add(Long.MAX_VALUE, 0L)); | ||
assertEquals(Long.MAX_VALUE, add(0L, Long.MAX_VALUE)); | ||
assertEquals(Long.MIN_VALUE, add(Long.MIN_VALUE, 0L)); | ||
assertEquals(Long.MIN_VALUE, add(0L, Long.MIN_VALUE)); | ||
} | ||
|
||
/** | ||
* test addition typical (long) | ||
*/ | ||
@Test | ||
public void testAdd100L() { | ||
assertEquals(200, add(100L, 100L)); | ||
assertEquals(0, add(100L, -100L)); | ||
assertEquals(0, add(-100L, 100L)); | ||
assertEquals(-200, add(-100L, -100L)); | ||
|
||
assertEquals(Long.MAX_VALUE, add(Long.MAX_VALUE, 100L)); | ||
assertEquals(Long.MAX_VALUE, add(100L, Long.MAX_VALUE)); | ||
assertEquals(Long.MIN_VALUE + 100, add(Long.MIN_VALUE, 100L)); | ||
assertEquals(Long.MIN_VALUE + 100, add(100L, Long.MIN_VALUE)); | ||
|
||
assertEquals(Long.MAX_VALUE - 100, add(Long.MAX_VALUE, -100L)); | ||
assertEquals(Long.MAX_VALUE - 100, add(-100L, Long.MAX_VALUE)); | ||
assertEquals(Long.MIN_VALUE, add(Long.MIN_VALUE, -100L)); | ||
assertEquals(Long.MIN_VALUE, add(-100L, Long.MIN_VALUE)); | ||
} | ||
|
||
/** | ||
* test addition limit (long) | ||
*/ | ||
@Test | ||
public void testAddLimitL() { | ||
assertEquals(Long.MAX_VALUE, add(Long.MAX_VALUE, Long.MAX_VALUE)); | ||
// min value is 1 larger than max value | ||
assertEquals(-1, add(Long.MAX_VALUE, Long.MIN_VALUE)); | ||
assertEquals(-1, add(Long.MIN_VALUE, Long.MAX_VALUE)); | ||
assertEquals(Long.MIN_VALUE, add(Long.MIN_VALUE, Long.MIN_VALUE)); | ||
} | ||
|
||
/** | ||
* test same sign | ||
*/ | ||
@Test | ||
public void testSameSign() { | ||
assertTrue(sameSign(0, 0)); | ||
assertTrue(sameSign(0, -0)); | ||
|
||
assertFalse(sameSign(0, -100)); | ||
assertFalse(sameSign(-100, 0)); | ||
assertTrue(sameSign(0, 100)); | ||
assertTrue(sameSign(100, 0)); | ||
|
||
assertFalse(sameSign(-0, -100)); | ||
assertFalse(sameSign(-100, -0)); | ||
assertTrue(sameSign(-0, 100)); | ||
assertTrue(sameSign(100, -0)); | ||
|
||
assertTrue(sameSign(100, 100)); | ||
assertFalse(sameSign(100, -100)); | ||
assertFalse(sameSign(-100, 100)); | ||
assertTrue(sameSign(-100, -100)); | ||
|
||
assertTrue(sameSign(Long.MAX_VALUE, 100)); | ||
assertTrue(sameSign(100, Long.MAX_VALUE)); | ||
assertFalse(sameSign(Long.MIN_VALUE, 100)); | ||
assertFalse(sameSign(100, Long.MIN_VALUE)); | ||
|
||
assertFalse(sameSign(Long.MAX_VALUE, -100)); | ||
assertFalse(sameSign(-100, Long.MAX_VALUE)); | ||
assertTrue(sameSign(Long.MIN_VALUE, -100)); | ||
assertTrue(sameSign(-100, Long.MIN_VALUE)); | ||
} | ||
|
||
/** | ||
* Saturated multiplication implementation. | ||
* | ||
* @param left | ||
* The left int to multiply | ||
* @param right | ||
* The right int to multiply | ||
* @return The saturated multiplication result. | ||
*/ | ||
abstract protected int multiply(int left, int right); | ||
|
||
/** | ||
* Saturated multiplication implementation. | ||
* | ||
* @param left | ||
* The left long to multiply | ||
* @param right | ||
* The right long to multiply | ||
* @return The saturated multiplication result. | ||
*/ | ||
abstract protected long multiply(long left, long right); | ||
|
||
/** | ||
* Saturated addition implementation. | ||
* | ||
* @param left | ||
* The left int to add | ||
* @param right | ||
* The right int to add | ||
* @return The saturated addition result. | ||
*/ | ||
abstract protected int add(final int left, final int right); | ||
|
||
/** | ||
* Saturated addition implementation. | ||
* | ||
* @param left | ||
* The left long to add | ||
* @param right | ||
* The right long to add | ||
* @return The saturated addition result. | ||
*/ | ||
abstract protected long add(final long left, final long right); | ||
|
||
/** | ||
* Test if two numbers are the same sign or not. | ||
* | ||
* @param left | ||
* the left long | ||
* @param right | ||
* the right long | ||
* @return true if both left and right are positive or both negative, false | ||
* otherwise | ||
*/ | ||
abstract protected boolean sameSign(final long left, final long right); | ||
} |
Oops, something went wrong.