Mercurial Mercurial > jdk-sandbox / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
langtools/test/tools/javac/defaultMethods/syntax/TestDefaultMethodsSyntax.java
changeset 29293 1583c6dd6df7
parent 27319 030080f03e4f
child 30730 d3ce7619db2c
equal deleted inserted replaced
29292:c10d63c667cd 29293:1583c6dd6df7 
     1 /*
 
     1 /*
 
     2  * Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
 
     2  * Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
 
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 
     4  *
 
     4  *
 
     5  * This code is free software; you can redistribute it and/or modify it
 
     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
 
     6  * under the terms of the GNU General Public License version 2 only, as
 
     7  * published by the Free Software Foundation.
 
     7  * published by the Free Software Foundation.
 
    21  * questions.
 
    21  * questions.
 
    22  */
 
    22  */
 
    23 
    23 
    24 /*
 
    24 /*
 
    25  * @test
 
    25  * @test
 
    26  * @bug 7192245 8005851 8005166
 
    26  * @bug 7192245 8005851 8005166 8071453
 
    27  * @summary Automatic test for checking set of allowed modifiers on interface methods
 
    27  * @summary Automatic test for checking set of allowed modifiers on interface methods
 
    28  */
 
    28  */
 
    29 
    29 
    30 import com.sun.source.util.JavacTask;
 
    30 import com.sun.source.util.JavacTask;
 
    31 import java.net.URI;
 
    31 import java.net.URI;
 
    43 
    43 
    44     static int checkCount = 0;
 
    44     static int checkCount = 0;
 
    45 
    45 
    46     enum VersionKind {
 
    46     enum VersionKind {
 
    47         PRE_LAMBDA("7"),
 
    47         PRE_LAMBDA("7"),
 
    48         LAMBDA("8");
 
    48         LAMBDA("8"),
 
       
    49         POST_LAMBDA("9");
 
    49 
    50 
    50         String versionString;
 
    51         String versionString;
 
    51 
    52 
    52         VersionKind(String versionString) {
 
    53         VersionKind(String versionString) {
 
    53             this.versionString = versionString;
 
    54             this.versionString = versionString;
 
    85         }
 
    86         }
 
    86 
    87 
    87         static boolean compatible(MethodKind mk, ModifierKind mod1, ModifierKind mod2, EnclosingKind ek) {
 
    88         static boolean compatible(MethodKind mk, ModifierKind mod1, ModifierKind mod2, EnclosingKind ek) {
 
    88             if (intersect(ABSTRACT, mod1, mod2) || intersect(NATIVE, mod1, mod2)) {
 
    89             if (intersect(ABSTRACT, mod1, mod2) || intersect(NATIVE, mod1, mod2)) {
 
    89                 return mk == MethodKind.NO_BODY;
 
    90                 return mk == MethodKind.NO_BODY;
 
    90             } else if (intersect(DEFAULT, mod1, mod2) || intersect(STATIC, mod1, mod2)) {
 
    91             } else if (intersect(DEFAULT, mod1, mod2) || intersect(STATIC, mod1, mod2)
 
       
    92                     || intersect(PRIVATE, mod1, mod2)) {
 
    91                 return mk == MethodKind.BODY;
 
    93                 return mk == MethodKind.BODY;
 
    92             } else {
 
    94             } else {
 
    93                 return ek == EnclosingKind.INTERFACE ?
 
    95                 return ek == EnclosingKind.INTERFACE ?
 
    94                         mk == MethodKind.NO_BODY : mk == MethodKind.BODY;
 
    96                         mk == MethodKind.NO_BODY : mk == MethodKind.BODY;
 
    95             }
 
    97             }
 
    96         }
 
    98         }
 
    97 
    99 
    98         boolean compatible(EnclosingKind ek) {
 
   100         boolean compatible(EnclosingKind ek) {
 
    99             switch (this) {
 
   101             switch (this) {
 
   100                 case PRIVATE:
 
       
   101                 case PROTECTED:
 
   102                 case PROTECTED:
 
   102                     return ek != EnclosingKind.INTERFACE;
 
   103                     return ek != EnclosingKind.INTERFACE;
 
   103                 default:
 
   104                 default:
 
   104                     return true;
 
   105                     return true;
 
   105             }
 
   106             }
 
   147             }
 
   148             }
 
   148         };
 
   149         };
 
   149 
   150 
   150         static Result[][] allowedModifierPairs = {
 
   151         static Result[][] allowedModifierPairs = {
 
   151             /*                     NONE  PUBLIC  PROTECTED  PRIVATE  ABSTRACT  STATIC  NATIVE  SYNCHRONIZED  FINAL  STRICTFP  DEFAULT */
 
   152             /*                     NONE  PUBLIC  PROTECTED  PRIVATE  ABSTRACT  STATIC  NATIVE  SYNCHRONIZED  FINAL  STRICTFP  DEFAULT */
 
   152             /* NONE */           { T   , T    , C        , C       , T       , T     , C     , C           , C    , C       , I   },
 
   153             /* NONE */           { T   , T    , C        , T       , T       , T     , C     , C           , C    , C       , I   },
 
   153             /* PUBLIC */         { T   , F    , F        , F       , T       , T     , C     , C           , C    , C       , I   },
 
   154             /* PUBLIC */         { T   , F    , F        , F       , T       , T     , C     , C           , C    , C       , I   },
 
   154             /* PROTECTED */      { C   , F    , F        , F       , C       , C     , C     , C           , C    , C       , F   },
 
   155             /* PROTECTED */      { C   , F    , F        , F       , C       , C     , C     , C           , C    , C       , F   },
 
   155             /* PRIVATE */        { C   , F    , F        , F       , F       , C     , C     , C           , C    , C       , F   },
 
   156             /* PRIVATE */        { T   , F    , F        , F       , F       , T     , C     , C           , C    , T       , F   },
 
   156             /* ABSTRACT */       { T   , T    , C        , F       , F       , F     , F     , F           , F    , F       , F   },
 
   157             /* ABSTRACT */       { T   , T    , C        , F       , F       , F     , F     , F           , F    , F       , F   },
 
   157             /* STATIC */         { T   , T    , C        , C       , F       , F     , C     , C           , C    , T       , F   },
 
   158             /* STATIC */         { T   , T    , C        , T       , F       , F     , C     , C           , C    , T       , F   },
 
   158             /* NATIVE */         { C   , C    , C        , C       , F       , C     , F     , C           , C    , F       , F   },
 
   159             /* NATIVE */         { C   , C    , C        , C       , F       , C     , F     , C           , C    , F       , F   },
 
   159             /* SYNCHRONIZED */   { C   , C    , C        , C       , F       , C     , C     , F           , C    , C       , F   },
 
   160             /* SYNCHRONIZED */   { C   , C    , C        , C       , F       , C     , C     , F           , C    , C       , F   },
 
   160             /* FINAL */          { C   , C    , C        , C       , F       , C     , C     , C           , F    , C       , F   },
 
   161             /* FINAL */          { C   , C    , C        , C       , F       , C     , C     , C           , F    , C       , F   },
 
   161             /* STRICTFP */       { C   , C    , C        , C       , F       , T     , F     , C           , C    , F       , I   },
 
   162             /* STRICTFP */       { C   , C    , C        , T       , F       , T     , F     , C           , C    , F       , I   },
 
   162             /* DEFAULT */        { I   , I    , F        , F       , F       , F     , F     , F           , F    , I       , F   }};
 
   163             /* DEFAULT */        { I   , I    , F        , F       , F       , F     , F     , F           , F    , I       , F   }};
 
   163     }
 
   164     }
 
   164 
   165 
   165     enum MethodKind {
 
   166     enum MethodKind {
 
   166         NO_BODY("void m();"),
 
   167         NO_BODY("void m();"),
 
   266                 vk == VersionKind.PRE_LAMBDA;
 
   267                 vk == VersionKind.PRE_LAMBDA;
 
   267 
   268 
   268         errorExpected |= ModifierKind.intersect(ModifierKind.STATIC, modk1, modk2) &&
 
   269         errorExpected |= ModifierKind.intersect(ModifierKind.STATIC, modk1, modk2) &&
 
   269                 ek == EnclosingKind.INTERFACE && vk == VersionKind.PRE_LAMBDA;
 
   270                 ek == EnclosingKind.INTERFACE && vk == VersionKind.PRE_LAMBDA;
 
   270 
   271 
       
   272         errorExpected |= ModifierKind.intersect(ModifierKind.PRIVATE, modk1, modk2) &&
 
       
   273                 ek == EnclosingKind.INTERFACE && (vk == VersionKind.LAMBDA || vk == VersionKind.PRE_LAMBDA);
 
       
   274 
   271         checkCount++;
 
   275         checkCount++;
 
   272         if (diagChecker.errorFound != errorExpected) {
 
   276         if (diagChecker.errorFound != errorExpected) {
 
   273             throw new AssertionError("Problem when compiling source:\n" + source.getCharContent(true) +
 
   277             throw new AssertionError("Problem when compiling source:\n" + source.getCharContent(true) +
 
   274                     "\nfound error: " + diagChecker.errorFound);
 
   278                     "\nfound error: " + diagChecker.errorFound);
 
   275         }
 
   279         }
jdk-sandbox