hotspot/test/compiler/stable/TestStableByte.java
changeset 23192 f6a1c8866065
child 25641 d99065e4572b
equal deleted inserted replaced
23191:5f3c5592f0e8 23192:f6a1c8866065
       
     1 /*
       
     2  * Copyright (c) 2014, 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.  Oracle designates this
       
     8  * particular file as subject to the "Classpath" exception as provided
       
     9  * by Oracle in the LICENSE file that accompanied this code.
       
    10  *
       
    11  * This code is distributed in the hope that it will be useful, but WITHOUT
       
    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
       
    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
       
    14  * version 2 for more details (a copy is included in the LICENSE file that
       
    15  * accompanied this code).
       
    16  *
       
    17  * You should have received a copy of the GNU General Public License version
       
    18  * 2 along with this work; if not, write to the Free Software Foundation,
       
    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
       
    20  *
       
    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
       
    22  * or visit www.oracle.com if you need additional information or have any
       
    23  * questions.
       
    24  */
       
    25 
       
    26 /*
       
    27  * @test TestStableByte
       
    28  * @summary tests on stable fields and arrays
       
    29  * @library /testlibrary
       
    30  * @compile -XDignore.symbol.file TestStableByte.java
       
    31  * @run main ClassFileInstaller
       
    32  *           java/lang/invoke/TestStableByte
       
    33  *           java/lang/invoke/TestStableByte$ByteStable
       
    34  *           java/lang/invoke/TestStableByte$StaticByteStable
       
    35  *           java/lang/invoke/TestStableByte$VolatileByteStable
       
    36  *           java/lang/invoke/TestStableByte$ByteArrayDim1
       
    37  *           java/lang/invoke/TestStableByte$ByteArrayDim2
       
    38  *           java/lang/invoke/TestStableByte$ByteArrayDim3
       
    39  *           java/lang/invoke/TestStableByte$ByteArrayDim4
       
    40  *           java/lang/invoke/TestStableByte$ObjectArrayLowerDim0
       
    41  *           java/lang/invoke/TestStableByte$ObjectArrayLowerDim1
       
    42  *           java/lang/invoke/TestStableByte$NestedStableField
       
    43  *           java/lang/invoke/TestStableByte$NestedStableField$A
       
    44  *           java/lang/invoke/TestStableByte$NestedStableField1
       
    45  *           java/lang/invoke/TestStableByte$NestedStableField1$A
       
    46  *           java/lang/invoke/TestStableByte$NestedStableField2
       
    47  *           java/lang/invoke/TestStableByte$NestedStableField2$A
       
    48  *           java/lang/invoke/TestStableByte$NestedStableField3
       
    49  *           java/lang/invoke/TestStableByte$NestedStableField3$A
       
    50  *           java/lang/invoke/TestStableByte$DefaultValue
       
    51  *           java/lang/invoke/TestStableByte$ObjectArrayLowerDim2
       
    52  *
       
    53  * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
       
    54  *                   -XX:+UnlockDiagnosticVMOptions -XX:+FoldStableValues -XX:+UseCompressedOop
       
    55  *                   -server -XX:-TieredCompilation -Xcomp
       
    56  *                   -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
       
    57  *                   java.lang.invoke.TestStableByte
       
    58  *
       
    59  * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
       
    60  *                   -XX:+UnlockDiagnosticVMOptions -XX:+FoldStableValues -XX:-UseCompressedOop
       
    61  *                   -server -XX:-TieredCompilation -Xcomp
       
    62  *                   -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
       
    63  *                   java.lang.invoke.TestStableByte
       
    64  *
       
    65  * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
       
    66  *                   -XX:+UnlockDiagnosticVMOptions -XX:-FoldStableValues -XX:+UseCompressedOop
       
    67  *                   -server -XX:-TieredCompilation -Xcomp
       
    68  *                   -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
       
    69  *                   java.lang.invoke.TestStableByte
       
    70  *
       
    71  * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
       
    72  *                   -XX:+UnlockDiagnosticVMOptions -XX:-FoldStableValues -XX:-UseCompressedOop
       
    73  *                   -server -XX:-TieredCompilation -Xcomp
       
    74  *                   -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
       
    75  *                   java.lang.invoke.TestStableByte
       
    76  */
       
    77 package java.lang.invoke;
       
    78 
       
    79 import com.sun.management.HotSpotDiagnosticMXBean;
       
    80 import com.sun.management.VMOption;
       
    81 import sun.management.ManagementFactoryHelper;
       
    82 import java.lang.reflect.InvocationTargetException;
       
    83 
       
    84 public class TestStableByte {
       
    85     public static void main(String[] args) throws Exception {
       
    86         System.out.println("@Stable enabled: "+isStableEnabled);
       
    87         System.out.println();
       
    88 
       
    89         run(DefaultValue.class);
       
    90         run(ByteStable.class);
       
    91         run(StaticByteStable.class);
       
    92         run(VolatileByteStable.class);
       
    93 
       
    94         // @Stable arrays: Dim 1-4
       
    95         run(ByteArrayDim1.class);
       
    96         run(ByteArrayDim2.class);
       
    97         run(ByteArrayDim3.class);
       
    98         run(ByteArrayDim4.class);
       
    99 
       
   100         // @Stable Object field: dynamic arrays
       
   101         run(ObjectArrayLowerDim0.class);
       
   102         run(ObjectArrayLowerDim1.class);
       
   103         run(ObjectArrayLowerDim2.class);
       
   104 
       
   105         // Nested @Stable fields
       
   106         run(NestedStableField.class);
       
   107         run(NestedStableField1.class);
       
   108         run(NestedStableField2.class);
       
   109         run(NestedStableField3.class);
       
   110 
       
   111         if (failed) {
       
   112             throw new Error("TEST FAILED");
       
   113         }
       
   114     }
       
   115 
       
   116     /* ==================================================== */
       
   117 
       
   118     static class DefaultValue {
       
   119         public @Stable byte v;
       
   120 
       
   121         public static final DefaultValue c = new DefaultValue();
       
   122         public static byte get() { return c.v; }
       
   123         public static void test() throws Exception {
       
   124                      byte val1 = get();
       
   125             c.v = 1; byte val2 = get();
       
   126             assertEquals(val1, 0);
       
   127             assertEquals(val2, 1);
       
   128         }
       
   129     }
       
   130 
       
   131     /* ==================================================== */
       
   132 
       
   133     static class ByteStable {
       
   134         public @Stable byte v;
       
   135 
       
   136         public static final ByteStable c = new ByteStable();
       
   137         public static byte get() { return c.v; }
       
   138         public static void test() throws Exception {
       
   139             c.v = 5;   byte val1 = get();
       
   140             c.v = 127; byte val2 = get();
       
   141             assertEquals(val1, 5);
       
   142             assertEquals(val2, (isStableEnabled ? 5 : 127));
       
   143         }
       
   144     }
       
   145 
       
   146     /* ==================================================== */
       
   147 
       
   148     static class StaticByteStable {
       
   149         public static @Stable byte v;
       
   150 
       
   151         public static final StaticByteStable c = new StaticByteStable();
       
   152         public static byte get() { return c.v; }
       
   153         public static void test() throws Exception {
       
   154             c.v = 5;   byte val1 = get();
       
   155             c.v = 127; byte val2 = get();
       
   156             assertEquals(val1, 5);
       
   157             assertEquals(val2, (isStableEnabled ? 5 : 127));
       
   158         }
       
   159     }
       
   160 
       
   161     /* ==================================================== */
       
   162 
       
   163     static class VolatileByteStable {
       
   164         public @Stable volatile byte v;
       
   165 
       
   166         public static final VolatileByteStable c = new VolatileByteStable();
       
   167         public static byte get() { return c.v; }
       
   168         public static void test() throws Exception {
       
   169             c.v = 5;   byte val1 = get();
       
   170             c.v = 127; byte val2 = get();
       
   171             assertEquals(val1, 5);
       
   172             assertEquals(val2, (isStableEnabled ? 5 : 127));
       
   173         }
       
   174     }
       
   175 
       
   176     /* ==================================================== */
       
   177     // @Stable array == field && all components are stable
       
   178 
       
   179     static class ByteArrayDim1 {
       
   180         public @Stable byte[] v;
       
   181 
       
   182         public static final ByteArrayDim1 c = new ByteArrayDim1();
       
   183         public static byte get() { return c.v[0]; }
       
   184         public static byte get1() { return c.v[10]; }
       
   185         public static byte[] get2() { return c.v; }
       
   186         public static void test() throws Exception {
       
   187             {
       
   188                 c.v = new byte[1]; c.v[0] = 1; byte val1 = get();
       
   189                                    c.v[0] = 2; byte val2 = get();
       
   190                 assertEquals(val1, 1);
       
   191                 assertEquals(val2, (isStableEnabled ? 1 : 2));
       
   192 
       
   193                 c.v = new byte[1]; c.v[0] = 3; byte val3 = get();
       
   194                 assertEquals(val3, (isStableEnabled ? 1 : 3));
       
   195             }
       
   196 
       
   197             {
       
   198                 c.v = new byte[20]; c.v[10] = 1; byte val1 = get1();
       
   199                                     c.v[10] = 2; byte val2 = get1();
       
   200                 assertEquals(val1, 1);
       
   201                 assertEquals(val2, (isStableEnabled ? 1 : 2));
       
   202 
       
   203                 c.v = new byte[20]; c.v[10] = 3; byte val3 = get1();
       
   204                 assertEquals(val3, (isStableEnabled ? 1 : 3));
       
   205             }
       
   206 
       
   207             {
       
   208                 c.v = new byte[1]; byte[] val1 = get2();
       
   209                 c.v = new byte[1]; byte[] val2 = get2();
       
   210                 assertTrue((isStableEnabled ? (val1 == val2) : (val1 != val2)));
       
   211             }
       
   212         }
       
   213     }
       
   214 
       
   215     /* ==================================================== */
       
   216 
       
   217     static class ByteArrayDim2 {
       
   218         public @Stable byte[][] v;
       
   219 
       
   220         public static final ByteArrayDim2 c = new ByteArrayDim2();
       
   221         public static byte get() { return c.v[0][0]; }
       
   222         public static byte[] get1() { return c.v[0]; }
       
   223         public static byte[][] get2() { return c.v; }
       
   224         public static void test() throws Exception {
       
   225             {
       
   226                 c.v = new byte[1][1]; c.v[0][0] = 1; byte val1 = get();
       
   227                                       c.v[0][0] = 2; byte val2 = get();
       
   228                 assertEquals(val1, 1);
       
   229                 assertEquals(val2, (isStableEnabled ? 1 : 2));
       
   230 
       
   231                 c.v = new byte[1][1]; c.v[0][0] = 3; byte val3 = get();
       
   232                 assertEquals(val3, (isStableEnabled ? 1 : 3));
       
   233 
       
   234                 c.v[0] = new byte[1]; c.v[0][0] = 4; byte val4 = get();
       
   235                 assertEquals(val4, (isStableEnabled ? 1 : 4));
       
   236             }
       
   237 
       
   238             {
       
   239                 c.v = new byte[1][1]; byte[] val1 = get1();
       
   240                 c.v[0] = new byte[1]; byte[] val2 = get1();
       
   241                 assertTrue((isStableEnabled ? (val1 == val2) : (val1 != val2)));
       
   242             }
       
   243 
       
   244             {
       
   245                 c.v = new byte[1][1]; byte[][] val1 = get2();
       
   246                 c.v = new byte[1][1]; byte[][] val2 = get2();
       
   247                 assertTrue((isStableEnabled ? (val1 == val2) : (val1 != val2)));
       
   248             }
       
   249         }
       
   250     }
       
   251 
       
   252     /* ==================================================== */
       
   253 
       
   254     static class ByteArrayDim3 {
       
   255         public @Stable byte[][][] v;
       
   256 
       
   257         public static final ByteArrayDim3 c = new ByteArrayDim3();
       
   258         public static byte get() { return c.v[0][0][0]; }
       
   259         public static byte[] get1() { return c.v[0][0]; }
       
   260         public static byte[][] get2() { return c.v[0]; }
       
   261         public static byte[][][] get3() { return c.v; }
       
   262         public static void test() throws Exception {
       
   263             {
       
   264                 c.v = new byte[1][1][1]; c.v[0][0][0] = 1; byte val1 = get();
       
   265                                          c.v[0][0][0] = 2; byte val2 = get();
       
   266                 assertEquals(val1, 1);
       
   267                 assertEquals(val2, (isStableEnabled ? 1 : 2));
       
   268 
       
   269                 c.v = new byte[1][1][1]; c.v[0][0][0] = 3; byte val3 = get();
       
   270                 assertEquals(val3, (isStableEnabled ? 1 : 3));
       
   271 
       
   272                 c.v[0] = new byte[1][1]; c.v[0][0][0] = 4; byte val4 = get();
       
   273                 assertEquals(val4, (isStableEnabled ? 1 : 4));
       
   274 
       
   275                 c.v[0][0] = new byte[1]; c.v[0][0][0] = 5; byte val5 = get();
       
   276                 assertEquals(val5, (isStableEnabled ? 1 : 5));
       
   277             }
       
   278 
       
   279             {
       
   280                 c.v = new byte[1][1][1]; byte[] val1 = get1();
       
   281                 c.v[0][0] = new byte[1]; byte[] val2 = get1();
       
   282                 assertTrue((isStableEnabled ? (val1 == val2) : (val1 != val2)));
       
   283             }
       
   284 
       
   285             {
       
   286                 c.v = new byte[1][1][1]; byte[][] val1 = get2();
       
   287                 c.v[0] = new byte[1][1]; byte[][] val2 = get2();
       
   288                 assertTrue((isStableEnabled ? (val1 == val2) : (val1 != val2)));
       
   289             }
       
   290 
       
   291             {
       
   292                 c.v = new byte[1][1][1]; byte[][][] val1 = get3();
       
   293                 c.v = new byte[1][1][1]; byte[][][] val2 = get3();
       
   294                 assertTrue((isStableEnabled ? (val1 == val2) : (val1 != val2)));
       
   295             }
       
   296         }
       
   297     }
       
   298 
       
   299     /* ==================================================== */
       
   300 
       
   301     static class ByteArrayDim4 {
       
   302         public @Stable byte[][][][] v;
       
   303 
       
   304         public static final ByteArrayDim4 c = new ByteArrayDim4();
       
   305         public static byte get() { return c.v[0][0][0][0]; }
       
   306         public static byte[] get1() { return c.v[0][0][0]; }
       
   307         public static byte[][] get2() { return c.v[0][0]; }
       
   308         public static byte[][][] get3() { return c.v[0]; }
       
   309         public static byte[][][][] get4() { return c.v; }
       
   310         public static void test() throws Exception {
       
   311             {
       
   312                 c.v = new byte[1][1][1][1]; c.v[0][0][0][0] = 1; byte val1 = get();
       
   313                                             c.v[0][0][0][0] = 2; byte val2 = get();
       
   314                 assertEquals(val1, 1);
       
   315                 assertEquals(val2, (isStableEnabled ? 1 : 2));
       
   316 
       
   317                 c.v = new byte[1][1][1][1]; c.v[0][0][0][0] = 3; byte val3 = get();
       
   318                 assertEquals(val3, (isStableEnabled ? 1 : 3));
       
   319 
       
   320                 c.v[0] = new byte[1][1][1]; c.v[0][0][0][0] = 4; byte val4 = get();
       
   321                 assertEquals(val4, (isStableEnabled ? 1 : 4));
       
   322 
       
   323                 c.v[0][0] = new byte[1][1]; c.v[0][0][0][0] = 5; byte val5 = get();
       
   324                 assertEquals(val5, (isStableEnabled ? 1 : 5));
       
   325 
       
   326                 c.v[0][0][0] = new byte[1]; c.v[0][0][0][0] = 6; byte val6 = get();
       
   327                 assertEquals(val6, (isStableEnabled ? 1 : 6));
       
   328             }
       
   329 
       
   330             {
       
   331                 c.v = new byte[1][1][1][1]; byte[] val1 = get1();
       
   332                 c.v[0][0][0] = new byte[1]; byte[] val2 = get1();
       
   333                 assertTrue((isStableEnabled ? (val1 == val2) : (val1 != val2)));
       
   334             }
       
   335 
       
   336             {
       
   337                 c.v = new byte[1][1][1][1]; byte[][] val1 = get2();
       
   338                 c.v[0][0] = new byte[1][1]; byte[][] val2 = get2();
       
   339                 assertTrue((isStableEnabled ? (val1 == val2) : (val1 != val2)));
       
   340             }
       
   341 
       
   342             {
       
   343                 c.v = new byte[1][1][1][1]; byte[][][] val1 = get3();
       
   344                 c.v[0] = new byte[1][1][1]; byte[][][] val2 = get3();
       
   345                 assertTrue((isStableEnabled ? (val1 == val2) : (val1 != val2)));
       
   346             }
       
   347 
       
   348             {
       
   349                 c.v = new byte[1][1][1][1]; byte[][][][] val1 = get4();
       
   350                 c.v = new byte[1][1][1][1]; byte[][][][] val2 = get4();
       
   351                 assertTrue((isStableEnabled ? (val1 == val2) : (val1 != val2)));
       
   352             }
       
   353 
       
   354         }
       
   355     }
       
   356 
       
   357     /* ==================================================== */
       
   358     // Dynamic Dim is higher than static
       
   359 
       
   360     static class ObjectArrayLowerDim0 {
       
   361         public @Stable Object v;
       
   362 
       
   363         public static final ObjectArrayLowerDim0 c = new ObjectArrayLowerDim0();
       
   364         public static byte get() { return ((byte[])c.v)[0]; }
       
   365         public static byte[] get1() { return (byte[])c.v; }
       
   366 
       
   367         public static void test() throws Exception {
       
   368             {
       
   369                 c.v = new byte[1]; ((byte[])c.v)[0] = 1; byte val1 = get();
       
   370                                    ((byte[])c.v)[0] = 2; byte val2 = get();
       
   371 
       
   372                 assertEquals(val1, 1);
       
   373                 assertEquals(val2, 2);
       
   374             }
       
   375 
       
   376             {
       
   377                 c.v = new byte[1]; byte[] val1 = get1();
       
   378                 c.v = new byte[1]; byte[] val2 = get1();
       
   379                 assertTrue((isStableEnabled ? (val1 == val2) : (val1 != val2)));
       
   380             }
       
   381         }
       
   382     }
       
   383 
       
   384     /* ==================================================== */
       
   385 
       
   386     static class ObjectArrayLowerDim1 {
       
   387         public @Stable Object[] v;
       
   388 
       
   389         public static final ObjectArrayLowerDim1 c = new ObjectArrayLowerDim1();
       
   390         public static byte get() { return ((byte[][])c.v)[0][0]; }
       
   391         public static byte[] get1() { return (byte[])(c.v[0]); }
       
   392         public static Object[] get2() { return c.v; }
       
   393 
       
   394         public static void test() throws Exception {
       
   395             {
       
   396                 c.v = new byte[1][1]; ((byte[][])c.v)[0][0] = 1; byte val1 = get();
       
   397                                       ((byte[][])c.v)[0][0] = 2; byte val2 = get();
       
   398 
       
   399                 assertEquals(val1, 1);
       
   400                 assertEquals(val2, 2);
       
   401             }
       
   402 
       
   403             {
       
   404                 c.v = new byte[1][1]; c.v[0] = new byte[0]; byte[] val1 = get1();
       
   405                                      c.v[0] = new byte[0]; byte[] val2 = get1();
       
   406 
       
   407                 assertTrue((isStableEnabled ? (val1 == val2) : (val1 != val2)));
       
   408             }
       
   409 
       
   410             {
       
   411                 c.v = new byte[0][0]; Object[] val1 = get2();
       
   412                 c.v = new byte[0][0]; Object[] val2 = get2();
       
   413 
       
   414                 assertTrue((isStableEnabled ? (val1 == val2) : (val1 != val2)));
       
   415             }
       
   416         }
       
   417     }
       
   418 
       
   419     /* ==================================================== */
       
   420 
       
   421     static class ObjectArrayLowerDim2 {
       
   422         public @Stable Object[][] v;
       
   423 
       
   424         public static final ObjectArrayLowerDim2 c = new ObjectArrayLowerDim2();
       
   425         public static byte get() { return ((byte[][][])c.v)[0][0][0]; }
       
   426         public static byte[] get1() { return (byte[])(c.v[0][0]); }
       
   427         public static byte[][] get2() { return (byte[][])(c.v[0]); }
       
   428         public static Object[][] get3() { return c.v; }
       
   429 
       
   430         public static void test() throws Exception {
       
   431             {
       
   432                 c.v = new byte[1][1][1]; ((byte[][][])c.v)[0][0][0] = 1;  byte val1 = get();
       
   433                                          ((byte[][][])c.v)[0][0][0] = 2; byte val2 = get();
       
   434 
       
   435                 assertEquals(val1, 1);
       
   436                 assertEquals(val2, 2);
       
   437             }
       
   438 
       
   439             {
       
   440                 c.v = new byte[1][1][1]; c.v[0][0] = new byte[0]; byte[] val1 = get1();
       
   441                                          c.v[0][0] = new byte[0]; byte[] val2 = get1();
       
   442 
       
   443                 assertTrue((isStableEnabled ? (val1 == val2) : (val1 != val2)));
       
   444             }
       
   445 
       
   446             {
       
   447                 c.v = new byte[1][1][1]; c.v[0] = new byte[0][0]; byte[][] val1 = get2();
       
   448                                          c.v[0] = new byte[0][0]; byte[][] val2 = get2();
       
   449 
       
   450                 assertTrue((isStableEnabled ? (val1 == val2) : (val1 != val2)));
       
   451             }
       
   452 
       
   453             {
       
   454                 c.v = new byte[0][0][0]; Object[][] val1 = get3();
       
   455                 c.v = new byte[0][0][0]; Object[][] val2 = get3();
       
   456 
       
   457                 assertTrue((isStableEnabled ? (val1 == val2) : (val1 != val2)));
       
   458             }
       
   459         }
       
   460     }
       
   461 
       
   462     /* ==================================================== */
       
   463 
       
   464     static class NestedStableField {
       
   465         static class A {
       
   466             public @Stable byte a;
       
   467 
       
   468         }
       
   469         public @Stable A v;
       
   470 
       
   471         public static final NestedStableField c = new NestedStableField();
       
   472         public static A get() { return c.v; }
       
   473         public static byte get1() { return get().a; }
       
   474 
       
   475         public static void test() throws Exception {
       
   476             {
       
   477                 c.v = new A(); c.v.a = 1; A val1 = get();
       
   478                                c.v.a = 2; A val2 = get();
       
   479 
       
   480                 assertEquals(val1.a, 2);
       
   481                 assertEquals(val2.a, 2);
       
   482             }
       
   483 
       
   484             {
       
   485                 c.v = new A(); c.v.a = 1; byte val1 = get1();
       
   486                                c.v.a = 2; byte val2 = get1();
       
   487                 c.v = new A(); c.v.a = 3; byte val3 = get1();
       
   488 
       
   489                 assertEquals(val1, 1);
       
   490                 assertEquals(val2, (isStableEnabled ? 1 : 2));
       
   491                 assertEquals(val3, (isStableEnabled ? 1 : 3));
       
   492             }
       
   493         }
       
   494     }
       
   495 
       
   496     /* ==================================================== */
       
   497 
       
   498     static class NestedStableField1 {
       
   499         static class A {
       
   500             public @Stable byte a;
       
   501             public @Stable A next;
       
   502         }
       
   503         public @Stable A v;
       
   504 
       
   505         public static final NestedStableField1 c = new NestedStableField1();
       
   506         public static A get() { return c.v.next.next.next.next.next.next.next; }
       
   507         public static byte get1() { return get().a; }
       
   508 
       
   509         public static void test() throws Exception {
       
   510             {
       
   511                 c.v = new A(); c.v.next = new A();   c.v.next.next  = c.v;
       
   512                                c.v.a = 1; c.v.next.a = 1; A val1 = get();
       
   513                                c.v.a = 2; c.v.next.a = 2; A val2 = get();
       
   514 
       
   515                 assertEquals(val1.a, 2);
       
   516                 assertEquals(val2.a, 2);
       
   517             }
       
   518 
       
   519             {
       
   520                 c.v = new A(); c.v.next = c.v;
       
   521                                c.v.a = 1; byte val1 = get1();
       
   522                                c.v.a = 2; byte val2 = get1();
       
   523                 c.v = new A(); c.v.next = c.v;
       
   524                                c.v.a = 3; byte val3 = get1();
       
   525 
       
   526                 assertEquals(val1, 1);
       
   527                 assertEquals(val2, (isStableEnabled ? 1 : 2));
       
   528                 assertEquals(val3, (isStableEnabled ? 1 : 3));
       
   529             }
       
   530         }
       
   531     }
       
   532    /* ==================================================== */
       
   533 
       
   534     static class NestedStableField2 {
       
   535         static class A {
       
   536             public @Stable byte a;
       
   537             public @Stable A left;
       
   538             public         A right;
       
   539         }
       
   540 
       
   541         public @Stable A v;
       
   542 
       
   543         public static final NestedStableField2 c = new NestedStableField2();
       
   544         public static byte get() { return c.v.left.left.left.a; }
       
   545         public static byte get1() { return c.v.left.left.right.left.a; }
       
   546 
       
   547         public static void test() throws Exception {
       
   548             {
       
   549                 c.v = new A(); c.v.left = c.v.right = c.v;
       
   550                                c.v.a = 1; byte val1 = get(); byte val2 = get1();
       
   551                                c.v.a = 2; byte val3 = get(); byte val4 = get1();
       
   552 
       
   553                 assertEquals(val1, 1);
       
   554                 assertEquals(val3, (isStableEnabled ? 1 : 2));
       
   555 
       
   556                 assertEquals(val2, 1);
       
   557                 assertEquals(val4, 2);
       
   558             }
       
   559         }
       
   560     }
       
   561 
       
   562     /* ==================================================== */
       
   563 
       
   564     static class NestedStableField3 {
       
   565         static class A {
       
   566             public @Stable byte a;
       
   567             public @Stable A[] left;
       
   568             public         A[] right;
       
   569         }
       
   570 
       
   571         public @Stable A[] v;
       
   572 
       
   573         public static final NestedStableField3 c = new NestedStableField3();
       
   574         public static byte get() { return c.v[0].left[1].left[0].left[1].a; }
       
   575         public static byte get1() { return c.v[1].left[0].left[1].right[0].left[1].a; }
       
   576 
       
   577         public static void test() throws Exception {
       
   578             {
       
   579                 A elem = new A();
       
   580                 c.v = new A[] { elem, elem }; c.v[0].left = c.v[0].right = c.v;
       
   581                                elem.a = 1; byte val1 = get(); byte val2 = get1();
       
   582                                elem.a = 2; byte val3 = get(); byte val4 = get1();
       
   583 
       
   584                 assertEquals(val1, 1);
       
   585                 assertEquals(val3, (isStableEnabled ? 1 : 2));
       
   586 
       
   587                 assertEquals(val2, 1);
       
   588                 assertEquals(val4, 2);
       
   589             }
       
   590         }
       
   591     }
       
   592 
       
   593     /* ==================================================== */
       
   594     // Auxiliary methods
       
   595     static void assertEquals(int i, int j) { if (i != j)  throw new AssertionError(i + " != " + j); }
       
   596     static void assertTrue(boolean b) { if (!b)  throw new AssertionError(); }
       
   597 
       
   598     static boolean failed = false;
       
   599 
       
   600     public static void run(Class<?> test) {
       
   601         Throwable ex = null;
       
   602         System.out.print(test.getName()+": ");
       
   603         try {
       
   604             test.getMethod("test").invoke(null);
       
   605         } catch (InvocationTargetException e) {
       
   606             ex = e.getCause();
       
   607         } catch (Throwable e) {
       
   608             ex = e;
       
   609         } finally {
       
   610             if (ex == null) {
       
   611                 System.out.println("PASSED");
       
   612             } else {
       
   613                 failed = true;
       
   614                 System.out.println("FAILED");
       
   615                 ex.printStackTrace(System.out);
       
   616             }
       
   617         }
       
   618     }
       
   619 
       
   620     static final boolean isStableEnabled;
       
   621     static {
       
   622         HotSpotDiagnosticMXBean diagnostic
       
   623                 = ManagementFactoryHelper.getDiagnosticMXBean();
       
   624         VMOption tmp;
       
   625         try {
       
   626             tmp = diagnostic.getVMOption("FoldStableValues");
       
   627         } catch (IllegalArgumentException e) {
       
   628             tmp = null;
       
   629         }
       
   630         isStableEnabled = (tmp == null ? false : Boolean.parseBoolean(tmp.getValue()));
       
   631     }
       
   632 }