package org.netbeans.lib.callgraph.util;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.HashSet;

import java.util.List;

import java.util.Random;

import java.util.Set;

import org.junit.Test;

import static org.junit.Assert.*;

import org.netbeans.lib.callgraph.util.EightBitStrings.Concatenation;

/**

 *

 * @author tim

 */

public class SmallStringTest {

    @Test

    public void testCreate() {

        EightBitStrings strings = new EightBitStrings(false);

        CharSequence testOne = strings.create("A first test one");

        CharSequence testTwo = strings.create("A second test one");

        assertNotEquals(testOne, testTwo);

        CharSequence hello = strings.create("Hello world");

        CharSequence hello2 = strings.create("Hello world");

        assertEquals(hello, hello2);

        assertSame(hello, hello2);

        assertEquals(hello.hashCode(), "Hello world".hashCode());

        assertEquals("Hello world", hello.toString());

        assertEquals("Hello world".length(), hello.length());

        CharSequence worlds = strings.create("Hello worlds");

        assertNotEquals(hello2, worlds);

        assertEquals(hello, "Hello world");

//        assertEquals("Hello world", hello);

    }

    @Test

    public void testInterning() {

        EightBitStrings strings = new EightBitStrings(false);

        List<String> all = new ArrayList<>(500);

        List<CharSequence> seqs = new ArrayList<>();

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

            String s = randomString(5 + r.nextInt(20));

            all.add(s);

            seqs.add(strings.create(s));

        }

        int size = strings.internTableSize();

        Set<CharSequence> xseqs = new HashSet<>(seqs);

        int oldSize = xseqs.size();

        for (String again : all) {

            CharSequence ss = strings.create(again);

            xseqs.add(ss);

            assertEquals(size, strings.internTableSize());

            assertEquals(oldSize, xseqs.size());

        }

    }

    @Test

    public void testConcatenations() {

        EightBitStrings strings = new EightBitStrings(false);

        CharSequence concat = strings.concat("Hello ", "there ", "how ", "are ", "you?");

        CharSequence concat2 = strings.concat("Hello ", "there ", "how ", "are ", "you?");

        assertEquals("Hello there how are you?", concat.toString());

        assertEquals("Hello there how are you?".hashCode(), concat.toString().hashCode());

        assertEquals(concat, concat2);

    }

    @Test

    public void testSorting() {

        EightBitStrings strings = new EightBitStrings(false);

        ComparableCharSequence a = strings.concat(strings.create("a"), strings.create("b"), strings.create("c"), strings.create("d"));

        ComparableCharSequence b = strings.concat(strings.create("a"), strings.create("b"), strings.create("cd"));

        ComparableCharSequence c = strings.concat(strings.create("ab"), strings.create("cd"));

        ComparableCharSequence d = strings.concat(strings.create("a"), strings.create("bcd"));

        ComparableCharSequence e = strings.concat(strings.create("abcd"));

        assertEquals(4, a.length());

        assertEquals(4, b.length());

        assertEquals(4, c.length());

        assertEquals(4, d.length());

        assertEquals(4, e.length());

        for (ComparableCharSequence c1 : new ComparableCharSequence[]{a, b, c, d, e}) {

            for (ComparableCharSequence c2 : new ComparableCharSequence[]{a, b, c, d, e}) {

                assertEquals(c1, c2);

                assertEquals(0, c1.compareTo(c2));

            }

        }

        ComparableCharSequence cs = strings.concatQuoted(Arrays.asList(strings.create("a"), strings.create("b"), strings.create("c"), strings.create("d")));

        assertEquals("\"a\" \"b\" \"c\" \"d\"", cs.toString());

        strings = new EightBitStrings(true);

        a = strings.concat("a", "b", "c", "d");

        b = strings.concat("a", "b", "cd");

        c = strings.concat("ab", "cd");

        d = strings.concat("a", "bcd");

        e = strings.concat("abcd");

        assertEquals(4, a.length());

        assertEquals(4, b.length());

        assertEquals(4, c.length());

        assertEquals(4, d.length());

        assertEquals(4, e.length());

        for (ComparableCharSequence c1 : new ComparableCharSequence[]{a, b, c, d, e}) {

            for (ComparableCharSequence c2 : new ComparableCharSequence[]{a, b, c, d, e}) {

                assertEquals(c1, c2);

                assertEquals(0, c1.compareTo(c2));

            }

        }

        strings = new EightBitStrings(false);

        a = strings.concat(strings.create("abc"), strings.create("def"));

        b = strings.concat("bcd", strings.create("efg"));

        c = strings.concat("cde", strings.create("fgh"));

        d = strings.create("defghi");

        e = strings.create("efghij");

        List<ComparableCharSequence> l = Arrays.asList(e, c, d, a, b);

        Collections.sort(l);

        assertEquals(l, Arrays.asList(a, b, c, d, e));

    }

    List<String> stringsOf(List<CharSequence> cs) {

        List<String> result = new ArrayList<>();

        for (CharSequence c : cs) {

            if (c == null) {

                break;

            }

            result.add(c.toString());

        }

        return result;

    }

    @Test

    public void testAggressive() {

        EightBitStrings strings = new EightBitStrings(false, true);

        ComparableCharSequence c = strings.concat("com.foo.", "bar.baz.", "Hey$You");

        assertEquals("com.foo.bar.baz.Hey$You", c.toString());

        ComparableCharSequence c2 = strings.concat("com.foo.", "bar.whoodle.", "Hey$You");

        List<String> interned = stringsOf(strings.dumpInternTable());

        for (String cs : interned) {

            if (cs == null) {

                break;

            }

            System.out.println("  " + cs);

        }

        assertTrue(interned.contains("com"));

        assertTrue(interned.contains("foo"));

        assertTrue(interned.contains("bar"));

        assertTrue(interned.contains("baz"));

        assertTrue(interned.contains("Hey"));

        assertTrue(interned.contains("You"));

        assertTrue(interned.contains("whoodle"));

        assertTrue(interned.contains("."));

        assertTrue(interned.contains("$"));

        assertTrue(interned.contains("\""));

    }

    @Test

    public void testConcatQuoted() {

        EightBitStrings strings = new EightBitStrings(false);

        List<Object> l = Arrays.asList(strings.create("hey"), false, 23, strings.create("bar"), "baz");

        CharSequence cc = strings.concatQuoted(l);

        assertEquals("\"hey\" false 23 \"bar\" \"baz\"", cc.toString());

    }

    private static String randomString(int len) {

        char[] c = new char[len];

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

            c[i] = randomChar();

        }

        return new String(c);

    }

    private static char randomChar() {

        return alpha[r.nextInt(alpha.length)];

    }

    static final Random r = new Random(320392);

    private static final char[] alpha = "abcdefghijklmnopqrstuvwxyz".toCharArray();

}