1 /*
   2  * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 package org.graalvm.compiler.nodes.test;
  24 
  25 import org.graalvm.compiler.nodes.calc.ReinterpretNode;
  26 
  27 /**
  28  * Unit tests for the {@link ReinterpretNode#inferStamp} method.
  29  */
  30 public class ReinterpretStampTest {
  31 
  32     protected static final long[] interestingLongs = {
  33                     // @formatter:off
  34                     Long.MIN_VALUE,                                        // -0.0d
  35                     Long.MIN_VALUE + 1,                                    // largest negative number
  36                     Double.doubleToLongBits(-42.0),                        // random negative number
  37                     Double.doubleToLongBits(Double.NEGATIVE_INFINITY) - 1, // smallest negative number
  38                     Double.doubleToLongBits(Double.NEGATIVE_INFINITY),     // -Inf
  39                     Double.doubleToLongBits(Double.NEGATIVE_INFINITY) + 1, // smallest negative NaN
  40                     -42,                                                   // random negative NaN
  41                     -1,                                                    // largest negative NaN
  42                     0,                                                     // 0.0d
  43                     1,                                                     // smallest positive number
  44                     Double.doubleToLongBits(42.0),                         // random positive number
  45                     Double.doubleToLongBits(Double.POSITIVE_INFINITY) - 1, // largest positive number
  46                     Double.doubleToLongBits(Double.POSITIVE_INFINITY),     // +Inf
  47                     Double.doubleToLongBits(Double.POSITIVE_INFINITY) + 1, // smallest positive NaN
  48                     Long.MAX_VALUE - 42,                                   // random positive NaN
  49                     Long.MAX_VALUE,                                        // largest positive NaN
  50                     // @formatter:on
  51     };
  52 
  53     protected static final int[] interestingInts = {
  54                     // @formatter:off
  55                     Integer.MIN_VALUE,                                 // -0.0f
  56                     Integer.MIN_VALUE + 1,                             // largest negative number
  57                     Float.floatToIntBits(-42.0f),                      // random negative number
  58                     Float.floatToIntBits(Float.NEGATIVE_INFINITY) - 1, // smallest negative number
  59                     Float.floatToIntBits(Float.NEGATIVE_INFINITY),     // -Inf
  60                     Float.floatToIntBits(Float.NEGATIVE_INFINITY) + 1, // smallest negative NaN
  61                     -42,                                               // random negative NaN
  62                     -1,                                                // largest negative NaN
  63                     0,                                                 // 0.0f
  64                     1,                                                 // smallest positive number
  65                     Float.floatToIntBits(42.0f),                       // random positive number
  66                     Float.floatToIntBits(Float.POSITIVE_INFINITY) - 1, // largest positive number
  67                     Float.floatToIntBits(Float.POSITIVE_INFINITY),     // +Inf
  68                     Float.floatToIntBits(Float.POSITIVE_INFINITY) + 1, // smallest positive NaN
  69                     Integer.MAX_VALUE - 42,                            // random positive NaN
  70                     Integer.MAX_VALUE,                                 // largest positive NaN
  71                     // @formatter:on
  72     };
  73 }