/* 
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.
 */
package org.apache.harmony.text.tests.java.text;

import dalvik.annotation.KnownFailure;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetClass;
import dalvik.annotation.TestTargetNew;
import dalvik.annotation.TestTargets;

import java.io.UnsupportedEncodingException;
import java.text.CollationKey;
import java.text.Collator;
import java.text.ParseException;
import java.text.RuleBasedCollator;
import java.util.Locale;

@TestTargetClass(Collator.class) 
public class CollatorTest extends junit.framework.TestCase {

    /**
     * @tests java.text.Collator#clone()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "clone",
        args = {}
    )
    public void test_clone() {
        Collator c = Collator.getInstance(Locale.GERMAN);
        Collator c2 = (Collator) c.clone();
        assertTrue("Clones answered false to equals", c.equals(c2));
        assertTrue("Clones were equivalent", c != c2);
    }

    /**
     * @tests java.text.Collator#compare(java.lang.Object, java.lang.Object)
     */
    @TestTargets({
        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "",
            method = "compare",
            args = {java.lang.Object.class, java.lang.Object.class}
        ),
        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "",
            method = "setStrength",
            args = {int.class}
        )
    })
    public void test_compareLjava_lang_ObjectLjava_lang_Object() {
        Collator c = Collator.getInstance(Locale.FRENCH);
        Object o, o2;

        c.setStrength(Collator.IDENTICAL);
        o = "E";
        o2 = "F";
        assertTrue("a) Failed on primary difference", c.compare(o, o2) < 0);
        o = "e";
        o2 = "\u00e9";
        assertTrue("a) Failed on secondary difference", c.compare(o, o2) < 0);
        o = "e";
        o2 = "E";
        assertTrue("a) Failed on tertiary difference", c.compare(o, o2) < 0);
        o = "\u0001";
        o2 = "\u0002";
        assertTrue("a) Failed on identical", c.compare(o, o2) < 0);
        o = "e";
        o2 = "e";
        assertEquals("a) Failed on equivalence", 0, c.compare(o, o2));
        assertTrue("a) Failed on primary expansion",
                c.compare("\u01db", "v") < 0);

        c.setStrength(Collator.TERTIARY);
        o = "E";
        o2 = "F";
        assertTrue("b) Failed on primary difference", c.compare(o, o2) < 0);
        o = "e";
        o2 = "\u00e9";
        assertTrue("b) Failed on secondary difference", c.compare(o, o2) < 0);
        o = "e";
        o2 = "E";
        assertTrue("b) Failed on tertiary difference", c.compare(o, o2) < 0);
        o = "\u0001";
        o2 = "\u0002";
        assertEquals("b) Failed on identical", 0, c.compare(o, o2));
        o = "e";
        o2 = "e";
        assertEquals("b) Failed on equivalence", 0, c.compare(o, o2));

        c.setStrength(Collator.SECONDARY);
        o = "E";
        o2 = "F";
        assertTrue("c) Failed on primary difference", c.compare(o, o2) < 0);
        o = "e";
        o2 = "\u00e9";
        assertTrue("c) Failed on secondary difference", c.compare(o, o2) < 0);
        o = "e";
        o2 = "E";
        assertEquals("c) Failed on tertiary difference", 0, c.compare(o, o2));
        o = "\u0001";
        o2 = "\u0002";
        assertEquals("c) Failed on identical", 0, c.compare(o, o2));
        o = "e";
        o2 = "e";
        assertEquals("c) Failed on equivalence", 0, c.compare(o, o2));

        c.setStrength(Collator.PRIMARY);
        o = "E";
        o2 = "F";
        assertTrue("d) Failed on primary difference", c.compare(o, o2) < 0);
        o = "e";
        o2 = "\u00e9";
        assertEquals("d) Failed on secondary difference", 0, c.compare(o, o2));
        o = "e";
        o2 = "E";
        assertEquals("d) Failed on tertiary difference", 0, c.compare(o, o2));
        o = "\u0001";
        o2 = "\u0002";
        assertEquals("d) Failed on identical", 0, c.compare(o, o2));
        o = "e";
        o2 = "e";
        assertEquals("d) Failed on equivalence", 0, c.compare(o, o2));

        try {
            c.compare("e", new StringBuffer("Blah"));
        } catch (ClassCastException e) {
            // correct
            return;
        }
        fail("Failed to throw ClassCastException");
    }

    /**
     * @tests java.text.Collator#equals(java.lang.Object)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "equals",
        args = {java.lang.Object.class}
    )
    public void test_equalsLjava_lang_Object() {
        Collator c = Collator.getInstance(Locale.ENGLISH);
        Collator c2 = (Collator) c.clone();
        assertTrue("Cloned collators not equal", c.equals(c2));
        c2.setStrength(Collator.SECONDARY);
        assertTrue("Collators with different strengths equal", !c.equals(c2));
    }

    /**
     * @tests java.text.Collator#equals(java.lang.String, java.lang.String)
     */
    @TestTargets({
        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "",
            method = "equals",
            args = {java.lang.String.class, java.lang.String.class}
        ),
        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "",
            method = "setStrength",
            args = {int.class}
        )
    })
    public void test_equalsLjava_lang_StringLjava_lang_String() {
        Collator c = Collator.getInstance(Locale.FRENCH);

        c.setStrength(Collator.IDENTICAL);
        assertTrue("a) Failed on primary difference", !c.equals("E", "F"));
        assertTrue("a) Failed on secondary difference", !c
                .equals("e", "\u00e9"));
        assertTrue("a) Failed on tertiary difference", !c.equals("e", "E"));
        assertTrue("a) Failed on identical", !c.equals("\u0001", "\u0002"));
        assertTrue("a) Failed on equivalence", c.equals("e", "e"));

        c.setStrength(Collator.TERTIARY);
        assertTrue("b) Failed on primary difference", !c.equals("E", "F"));
        assertTrue("b) Failed on secondary difference", !c
                .equals("e", "\u00e9"));
        assertTrue("b) Failed on tertiary difference", !c.equals("e", "E"));
        assertTrue("b) Failed on identical", c.equals("\u0001", "\u0002"));
        assertTrue("b) Failed on equivalence", c.equals("e", "e"));

        c.setStrength(Collator.SECONDARY);
        assertTrue("c) Failed on primary difference", !c.equals("E", "F"));
        assertTrue("c) Failed on secondary difference", !c
                .equals("e", "\u00e9"));
        assertTrue("c) Failed on tertiary difference", c.equals("e", "E"));
        assertTrue("c) Failed on identical", c.equals("\u0001", "\u0002"));
        assertTrue("c) Failed on equivalence", c.equals("e", "e"));

        c.setStrength(Collator.PRIMARY);
        assertTrue("d) Failed on primary difference", !c.equals("E", "F"));
        assertTrue("d) Failed on secondary difference", c.equals("e", "\u00e9"));
        assertTrue("d) Failed on tertiary difference", c.equals("e", "E"));
        assertTrue("d) Failed on identical", c.equals("\u0001", "\u0002"));
        assertTrue("d) Failed on equivalence", c.equals("e", "e"));
    }

    /**
     * @tests java.text.Collator#getAvailableLocales()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "getAvailableLocales",
        args = {}
    )
    public void test_getAvailableLocales() {
        Locale[] locales = Collator.getAvailableLocales();
        assertTrue("No locales", locales.length > 0);
        boolean hasUS = false;
        for (int i = locales.length; --i >= 0;) {
            Collator c1 = Collator.getInstance(locales[i]);
            assertTrue("Doesn't work", c1.compare("a", "b") < 0);
            assertTrue("Wrong decomposition",
                    c1.getDecomposition() == Collator.NO_DECOMPOSITION);
            assertTrue("Wrong strength", c1.getStrength() == Collator.TERTIARY);
            // The default decomposition for collators created with getInstance
            // is NO_DECOMPOSITION where collators created from rules have
            // CANONICAL_DECOMPOSITION. Verified on RI.
            c1.setDecomposition(Collator.CANONICAL_DECOMPOSITION);
            if (locales[i].equals(Locale.US)) {
                hasUS = true;
            }
            if (c1 instanceof RuleBasedCollator) {
                String rule = "";
                Collator temp = null;
                try {
                    rule = ((RuleBasedCollator) c1).getRules();
                    temp = new RuleBasedCollator(rule);
                } catch (ParseException e) {
                    fail(e.getMessage() + " for rule: \"" + rule + "\"");
                }
                assertTrue("Can't recreate: " + locales[i], temp.equals(c1));
            }
        }
        assertTrue("en_US locale not available", hasUS);
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "Collator",
        args = {}
    )
    public void test_Constructor() {
        TestCollator collator = new TestCollator();
        assertEquals(Collator.TERTIARY, collator.getStrength());
    }
    
    /**
     * @tests java.text.Collator#getDecomposition()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "getDecomposition",
        args = {}
    )
    public void test_getDecomposition() {
        RuleBasedCollator collator;
        try {
            collator = new RuleBasedCollator("; \u0300 < a, A < b < c < d");
        } catch (ParseException e) {
            fail("ParseException");
            return;
        }
        assertTrue("Wrong default",
                collator.getDecomposition() == Collator.CANONICAL_DECOMPOSITION);
        
        collator.setDecomposition(Collator.NO_DECOMPOSITION);
        assertEquals(Collator.NO_DECOMPOSITION, collator.getDecomposition());

        // BEGIN android-removed
        // Android doesn't support full decomposition
        // collator.setDecomposition(Collator.FULL_DECOMPOSITION);
        // assertEquals(Collator.FULL_DECOMPOSITION, collator.getDecomposition());
        // EN android-removed
    }

    /**
     * @tests java.text.Collator#getInstance()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getInstance",
        args = {}
    )
    public void test_getInstance() {
        Collator c1 = Collator.getInstance();
        Collator c2 = Collator.getInstance(Locale.getDefault());
        assertTrue("Wrong locale", c1.equals(c2));
    }

    /**
     * @tests java.text.Collator#getInstance(java.util.Locale)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getInstance",
        args = {java.util.Locale.class}
    )
    public void test_getInstanceLjava_util_Locale() {
        assertTrue("Used to test", true);
    }

    /**
     * @tests java.text.Collator#getStrength()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getStrength",
        args = {}
    )
    public void test_getStrength() {
        RuleBasedCollator collator;
        try {
            collator = new RuleBasedCollator("; \u0300 < a, A < b < c < d");
        } catch (ParseException e) {
            fail("ParseException");
            return;
        }
        assertTrue("Wrong default", collator.getStrength() == Collator.TERTIARY);
    }

    /**
     * @tests java.text.Collator#setDecomposition(int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "setDecomposition",
        args = {int.class}
    )
    public void test_setDecompositionI() {
        Collator c = Collator.getInstance(Locale.FRENCH);
        c.setStrength(Collator.IDENTICAL);
        c.setDecomposition(Collator.NO_DECOMPOSITION);
        assertFalse("Collator should not be using decomposition", c.equals(
                "\u212B", "\u00C5")); // "ANGSTROM SIGN" and "LATIN CAPITAL
                                      // LETTER A WITH RING ABOVE"
        c.setDecomposition(Collator.CANONICAL_DECOMPOSITION);
        assertTrue("Collator should be using decomposition", c.equals("\u212B",
                "\u00C5")); // "ANGSTROM SIGN" and "LATIN CAPITAL LETTER A WITH
        // RING ABOVE"
        // BEGIN android-removed
        // Android doesn't support FULL_DECOMPOSITION
        // c.setDecomposition(Collator.FULL_DECOMPOSITION);
        // assertTrue("Should be equal under full decomposition", c.equals(
        //         "\u2163", "IV")); // roman number "IV"
        // END android-removed
        
        try {
            c.setDecomposition(-1);
            fail("IllegalArgumentException should be thrown.");
        } catch(IllegalArgumentException iae) {
            //expected
        }
    }

    /**
     * @tests java.text.Collator#setStrength(int)
     */
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "Verifies IllegalArgumentException.",
        method = "setStrength",
        args = {int.class}
    )
    public void test_setStrengthI() {
        // Functionality is verified in compare and equals tests.
        Collator collator = Collator.getInstance();
        collator.setStrength(Collator.PRIMARY);
        assertEquals(Collator.PRIMARY, collator.getStrength());
        
        collator.setStrength(Collator.SECONDARY);
        assertEquals(Collator.SECONDARY, collator.getStrength());
        
        collator.setStrength(Collator.TERTIARY);
        assertEquals(Collator.TERTIARY, collator.getStrength());
        
        collator.setStrength(Collator.IDENTICAL);
        assertEquals(Collator.IDENTICAL, collator.getStrength());        
        
        try {
            collator.setStrength(-1);
            fail("IllegalArgumentException was not thrown.");
        } catch(IllegalArgumentException  iae) {
            //expected
        }        
    }
    // Regression test for Android bug   
    @TestTargets({
        @TestTargetNew(
            level = TestLevel.PARTIAL,
            notes = "Regression test.",
            method = "setStrength",
            args = {int.class}
        ),
        @TestTargetNew(
            level = TestLevel.PARTIAL,
            notes = "Regression test.",
            method = "getCollationKey",
            args = {java.lang.String.class}
        )
    })
    public void test_stackCorruption() {
        Collator mColl = Collator.getInstance();
        mColl.setStrength(Collator.PRIMARY);
        mColl.getCollationKey("2d294f2d3739433565147655394f3762f3147312d3731641452f310");    
    }
    
    // Test to verify that very large collation keys are not truncated.
    @TestTargetNew(
        level = TestLevel.PARTIAL,
        notes = "Doesn't verify null as a parameter.",
        method = "getCollationKey",
        args = {java.lang.String.class}
    )
    public void test_collationKeySize() {
        StringBuilder b = new StringBuilder();
        for (int i = 0; i < 1024; i++) {
            b.append("0123456789ABCDEF");
        }
        String sixteen = b.toString();
        b.append("_THE_END");
        String sixteenplus = b.toString();
        
        Collator mColl = Collator.getInstance();
        mColl.setStrength(Collator.PRIMARY);

        try {
            byte [] arr = mColl.getCollationKey(sixteen).toByteArray();
            int len = arr.length;
            assertTrue("Collation key not 0 terminated", arr[arr.length - 1] == 0);
            len--;
            String foo = new String(arr, 0, len, "iso8859-1");

            arr = mColl.getCollationKey(sixteen).toByteArray();
            len = arr.length;
            assertTrue("Collation key not 0 terminated", arr[arr.length - 1] == 0);
            len--;
            String bar = new String(arr, 0, len, "iso8859-1");
            
            assertTrue("Collation keys should differ", foo.equals(bar));
        } catch (UnsupportedEncodingException ex) {
            fail("UnsupportedEncodingException");
        }
    }
    @TestTargets({
        @TestTargetNew(
            level = TestLevel.PARTIAL,
            notes = "",
            method = "setDecomposition",
            args = {int.class}
        ),
        @TestTargetNew(
            level = TestLevel.PARTIAL,
            notes = "",
            method = "compare",
            args = {java.lang.String.class, java.lang.String.class}
        )
    })
    public void test_decompositionCompatibility() {
        Collator myCollator = Collator.getInstance();
        myCollator.setDecomposition(Collator.NO_DECOMPOSITION);
        assertFalse("Error: \u00e0\u0325 should not equal to a\u0325\u0300 " +
                "without decomposition", 
                myCollator.compare("\u00e0\u0325", "a\u0325\u0300") == 0);
        myCollator.setDecomposition(Collator.CANONICAL_DECOMPOSITION);
        assertTrue("Error: \u00e0\u0325 should equal to a\u0325\u0300 " +
                "with decomposition", 
                myCollator.compare("\u00e0\u0325", "a\u0325\u0300") == 0);
    }
    
    class TestCollator extends Collator {

        @Override
        public int compare(String source, String target) {
            return 0;
        }

        @Override
        public CollationKey getCollationKey(String source) {
            return null;
        }

        @Override
        public int hashCode() {
            return 0;
        }
        
    }
}