/*
 * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   - Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *
 *   - Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *
 *   - Neither the name of Oracle nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * This source code is provided to illustrate the usage of a given feature
 * or technique and has been deliberately simplified. Additional steps
 * required for a production-quality application, such as security checks,
 * input validation and proper error handling, might not be present in
 * this sample code.
 */

package comparator;

import java.util.Arrays;
import java.util.Random;

public class Test {
    private final static Random random = new Random();

    private static String[] source1() {
        return new String[] {
                "java 1",
                "java 2",
                "java 3",
                "java 4",
                "java 5",
                "java 6",
                "java 7",
                "java 8",
                "java 9",
                "java 10",
                "java 11",
            };
    }

    private static String[] source2() {
        return new String[] {
                "string",
                "string0",
                "string00",
                "string1",
                "string01",
                "string001",
                "string2",
                "string02",
                "string002",
                "string002.a",
                "string002.a0",
                "string002.a1",
                "string0002",
                "string0002",
            };
    }

    public static void main(String[] args) throws Exception {
        test(source1());
        test(source2());
        System.out.println("Okay");
    }

    private static void test(String[] strings) throws Exception {
        // test sorting array of strings
        String[] shuffledStrings = (String[])strings.clone();
        for (int i = 0; i < shuffledStrings.length - 1; ++i) {
            int j = i + random.nextInt(shuffledStrings.length - i);
            String tmp = shuffledStrings[i];
            shuffledStrings[i] = shuffledStrings[j];
            shuffledStrings[j] = tmp;
        }

        Arrays.sort(shuffledStrings, new AlphaNumericStringComparator());
        for (int i = 0; i < strings.length - 1; ++i) {
            if (!strings[i].equals(shuffledStrings[i])) {
                throw new Exception("Wrong sorting order!");
            }
        }

        // test sorting array of char-arrays
        char[][] shuffledChars = new char[strings.length][];
        for (int i = 0; i < strings.length; ++i) {
            shuffledChars[i] = strings[i].toCharArray();
        }
        for (int i = 0; i < shuffledChars.length - 1; ++i) {
            int j = i + random.nextInt(shuffledChars.length - i);
            char[] tmp = shuffledChars[i];
            shuffledChars[i] = shuffledChars[j];
            shuffledChars[j] = tmp;
        }

        Arrays.sort(shuffledChars, new AlphaNumericCharArrayComparator());
        for (int i = 0; i < strings.length - 1; ++i) {
            if (!strings[i].equals(new String(shuffledChars[i]))) {
                throw new Exception("Wrong sorting order!");
            }
        }
    }
}