1 /*
2  * Copyright (c) 2001, 2018, Oracle and/or its affiliates. All rights reserved.
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * This code is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License version 2 only, as
7  * published by the Free Software Foundation.
8  *
9  * This code is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12  * version 2 for more details (a copy is included in the LICENSE file that
13  * accompanied this code).
14  *
15  * You should have received a copy of the GNU General Public License version
16  * 2 along with this work; if not, write to the Free Software Foundation,
17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18  *
19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20  * or visit www.oracle.com if you need additional information or have any
21  * questions.
22  */
23 
24 
25 package nsk.jdi.TypeComponent.isSynthetic;
26 
27 import nsk.share.*;
28 import nsk.share.jpda.*;
29 import nsk.share.jdi.*;
30 
31 
32 public class issynthetic002a {
main(String argv[])33         public static void main (String argv[]) {
34         ArgumentHandler argHandler = new ArgumentHandler(argv);
35         Log log = new Log(System.err, argHandler);
36         IOPipe pipe = argHandler.createDebugeeIOPipe(log);
37         issynthetic002aClassToCheck classToCheck = new issynthetic002aClassToCheck();
38 
39         log.display("DEBUGEE> debugee started.");
40             pipe.println("ready");
41         String instruction = pipe.readln();
42         if (instruction.equals("quit")) {
43             log.display("DEBUGEE> \"quit\" signal recieved.");
44             log.display("DEBUGEE> completed succesfully.");
45             System.exit(95);
46         }
47         log.complain("DEBUGEE FAILURE> unexpected signal "
48                          + "(no \"quit\") - " + instruction);
49         log.complain("DEBUGEE FAILURE> TEST FAILED");
50         System.exit(97);
51     }
52 }
53 
54 interface issynthetic002aClassToCheckIntf<T> {
test(T t)55     T test(T t);
56 }
57 
58 class issynthetic002aClassToCheck implements issynthetic002aClassToCheckIntf<String> {
59     // Not-synthetic methods
60 
61     // User class and interface
62     class Class {}
63     interface Inter {}
64 
Mv()65     void        Mv() {};
Mz(boolean z)66     boolean     Mz(boolean z)      { return z; };
Mz1(boolean z[])67     boolean[]   Mz1(boolean z[])   { return z; };
Mz2(boolean z[][])68     boolean[][] Mz2(boolean z[][]) { return z; };
Mb(byte b)69     byte        Mb(byte b)         { return b; };
Mb1(byte b[])70     byte[]      Mb1(byte b[])      { return b; };
Mb2(byte b[][])71     byte[][]    Mb2(byte b[][])    { return b; };
Mc(char c)72     char        Mc(char c)         { return c; };
Mc1(char c[])73     char[]      Mc1(char c[])      { return c; };
Mc2(char c[][])74     char[][]    Mc2(char c[][])    { return c; };
Md(double d)75     double      Md(double d)       { return d; };
Md1(double d[])76     double[]    Md1(double d[])    { return d; };
Md2(double d[][])77     double[][]  Md2(double d[][])  { return d; };
Mf(float f)78     float       Mf(float f)        { return f; };
Mf1(float f[])79     float[]     Mf1(float f[])     { return f; };
Mf2(float f[][])80     float[][]   Mf2(float f[][])   { return f; };
Mi(int i)81     int         Mi(int i)          { return i; };
Mi1(int i[])82     int[]       Mi1(int i[])       { return i; };
Mi2(int i[][])83     int[][]     Mi2(int i[][])     { return i; };
Ml(long l)84     long        Ml(long l)         { return l; };
Ml1(long l[])85     long[]      Ml1(long l[])      { return l; };
Ml2(long l[][])86     long[][]    Ml2(long l[][])    { return l; };
Mr(short r)87     short       Mr(short r)        { return r; };
Mr1(short r[])88     short[]     Mr1(short r[])     { return r; };
Mr2(short r[][])89     short[][]   Mr2(short r[][])   { return r; };
90 
MvF()91     final        void     MvF()            {};
MlF(long l)92     final        long     MlF(long l)      { return l; };
MlF1(long l[])93     final        long[]   MlF1(long l[])   { return l; };
MlF2(long l[][])94     final        long[][] MlF2(long l[][]) { return l; };
MvN()95     native       void     MvN();
MlN(long l)96     native       long     MlN(long l);
MlN1(long l[])97     native       long[]   MlN1(long l[]);
MlN2(long l[][])98     native       long[][] MlN2(long l[][]);
MvS()99     static       void     MvS()            {};
MlS(long l)100     static       long     MlS(long l)      { return l; };
MlS1(long l[])101     static       long[]   MlS1(long l[])   { return l; };
MlS2(long l[][])102     static       long[][] MlS2(long l[][]) { return l; };
MvI()103     strictfp     void     MvI()            {};
MlI(long l)104     strictfp     long     MlI(long l)      { return l; };
MlI1(long l[])105     strictfp     long[]   MlI1(long l[])   { return l; };
MlI2(long l[][])106     strictfp     long[][] MlI2(long l[][]) { return l; };
MvY()107     synchronized void     MvY()            {};
MlY(long l)108     synchronized long     MlY(long l)      { return l; };
MlY1(long l[])109     synchronized long[]   MlY1(long l[])   { return l; };
MlY2(long l[][])110     synchronized long[][] MlY2(long l[][]) { return l; };
MvU()111     public       void     MvU()            {};
MlU(long l)112     public       long     MlU(long l)      { return l; };
MlU1(long l[])113     public       long[]   MlU1(long l[])   { return l; };
MlU2(long l[][])114     public       long[][] MlU2(long l[][]) { return l; };
MvR()115     protected    void     MvR()            {};
MlR(long l)116     protected    long     MlR(long l)      { return l; };
MlR1(long l[])117     protected    long[]   MlR1(long l[])   { return l; };
MlR2(long l[][])118     protected    long[][] MlR2(long l[][]) { return l; };
MvP()119     private      void     MvP()            {};
MlP(long l)120     private      long     MlP(long l)      { return l; };
MlP1(long l[])121     private      long[]   MlP1(long l[])   { return l; };
MlP2(long l[][])122     private      long[][] MlP2(long l[][]) { return l; };
123 
MX(Class X)124     Class         MX(Class X)          { return X; };
MX1(Class X[])125     Class[]       MX1(Class X[])       { return X; };
MX2(Class X[][])126     Class[][]     MX2(Class X[][])     { return X; };
MO(Object O)127     Object        MO(Object O)         { return O; };
MO1(Object[] O)128     Object[]      MO1(Object[] O)      { return O; };
MO2(Object[][] O)129     Object[][]    MO2(Object[][] O)    { return O; };
130 
MLF(Long L)131     final        Long     MLF(Long L)      { return L; };
MLF1(Long[] L)132     final        Long[]   MLF1(Long[] L)   { return L; };
MLF2(Long[][] L)133     final        Long[][] MLF2(Long[][] L) { return L; };
MLN(Long L)134     native       Long     MLN(Long L);
MLN1(Long L[])135     native       Long[]   MLN1(Long L[]);
MLN2(Long L[][])136     native       Long[][] MLN2(Long L[][]);
MLS(Long L)137     static       Long     MLS(Long L)      { return L; };
MLS1(Long L[])138     static       Long[]   MLS1(Long L[])   { return L; };
MLS2(Long L[][])139     static       Long[][] MLS2(Long L[][]) { return L; };
MLI(Long L)140     strictfp     Long     MLI(Long L)      { return L; };
MLI1(Long L[])141     strictfp     Long[]   MLI1(Long L[])   { return L; };
MLI2(Long L[][])142     strictfp     Long[][] MLI2(Long L[][]) { return L; };
MLY(Long L)143     synchronized Long     MLY(Long L)      { return L; };
MLY1(Long[] L)144     synchronized Long[]   MLY1(Long[] L)   { return L; };
MLY2(Long[][] L)145     synchronized Long[][] MLY2(Long[][] L) { return L; };
MLU(Long L)146     public       Long     MLU(Long L)      { return L; };
MLU1(Long[] L)147     public       Long[]   MLU1(Long[] L)   { return L; };
MLU2(Long[][] L)148     public       Long[][] MLU2(Long[][] L) { return L; };
MLR(Long L)149     protected    Long     MLR(Long L)      { return L; };
MLR1(Long[] L)150     protected    Long[]   MLR1(Long[] L)   { return L; };
MLR2(Long[][] L)151     protected    Long[][] MLR2(Long[][] L) { return L; };
MLP(Long L)152     private      Long     MLP(Long L)      { return L; };
MLP1(Long[] L)153     private      Long[]   MLP1(Long[] L)   { return L; };
MLP2(Long[][] L)154     private      Long[][] MLP2(Long[][] L) { return L; };
155 
ME(Inter E)156     Inter     ME(Inter E)      { return E; };
ME1(Inter[] E)157     Inter[]   ME1(Inter[] E)   { return E; };
ME2(Inter[][] E)158     Inter[][] ME2(Inter[][] E) { return E; };
159 
MEF(Inter E)160     final        Inter     MEF(Inter E)      { return E; };
MEF1(Inter[] E)161     final        Inter[]   MEF1(Inter[] E)   { return E; };
MEF2(Inter[][] E)162     final        Inter[][] MEF2(Inter[][] E) { return E; };
MEN(Inter E)163     native       Inter     MEN(Inter E);
MEN1(Inter[] E)164     native       Inter[]   MEN1(Inter[] E);
MEN2(Inter[][] E)165     native       Inter[][] MEN2(Inter[][] E);
MES(Inter E)166     static       Inter     MES(Inter E)      { return E; };
ME1S(Inter[] E)167     static       Inter[]   ME1S(Inter[] E)   { return E; };
ME2S(Inter[][] E)168     static       Inter[][] ME2S(Inter[][] E) { return E; };
MEI(Inter E)169     strictfp     Inter     MEI(Inter E)      { return E; };
MEI1(Inter[] E)170     strictfp     Inter[]   MEI1(Inter[] E)   { return E; };
MEI2(Inter[][] E)171     strictfp     Inter[][] MEI2(Inter[][] E) { return E; };
MEY(Inter E)172     synchronized Inter     MEY(Inter E)      { return E; };
MEY1(Inter[] E)173     synchronized Inter[]   MEY1(Inter[] E)   { return E; };
MEY2(Inter[][] E)174     synchronized Inter[][] MEY2(Inter[][] E) { return E; };
MEU(Inter E)175     public       Inter     MEU(Inter E)      { return E; };
MEU1(Inter[] E)176     public       Inter[]   MEU1(Inter[] E)   { return E; };
MEU2(Inter[][] E)177     public       Inter[][] MEU2(Inter[][] E) { return E; };
MER(Inter E)178     protected    Inter     MER(Inter E)      { return E; };
MER1(Inter[] E)179     protected    Inter[]   MER1(Inter[] E)   { return E; };
MER2(Inter[][] E)180     protected    Inter[][] MER2(Inter[][] E) { return E; };
MEP(Inter E)181     private      Inter     MEP(Inter E)      { return E; };
MEP1(Inter[] E)182     private      Inter[]   MEP1(Inter[] E)   { return E; };
MEP2(Inter[][] E)183     private      Inter[][] MEP2(Inter[][] E) { return E; };
184 
185 
186    // The implementation of the parametrized interface issynthetic002aClassToCheckIntf
187    // triggers the compiler to create the synthetic bridge method
188    // "test(Ljava/lang/Object;)Ljava/lang/Object;".
test(String s)189     public String test(String s) {
190         return s;
191     }
192 
193 
194 }
195