/*
 * Copyright (c) 2014, 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
 * @summary unit tests for java.lang.invoke.LambdaForm
 * @library /testlibrary
 * @build LambdaFormTest
 * @run main ClassFileInstaller java.lang.invoke.LambdaFormTest
 * @run main/othervm -Xbootclasspath/a:. java.lang.invoke.LambdaFormTest
 */
package java.lang.invoke;

import static java.lang.invoke.LambdaForm.BasicType.*;
import java.util.Arrays;

public class LambdaFormTest {
    static void testBasicType() {
        for (int i = 0; i < ARG_TYPE_LIMIT; i++) {
            assertEquals(i, ARG_TYPES[i].ordinal());
            assertEquals(ARG_TYPES[i], ALL_TYPES[i]);
        }
        for (int i = 0; i < TYPE_LIMIT; i++) {
            assertEquals(i, ALL_TYPES[i].ordinal());
        }
        assertEquals(ALL_TYPES[TYPE_LIMIT-1], V_TYPE);
        assertFalse(Arrays.asList(ARG_TYPES).contains(V_TYPE));
    }

    static void testShortenSignature() {
        for (String s : new String[] {
                // invariant strings:
                "L", "LL", "ILL", "LIL", "LLI", "IILL", "ILIL", "ILLI",
                // a few mappings:
                "LLL=L3", "LLLL=L4", "LLLLLLLLLL=L10",
                "IIIDDD=I3D3", "IDDD=ID3", "IIDDD=IID3", "IIID=I3D", "IIIDD=I3DD"
            }) {
            String s2 = s.substring(s.indexOf('=')+1);
            String s1 = s.equals(s2) ? s : s.substring(0, s.length() - s2.length() - 1);
            // mix the above cases with before and after reps of Z*
            for (int k = -3; k <= 3; k++) {
                String beg = (k < 0 ? "ZZZZ".substring(-k) : "");
                String end = (k > 0 ? "ZZZZ".substring(+k) : "");
                String ks1 = beg+s1+end;
                String ks2 = LambdaForm.shortenSignature(beg)+s2+LambdaForm.shortenSignature(end);
                String ks3 = LambdaForm.shortenSignature(ks1);
                if (!ks2.equals(ks3)) {
                    throw new AssertionError(ks2 + " != " + ks3);
                }
            }
        }
    }

    public static void main(String[] args) {
        testBasicType();
        testShortenSignature();
    }

    static void assertEquals(Object o1, Object o2) {
        if (o1 == null && o2 == null)  return;
        if (o1 != null && !o1.equals(o2)) {
            throw new AssertionError(o1 + " != " + o2);
        }
    }

    static void assertTrue(boolean b) {
        if (!b) {
            throw new AssertionError();
        }
    }

    static void assertFalse(boolean b) {
        assertTrue(!b);
    }
}