common/org.eclipse.tracecompass.common.core.tests/src/org/eclipse/tracecompass/common/core/tests/math/SaturatedArithmeticTest.java

   1 /*******************************************************************************
   2  * Copyright (c) 2016 Ericsson
   3  *
   4  * All rights reserved. This program and the accompanying materials are
   5  * made available under the terms of the Eclipse Public License v1.0 which
   6  * accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *******************************************************************************/
   9
  10 package org.eclipse.tracecompass.common.core.tests.math;
  11
  12 import static org.eclipse.tracecompass.common.core.math.SaturatedArithmetic.add;
  13 import static org.eclipse.tracecompass.common.core.math.SaturatedArithmetic.multiply;
  14 import static org.eclipse.tracecompass.common.core.math.SaturatedArithmetic.sameSign;
  15 import static org.junit.Assert.*;
  16
  17 import org.eclipse.tracecompass.common.core.math.SaturatedArithmetic;
  18 import org.junit.Test;
  19
  20 /**
  21  * Test suite for the {@link SaturatedArithmetic} All tests must test
  22  * reciprocity as well as low and high limits
  23  *
  24  * @author Matthew Khouzam
  25  */
  26 public class SaturatedArithmeticTest {
  27
  28     /**
  29      * test absorbtion
  30      */
  31     @Test
  32     public void testMult0() {
  33         assertEquals(0, multiply(0, 0));
  34         assertEquals(0, multiply(0, 1));
  35         assertEquals(0, multiply(1, 0));
  36         assertEquals(0, multiply(42, 0));
  37         assertEquals(0, multiply(0, 42));
  38         assertEquals(0, multiply(-42, 0));
  39         assertEquals(0, multiply(0, -42));
  40         assertEquals(0, multiply(Long.MAX_VALUE, 0));
  41         assertEquals(0, multiply(0, Long.MAX_VALUE));
  42         assertEquals(0, multiply(Long.MIN_VALUE, 0));
  43         assertEquals(0, multiply(0, Long.MIN_VALUE));
  44     }
  45
  46     /**
  47      * test identity
  48      */
  49     @Test
  50     public void testMult1() {
  51         assertEquals(0, multiply(0, 1));
  52         assertEquals(1, multiply(1, 1));
  53         assertEquals(42, multiply(42, 1));
  54         assertEquals(42, multiply(1, 42));
  55         assertEquals(-42, multiply(-42, 1));
  56         assertEquals(-42, multiply(1, -42));
  57         assertEquals(Long.MAX_VALUE, multiply(Long.MAX_VALUE, 1));
  58         assertEquals(Long.MAX_VALUE, multiply(1, Long.MAX_VALUE));
  59         assertEquals(Long.MIN_VALUE, multiply(Long.MIN_VALUE, 1));
  60         assertEquals(Long.MIN_VALUE, multiply(1, Long.MIN_VALUE));
  61     }
  62
  63     /**
  64      * test typical
  65      */
  66     @Test
  67     public void testMult100() {
  68         assertEquals(10000, multiply(100, 100));
  69         assertEquals(-10000, multiply(100, -100));
  70         assertEquals(-10000, multiply(-100, 100));
  71         assertEquals(10000, multiply(-100, -100));
  72
  73         assertEquals(Long.MAX_VALUE, multiply(Long.MAX_VALUE, 100));
  74         assertEquals(Long.MAX_VALUE, multiply(100, Long.MAX_VALUE));
  75         assertEquals(Long.MIN_VALUE, multiply(Long.MIN_VALUE, 100));
  76         assertEquals(Long.MIN_VALUE, multiply(100, Long.MIN_VALUE));
  77
  78         assertEquals(Long.MIN_VALUE, multiply(Long.MAX_VALUE, -100));
  79         assertEquals(Long.MIN_VALUE, multiply(-100, Long.MAX_VALUE));
  80         assertEquals(Long.MAX_VALUE, multiply(Long.MIN_VALUE, -100));
  81         assertEquals(Long.MAX_VALUE, multiply(-100, Long.MIN_VALUE));
  82     }
  83
  84     /**
  85      * test limit
  86      */
  87     @Test
  88     public void testMultLimit() {
  89         assertEquals(Long.MAX_VALUE, multiply(Long.MAX_VALUE, Long.MAX_VALUE));
  90         assertEquals(Long.MIN_VALUE, multiply(Long.MAX_VALUE, Long.MIN_VALUE));
  91         assertEquals(Long.MIN_VALUE, multiply(Long.MIN_VALUE, Long.MAX_VALUE));
  92         assertEquals(Long.MAX_VALUE, multiply(Long.MIN_VALUE, Long.MIN_VALUE));
  93     }
  94
  95     /**
  96      * test identity
  97      */
  98     @Test
  99     public void testAdd0() {
 100         assertEquals(0, add(0, 0));
 101         assertEquals(1, add(0, 1));
 102         assertEquals(1, add(1, 0));
 103
 104         assertEquals(42, add(42, 0));
 105         assertEquals(42, add(0, 42));
 106         assertEquals(-42, add(-42, 0));
 107         assertEquals(-42, add(0, -42));
 108
 109         assertEquals(Long.MAX_VALUE, add(Long.MAX_VALUE, 0));
 110         assertEquals(Long.MAX_VALUE, add(0, Long.MAX_VALUE));
 111         assertEquals(Long.MIN_VALUE, add(Long.MIN_VALUE, 0));
 112         assertEquals(Long.MIN_VALUE, add(0, Long.MIN_VALUE));
 113     }
 114
 115     /**
 116      * test typical
 117      */
 118     @Test
 119     public void testAdd100() {
 120         assertEquals(200, add(100, 100));
 121         assertEquals(0, add(100, -100));
 122         assertEquals(0, add(-100, 100));
 123         assertEquals(-200, add(-100, -100));
 124
 125         assertEquals(Long.MAX_VALUE, add(Long.MAX_VALUE, 100));
 126         assertEquals(Long.MAX_VALUE, add(100, Long.MAX_VALUE));
 127         assertEquals(Long.MIN_VALUE + 100, add(Long.MIN_VALUE, 100));
 128         assertEquals(Long.MIN_VALUE + 100, add(100, Long.MIN_VALUE));
 129
 130         assertEquals(Long.MAX_VALUE - 100, add(Long.MAX_VALUE, -100));
 131         assertEquals(Long.MAX_VALUE - 100, add(-100, Long.MAX_VALUE));
 132         assertEquals(Long.MIN_VALUE, add(Long.MIN_VALUE, -100));
 133         assertEquals(Long.MIN_VALUE, add(-100, Long.MIN_VALUE));
 134     }
 135
 136     /**
 137      * test limit
 138      */
 139     @Test
 140     public void testAddLimit() {
 141         assertEquals(Long.MAX_VALUE, add(Long.MAX_VALUE, Long.MAX_VALUE));
 142         assertEquals(-1, add(Long.MAX_VALUE, Long.MIN_VALUE)); // min value is 1
 143                                                                // larger than
 144                                                                // max value
 145         assertEquals(-1, add(Long.MIN_VALUE, Long.MAX_VALUE));
 146         assertEquals(Long.MIN_VALUE, add(Long.MIN_VALUE, Long.MIN_VALUE));
 147     }
 148
 149     /**
 150      * test same sign
 151      */
 152     @Test
 153     public void testSameSign() {
 154         assertTrue(sameSign(0, 0));
 155         assertTrue(sameSign(0, -0));
 156
 157         assertFalse(sameSign(0, -100));
 158         assertFalse(sameSign(-100, 0));
 159         assertTrue(sameSign(0, 100));
 160         assertTrue(sameSign(100, 0));
 161
 162         assertFalse(sameSign(-0, -100));
 163         assertFalse(sameSign(-100, -0));
 164         assertTrue(sameSign(-0, 100));
 165         assertTrue(sameSign(100, -0));
 166
 167         assertTrue(sameSign(100, 100));
 168         assertFalse(sameSign(100, -100));
 169         assertFalse(sameSign(-100, 100));
 170         assertTrue(sameSign(-100, -100));
 171
 172         assertTrue(sameSign(Long.MAX_VALUE, 100));
 173         assertTrue(sameSign(100, Long.MAX_VALUE));
 174         assertFalse(sameSign(Long.MIN_VALUE, 100));
 175         assertFalse(sameSign(100, Long.MIN_VALUE));
 176
 177         assertFalse(sameSign(Long.MAX_VALUE, -100));
 178         assertFalse(sameSign(-100, Long.MAX_VALUE));
 179         assertTrue(sameSign(Long.MIN_VALUE, -100));
 180         assertTrue(sameSign(-100, Long.MIN_VALUE));
 181     }
 182
 183 }