TestGetConstantExpression.java revision 2933:49d207bf704d 
1/*
2 * Copyright (c) 2009, 2015, 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 * @test
26 * @bug 6471577 6517779
27 * @summary Test Elements.getConstantExpression
28 * @author  Joseph D. Darcy
29 * @library /tools/javac/lib
30 * @modules java.compiler
31 *          jdk.compiler
32 * @build   JavacTestingAbstractProcessor TestGetConstantExpression
33 * @compile -processor TestGetConstantExpression Foo.java
34 */
35
36import java.util.Set;
37import javax.annotation.processing.*;
38import javax.lang.model.SourceVersion;
39import static javax.lang.model.SourceVersion.*;
40import javax.lang.model.element.*;
41import javax.lang.model.util.*;
42import static javax.lang.model.util.ElementFilter.*;
43import static javax.tools.Diagnostic.Kind.*;
44import static javax.tools.StandardLocation.*;
45import java.io.*;
46
47/**
48 * Test basic workings of Elements.getConstantExpression.
49 */
50public class TestGetConstantExpression extends JavacTestingAbstractProcessor {
51    private int round = 1;
52
53    /**
54     * Check expected behavior on classes and packages.
55     */
56    public boolean process(Set<? extends TypeElement> annotations,
57                           RoundEnvironment roundEnv) {
58        int errors = 0;
59        boolean processingOver = roundEnv.processingOver();
60
61        if (!processingOver && round == 1) {
62            errors += expectIllegalArgumentException(null);
63            errors += expectIllegalArgumentException(this);
64
65            // Generate source code with various constant values and
66            // make sure it compiles.
67
68            try {
69                PrintWriter pw = new PrintWriter(filer.createSourceFile("ConstantTest").openWriter());
70                try {
71                    Boolean[]   booleans = {true, false};
72                    Byte[]      bytes    = {Byte.MIN_VALUE,    -1,  0, 1,  Byte.MAX_VALUE};
73                    Short[]     shorts   = {Short.MIN_VALUE,   -1,  0, 1,  Short.MAX_VALUE};
74                    Integer[]   ints     = {Integer.MIN_VALUE, -1,  0, 1,  Integer.MAX_VALUE};
75                    Long[]      longs    = {Long.MIN_VALUE,    -1L, 0L,1L, Long.MAX_VALUE};
76                    Character[] chars    = {Character.MIN_VALUE, ' ', '\t', 'a', 'b', 'c', '~', Character.MAX_VALUE};
77                    Float[]     floats   = {Float.NaN,  Float.NEGATIVE_INFINITY,  -1.0f, -0.0f, 0.0f, 1.0f, Float.POSITIVE_INFINITY};
78                    Double[]    doubles  = {Double.NaN, Double.NEGATIVE_INFINITY, -1.0,  -0.0,  0.0,  1.0,  Double.POSITIVE_INFINITY};
79
80                    pw.println("class ConstantTest {");
81                    pw.println(String.format("  private static boolean[] booleans = {%s};",
82                                             printConstants(booleans)));
83                    pw.println(String.format("  private static byte[] bytes = {%s};",
84                                             printConstants(bytes)));
85                    pw.println(String.format("  private static short[] shorts = {%s};",
86                                             printConstants(shorts)));
87                    pw.println(String.format("  private static int[] ints = {%s};",
88                                             printConstants(ints)));
89                    pw.println(String.format("  private static long[] longs = {%s};",
90                                             printConstants(longs)));
91                    pw.println(String.format("  private static char[] chars = {%s};",
92                                             printConstants(chars)));
93                    pw.println(String.format("  private static float[] floats = {%s};",
94                                             printConstants(floats)));
95                    pw.println(String.format("  private static double[] doubles = {%s};",
96                                             printConstants(doubles)));
97                    pw.println("}");
98                } finally {
99                    pw.close();
100                }
101            } catch(IOException io) {
102                throw new RuntimeException(io);
103            }
104            round++;
105        } else if (processingOver) {
106            if (errors > 0) {
107                throw new RuntimeException();
108            }
109        }
110        return true;
111    }
112
113    String printConstants(Object[] constants) {
114        StringBuilder sb = new StringBuilder();
115
116        for(Object o : constants) {
117            sb.append(eltUtils.getConstantExpression(o));
118            sb.append(", ");
119        }
120        return sb.toString();
121    }
122
123    int expectIllegalArgumentException(Object o) {
124        String s = "";
125        try {
126            s = eltUtils.getConstantExpression(o);
127            System.err.println("Unexpected string returned: " + s);
128            return 1;
129        } catch (IllegalArgumentException iae) {
130            return 0;
131        }
132    }
133}
134