jdk8-mips64-public/langtools: comparison test/tools/javac/7153958/CPoolRefClassContainingInlinedCts.java

-:e7e42c79861e
+:1b59f823d630
 /*
-* Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2012, 2015, 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.  Oracle designates this
 * questions.
 */
 /*
 * @test
-* @bug 7153958
+* @bug 7153958 8073372
 * @summary add constant pool reference to class containing inlined constants
-* @compile pkg/ClassToBeStaticallyImported.java CPoolRefClassContainingInlinedCts.java
+* @compile pkg/ClassToBeStaticallyImportedA.java pkg/ClassToBeStaticallyImportedB.java CPoolRefClassContainingInlinedCts.java
 * @run main CPoolRefClassContainingInlinedCts
 */
 import com.sun.tools.classfile.ClassFile;
 import com.sun.tools.classfile.ConstantPool.CONSTANT_Class_info;
 import com.sun.tools.classfile.ConstantPool.CPInfo;
 import com.sun.tools.classfile.ConstantPoolException;
 import java.io.File;
 import java.io.IOException;
-import static pkg.ClassToBeStaticallyImported.staticField;
+import static pkg.ClassToBeStaticallyImportedA.staticFieldA;
+import static pkg.ClassToBeStaticallyImportedB.staticFieldB;
 public class CPoolRefClassContainingInlinedCts {
 public static void main(String args[]) throws Exception {
 new CPoolRefClassContainingInlinedCts().run();
 int numberOfReferencedClassesToBeChecked = 0;
 void checkClassName(String className) {
 switch (className) {
-case "SimpleAssignClass" : case "BinaryExpClass":
+case "SimpleAssignClassA" : case "BinaryExpClassA":
-case "UnaryExpClass" : case "CastClass":
+case "UnaryExpClassA" : case "CastClassA":
-case "ParensClass" : case "CondClass":
+case "ParensClassA" : case "CondClassA":
-case "IfClass" : case "pkg/ClassToBeStaticallyImported":
+case "IfClassA" : case "pkg/ClassToBeStaticallyImportedA":
+case "SimpleAssignClassB" : case "BinaryExpClassB":
+case "UnaryExpClassB" : case "CastClassB":
+case "ParensClassB" : case "CondClassB":
+case "IfClassB" : case "pkg/ClassToBeStaticallyImportedB":
 numberOfReferencedClassesToBeChecked++;
 }
 }
 void checkReferences() throws IOException, ConstantPoolException {
 if (cpInfo instanceof CONSTANT_Class_info) {
 checkClassName(((CONSTANT_Class_info)cpInfo).getName());
 }
 i += cpInfo.size();
 }
-if (numberOfReferencedClassesToBeChecked != 8) {
+if (numberOfReferencedClassesToBeChecked != 16) {
 throw new AssertionError("Class reference missing in the constant pool");
 }
 }
-private int assign = SimpleAssignClass.x;
+private int assignA = SimpleAssignClassA.x;
-private int binary = BinaryExpClass.x + 1;
+private int binaryA = BinaryExpClassA.x + 1;
-private int unary = -UnaryExpClass.x;
+private int unaryA = -UnaryExpClassA.x;
-private int cast = (int)CastClass.x;
+private int castA = (int)CastClassA.x;
-private int parens = (ParensClass.x);
+private int parensA = (ParensClassA.x);
-private int cond = (CondClass.x == 1) ? 1 : 2;
+private int condA = (CondClassA.x == 1) ? 1 : 2;
-private static int ifConstant;
+private static int ifConstantA;
-private static int importStatic;
+private static int importStaticA;
 static {
-if (IfClass.x == 1) {
+if (IfClassA.x == 1) {
-ifConstant = 1;
+ifConstantA = 1;
 } else {
-ifConstant = 2;
+ifConstantA = 2;
 }
 }
 static {
-if (staticField == 1) {
+if (staticFieldA == 1) {
-importStatic = 1;
+importStaticA = 1;
 } else {
-importStatic = 2;
+importStaticA = 2;
+}
+}
+// now as final constants
+private static final int assignB = SimpleAssignClassB.x;
+private static final int binaryB = BinaryExpClassB.x + 1;
+private static final int unaryB = -UnaryExpClassB.x;
+private static final int castB = (int)CastClassB.x;
+private static final int parensB = (ParensClassB.x);
+private static final int condB = (CondClassB.x == 1) ? 1 : 2;
+private static final int ifConstantB;
+private static final int importStaticB;
+static {
+if (IfClassB.x == 1) {
+ifConstantB = 1;
+} else {
+ifConstantB = 2;
+}
+}
+static {
+if (staticFieldB == 1) {
+importStaticB = 1;
+} else {
+importStaticB = 2;
 }
 }
 }
-class SimpleAssignClass {
+class SimpleAssignClassA {
 public static final int x = 1;
 }
-class BinaryExpClass {
+class SimpleAssignClassB {
 public static final int x = 1;
 }
-class UnaryExpClass {
+class BinaryExpClassA {
 public static final int x = 1;
 }
-class CastClass {
+class BinaryExpClassB {
 public static final int x = 1;
 }
-class ParensClass {
+class UnaryExpClassA {
 public static final int x = 1;
 }
-class CondClass {
+class UnaryExpClassB {
 public static final int x = 1;
 }
-class IfClass {
+class CastClassA {
 public static final int x = 1;
 }
+class CastClassB {
+public static final int x = 1;
+}
+class ParensClassA {
+public static final int x = 1;
+}
+class ParensClassB {
+public static final int x = 1;
+}
+class CondClassA {
+public static final int x = 1;
+}
+class CondClassB {
+public static final int x = 1;
+}
+class IfClassA {
+public static final int x = 1;
+}
+class IfClassB {
+public static final int x = 1;
+}

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: test/tools/javac/7153958/CPoolRefClassContainingInlinedCts.java

test/tools/javac/7153958/CPoolRefClassContainingInlinedCts.java