/*
 * Copyright (C) 2023 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * Tests for autovectorization of loops with control flow.
 */
public class Main {

  public static final int ARRAY_LENGTH = 128;
  public static final int USED_ARRAY_LENGTH = ARRAY_LENGTH - 1;

  public static boolean[] booleanArray = new boolean[ARRAY_LENGTH];
  public static boolean[] booleanArray2 = new boolean[ARRAY_LENGTH];
  public static byte[] byteArray = new byte[ARRAY_LENGTH];
  public static short[] shortArray = new short[ARRAY_LENGTH];
  public static char[] charArray = new char[ARRAY_LENGTH];
  public static int[] intArray = new int[ARRAY_LENGTH];
  public static long[] longArray = new long[ARRAY_LENGTH];
  public static float[] floatArray = new float[ARRAY_LENGTH];
  public static double[] doubleArray = new double[ARRAY_LENGTH];

  public static final int MAGIC_VALUE_A = 2;
  public static final int MAGIC_VALUE_B = 10;
  public static final int MAGIC_VALUE_C = 100;

  public static final int MAGIC_ADD_CONST = 99;

  public static final float MAGIC_FLOAT_VALUE_A = 2.0f;
  public static final float MAGIC_FLOAT_VALUE_B = 10.0f;
  public static final float MAGIC_FLOAT_VALUE_C = 100.0f;

  public static final float MAGIC_FLOAT_ADD_CONST = 99.0f;

  /// CHECK-START-ARM64: int Main.$compile$noinline$FullDiamond(int[]) loop_optimization (after)
  /// CHECK-IF:     hasIsaFeature("sve")
  //
  ///     CHECK-DAG: <<C0:i\d+>>      IntConstant 0                                         loop:none
  ///     CHECK-DAG: <<C4:i\d+>>      IntConstant 4                                         loop:none
  ///     CHECK-DAG: <<C99:i\d+>>     IntConstant 99                                        loop:none
  ///     CHECK-DAG: <<C100:i\d+>>    IntConstant 100                                       loop:none
  ///     CHECK-DAG: <<Vec4:d\d+>>    VecReplicateScalar [<<C4>>,{{j\d+}}]                  loop:none
  ///     CHECK-DAG: <<Vec99:d\d+>>   VecReplicateScalar [<<C99>>,{{j\d+}}]                 loop:none
  ///     CHECK-DAG: <<Vec100:d\d+>>  VecReplicateScalar [<<C100>>,{{j\d+}}]                loop:none
  //
  ///     CHECK-DAG: <<Phi:i\d+>>     Phi [<<C0>>,{{i\d+}}]                                 loop:<<Loop:B\d+>> outer_loop:none
  ///     CHECK-DAG: <<LoopP:j\d+>>   VecPredWhile [<<Phi>>,{{i\d+}}]                       loop:<<Loop>>      outer_loop:none
  //
  ///     CHECK-DAG: <<Load1:d\d+>>   VecLoad [<<Arr:l\d+>>,<<Phi>>,<<LoopP>>]              loop:<<Loop>>      outer_loop:none
  ///     CHECK-DAG: <<Cond:j\d+>>    VecCondition [<<Load1>>,<<Vec100>>,<<LoopP>>]         loop:<<Loop>>      outer_loop:none
  ///     CHECK-DAG: <<CondR:j\d+>>   VecPredNot [<<Cond>>,<<LoopP>>]                       loop:<<Loop>>      outer_loop:none
  ///     CHECK-DAG: <<AddT:d\d+>>    VecAdd [<<Load1>>,<<Vec99>>,<<CondR>>]                loop:<<Loop>>      outer_loop:none
  ///     CHECK-DAG: <<StT:d\d+>>     VecStore [<<Arr>>,<<Phi>>,<<AddT>>,<<CondR>>]         loop:<<Loop>>      outer_loop:none
  ///     CHECK-DAG: <<StF:d\d+>>     VecStore [<<Arr>>,<<Phi>>,{{d\d+}},<<Cond>>]          loop:<<Loop>>      outer_loop:none
  ///     CHECK-DAG: <<Ld2:d\d+>>     VecLoad [<<Arr>>,<<Phi>>,<<LoopP>>]                   loop:<<Loop>>      outer_loop:none
  ///     CHECK-DAG: <<Add2:d\d+>>    VecAdd [<<Ld2>>,<<Vec4>>,<<LoopP>>]                   loop:<<Loop>>      outer_loop:none
  ///     CHECK-DAG: <<St21:d\d+>>    VecStore [<<Arr>>,<<Phi>>,<<Add2>>,<<LoopP>>]         loop:<<Loop>>      outer_loop:none
  //
  /// CHECK-ELSE:
  //
  ///     CHECK-NOT:                      VecLoad
  //
  /// CHECK-FI:
  public static int $compile$noinline$FullDiamond(int[] x) {
    int i = 0;
    for (; i < USED_ARRAY_LENGTH; i++) {
      int val = x[i];
      if (val != MAGIC_VALUE_C) {
        x[i] += MAGIC_ADD_CONST;
      } else {
        x[i] += 3;
      }
      x[i] += 4;
    }
    return i;
  }

  //
  // Test various types.
  //

  /// CHECK-START-ARM64: void Main.$compile$noinline$SimpleBoolean(boolean[], boolean[]) loop_optimization (after)
  /// CHECK-IF:     hasIsaFeature("sve")
  //
  ///     CHECK-NOT: VecLoad
  //
  /// CHECK-FI:
  //
  // TODO: Support extra condition types and boolean comparisons.
  public static void $compile$noinline$SimpleBoolean(boolean[] x, boolean[] y) {
    for (int i = 0; i < USED_ARRAY_LENGTH; i++) {
      boolean val = x[i];
      if (val != y[i]) {
        x[i] |= y[i];
      }
    }
  }

  /// CHECK-START-ARM64: void Main.$compile$noinline$SimpleByte(byte[]) loop_optimization (after)
  /// CHECK-IF:     hasIsaFeature("sve")
  //
  ///     CHECK-DAG: VecLoad
  //
  /// CHECK-FI:
  public static void $compile$noinline$SimpleByte(byte[] x) {
    for (int i = 0; i < USED_ARRAY_LENGTH; i++) {
      byte val = x[i];
      if (val != MAGIC_VALUE_C) {
        x[i] += MAGIC_ADD_CONST;
      }
    }
  }

  /// CHECK-START-ARM64: void Main.$compile$noinline$SimpleUByte(byte[]) loop_optimization (after)
  /// CHECK-IF:     hasIsaFeature("sve")
  //
  ///     CHECK-DAG: VecLoad
  //
  /// CHECK-FI:
  public static void $compile$noinline$SimpleUByte(byte[] x) {
    for (int i = 0; i < USED_ARRAY_LENGTH; i++) {
      if ((x[i] & 0xFF) != MAGIC_VALUE_C) {
        x[i] += MAGIC_ADD_CONST;
      }
    }
  }

  /// CHECK-START-ARM64: void Main.$compile$noinline$SimpleShort(short[]) loop_optimization (after)
  /// CHECK-IF:     hasIsaFeature("sve")
  //
  ///     CHECK-DAG: VecLoad
  //
  /// CHECK-FI:
  public static void $compile$noinline$SimpleShort(short[] x) {
    for (int i = 0; i < USED_ARRAY_LENGTH; i++) {
      short val = x[i];
      if (val != MAGIC_VALUE_C) {
        x[i] += MAGIC_ADD_CONST;
      }
    }
  }

  /// CHECK-START-ARM64: void Main.$compile$noinline$SimpleChar(char[]) loop_optimization (after)
  /// CHECK-IF:     hasIsaFeature("sve")
  //
  ///     CHECK-DAG: VecLoad
  //
  /// CHECK-FI:
  public static void $compile$noinline$SimpleChar(char[] x) {
    for (int i = 0; i < USED_ARRAY_LENGTH; i++) {
      char val = x[i];
      if (val != MAGIC_VALUE_C) {
        x[i] += MAGIC_ADD_CONST;
      }
    }
  }

  /// CHECK-START-ARM64: void Main.$compile$noinline$SimpleInt(int[]) loop_optimization (after)
  /// CHECK-IF:     hasIsaFeature("sve")
  //
  ///     CHECK-DAG: VecLoad
  //
  /// CHECK-FI:
  public static void $compile$noinline$SimpleInt(int[] x) {
    for (int i = 0; i < USED_ARRAY_LENGTH; i++) {
      int val = x[i];
      if (val != MAGIC_VALUE_C) {
        x[i] += MAGIC_ADD_CONST;
      }
    }
  }

  /// CHECK-START-ARM64: void Main.$compile$noinline$SimpleLong(long[]) loop_optimization (after)
  /// CHECK-IF:     hasIsaFeature("sve")
  //
  ///     CHECK-NOT: VecLoad
  //
  /// CHECK-FI:
  //
  // TODO: Support long comparisons.
  public static void $compile$noinline$SimpleLong(long[] x) {
    for (int i = 0; i < USED_ARRAY_LENGTH; i++) {
      long val = x[i];
      if (val != MAGIC_VALUE_C) {
        x[i] += MAGIC_ADD_CONST;
      }
    }
  }

  /// CHECK-START-ARM64: void Main.$compile$noinline$SimpleFloat(float[]) loop_optimization (after)
  /// CHECK-IF:     hasIsaFeature("sve")
  //
  ///     CHECK-NOT: VecLoad
  //
  /// CHECK-FI:
  //
  // TODO: Support FP comparisons.
  public static void $compile$noinline$SimpleFloat(float[] x) {
    for (int i = 0; i < USED_ARRAY_LENGTH; i++) {
      float val = x[i];
      if (val > 10.0f) {
        x[i] += 99.1f;
      }
    }
  }

  /// CHECK-START-ARM64: void Main.$compile$noinline$SimpleDouble(double[]) loop_optimization (after)
  /// CHECK-IF:     hasIsaFeature("sve")
  //
  ///     CHECK-NOT: VecLoad
  //
  /// CHECK-FI:
  //
  // TODO: Support FP comparisons.
  public static void $compile$noinline$SimpleDouble(double[] x) {
    for (int i = 0; i < USED_ARRAY_LENGTH; i++) {
      double val = x[i];
      if (val != 10.0) {
        x[i] += 99.1;
      }
    }
  }

  //
  // Narrowing types.
  //

  /// CHECK-START-ARM64: void Main.$compile$noinline$ByteConv(byte[], byte[]) loop_optimization (after)
  /// CHECK-IF:     hasIsaFeature("sve")
  //
  ///     CHECK-DAG: VecLoad
  //
  /// CHECK-FI:
  public static void $compile$noinline$ByteConv(byte[] x, byte[] y) {
    for (int i = 0; i < USED_ARRAY_LENGTH; i++) {
      byte val = (byte)(x[i] + 1);
      if (val != y[i]) {
        x[i] += MAGIC_ADD_CONST;
      }
    }
  }

  /// CHECK-START-ARM64: void Main.$compile$noinline$UByteAndWrongConst(byte[]) loop_optimization (after)
  /// CHECK-IF:     hasIsaFeature("sve")
  //
  ///     CHECK-NOT: VecLoad
  //
  /// CHECK-FI:
  //
  // 'NarrowerOperands' not met: the constant is not a ubyte one.
  public static void $compile$noinline$UByteAndWrongConst(byte[] x) {
    for (int i = 0; i < USED_ARRAY_LENGTH; i++) {
      if ((x[i] & 0xFF) != (MAGIC_VALUE_C | 0x100)) {
        x[i] += MAGIC_ADD_CONST;
      }
    }
  }

  /// CHECK-START-ARM64: void Main.$compile$noinline$ByteNoHiBits(byte[], byte[]) loop_optimization (after)
  /// CHECK-IF:     hasIsaFeature("sve")
  //
  ///     CHECK-NOT: VecLoad
  //
  /// CHECK-FI:
  //
  // Check kNoHiBits case when "wider" operations cannot bring in higher order bits.
  public static void $compile$noinline$ByteNoHiBits(byte[] x, byte[] y) {
    for (int i = 0; i < USED_ARRAY_LENGTH; i++) {
      byte val = x[i];
      if ((val >>> 3) != y[i]) {
        x[i] += MAGIC_ADD_CONST;
      }
    }
  }

  //
  // Test condition types.
  //

  /// CHECK-START-ARM64: void Main.$compile$noinline$SimpleBelow(int[]) loop_optimization (after)
  /// CHECK-IF:     hasIsaFeature("sve")
  //
  ///     CHECK-NOT: VecLoad
  //
  /// CHECK-FI:
  //
  // TODO: Support other conditions.
  public static void $compile$noinline$SimpleBelow(int[] x) {
    for (int i = 0; i < USED_ARRAY_LENGTH; i++) {
      int val = x[i];
      if (val < MAGIC_VALUE_C) {
        x[i] += MAGIC_ADD_CONST;
      }
    }
  }

  //
  // Test vectorization idioms.
  //

  /// CHECK-START-ARM64: void Main.$compile$noinline$Select(int[]) loop_optimization (after)
  /// CHECK-IF:     hasIsaFeature("sve")
  //
  ///     CHECK-NOT: VecLoad
  //
  /// CHECK-FI:
  //
  // TODO: vectorize loops with select in the body.
  public static void $compile$noinline$Select(int[] x) {
    for (int i = 0; i < USED_ARRAY_LENGTH; i++) {
      int val = x[i];
      if (val != MAGIC_VALUE_C) {
        val += MAGIC_ADD_CONST;
      }
      x[i] = val;
    }
  }

  /// CHECK-START-ARM64: void Main.$compile$noinline$Phi(int[]) loop_optimization (after)
  /// CHECK-IF:     hasIsaFeature("sve")
  //
  ///     CHECK-NOT: VecLoad
  //
  /// CHECK-FI:
  //
  // TODO: vectorize loops with phis in the body.
  public static void $compile$noinline$Phi(int[] x) {
    for (int i = 0; i < USED_ARRAY_LENGTH; i++) {
      int val = x[i];
      if (val != MAGIC_VALUE_C) {
        val += MAGIC_ADD_CONST;
        x[i] += val;
      }
      x[i] += val;
    }
  }

  // TODO: when Phis are supported, test dotprod and sad idioms.

  /// CHECK-START-ARM64: int Main.$compile$noinline$Reduction(int[]) loop_optimization (after)
  /// CHECK-IF:     hasIsaFeature("sve")
  //
  ///     CHECK-NOT: VecLoad
  //
  /// CHECK-FI:
  //
  // TODO: vectorize loops with phis and reductions in the body.
  private static int $compile$noinline$Reduction(int[] x) {
    int sum = 0;
    for (int i = 0; i < ARRAY_LENGTH; i++) {
      int val = x[i];
      if (val != MAGIC_VALUE_C) {
        sum += val + x[i];
      }
    }
    return sum;
  }

  /// CHECK-START-ARM64: int Main.$compile$noinline$ReductionBackEdge(int[]) loop_optimization (after)
  /// CHECK-IF:     hasIsaFeature("sve")
  //
  ///     CHECK-DAG: VecLoad
  //
  /// CHECK-FI:
  //
  // Reduction in the back edge block, non-CF-dependent.
  public static int $compile$noinline$ReductionBackEdge(int[] x) {
    int sum = 0;
    for (int i = 0; i < USED_ARRAY_LENGTH; i++) {
      int val = x[i];
      if (val != MAGIC_VALUE_C) {
        x[i] += MAGIC_ADD_CONST;
      }
      sum += x[i];
    }
    return sum;
  }

  //
  // Negative compile tests.
  //

  public static final int STENCIL_ARRAY_SIZE = 130;

  /// CHECK-START-ARM64: void Main.$compile$noinline$stencilAlike(int[], int[]) loop_optimization (after)
  /// CHECK-IF:     hasIsaFeature("sve")
  //
  ///     CHECK-NOT: VecLoad
  //
  /// CHECK-FI:
  //
  // This loop needs a runtime test for array references disambiguation and a scalar cleanup loop.
  // Currently we can't generate a scalar clean up loop with control flow.
  private static void $compile$noinline$stencilAlike(int[] a, int[] b) {
    for (int i = 1; i < STENCIL_ARRAY_SIZE - 1; i++) {
      int val0 = b[i - 1];
      int val1 = b[i];
      int val2 = b[i + 1];
      int un = a[i];
      if (val1 != MAGIC_VALUE_C) {
        a[i] = val0 + val1 + val2;
      }
    }
  }

  /// CHECK-START-ARM64: void Main.$compile$noinline$NotDiamondCf(int[]) loop_optimization (after)
  /// CHECK-IF:     hasIsaFeature("sve")
  //
  ///     CHECK-NOT: VecLoad
  //
  /// CHECK-FI:
  //
  // Loops with complex CF are not supported.
  public static void $compile$noinline$NotDiamondCf(int[] x) {
    for (int i = 0; i < USED_ARRAY_LENGTH; i++) {
      int val = x[i];
      if (val != MAGIC_VALUE_C) {
        if (val != 1234) {
          x[i] += MAGIC_ADD_CONST;
        }
      }
    }
  }

  /// CHECK-START-ARM64: void Main.$compile$noinline$BrokenInduction(int[]) loop_optimization (after)
  /// CHECK-IF:     hasIsaFeature("sve")
  //
  ///     CHECK-NOT: VecLoad
  //
  /// CHECK-FI:
  public static void $compile$noinline$BrokenInduction(int[] x) {
    for (int i = 0; i < USED_ARRAY_LENGTH; i++) {
      int val = x[i];
      if (val != MAGIC_VALUE_C) {
        x[i] += MAGIC_ADD_CONST;
        i++;
      }
    }
  }

  //
  // Main driver.
  //

  public static void main(String[] args) {
    initIntArray(intArray);
    int final_ind_value = $compile$noinline$FullDiamond(intArray);
    expectIntEquals(23755, IntArraySum(intArray));
    expectIntEquals(USED_ARRAY_LENGTH, final_ind_value);

    // Types.
    initBooleanArray(booleanArray);
    booleanArray2[12] = true;
    $compile$noinline$SimpleBoolean(booleanArray, booleanArray2);
    expectIntEquals(86, BooleanArraySum(booleanArray));

    initByteArray(byteArray);
    $compile$noinline$SimpleByte(byteArray);
    expectIntEquals(-64, ByteArraySum(byteArray));

    initByteArray(byteArray);
    $compile$noinline$SimpleUByte(byteArray);
    expectIntEquals(-64, ByteArraySum(byteArray));

    initShortArray(shortArray);
    $compile$noinline$SimpleShort(shortArray);
    expectIntEquals(23121, ShortArraySum(shortArray));

    initCharArray(charArray);
    $compile$noinline$SimpleChar(charArray);
    expectIntEquals(23121, CharArraySum(charArray));

    initIntArray(intArray);
    $compile$noinline$SimpleInt(intArray);
    expectIntEquals(23121, IntArraySum(intArray));

    initLongArray(longArray);
    $compile$noinline$SimpleLong(longArray);
    expectLongEquals(23121, LongArraySum(longArray));

    initFloatArray(floatArray);
    $compile$noinline$SimpleFloat(floatArray);
    expectFloatEquals(18868.2f, FloatArraySum(floatArray));

    initDoubleArray(doubleArray);
    $compile$noinline$SimpleDouble(doubleArray);
    expectDoubleEquals(23129.5, DoubleArraySum(doubleArray));

    // Narrowing types.
    initByteArray(byteArray);
    $compile$noinline$ByteConv(byteArray, byteArray);
    expectIntEquals(-2, ByteArraySum(byteArray));

    initByteArray(byteArray);
    $compile$noinline$UByteAndWrongConst(byteArray);
    expectIntEquals(-2, ByteArraySum(byteArray));

    initByteArray(byteArray);
    $compile$noinline$ByteNoHiBits(byteArray, byteArray);
    expectIntEquals(-2, ByteArraySum(byteArray));

    // Conditions.
    initIntArray(intArray);
    $compile$noinline$SimpleBelow(intArray);
    expectIntEquals(23121, IntArraySum(intArray));

    // Idioms.
    initIntArray(intArray);
    $compile$noinline$Select(intArray);
    expectIntEquals(23121, IntArraySum(intArray));

    initIntArray(intArray);
    $compile$noinline$Phi(intArray);
    expectIntEquals(36748, IntArraySum(intArray));

    int reduction_result = 0;

    initIntArray(intArray);
    reduction_result = $compile$noinline$Reduction(intArray);
    expectIntEquals(14706, IntArraySum(intArray));
    expectIntEquals(21012, reduction_result);

    initIntArray(intArray);
    reduction_result = $compile$noinline$ReductionBackEdge(intArray);
    expectIntEquals(23121, IntArraySum(intArray));
    expectIntEquals(13121, reduction_result);

    int[] stencilArrayA = new int[STENCIL_ARRAY_SIZE];
    int[] stencilArrayB = new int[STENCIL_ARRAY_SIZE];
    initIntArray(stencilArrayA);
    initIntArray(stencilArrayB);
    $compile$noinline$stencilAlike(stencilArrayA, stencilArrayB);
    expectIntEquals(43602, IntArraySum(stencilArrayA));

    initIntArray(intArray);
    $compile$noinline$NotDiamondCf(intArray);
    expectIntEquals(23121, IntArraySum(intArray));

    initIntArray(intArray);
    $compile$noinline$BrokenInduction(intArray);
    expectIntEquals(18963, IntArraySum(intArray));

    System.out.println("passed");
  }

  public static void initBooleanArray(boolean[] a) {
    for (int i = 0; i < ARRAY_LENGTH; i++) {
      if (i % 3 != 0) {
        a[i] = true;
      }
    }
  }

  public static void initByteArray(byte[] a) {
    for (int i = 0; i < ARRAY_LENGTH; i++) {
      if (i % 3 == 0) {
        a[i] = (byte)MAGIC_VALUE_A;
      } else if (i % 3 == 1) {
        a[i] = (byte)MAGIC_VALUE_B;
      } else {
        a[i] = (byte)MAGIC_VALUE_C;
      }
    }
    a[USED_ARRAY_LENGTH] = 127;
  }

  public static void initShortArray(short[] a) {
    for (int i = 0; i < ARRAY_LENGTH; i++) {
      if (i % 3 == 0) {
        a[i] = (short)MAGIC_VALUE_A;
      } else if (i % 3 == 1) {
        a[i] = (short)MAGIC_VALUE_B;
      } else {
        a[i] = (short)MAGIC_VALUE_C;
      }
    }
    a[USED_ARRAY_LENGTH] = 10000;
  }

  public static void initCharArray(char[] a) {
    for (int i = 0; i < ARRAY_LENGTH; i++) {
      if (i % 3 == 0) {
        a[i] = (char)MAGIC_VALUE_A;
      } else if (i % 3 == 1) {
        a[i] = (char)MAGIC_VALUE_B;
      } else {
        a[i] = (char)MAGIC_VALUE_C;
      }
    }
    a[USED_ARRAY_LENGTH] = 10000;
  }

  public static void initIntArray(int[] a) {
    for (int i = 0; i < ARRAY_LENGTH; i++) {
      if (i % 3 == 0) {
        a[i] = MAGIC_VALUE_A;
      } else if (i % 3 == 1) {
        a[i] = MAGIC_VALUE_B;
      } else {
        a[i] = MAGIC_VALUE_C;
      }
    }
    a[USED_ARRAY_LENGTH] = 10000;
  }

  public static void initLongArray(long[] a) {
    for (int i = 0; i < ARRAY_LENGTH; i++) {
      if (i % 3 == 0) {
        a[i] = MAGIC_VALUE_A;
      } else if (i % 3 == 1) {
        a[i] = MAGIC_VALUE_B;
      } else {
        a[i] = MAGIC_VALUE_C;
      }
    }
    a[USED_ARRAY_LENGTH] = 10000;
  }

  public static void initFloatArray(float[] a) {
    for (int i = 0; i < ARRAY_LENGTH; i++) {
      if (i % 3 == 0) {
        a[i] = MAGIC_FLOAT_VALUE_A;
      } else if (i % 3 == 1) {
        a[i] = MAGIC_FLOAT_VALUE_B;
      } else {
        a[i] = MAGIC_FLOAT_VALUE_C;
      }
    }
    a[USED_ARRAY_LENGTH] = 10000.0f;
  }

  public static void initDoubleArray(double[] a) {
    for (int i = 0; i < ARRAY_LENGTH; i++) {
      if (i % 3 == 0) {
        a[i] = MAGIC_FLOAT_VALUE_A;
      } else if (i % 3 == 1) {
        a[i] = MAGIC_FLOAT_VALUE_B;
      } else {
        a[i] = MAGIC_FLOAT_VALUE_C;
      }
    }
    a[USED_ARRAY_LENGTH] = 10000.0f;
  }

  public static byte BooleanArraySum(boolean[] a) {
    byte sum = 0;
    for (int i = 0; i < a.length; i++) {
      sum += a[i] ? 1 : 0;
    }
    return sum;
  }

  public static byte ByteArraySum(byte[] a) {
    byte sum = 0;
    for (int i = 0; i < a.length; i++) {
      sum += a[i];
    }
    return sum;
  }

  public static short ShortArraySum(short[] a) {
    short sum = 0;
    for (int i = 0; i < a.length; i++) {
      sum += a[i];
    }
    return sum;
  }

  public static char CharArraySum(char[] a) {
    char sum = 0;
    for (int i = 0; i < a.length; i++) {
      sum += a[i];
    }
    return sum;
  }

  public static int IntArraySum(int[] a) {
    int sum = 0;
    for (int i = 0; i < a.length; i++) {
      sum += a[i];
    }
    return sum;
  }

  public static long LongArraySum(long[] a) {
    long sum = 0;
    for (int i = 0; i < a.length; i++) {
      sum += a[i];
    }
    return sum;
  }

  public static float FloatArraySum(float[] a) {
    float sum = 0.0f;
    for (int i = 0; i < a.length; i++) {
      sum += a[i];
    }
    return sum;
  }

  public static double DoubleArraySum(double[] a) {
    double sum = 0.0;
    for (int i = 0; i < a.length; i++) {
      sum += a[i];
    }
    return sum;
  }

  private static void expectIntEquals(int expected, int result) {
    if (expected != result) {
      throw new Error("Expected: " + expected + ", found: " + result);
    }
  }

  private static void expectLongEquals(long expected, long result) {
    if (expected != result) {
      throw new Error("Expected: " + expected + ", found: " + result);
    }
  }

  private static void expectFloatEquals(float expected, float result) {
    final float THRESHOLD = .1f;
    if (Math.abs(expected - result) >= THRESHOLD) {
      throw new Error("Expected: " + expected + ", found: " + result);
    }
  }

  private static void expectDoubleEquals(double expected, double result) {
    final double THRESHOLD = .1;
    if (Math.abs(expected - result) >= THRESHOLD) {
      throw new Error("Expected: " + expected + ", found: " + result);
    }
  }
}