/*

 * Copyright (c) 1997, 2016, 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.

 */

/*

 *

 * A part of tests on the bug 4106263. CollationKey became non-final extendable class.

 *          The implementation of CollationKey is moved to the new private class,

 *          RuleBasedCollationKey. This test basically tests on the two features:

 *          1. Existing code using CollationKey works (backward compatiblility)

 *          2. CollationKey can be extended by its subclass.

 */

import java.util.Locale;

import java.text.Collator;

import java.text.CollationKey;

import java.io.*;

import java.text.*;

public class CollationKeyTestImpl extends CollationKey {

    private static String[] sourceData_ja = {

        "\u3042\u3044\u3046\u3048\u3048",

        "\u3041\u3043\u3045\u3047\u3049",

        "\u3052\u3054\u3056\u3058\u3058",

        "\u3051\u3053\u3055\u3057\u3059",

        "\u3062\u3064\u3066\u3068\u3068",

        "\u3061\u3063\u3065\u3067\u3069",

        "\u3072\u3074\u3075\u3078\u3078",

        "\u3071\u3073\u3075\u3077\u3079",

        "\u3082\u3084\u3085\u3088\u3088",

        "\u3081\u3083\u3085\u3087\u3089",

        "\u30a2\u30a4\u30a6\u30a8\u30aa",

        "\u30a1\u30a3\u30a5\u30a7\u30a9",

        "\u30c2\u30c4\u30c6\u30c8\u30ca",

        "\u30c1\u30c3\u30c5\u30c7\u30c9",

        "\u30b2\u30b4\u30b6\u30b8\u30ba",

        "\u30b1\u30b3\u30b5\u30b7\u30b9",

        "\u30d2\u30d4\u30d6\u30d8\u30da",

        "\u30d1\u30d3\u30d5\u30d7\u30d9",

        "\u30e2\u30e4\u30e6\u30e8\u30ea",

        "\u30e1\u30e3\u30e5\u30e7\u30e9"

        };

    private static final String[] targetData_ja = {

        "\u3042\u3044\u3046\u3048\u3048",

        "\u3041\u3043\u3045\u3047\u3049",

        "\u30a2\u30a4\u30a6\u30a8\u30aa",

        "\u30a1\u30a3\u30a5\u30a7\u30a9",

        "\u3052\u3054\u3056\u3058\u3058",

        "\u3051\u3053\u3055\u3057\u3059",

        "\u30b1\u30b3\u30b5\u30b7\u30b9",

        "\u30b2\u30b4\u30b6\u30b8\u30ba",

        "\u3061\u3063\u3065\u3067\u3069",

        "\u30c1\u30c3\u30c5\u30c7\u30c9",

        "\u3062\u3064\u3066\u3068\u3068",

        "\u30c2\u30c4\u30c6\u30c8\u30ca",

        "\u3071\u3073\u3075\u3077\u3079",

        "\u30d1\u30d3\u30d5\u30d7\u30d9",

        "\u3072\u3074\u3075\u3078\u3078",

        "\u30d2\u30d4\u30d6\u30d8\u30da",

        "\u3081\u3083\u3085\u3087\u3089",

        "\u30e1\u30e3\u30e5\u30e7\u30e9",

        "\u3082\u3084\u3085\u3088\u3088",

        "\u30e2\u30e4\u30e6\u30e8\u30ea"

        };

    public void run() {

        /** debug: printout the test data

        for (int i=0; i<sourceData_ja.length; i++){

                System.out.println(i+": "+sourceData_ja[i]);

        }

        **/

       /*

        * 1. Test the backward compatibility

        *    note: targetData_ja.length is equal to sourceData_ja.length

        */

        Collator myCollator = Collator.getInstance(Locale.JAPAN);

        CollationKey[] keys = new CollationKey[sourceData_ja.length];

        CollationKey[] target_keys = new CollationKey[targetData_ja.length];

        for (int i=0; i<sourceData_ja.length; i++){

                keys[i] = myCollator.getCollationKey(sourceData_ja[i]);

                target_keys[i] = myCollator.getCollationKey(targetData_ja[i]); //used later

        }

        /* Sort the string using CollationKey */

        InsertionSort(keys);

        /** debug: printout the result after sort

        System.out.println("--- After Sorting ---");

        for (int i=0; i<sourceData_ja.length; i++){

                System.out.println(i+" :"+keys[i].getSourceString());

        }

        **/

       /*

        * Compare the result using equals method and getSourceString method.

        */

        boolean pass = true;

        for (int i=0; i<sourceData_ja.length; i++){

                /* Comparing using String.equals: in order to use getStringSource() */

                if (! targetData_ja[i].equals(keys[i].getSourceString())){

                        throw new RuntimeException("FAILED: CollationKeyTest backward compatibility "

                                  +"while comparing" +targetData_ja[i]+" vs "

                                  +keys[i].getSourceString());

                }

                /* Comparing using CollaionKey.equals: in order to use equals() */

                if (! target_keys[i].equals(keys[i])){

                        throw new RuntimeException("FAILED: CollationKeyTest backward compatibility."

                                  +" Using CollationKey.equals " +targetData_ja[i]

                                  +" vs " +keys[i].getSourceString());

                }

                /* Comparing using CollaionKey.hashCode(): in order to use hashCode() */

                if (target_keys[i].hashCode() != keys[i].hashCode()){

                        throw new RuntimeException("FAILED: CollationKeyTest backward compatibility."

                                  +" Using CollationKey.hashCode " +targetData_ja[i]

                                  +" vs " +keys[i].getSourceString());

                }

                /* Comparing using CollaionKey.toByteArray(): in order to use toByteArray() */

                byte[] target_bytes = target_keys[i].toByteArray();

                byte[] source_bytes = keys[i].toByteArray();

                for (int j=0; j<target_bytes.length; j++){

                        Byte targetByte = new Byte(target_bytes[j]);

                        Byte sourceByte = new Byte(source_bytes[j]);

                        if (targetByte.compareTo(sourceByte)!=0){

                            throw new RuntimeException("FAILED: CollationKeyTest backward "

                                  +"compatibility. Using Byte.compareTo from CollationKey.toByteArray "

                                  +targetData_ja[i]

                                  +" vs " +keys[i].getSourceString());

                        }

                }

        }

        testSubclassMethods();

        testConstructor();

    }

   /*

    * Sort the array of CollationKey using compareTo method in insertion sort.

    */

    private  void  InsertionSort(CollationKey[] keys){

        int f, i;

        CollationKey tmp;

        for (f=1; f < keys.length; f++){

            if(keys[f].compareTo( keys[f-1]) > 0){

                continue;

            }

            tmp = keys[f];

            i = f-1;

            while ( (i>=0) && (keys[i].compareTo(tmp) > 0) ) {

                keys[i+1] = keys[i];

                i--;

            }

            keys[i+1]=tmp;

        }

    }

  /*

   * From here is the bogus methods to test the subclass of

   * the CollationKey class.

   */

    public CollationKeyTestImpl(String str){

        super (str);

        // debug: System.out.println("CollationKeyTest extends CollationKey class: "+str);

    }

    /* abstract method: needs to be implemented */

    public byte[] toByteArray(){

        String foo= "Hello";

        return foo.getBytes();

    }

   /* abstract method: needs to be implemented */

   public int compareTo(CollationKey target){

        return 0;

   }

   public boolean equals(Object target){

        return true;

   }

   public String getSourceString(){

        return "CollationKeyTestImpl";

   }

  /*

   * This method tests the collection of bugus methods from the extended

   * subclass of CollationKey class.

   */

   private void testSubclassMethods() {

        CollationKeyTestImpl clt1  = new CollationKeyTestImpl("testSubclassMethods-1");

        CollationKeyTestImpl clt2  = new CollationKeyTestImpl("testSubclassMethods-2");

        // extended method, equals always returns true

        if (!clt1.equals(clt2)){

            throw new RuntimeException("Failed: equals(CollationKeySubClass)");

        }

        // extended method, compareTo always returns 0

        if (clt1.compareTo(clt2)!=0){

            throw new RuntimeException("Failed: compareTo(CollationKeySubClass)");

        }

        // overriding extended method, getSourceString always returns "CollationKeyTestImpl"

        if (! clt1.getSourceString().equals("CollationKeyTestImpl")){

            throw new RuntimeException("Failed: CollationKey subclass overriding getSourceString()");

        }

        // extended method, toByteArray always returns bytes from "Hello"

        String str2 = new String( clt2.toByteArray());

        if (! clt2.equals("Hello")){

            throw new RuntimeException("Failed: CollationKey subclass toByteArray()");

        }

    }

  /*

   * This method tests CollationKey constructor with null source string.

   * It should throw NPE.

   */

   private void testConstructor() {

       boolean npe=false;

       try{

            CollationKeyTestImpl cltNull  = new CollationKeyTestImpl(null);

        } catch (NullPointerException npException){

            npe=true;

            // debug: System.out.println("--- NPE is thrown with NULL arguement: PASS ---");

        }

        if(!npe){

           throw new RuntimeException("Failed: CollationKey Constructor with null source"+

                                   " didn't throw NPE!");

        }

    }

}