1/*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17import java.lang.reflect.Type;
18
19/**
20 * Throw a few things at the verifier, all of which are expected to pass.
21 */
22public class Main {
23    static public void main(String[] args) {
24        tryBlah(1);
25
26        System.out.println("Zorch.");
27        System.out.println("10 == " + instanceOfTest(10));
28    }
29
30    /*
31     * Make sure the verifier is handling type merge of arrays of
32     * references correctly.
33     */
34    static Object[] arrayCheck1(int wanted) {
35        String[] arrayOne;
36        Integer[] arrayTwo;
37
38        arrayOne = new String[1];
39        arrayTwo = new Integer[1];
40
41        switch (wanted) {
42            case 0:     return arrayOne;
43            case 1:     return arrayTwo;
44            default:    return null;
45        }
46    }
47
48    static Object arrayCheck1b(int wanted) {
49        String[] arrayOne;
50        Integer[] arrayTwo;
51        int[] arrayThree;
52
53        arrayOne = new String[1];
54        arrayTwo = new Integer[1];
55        arrayThree = new int[1];
56
57        switch (wanted) {
58            case 0:     return arrayOne;
59            case 1:     return arrayTwo;
60            case 2:     return arrayThree;
61            default:    return null;
62        }
63    }
64
65    static Object[] arrayCheck2(int wanted) {
66        String[][] arrayOne;
67        String[][] arrayTwo;
68        Integer[][] arrayThree;
69
70        arrayOne = new String[1][];
71        arrayTwo = new String[1][];
72        arrayThree = new Integer[1][];
73
74        switch (wanted) {
75            case 0:     return arrayOne;
76            case 1:     return arrayTwo;
77            case 2:     return arrayThree;
78            default:    return null;
79        }
80    }
81
82    static Object[] arrayCheck3(int wanted) {
83        String[][] arrayTwo;
84        String[][][][] arrayFour;
85
86        arrayTwo = new String[1][];
87        arrayFour = new String[1][][][];
88
89        switch (wanted) {
90            case 0:     return arrayTwo;
91            case 1:     return arrayFour;
92            default:    return null;
93        }
94    }
95
96    /*
97     * Check return type merge.
98     */
99    private Type[] typeTest() {
100        if(this == null) {
101            return (Class<?>[])null;
102        }
103        return (Type[])null;
104    }
105
106
107    /*
108     * Exercise the blahs.
109     */
110    static void tryBlah(int num) {
111        BlahFeature feature = null;     // interface ref
112
113        switch (num) {
114            case 1:
115                feature = new BlahOne();
116                break;
117            default:
118                feature = new BlahTwo();
119                break;
120        }
121
122        feature.doStuff();
123    }
124
125    static int instanceOfTest(Integer x) {
126      Object y = x;
127      if (y instanceof String) {
128        // Bug: 15808277
129        // Non-sensical instance-of to check merging after the branch doesn't result in a verifier
130        // error.
131        ((String)y).charAt(0);
132      }
133      return x.intValue();
134    }
135}
136