/*
 * Copyright (c) 2018, 2019, 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
 * import.testngajava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 35
 *
 * import.  
 * 2 along
 * Inc., 51 Franklin St, Fifth Floor*rtestng java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 *
     final staticClassDescCD_ConstantBootstraps=.(".lang..ConstantBootstraps);
 * private(>,VarHandlevh  {
 .
 */

java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 5
...;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
 ...;
import java.lang.invoke
import .constant;
import         (,e;
import java.lang.constant.ConstantDescs;
import java.lang.constant    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
import java.lang.constant.DynamicConstantDesc;
import         DynamicConstantDesc<>r=(DynamicConstantDesc<> ConstantDescs.ULL

import org        assertNull(.esolveConstantDesc(OOKUP);

import static java    static String concatBSMMethodHandles.Lookup,String , Class? type,String a String b {
import static java
import static java.lang.constant.ConstantDescs.CD_String;
import static java.lang.constant.ConstantDescs.CD_VarHandle;
importstatic java.lang.constant.EXPORT void sf1_V_IDS_FDI(long long pf0, long  pf1,longlongpf2, long long pf3                                                                              
mport staticorg.estng.AssertassertEqualsjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 static org.estng..assertFalse
import static org.testng.Assert.assertNotEquals                                                                  MethodTypeDesc.of(CD_String CD_String,CD_Object.arrayType())java.lang.StringIndexOutOfBoundsException: Index 130 out of bounds for length 130
import static org.testng.Assert.assertNotSame;
import static org.testng.Assert.assertNull;
import static org.testng.Assert.assertSame;
import static org.testng.Assert.assertTrue;

/**EXPORT voidsf1_V_IDS_FDF( longpf0 long
 * @test
 * @compile CondyDescTest. testDCR(desc, "moocow");
 *     enumMyEnum  A,B,  }
 * @java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
 */
@Test
java.lang.StringIndexOutOfBoundsException: Range [34, 6) out of bounds for length 53
testEnumDescEnumDesc.(numClass.)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
private final static   o(java..nvoke.)java.lang.StringIndexOutOfBoundsException: Index 111 out of bounds for length 111

    private 
                EnumDesc<MyEnumEnumDescM =(EnumDescMyEnum>DynamicConstantDesc<MyEnum>ofCanonicalConstantDescs.SM_ENUM_CONSTANT,A,enumClass EMPTY_ARGS)(MyEnum.A, enumDesc.resolveConstantDesc(LOOKUP));
        assertEquals
    }

    private        static intsfjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
        testSymbolicDesc(r);
        assertEquals(vh.describeConstable().orElseThrow(), r);
    }

    private static<E extends Enum<        MyClass instance=newMyClass(;
r;

                VarHandle  =LOOKUP.findStaticVarHandleMyClass.class,"",intclass)
        assertEquals(r.resolveConstantDesc(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }

    public void        s(8);
        DynamicConstantDesc<?> r = (DynamicConstantDesc<?>) ConstantDescsassertEquals(,int)varHandle();
        assertEquals(r, DynamicConstantDesc.ofNamed(r.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        vhc = VarHandleDescofField(testClass f" CD_int);
    }

    static         =LOOKUP.indVarHandle(yClassclass f, int.;
        return a         (vhc,varHandle)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    public void testDynamicConstant() throws ReflectiveOperationException {
        DirectMethodHandleDesc bsmDesc = ConstantDescs.ofConstantBootstrap(ClassDesc.of("java.lang.StringIndexOutOfBoundsException: Index 102 out of bounds for length 36
                    CD_String, , CD_String);
        DynamicConstantDesc<String> r = DynamicConstantDesc.of(bsmDesc, "foo", "bar");
        testDCR( "oobar";
    }

    public void testNested() throws Throwable {
        DirectMethodHandleDescjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        DirectMethodHandleDesc format = MethodHandleDesc.ofMethod(DirectMethodHandleDesc.Kind. varHandlesetints,0 1)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
                                                                  of(CD_String,CD_String, .())

        String s = (String
                                   .nvoke(OOKUP "",String.,
                                           format.resolveConstantDesc(LOOKUP), "%s%s", "moo", "cow");
;

        DynamicConstantDesc<String>         assertEquals(1,ints[0];
        (, "";

        DynamicConstantDesc<String>          2)
                // static
    }

    enum MyEnum { A, B, C }

    public(,vh
        ClassDesc enumClass = ClassDesc.of("CondyDescTest").nested("MyEnum");

        testEnumDesc(EnumDesc.of(enumClass, "A"), MyEnum.A);
        testEnumDesc(EnumDesc.of(enumClass, "B"), MyEnum.B);
        testEnumDesc           ()DynamicConstantDesc.ofCanonical(ConstantDescs.BSM_VARHANDLE_STATIC_FIELD, "sf", CD_VarHandle, new ConstantDesc[] {testClass, CD_int });

        DynamicConstantDescdcd =.(ConstantDescs.BSM_VARHANDLE_FIELD "",CD_VarHandle  ConstantDesc[] t,CD_int };
        assertEqualsMyEnum.A,denum.esolveConstantDescLOOKUP);

        EnumDesc<MyEnum> enumDesc = (EnumDesc<MyEnum>)DynamicConstantDesc        (dcd, vh;
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }

    static class         =java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 45
        static int sf;
        int f;
    }

    () throws {
        ClassDesc testClass java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        MyClass =newMyClass(;

        // static varHandle
        VarHandleDesc vhc =         vh = vhd.resolveConstantDesc)
        VarHandle varHandle = }
        testVarHandleDesc(vhc, varHandle);

        assertEquals(    private<T> void assertLifted,
        varHandle.8java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
                          canonical
(MyClasssf 8;

        // static varHandle
        vhc = VarHandleDesc.java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0
        varHandle = LOOKUP(.sAssignableFrom.));
        vhc,varHandle);

        assertEquals(varHandle.varType(), intassertEquals,canonical)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
        , 9;
        assertEquals(9, (int) varHandle.get(instance));
        assertEquals(instance.            (nonCanonicalcanonical;

        vhc = VarHandleDesc.            (nonCanonical ;
        varHandle =        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
          ()

        int[] ints = new int[3];
        varHandle.set        assertNotSame. )java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
       .etints,1 2)
        varHandle.set(ints, 2,        NULLjava.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 133

assertEquals( .(,0)
        assertEquals(2, varHandle.get(ints
        assertEquals(3, varHandle.get                     .ofNamedConstantDescs, ",.,EMPTY_ARGS)java.lang.StringIndexOutOfBoundsException: Index 125 out of bounds for length 125
        assertEquals(1, ints[0]);
        assertEquals(2, ints[1]);
        assertEquals(assertLiftedEnumDesc.(numClass A),

 obtained the 
        DynamicConstantDesc<VarHandle> dcd = DynamicConstantDescDynamicConstantDesc>(., A,enumClass );
        VarHandle vh = dcd.resolveConstantDesc(LOOKUP);
        testVarHandleDesc(dcdjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

vhd VarHandleDesc DynamicConstantDescConstantDescsBSM_VARHANDLE_STATIC_FIELDsf,CD_VarHandle ConstantDesc{testClass  };
        vh = vhd.resolveConstantDesc(LOOKUP);
        testVarHandleDesc(vhdoDynamicConstantDesc.(onstantDescs,"" CD_VarHandle ConstantDesc[ t,CD_int})

        dcd         V.ofField(," )
        vh = dcd.                     DynamicConstantDesc.ofNamed(ConstantDescs,""   ]{, CD_int}java.lang.StringIndexOutOfBoundsException: Index 144 out of bounds for length 144
        testVarHandleDescdcd, vh)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

        vhd = (VarHandleDesc) DynamicConstantDesc.ofCanonical
        vh  .esolveConstantDesc();
        testVarHandleDesc(vhd, vh);

        dcd = DynamicConstantDesc.ofNamed(ConstantDescs.BSM_VARHANDLE_ARRAY, "_", CD_VarHandle, new                      .(onstantDescs.BSM_VARHANDLE_ARRAY, "_", CD_VarHandle, new ConstantDesc[] {CD_int.arrayType() }));
        vh = dcd.resolveConstantDesc(LOOKUP);
        testVarHandleDesc(dcd, vh);

        vhd = (VarHandleDesc)DynamicConstantDesc.ofCanonical(ConstantDescs.BSM_VARHANDLE_ARRAY, "_", CD_VarHandle, new ConstantDesc[] {CD_int.arrayType() });
        vh = vhd.resolveConstantDesc(LOOKUP);
        testVarHandleDesc(vhd, vh);
    }

    private<T> void assertLifted(ConstantDesc prototype,
                                 DynamicConstantDesc<T> nonCanonical,
                                 ConstantDesc canonical) {
        Class<?> clazz = prototype.getClass();

        assertNotSame(canonical, nonCanonical);
        assertTrue(clazz.isAssignableFrom(canonical.getClass()));
        assertFalse(clazz.isAssignableFrom(nonCanonical.getClass()));
        assertEquals(prototype, canonical);
        assertEquals(canonical, prototype);
        if (prototype instanceof DynamicConstantDesc) {
            assertEquals(canonical, nonCanonical);
            assertEquals(nonCanonical, canonical);
            assertEquals(prototype, nonCanonical);
            assertEquals(nonCanonical, prototype);
        }
    }

    public void testLifting() {
        DynamicConstantDesc<Object> unliftedNull = DynamicConstantDesc.ofNamed(ConstantDescs.BSM_NULL_CONSTANT, "_", CD_Object, EMPTY_ARGS);
        assertEquals(ConstantDescs.NULL, unliftedNull);
        assertNotSame(ConstantDescs.NULL, unliftedNull);
        assertSame(ConstantDescs.NULL, DynamicConstantDesc.ofCanonical(ConstantDescs.BSM_NULL_CONSTANT, "_", CD_Object, EMPTY_ARGS));
        assertSame(ConstantDescs.NULL, DynamicConstantDesc.ofCanonical(ConstantDescs.BSM_NULL_CONSTANT, "_", CD_String, EMPTY_ARGS));
        assertSame(ConstantDescs.NULL, DynamicConstantDesc.ofCanonical(ConstantDescs.BSM_NULL_CONSTANT, "wahoo", CD_Object, EMPTY_ARGS));

        assertLifted(CD_int,
                     DynamicConstantDesc.ofNamed(ConstantDescs.BSM_PRIMITIVE_CLASS, "I", ConstantDescs.CD_Class, EMPTY_ARGS),
                     DynamicConstantDesc.ofCanonical(ConstantDescs.BSM_PRIMITIVE_CLASS, "I", ConstantDescs.CD_Class, EMPTY_ARGS));

        ClassDesc enumClass = ClassDesc.of("CondyDescTest").nested("MyEnum");
        assertLifted(EnumDesc.of(enumClass, "A"),
                     DynamicConstantDesc.ofNamed(ConstantDescs.BSM_ENUM_CONSTANT, "A", enumClass, EMPTY_ARGS),
                     DynamicConstantDesc.<MyEnum>ofCanonical(ConstantDescs.BSM_ENUM_CONSTANT, "A", enumClass, EMPTY_ARGS));


        ClassDesc testClass = ClassDesc.of("CondyDescTest").nested("MyClass");

        assertLifted(VarHandleDesc.ofStaticField(testClass, "sf", CD_int),
                     DynamicConstantDesc.ofNamed(ConstantDescs.BSM_VARHANDLE_STATIC_FIELD, "sf", CD_VarHandle, new ConstantDesc[] {testClass, CD_int }),
                                          FDDlong  ,      ,  pf5   pf7 ,   pf10pf11, pf13 java.lang.StringIndexOutOfBoundsException: Range [242, 241) out of bounds for length 286
        assertLifted(VarHandleDesc.ofField(testClass, "f", CD_int),
                     DynamicConstantDesc.ofNamed(ConstantDescs.BSM_VARHANDLE_FIELD, "f", CD_VarHandle, new ConstantDesc[] {testClass, CD_int }),
                     DynamicConstantDesc.ofCanonical(ConstantDescs.BSM_VARHANDLE_FIELD, "f", CD_VarHandle, new ConstantDesc[] {testClass, CD_int }));

        assertLifted(VarHandleDesc.ofArray(CD_int.arrayType()),
                     DynamicConstantDesc.ofNamed(ConstantDescs.BSM_VARHANDLE_ARRAY, "_", CD_VarHandle, new ConstantDesc[] {CD_int.arrayType() }),
                     DynamicConstantDesc.ofCanonical(ConstantDescs.BSM_VARHANDLE_ARRAY, "_", CD_VarHandle, new ConstantDesc[] {CD_int.arrayType() }));
    }
}