// Copyright (c) 2016, the R8 project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.smali;

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

import com.android.tools.r8.code.Const4;
import com.android.tools.r8.code.DivIntLit8;
import com.android.tools.r8.code.Instruction;
import com.android.tools.r8.code.RemIntLit8;
import com.android.tools.r8.code.Return;
import com.android.tools.r8.code.ReturnWide;
import com.android.tools.r8.graph.DexCode;
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.ir.code.Cmp.Bias;
import com.android.tools.r8.ir.code.If.Type;
import com.android.tools.r8.ir.code.SingleConstant;
import com.android.tools.r8.ir.code.WideConstant;
import com.google.common.collect.ImmutableList;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.junit.Test;

public class ConstantFoldingTest extends SmaliTestBase {

  public void generateBinopTest(String type, String op, List<Long> values, Long result) {
    boolean wide = type.equals("long") || type.equals("double");
    StringBuilder source = new StringBuilder();
    int factor = wide ? 2 : 1;
    for (int i = 0; i < values.size(); i++) {
      source.append("    ");
      source.append(wide ? "const-wide " : "const ");
      source.append("v" + (i * factor));
      source.append(", ");
      source.append("0x" + Long.toHexString(values.get(i)));
      source.append(wide ? "L" : "");
      source.append("\n");
    }

    for (int i = 0; i < values.size() - 1; i++) {
      source.append("    ");
      source.append(op + "-" + type + "/2addr ");
      source.append("v" + ((i + 1) * factor));
      source.append(", ");
      source.append("v" + (i * factor));
      source.append("\n");
    }

    source.append("    ");
    source.append(wide ? "return-wide " : "return ");
    source.append("v" + ((values.size() - 1) * factor));

    DexEncodedMethod method = oneMethodApplication(
        type, Collections.singletonList(type),
        values.size() * factor,
        source.toString());
    DexCode code = method.getCode().asDexCode();
    assertEquals(2, code.instructions.length);
    if (wide) {
      assertTrue(code.instructions[0] instanceof WideConstant);
      assertEquals(result.longValue(), ((WideConstant) code.instructions[0]).decodedValue());
      assertTrue(code.instructions[1] instanceof ReturnWide);
    } else {
      assertTrue(code.instructions[0] instanceof SingleConstant);
      assertEquals(
          result.longValue(), (long) ((SingleConstant) code.instructions[0]).decodedValue());
      assertTrue(code.instructions[1] instanceof Return);
    }
  }

  private long floatBits(float f) {
    return Float.floatToIntBits(f);
  }

  private long doubleBits(double d) {
    return Double.doubleToLongBits(d);
  }

  ImmutableList<Long> arguments = ImmutableList.of(1L, 2L, 3L, 4L);
  ImmutableList<Long> floatArguments = ImmutableList.of(
      floatBits(1.0f), floatBits(2.0f), floatBits(3.0f), floatBits(4.0f));
  ImmutableList<Long> doubleArguments = ImmutableList.of(
      doubleBits(1.0), doubleBits(2.0), doubleBits(3.0), doubleBits(4.0));

  @Test
  public void addFold() {
    generateBinopTest("int", "add", arguments, 10L);
    generateBinopTest("long", "add", arguments, 10L);
    generateBinopTest("float", "add", floatArguments, floatBits(10.0f));
    generateBinopTest("double", "add", doubleArguments, doubleBits(10.0));
  }

  @Test
  public void mulFold() {
    generateBinopTest("int", "mul", arguments, 24L);
    generateBinopTest("long", "mul", arguments, 24L);
    generateBinopTest("float", "mul", floatArguments, floatBits(24.0f));
    generateBinopTest("double", "mul", doubleArguments, doubleBits(24.0));
  }

  @Test
  public void subFold() {
    generateBinopTest("int", "sub", arguments.reverse(), -2L);
    generateBinopTest("long", "sub", arguments.reverse(), -2L);
    generateBinopTest("float", "sub", floatArguments.reverse(), floatBits(-2.0f));
    generateBinopTest("double", "sub", doubleArguments.reverse(), doubleBits(-2.0));
  }

  @Test
  public void divFold() {
    ImmutableList<Long> arguments = ImmutableList.of(2L, 24L, 48L, 4L);
    ImmutableList<Long> floatArguments = ImmutableList.of(
        floatBits(2.0f), floatBits(24.0f), floatBits(48.0f), floatBits(4.0f));
    ImmutableList<Long> doubleArguments = ImmutableList.of(
        doubleBits(2.0), doubleBits(24.0), doubleBits(48.0), doubleBits(4.0));

    generateBinopTest("int", "div", arguments, 1L);
    generateBinopTest("long", "div", arguments, 1L);
    generateBinopTest("float", "div", floatArguments, floatBits(1.0f));
    generateBinopTest("double", "div", doubleArguments, doubleBits(1.0));
  }


  @Test
  public void remFold() {
    ImmutableList<Long> arguments = ImmutableList.of(10L, 6L, 3L, 2L);
    ImmutableList<Long> floatArguments = ImmutableList.of(
        floatBits(10.0f), floatBits(6.0f), floatBits(3.0f), floatBits(2.0f));
    ImmutableList<Long> doubleArguments = ImmutableList.of(
        doubleBits(10.0), doubleBits(6.0), doubleBits(3.0), doubleBits(2.0));

    generateBinopTest("int", "rem", arguments, 2L);
    generateBinopTest("long", "rem", arguments, 2L);
    generateBinopTest("float", "rem", floatArguments, floatBits(2.0f));
    generateBinopTest("double", "rem", doubleArguments, doubleBits(2.0));
  }

  @Test
  public void divIntFoldDivByZero() {
    DexEncodedMethod method = oneMethodApplication(
        "int", Collections.singletonList("int"),
        2,
        "    const/4 v0, 1           ",
        "    const/4 v1, 0           ",
        "    div-int/2addr v0, v1    ",
        "    return v0\n             "
    );
    DexCode code = method.getCode().asDexCode();
    // Division by zero is not folded, but div-int/lit8 is used.
    assertEquals(3, code.instructions.length);
    assertTrue(code.instructions[0] instanceof Const4);
    assertTrue(code.instructions[1] instanceof DivIntLit8);
    assertEquals(0, ((DivIntLit8) code.instructions[1]).CC);
    assertTrue(code.instructions[2] instanceof Return);
  }

  @Test
  public void divIntFoldRemByZero() {
    DexEncodedMethod method = oneMethodApplication(
        "int", Collections.singletonList("int"),
        2,
        "    const/4 v0, 1           ",
        "    const/4 v1, 0           ",
        "    rem-int/2addr v0, v1    ",
        "    return v0\n             "
    );
    DexCode code = method.getCode().asDexCode();
    // Division by zero is not folded, but rem-int/lit8 is used.
    assertEquals(3, code.instructions.length);
    assertTrue(code.instructions[0] instanceof Const4);
    assertTrue(code.instructions[1] instanceof RemIntLit8);
    assertEquals(0, ((RemIntLit8) code.instructions[1]).CC);
    assertTrue(code.instructions[2] instanceof Return);
  }

  public void generateUnopTest(String type, String op, Long value, Long result) {
    boolean wide = type.equals("long") || type.equals("double");
    StringBuilder source = new StringBuilder();
    source.append("    ");
    source.append(wide ? "const-wide " : "const ");
    source.append("v0 , ");
    source.append("0x" + Long.toHexString(value));
    source.append(wide ? "L" : "");
    source.append("\n");

    source.append("    ");
    source.append(op + "-" + type + " v0, v0\n");

    source.append("    ");
    source.append(wide ? "return-wide v0" : "return v0");

    DexEncodedMethod method = oneMethodApplication(
        type, Collections.singletonList(type),
        wide ? 2 : 1,
        source.toString());
    DexCode code = method.getCode().asDexCode();
    assertEquals(2, code.instructions.length);
    if (wide) {
      assertTrue(code.instructions[0] instanceof WideConstant);
      assertEquals(result.longValue(), ((WideConstant) code.instructions[0]).decodedValue());
      assertTrue(code.instructions[1] instanceof ReturnWide);
    } else {
      assertTrue(code.instructions[0] instanceof SingleConstant);
      assertEquals(
          result.longValue(), (long) ((SingleConstant) code.instructions[0]).decodedValue());
      assertTrue(code.instructions[1] instanceof Return);
    }
  }

  @Test
  public void negFold() {
    generateUnopTest("int", "neg", 2L, -2L);
    generateUnopTest("int", "neg", -2L, 2L);
    generateUnopTest("long", "neg", 2L, -2L);
    generateUnopTest("long", "neg", -2L, 2L);
    generateUnopTest("float", "neg", floatBits(2.0f), floatBits(-2.0f));
    generateUnopTest("float", "neg", floatBits(-2.0f), floatBits(2.0f));
    generateUnopTest("float", "neg", floatBits(0.0f), floatBits(-0.0f));
    generateUnopTest("float", "neg", floatBits(-0.0f), floatBits(0.0f));
    generateUnopTest("double", "neg", doubleBits(2.0), doubleBits(-2.0));
    generateUnopTest("double", "neg", doubleBits(-2.0), doubleBits(2.0));
    generateUnopTest("double", "neg", doubleBits(0.0), doubleBits(-0.0));
    generateUnopTest("double", "neg", doubleBits(-0.0), doubleBits(0.0));
  }

  private void assertConstValue(int expected, Instruction insn) {
    assertTrue(insn instanceof SingleConstant);
    assertEquals(expected, ((SingleConstant) insn).decodedValue());
  }

  private void assertConstValue(long expected, Instruction insn) {
    assertTrue(insn instanceof WideConstant);
    assertEquals(expected, ((WideConstant) insn).decodedValue());
  }

  public void testLogicalOperatorsFolding(String op, int[] v) {
    int v0 = v[0];
    int v1 = v[1];
    int v2 = v[2];
    int v3 = v[3];

    int expected = 0;
    switch (op) {
      case "and":
        expected = v0 & v1 & v2 & v3;
        break;
      case "or":
        expected = v0 | v1 | v2 | v3;
        break;
      case "xor":
        expected = v0 ^ v1 ^ v2 ^ v3;
        break;
      default:
        fail("Unsupported logical binop " + op);
    }

    DexEncodedMethod method = oneMethodApplication(
        "int", Collections.singletonList("int"),
        4,
        "    const v0, " + v0,
        "    const v1, " + v1,
        "    const v2, " + v2,
        "    const v3, " + v3,
        // E.g. and-int//2addr v1, v0
        "    " + op + "-int/2addr v1, v0    ",
        "    " + op + "-int/2addr v2, v1    ",
        "    " + op + "-int/2addr v3, v2    ",
        "    return v3\n                    "
    );
    DexCode code = method.getCode().asDexCode();
    // Test that this just returns a constant.
    assertEquals(2, code.instructions.length);
    assertConstValue(expected, code.instructions[0]);
    assertTrue(code.instructions[1] instanceof Return);
  }

  @Test
  public void logicalOperatorsFolding() {
    int[][] testValues = new int[][]{
        new int[]{0x00, 0x00, 0x00, 0x00},
        new int[]{0x0b, 0x06, 0x03, 0x00},
        new int[]{0x0f, 0x07, 0x03, 0x01},
        new int[]{0x08, 0x04, 0x02, 0x01},
    };

    for (int[] values : testValues) {
      testLogicalOperatorsFolding("and", values);
      testLogicalOperatorsFolding("or", values);
      testLogicalOperatorsFolding("xor", values);
    }
  }

  private void testShiftOperatorsFolding(String op, int[] v) {
    int v0 = v[0];
    int v1 = v[1];
    int v2 = v[2];
    int v3 = v[3];

    int expected = 0;
    switch (op) {
      case "shl":
        v0 = v0 << v1;
        v0 = v0 << v2;
        v0 = v0 << v3;
        break;
      case "shr":
        v0 = v0 >> v1;
        v0 = v0 >> v2;
        v0 = v0 >> v3;
        break;
      case "ushr":
        v0 = v0 >>> v1;
        v0 = v0 >>> v2;
        v0 = v0 >>> v3;
        break;
      default:
        fail("Unsupported shift " + op);
    }
    expected = v0;

    DexEncodedMethod method = oneMethodApplication(
        "int", Collections.singletonList("int"),
        4,
        "    const v0, " + v[0],
        "    const v1, " + v[1],
        "    const v2, " + v[2],
        "    const v3, " + v[3],
        // E.g. and-int//2addr v1, v0
        "    " + op + "-int/2addr v0, v1    ",
        "    " + op + "-int/2addr v0, v2    ",
        "    " + op + "-int/2addr v0, v3    ",
        "    return v0\n                    "
    );
    DexCode code = method.getCode().asDexCode();
    // Test that this just returns a constant.
    assertEquals(2, code.instructions.length);
    assertConstValue(expected, code.instructions[0]);
    assertTrue(code.instructions[1] instanceof Return);
  }

  @Test
  public void shiftOperatorsFolding() {
    int[][] testValues = new int[][]{
        new int[]{0x01, 0x01, 0x01, 0x01},
        new int[]{0x01, 0x02, 0x03, 0x04},
        new int[]{0x7f000000, 0x01, 0x2, 0x03},
        new int[]{0x80000000, 0x01, 0x2, 0x03},
        new int[]{0xffffffff, 0x01, 0x2, 0x03},
    };

    for (int[] values : testValues) {
      testShiftOperatorsFolding("shl", values);
      testShiftOperatorsFolding("shr", values);
      testShiftOperatorsFolding("ushr", values);
    }
  }

  private void testShiftOperatorsFoldingWide(String op, long[] v) {
    long v0 = v[0];
    int v2 = (int) v[1];
    int v4 = (int) v[2];
    int v6 = (int) v[3];

    long expected = 0;
    switch (op) {
      case "shl":
        v0 = v0 << v2;
        v0 = v0 << v4;
        v0 = v0 << v6;
        break;
      case "shr":
        v0 = v0 >> v2;
        v0 = v0 >> v4;
        v0 = v0 >> v6;
        break;
      case "ushr":
        v0 = v0 >>> v2;
        v0 = v0 >>> v4;
        v0 = v0 >>> v6;
        break;
      default:
        fail("Unsupported shift " + op);
    }
    expected = v0;

    DexEncodedMethod method = oneMethodApplication(
        "long", Collections.singletonList("long"),
        5,
        "    const-wide v0, 0x" + Long.toHexString(v[0]) + "L",
        "    const v2, " + v[1],
        "    const v3, " + v[2],
        "    const v4, " + v[3],
        // E.g. and-long//2addr v1, v0
        "    " + op + "-long/2addr v0, v2    ",
        "    " + op + "-long/2addr v0, v3    ",
        "    " + op + "-long/2addr v0, v4    ",
        "    return-wide v0\n                    "
    );
    DexCode code = method.getCode().asDexCode();
    // Test that this just returns a constant.
    assertEquals(2, code.instructions.length);
    assertConstValue(expected, code.instructions[0]);
    assertTrue(code.instructions[1] instanceof ReturnWide);
  }

  @Test
  public void shiftOperatorsFoldingWide() {
    long[][] testValues = new long[][]{
        new long[]{0x01, 0x01, 0x01, 0x01},
        new long[]{0x01, 0x02, 0x03, 0x04},
        new long[]{0x7f0000000000L, 0x01, 0x2, 0x03},
        new long[]{0x800000000000L, 0x01, 0x2, 0x03},
        new long[]{0x7f00000000000000L, 0x01, 0x2, 0x03},
        new long[]{0x8000000000000000L, 0x01, 0x2, 0x03},
        new long[]{0xffffffffffffffffL, 0x01, 0x2, 0x03},
    };

    for (long[] values : testValues) {
      testShiftOperatorsFoldingWide("shl", values);
      testShiftOperatorsFoldingWide("shr", values);
      testShiftOperatorsFoldingWide("ushr", values);
    }
  }

  @Test
  public void notIntFold() {
    int[] testValues = new int[]{0, 1, 0xff, 0xffffffff, 0xff000000, 0x80000000};
    for (int value : testValues) {
      DexEncodedMethod method = oneMethodApplication(
          "int", Collections.emptyList(),
          1,
          "    const v0, " + value,
          "    not-int v0, v0",
          "    return v0"
      );
      DexCode code = method.getCode().asDexCode();
      assertEquals(2, code.instructions.length);
      assertConstValue(~value, code.instructions[0]);
      assertTrue(code.instructions[1] instanceof Return);
    }
  }

  @Test
  public void notLongFold() {
    long[] testValues = new long[]{
        0L,
        1L,
        0xffL,
        0xffffffffffffffffL,
        0x00ffffffffffffffL,
        0xff00000000000000L,
        0x8000000000000000L
    };
    for (long value : testValues) {
      DexEncodedMethod method = oneMethodApplication(
          "long", Collections.emptyList(),
          2,
          "    const-wide v0, 0x" + Long.toHexString(value) + "L",
          "    not-long v0, v0",
          "    return-wide v0"
      );
      DexCode code = method.getCode().asDexCode();
      assertEquals(2, code.instructions.length);
      assertConstValue(~value, code.instructions[0]);
      assertTrue(code.instructions[1] instanceof ReturnWide);
    }
  }

  @Test
  public void negIntFold() {
    int[] testValues = new int[]{0, 1, 0xff, 0xffffffff, 0xff000000, 0x80000000};
    for (int value : testValues) {
      DexEncodedMethod method = oneMethodApplication(
          "int", Collections.emptyList(),
          1,
          "    const v0, " + value,
          "    neg-int v0, v0",
          "    return v0"
      );
      DexCode code = method.getCode().asDexCode();
      assertEquals(2, code.instructions.length);
      assertConstValue(-value, code.instructions[0]);
      assertTrue(code.instructions[1] instanceof Return);
    }
  }

  @Test
  public void negLongFold() {
    long[] testValues = new long[]{
        0L,
        1L,
        0xffL,
        0xffffffffffffffffL,
        0x00ffffffffffffffL,
        0xff00000000000000L,
        0x8000000000000000L
    };
    for (long value : testValues) {
      DexEncodedMethod method = oneMethodApplication(
          "long", Collections.emptyList(),
          2,
          "    const-wide v0, 0x" + Long.toHexString(value) + "L",
          "    neg-long v0, v0",
          "    return-wide v0"
      );
      DexCode code = method.getCode().asDexCode();
      assertEquals(2, code.instructions.length);
      long expected = -value;
      assertConstValue(-value, code.instructions[0]);
      assertTrue(code.instructions[1] instanceof ReturnWide);
    }
  }

  @Test
  public void cmpFloatFold() {
    String[] ifOpcode = new String[6];
    ifOpcode[Type.EQ.ordinal()] = "if-eqz";
    ifOpcode[Type.NE.ordinal()] = "if-nez";
    ifOpcode[Type.LE.ordinal()] = "if-lez";
    ifOpcode[Type.GE.ordinal()] = "if-gez";
    ifOpcode[Type.LT.ordinal()] = "if-ltz";
    ifOpcode[Type.GT.ordinal()] = "if-gtz";

    class FloatTestData {

      final float a;
      final float b;
      final boolean results[];

      FloatTestData(float a, float b) {
        this.a = a;
        this.b = b;
        results = new boolean[6];
        results[Type.EQ.ordinal()] = a == b;
        results[Type.NE.ordinal()] = a != b;
        results[Type.LE.ordinal()] = a <= b;
        results[Type.GE.ordinal()] = a >= b;
        results[Type.LT.ordinal()] = a < b;
        results[Type.GT.ordinal()] = a > b;
      }
    }

    float[] testValues = new float[]{
        Float.NEGATIVE_INFINITY,
        -100.0f,
        -0.0f,
        0.0f,
        100.0f,
        Float.POSITIVE_INFINITY,
        Float.NaN
    };

    List<FloatTestData> tests = new ArrayList<>();
    for (int i = 0; i < testValues.length; i++) {
      for (int j = 0; j < testValues.length; j++) {
        tests.add(new FloatTestData(testValues[i], testValues[j]));
      }
    }

    for (FloatTestData test : tests) {
      for (Type type : Type.values()) {
        for (Bias bias : Bias.values()) {
          if (bias == Bias.NONE) {
            // Bias NONE is only for long comparison.
            continue;
          }
          // If no NaNs are involved either bias produce the same result.
          if (Float.isNaN(test.a) || Float.isNaN(test.b)) {
            // For NaN comparison only test with the bias that provide Java semantics.
            // The Java Language Specification 4.2.3. Floating-Point Types, Formats, and Values
            // says:
            //
            // The numerical comparison operators <, <=, >, and >= return false if either or both
            // operands are NaN
            if ((type == Type.GE || type == Type.GT) && bias == Bias.GT) {
              continue;
            }
            if ((type == Type.LE || type == Type.LT) && bias == Bias.LT) {
              continue;
            }
          }
          String cmpInstruction;
          if (bias == Bias.LT) {
            cmpInstruction = "    cmpl-float v0, v0, v1";
          } else {
            cmpInstruction = "    cmpg-float v0, v0, v1";
          }
          DexEncodedMethod method = oneMethodApplication(
              "int", Collections.emptyList(),
              2,
              "    const v0, 0x" + Integer.toHexString(Float.floatToRawIntBits(test.a)),
              "    const v1, 0x" + Integer.toHexString(Float.floatToRawIntBits(test.b)),
              cmpInstruction,
              "    " + ifOpcode[type.ordinal()] + " v0, :label_2",
              "    const v0, 0",
              ":label_1",
              "    return v0",
              ":label_2",
              "  const v0, 1",
              "  goto :label_1"
          );
          DexCode code = method.getCode().asDexCode();
          assertEquals(2, code.instructions.length);
          int expected = test.results[type.ordinal()] ? 1 : 0;
          assertConstValue(expected, code.instructions[0]);
          assertTrue(code.instructions[1] instanceof Return);
        }
      }
    }
  }

  @Test
  public void cmpDoubleFold() {
    String[] ifOpcode = new String[6];
    ifOpcode[Type.EQ.ordinal()] = "if-eqz";
    ifOpcode[Type.NE.ordinal()] = "if-nez";
    ifOpcode[Type.LE.ordinal()] = "if-lez";
    ifOpcode[Type.GE.ordinal()] = "if-gez";
    ifOpcode[Type.LT.ordinal()] = "if-ltz";
    ifOpcode[Type.GT.ordinal()] = "if-gtz";

    class DoubleTestData {

      final double a;
      final double b;
      final boolean results[];

      DoubleTestData(double a, double b) {
        this.a = a;
        this.b = b;
        results = new boolean[6];
        results[Type.EQ.ordinal()] = a == b;
        results[Type.NE.ordinal()] = a != b;
        results[Type.LE.ordinal()] = a <= b;
        results[Type.GE.ordinal()] = a >= b;
        results[Type.LT.ordinal()] = a < b;
        results[Type.GT.ordinal()] = a > b;
      }
    }

    double[] testValues = new double[]{
        Double.NEGATIVE_INFINITY,
        -100.0f,
        -0.0f,
        0.0f,
        100.0f,
        Double.POSITIVE_INFINITY,
        Double.NaN
    };

    List<DoubleTestData> tests = new ArrayList<>();
    for (int i = 0; i < testValues.length; i++) {
      for (int j = 0; j < testValues.length; j++) {
        tests.add(new DoubleTestData(testValues[i], testValues[j]));
      }
    }

    for (DoubleTestData test : tests) {
      for (Type type : Type.values()) {
        for (Bias bias : Bias.values()) {
          if (bias == Bias.NONE) {
            // Bias NONE is only for long comparison.
            continue;
          }
          if (Double.isNaN(test.a) || Double.isNaN(test.b)) {
            // For NaN comparison only test with the bias that provide Java semantics.
            // The Java Language Specification 4.2.3. Doubleing-Point Types, Formats, and Values
            // says:
            //
            // The numerical comparison operators <, <=, >, and >= return false if either or both
            // operands are NaN
            if ((type == Type.GE || type == Type.GT) && bias == Bias.GT) {
              continue;
            }
            if ((type == Type.LE || type == Type.LT) && bias == Bias.LT) {
              continue;
            }
          }
          String cmpInstruction;
          if (bias == Bias.LT) {
            cmpInstruction = "    cmpl-double v0, v0, v2";
          } else {
            cmpInstruction = "    cmpg-double v0, v0, v2";
          }
          DexEncodedMethod method = oneMethodApplication(
              "int", Collections.emptyList(),
              4,
              "    const-wide v0, 0x" + Long.toHexString(Double.doubleToRawLongBits(test.a)) + "L",
              "    const-wide v2, 0x" + Long.toHexString(Double.doubleToRawLongBits(test.b)) + "L",
              cmpInstruction,
              "    " + ifOpcode[type.ordinal()] + " v0, :label_2",
              "    const v0, 0",
              ":label_1",
              "    return v0",
              ":label_2",
              "  const v0, 1",
              "  goto :label_1"
          );
          DexCode code = method.getCode().asDexCode();
          assertEquals(2, code.instructions.length);
          int expected = test.results[type.ordinal()] ? 1 : 0;
          assertConstValue(expected, code.instructions[0]);
          assertTrue(code.instructions[1] instanceof Return);
        }
      }
    }
  }

  @Test
  public void cmpLongFold() {
    long[][] longValues = new long[][]{
        {Long.MIN_VALUE, 1L},
        {Long.MAX_VALUE, 1L},
        {Long.MIN_VALUE, 0L},
        {Long.MAX_VALUE, 0L},
        {Long.MIN_VALUE, -1L},
        {Long.MAX_VALUE, -1L},
    };

    for (long[] values : longValues) {
      DexEncodedMethod method = oneMethodApplication(
          "int", Collections.emptyList(),
          4,
          "    const-wide v0, 0x" + Long.toHexString(values[0]) + "L",
          "    const-wide v2, 0x" + Long.toHexString(values[1]) + "L",
          "    cmp-long v0, v0, v2",
          "    return v0"
      );
      DexCode code = method.getCode().asDexCode();
      assertEquals(2, code.instructions.length);
      assertConstValue(Long.compare(values[0], values[1]), code.instructions[0]);
      assertTrue(code.instructions[1] instanceof Return);
    }
  }
}