/*

 * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

/**

 * @test

 * @bug 8001183

 * @summary incorrect results of char vectors right shift operaiton

 *

 * @run main/othervm/timeout=400 -Xbatch -Xmx64m TestCharVect

 */

public class TestCharVect {

  private static final int ARRLEN = 997;

  private static final int ITERS  = 11000;

  private static final int ADD_INIT = Character.MAX_VALUE-500;

  private static final int BIT_MASK = 0xB731;

  private static final int VALUE = 7;

  private static final int SHIFT = 16;

  public static void main(String args[]) {

    System.out.println("Testing Char vectors");

    int errn = test();

    if (errn > 0) {

      System.err.println("FAILED: " + errn + " errors");

      System.exit(97);

    }

    System.out.println("PASSED");

  }

  static int test() {

    char[] a0 = new char[ARRLEN];

    char[] a1 = new char[ARRLEN];

    short[] a2 = new short[ARRLEN];

    short[] a3 = new short[ARRLEN];

    short[] a4 = new short[ARRLEN];

     int[] p2 = new  int[ARRLEN/2];

    long[] p4 = new long[ARRLEN/4];

    // Initialize

    int gold_sum = 0;

    for (int i=0; i<ARRLEN; i++) {

      char val = (char)(ADD_INIT+i);

      gold_sum += val;

      a1[i] = val;

      a2[i] = VALUE;

      a3[i] = -VALUE;

      a4[i] = (short)BIT_MASK;

    }

    System.out.println("Warmup");

    for (int i=0; i<ITERS; i++) {

      test_sum(a1);

      test_addc(a0, a1);

      test_addv(a0, a1, (char)VALUE);

      test_adda(a0, a1, a2);

      test_subc(a0, a1);

      test_subv(a0, a1, (char)VALUE);

      test_suba(a0, a1, a2);

      test_mulc(a0, a1);

      test_mulv(a0, a1, (char)VALUE);

      test_mula(a0, a1, a2);

      test_divc(a0, a1);

      test_divv(a0, a1, VALUE);

      test_diva(a0, a1, a2);

      test_mulc_n(a0, a1);

      test_mulv(a0, a1, (char)-VALUE);

      test_mula(a0, a1, a3);

      test_divc_n(a0, a1);

      test_divv(a0, a1, -VALUE);

      test_diva(a0, a1, a3);

      test_andc(a0, a1);

      test_andv(a0, a1, (short)BIT_MASK);

      test_anda(a0, a1, a4);

      test_orc(a0, a1);

      test_orv(a0, a1, (short)BIT_MASK);

      test_ora(a0, a1, a4);

      test_xorc(a0, a1);

      test_xorv(a0, a1, (short)BIT_MASK);

      test_xora(a0, a1, a4);

      test_sllc(a0, a1);

      test_sllv(a0, a1, VALUE);

      test_srlc(a0, a1);

      test_srlv(a0, a1, VALUE);

      test_srac(a0, a1);

      test_srav(a0, a1, VALUE);

      test_sllc_n(a0, a1);

      test_sllv(a0, a1, -VALUE);

      test_srlc_n(a0, a1);

      test_srlv(a0, a1, -VALUE);

      test_srac_n(a0, a1);

      test_srav(a0, a1, -VALUE);

      test_sllc_o(a0, a1);

      test_sllv(a0, a1, SHIFT);

      test_srlc_o(a0, a1);

      test_srlv(a0, a1, SHIFT);

      test_srac_o(a0, a1);

      test_srav(a0, a1, SHIFT);

      test_sllc_on(a0, a1);

      test_sllv(a0, a1, -SHIFT);

      test_srlc_on(a0, a1);

      test_srlv(a0, a1, -SHIFT);

      test_srac_on(a0, a1);

      test_srav(a0, a1, -SHIFT);

      test_sllc_add(a0, a1);

      test_sllv_add(a0, a1, ADD_INIT);

      test_srlc_add(a0, a1);

      test_srlv_add(a0, a1, ADD_INIT);

      test_srac_add(a0, a1);

      test_srav_add(a0, a1, ADD_INIT);

      test_sllc_and(a0, a1);

      test_sllv_and(a0, a1, BIT_MASK);

      test_srlc_and(a0, a1);

      test_srlv_and(a0, a1, BIT_MASK);

      test_srac_and(a0, a1);

      test_srav_and(a0, a1, BIT_MASK);

      test_pack2(p2, a1);

      test_unpack2(a0, p2);

      test_pack2_swap(p2, a1);

      test_unpack2_swap(a0, p2);

      test_pack4(p4, a1);

      test_unpack4(a0, p4);

      test_pack4_swap(p4, a1);

      test_unpack4_swap(a0, p4);

    }

    // Test and verify results

    System.out.println("Verification");

    int errn = 0;

    {

      int sum = test_sum(a1);

      if (sum != gold_sum) {

        System.err.println("test_sum:  " + sum + " != " + gold_sum);

        errn++;

      }

      test_addc(a0, a1);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_addc: ", i, a0[i], (char)((char)(ADD_INIT+i)+VALUE));

      }

      test_addv(a0, a1, (char)VALUE);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_addv: ", i, a0[i], (char)((char)(ADD_INIT+i)+VALUE));

      }

      test_adda(a0, a1, a2);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_adda: ", i, a0[i], (char)((char)(ADD_INIT+i)+VALUE));

      }

      test_subc(a0, a1);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_subc: ", i, a0[i], (char)((char)(ADD_INIT+i)-VALUE));

      }

      test_subv(a0, a1, (char)VALUE);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_subv: ", i, a0[i], (char)((char)(ADD_INIT+i)-VALUE));

      }

      test_suba(a0, a1, a2);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_suba: ", i, a0[i], (char)((char)(ADD_INIT+i)-VALUE));

      }

      test_mulc(a0, a1);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_mulc: ", i, a0[i], (char)((char)(ADD_INIT+i)*VALUE));

      }

      test_mulv(a0, a1, (char)VALUE);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_mulv: ", i, a0[i], (char)((char)(ADD_INIT+i)*VALUE));

      }

      test_mula(a0, a1, a2);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_mula: ", i, a0[i], (char)((char)(ADD_INIT+i)*VALUE));

      }

      test_divc(a0, a1);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_divc: ", i, a0[i], (char)((char)(ADD_INIT+i)/VALUE));

      }

      test_divv(a0, a1, VALUE);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_divv: ", i, a0[i], (char)((char)(ADD_INIT+i)/VALUE));

      }

      test_diva(a0, a1, a2);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_diva: ", i, a0[i], (char)((char)(ADD_INIT+i)/VALUE));

      }

      test_mulc_n(a0, a1);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_mulc_n: ", i, a0[i], (char)((char)(ADD_INIT+i)*(-VALUE)));

      }

      test_mulv(a0, a1, (char)-VALUE);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_mulv_n: ", i, a0[i], (char)((char)(ADD_INIT+i)*(-VALUE)));

      }

      test_mula(a0, a1, a3);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_mula_n: ", i, a0[i], (char)((char)(ADD_INIT+i)*(-VALUE)));

      }

      test_divc_n(a0, a1);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_divc_n: ", i, a0[i], (char)((char)(ADD_INIT+i)/(-VALUE)));

      }

      test_divv(a0, a1, -VALUE);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_divv_n: ", i, a0[i], (char)((char)(ADD_INIT+i)/(-VALUE)));

      }

      test_diva(a0, a1, a3);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_diva_n: ", i, a0[i], (char)((char)(ADD_INIT+i)/(-VALUE)));

      }

      test_andc(a0, a1);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_andc: ", i, a0[i], (char)((char)(ADD_INIT+i)&BIT_MASK));

      }

      test_andv(a0, a1, (short)BIT_MASK);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_andv: ", i, a0[i], (char)((char)(ADD_INIT+i)&BIT_MASK));

      }

      test_anda(a0, a1, a4);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_anda: ", i, a0[i], (char)((char)(ADD_INIT+i)&BIT_MASK));

      }

      test_orc(a0, a1);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_orc: ", i, a0[i], (char)((char)(ADD_INIT+i)|BIT_MASK));

      }

      test_orv(a0, a1, (short)BIT_MASK);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_orv: ", i, a0[i], (char)((char)(ADD_INIT+i)|BIT_MASK));

      }

      test_ora(a0, a1, a4);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_ora: ", i, a0[i], (char)((char)(ADD_INIT+i)|BIT_MASK));

      }

      test_xorc(a0, a1);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_xorc: ", i, a0[i], (char)((char)(ADD_INIT+i)^BIT_MASK));

      }

      test_xorv(a0, a1, (short)BIT_MASK);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_xorv: ", i, a0[i], (char)((char)(ADD_INIT+i)^BIT_MASK));

      }

      test_xora(a0, a1, a4);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_xora: ", i, a0[i], (char)((char)(ADD_INIT+i)^BIT_MASK));

      }

      test_sllc(a0, a1);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_sllc: ", i, a0[i], (char)((char)(ADD_INIT+i)<<VALUE));

      }

      test_sllv(a0, a1, VALUE);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_sllv: ", i, a0[i], (char)((char)(ADD_INIT+i)<<VALUE));

      }

      test_srlc(a0, a1);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_srlc: ", i, a0[i], (char)((char)(ADD_INIT+i)>>>VALUE));

      }

      test_srlv(a0, a1, VALUE);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_srlv: ", i, a0[i], (char)((char)(ADD_INIT+i)>>>VALUE));

      }

      test_srac(a0, a1);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_srac: ", i, a0[i], (char)((char)(ADD_INIT+i)>>VALUE));

      }

      test_srav(a0, a1, VALUE);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_srav: ", i, a0[i], (char)((char)(ADD_INIT+i)>>VALUE));

      }

      test_sllc_n(a0, a1);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_sllc_n: ", i, a0[i], (char)((char)(ADD_INIT+i)<<(-VALUE)));

      }

      test_sllv(a0, a1, -VALUE);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_sllv_n: ", i, a0[i], (char)((char)(ADD_INIT+i)<<(-VALUE)));

      }

      test_srlc_n(a0, a1);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_srlc_n: ", i, a0[i], (char)((char)(ADD_INIT+i)>>>(-VALUE)));

      }

      test_srlv(a0, a1, -VALUE);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_srlv_n: ", i, a0[i], (char)((char)(ADD_INIT+i)>>>(-VALUE)));

      }

      test_srac_n(a0, a1);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_srac_n: ", i, a0[i], (char)((char)(ADD_INIT+i)>>(-VALUE)));

      }

      test_srav(a0, a1, -VALUE);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_srav_n: ", i, a0[i], (char)((char)(ADD_INIT+i)>>(-VALUE)));

      }

      test_sllc_o(a0, a1);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_sllc_o: ", i, a0[i], (char)((char)(ADD_INIT+i)<<SHIFT));

      }

      test_sllv(a0, a1, SHIFT);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_sllv_o: ", i, a0[i], (char)((char)(ADD_INIT+i)<<SHIFT));

      }

      test_srlc_o(a0, a1);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_srlc_o: ", i, a0[i], (char)((char)(ADD_INIT+i)>>>SHIFT));

      }

      test_srlv(a0, a1, SHIFT);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_srlv_o: ", i, a0[i], (char)((char)(ADD_INIT+i)>>>SHIFT));

      }

      test_srac_o(a0, a1);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_srac_o: ", i, a0[i], (char)((char)(ADD_INIT+i)>>SHIFT));

      }

      test_srav(a0, a1, SHIFT);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_srav_o: ", i, a0[i], (char)((char)(ADD_INIT+i)>>SHIFT));

      }

      test_sllc_on(a0, a1);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_sllc_on: ", i, a0[i], (char)((char)(ADD_INIT+i)<<(-SHIFT)));

      }

      test_sllv(a0, a1, -SHIFT);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_sllv_on: ", i, a0[i], (char)((char)(ADD_INIT+i)<<(-SHIFT)));

      }

      test_srlc_on(a0, a1);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_srlc_on: ", i, a0[i], (char)((char)(ADD_INIT+i)>>>(-SHIFT)));

      }

      test_srlv(a0, a1, -SHIFT);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_srlv_on: ", i, a0[i], (char)((char)(ADD_INIT+i)>>>(-SHIFT)));

      }

      test_srac_on(a0, a1);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_srac_on: ", i, a0[i], (char)((char)(ADD_INIT+i)>>(-SHIFT)));

      }

      test_srav(a0, a1, -SHIFT);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_srav_on: ", i, a0[i], (char)((char)(ADD_INIT+i)>>(-SHIFT)));

      }

      test_sllc_add(a0, a1);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_sllc_add: ", i, a0[i], (char)(((char)(ADD_INIT+i) + ADD_INIT)<<VALUE));

      }

      test_sllv_add(a0, a1, ADD_INIT);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_sllv_add: ", i, a0[i], (char)(((char)(ADD_INIT+i) + ADD_INIT)<<VALUE));

      }

      test_srlc_add(a0, a1);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_srlc_add: ", i, a0[i], (char)(((char)(ADD_INIT+i) + ADD_INIT)>>>VALUE));

      }

      test_srlv_add(a0, a1, ADD_INIT);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_srlv_add: ", i, a0[i], (char)(((char)(ADD_INIT+i) + ADD_INIT)>>>VALUE));

      }

      test_srac_add(a0, a1);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_srac_add: ", i, a0[i], (char)(((char)(ADD_INIT+i) + ADD_INIT)>>VALUE));

      }

      test_srav_add(a0, a1, ADD_INIT);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_srav_add: ", i, a0[i], (char)(((char)(ADD_INIT+i) + ADD_INIT)>>VALUE));

      }

      test_sllc_and(a0, a1);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_sllc_and: ", i, a0[i], (char)(((char)(ADD_INIT+i) & BIT_MASK)<<VALUE));

      }

      test_sllv_and(a0, a1, BIT_MASK);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_sllv_and: ", i, a0[i], (char)(((char)(ADD_INIT+i) & BIT_MASK)<<VALUE));

      }

      test_srlc_and(a0, a1);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_srlc_and: ", i, a0[i], (char)(((char)(ADD_INIT+i) & BIT_MASK)>>>VALUE));

      }

      test_srlv_and(a0, a1, BIT_MASK);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_srlv_and: ", i, a0[i], (char)(((char)(ADD_INIT+i) & BIT_MASK)>>>VALUE));

      }

      test_srac_and(a0, a1);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_srac_and: ", i, a0[i], (char)(((char)(ADD_INIT+i) & BIT_MASK)>>VALUE));

      }

      test_srav_and(a0, a1, BIT_MASK);

      for (int i=0; i<ARRLEN; i++) {

        errn += verify("test_srav_and: ", i, a0[i], (char)(((char)(ADD_INIT+i) & BIT_MASK)>>VALUE));

      }

      test_pack2(p2, a1);

      for (int i=0; i<ARRLEN/2; i++) {

        errn += verify("test_pack2: ", i, p2[i], ((int)(ADD_INIT+2*i) & 0xFFFF) | ((int)(ADD_INIT+2*i+1) << 16));

      }

      for (int i=0; i<ARRLEN; i++) {

        a0[i] = (char)-1;

      }

      test_unpack2(a0, p2);

      for (int i=0; i<(ARRLEN&(-2)); i++) {

        errn += verify("test_unpack2: ", i, a0[i], (char)(ADD_INIT+i));

      }

      test_pack2_swap(p2, a1);

      for (int i=0; i<ARRLEN/2; i++) {

        errn += verify("test_pack2_swap: ", i, p2[i], ((int)(ADD_INIT+2*i+1) & 0xFFFF) | ((int)(ADD_INIT+2*i) << 16));

      }

      for (int i=0; i<ARRLEN; i++) {

        a0[i] = (char)-1;

      }

      test_unpack2_swap(a0, p2);

      for (int i=0; i<(ARRLEN&(-2)); i++) {

        errn += verify("test_unpack2_swap: ", i, a0[i], (char)(ADD_INIT+i));

      }

      test_pack4(p4, a1);

      for (int i=0; i<ARRLEN/4; i++) {

        errn += verify("test_pack4: ", i, p4[i],  ((long)(ADD_INIT+4*i+0) & 0xFFFFl) |

                                                 (((long)(ADD_INIT+4*i+1) & 0xFFFFl) << 16)  |

                                                 (((long)(ADD_INIT+4*i+2) & 0xFFFFl) << 32)  |

                                                 (((long)(ADD_INIT+4*i+3) & 0xFFFFl) << 48));

      }

      for (int i=0; i<ARRLEN; i++) {

        a0[i] = (char)-1;

      }

      test_unpack4(a0, p4);

      for (int i=0; i<(ARRLEN&(-4)); i++) {

        errn += verify("test_unpack4: ", i, a0[i], (char)(ADD_INIT+i));

      }

      test_pack4_swap(p4, a1);

      for (int i=0; i<ARRLEN/4; i++) {

        errn += verify("test_pack4_swap: ", i, p4[i],  ((long)(ADD_INIT+4*i+3) & 0xFFFFl) |

                                                      (((long)(ADD_INIT+4*i+2) & 0xFFFFl) << 16)  |

                                                      (((long)(ADD_INIT+4*i+1) & 0xFFFFl) << 32)  |

                                                      (((long)(ADD_INIT+4*i+0) & 0xFFFFl) << 48));

      }

      for (int i=0; i<ARRLEN; i++) {

        a0[i] = (char)-1;

      }

      test_unpack4_swap(a0, p4);

      for (int i=0; i<(ARRLEN&(-4)); i++) {

        errn += verify("test_unpack4_swap: ", i, a0[i], (char)(ADD_INIT+i));

      }

    }

    if (errn > 0)

      return errn;

    System.out.println("Time");

    long start, end;

    start = System.currentTimeMillis();

    for (int i=0; i<ITERS; i++) {

      test_sum(a1);

    }

    end = System.currentTimeMillis();

    System.out.println("test_sum: " + (end - start));

    start = System.currentTimeMillis();

    for (int i=0; i<ITERS; i++) {

      test_addc(a0, a1);

    }

    end = System.currentTimeMillis();

    System.out.println("test_addc: " + (end - start));

    start = System.currentTimeMillis();

    for (int i=0; i<ITERS; i++) {

      test_addv(a0, a1, (char)VALUE);

    }

    end = System.currentTimeMillis();

    System.out.println("test_addv: " + (end - start));

    start = System.currentTimeMillis();

    for (int i=0; i<ITERS; i++) {

      test_adda(a0, a1, a2);

    }

    end = System.currentTimeMillis();

    System.out.println("test_adda: " + (end - start));