/*
 * Copyright (C) 2015 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

public class Main {
    public static boolean $inline$classTypeTest(Object o) {
        return ((SubMain) o) == o;
    }

    public static boolean $inline$interfaceTypeTest(Object o) {
        return ((Itf) o) == o;
    }

    public static SubMain subMain;
    public static Main mainField;
    public static Unrelated unrelatedField;
    public static FinalUnrelated finalUnrelatedField;

    /// CHECK-START: boolean Main.classTypeTestNull() register (after)
    /// CHECK-NOT: CheckCast
    public static boolean classTypeTestNull() {
        return $inline$classTypeTest(null);
    }

    /// CHECK-START: boolean Main.classTypeTestExactMain() register (after)
    /// CHECK: CheckCast
    public static boolean classTypeTestExactMain() {
        return $inline$classTypeTest(new Main());
    }

    /// CHECK-START: boolean Main.classTypeTestExactSubMain() register (after)
    /// CHECK-NOT: CheckCast
    public static boolean classTypeTestExactSubMain() {
        return $inline$classTypeTest(new SubMain());
    }

    /// CHECK-START: boolean Main.classTypeTestSubMainOrNull() register (after)
    /// CHECK-NOT: CheckCast
    public static boolean classTypeTestSubMainOrNull() {
        return $inline$classTypeTest(subMain);
    }

    /// CHECK-START: boolean Main.classTypeTestMainOrNull() register (after)
    /// CHECK: CheckCast
    public static boolean classTypeTestMainOrNull() {
        return $inline$classTypeTest(mainField);
    }

    /// CHECK-START: boolean Main.classTypeTestUnrelated() register (after)
    /// CHECK: CheckCast
    public static boolean classTypeTestUnrelated() {
        return $inline$classTypeTest(unrelatedField);
    }

    /// CHECK-START: boolean Main.classTypeTestFinalUnrelated() register (after)
    /// CHECK: CheckCast
    public static boolean classTypeTestFinalUnrelated() {
        return $inline$classTypeTest(finalUnrelatedField);
    }

    /// CHECK-START: boolean Main.interfaceTypeTestNull() register (after)
    /// CHECK-NOT: CheckCast
    public static boolean interfaceTypeTestNull() {
        return $inline$interfaceTypeTest(null);
    }

    /// CHECK-START: boolean Main.interfaceTypeTestExactMain() register (after)
    /// CHECK: CheckCast
    public static boolean interfaceTypeTestExactMain() {
        return $inline$interfaceTypeTest(new Main());
    }

    /// CHECK-START: boolean Main.interfaceTypeTestExactSubMain() register (after)
    /// CHECK-NOT: CheckCast
    public static boolean interfaceTypeTestExactSubMain() {
        return $inline$interfaceTypeTest(new SubMain());
    }

    /// CHECK-START: boolean Main.interfaceTypeTestSubMainOrNull() register (after)
    /// CHECK-NOT: CheckCast
    public static boolean interfaceTypeTestSubMainOrNull() {
        return $inline$interfaceTypeTest(subMain);
    }

    /// CHECK-START: boolean Main.interfaceTypeTestMainOrNull() register (after)
    /// CHECK: CheckCast
    public static boolean interfaceTypeTestMainOrNull() {
        return $inline$interfaceTypeTest(mainField);
    }

    /// CHECK-START: boolean Main.interfaceTypeTestUnrelated() register (after)
    /// CHECK: CheckCast
    public static boolean interfaceTypeTestUnrelated() {
        return $inline$interfaceTypeTest(unrelatedField);
    }

    /// CHECK-START: boolean Main.interfaceTypeTestFinalUnrelated() register (after)
    /// CHECK: CheckCast
    public static boolean interfaceTypeTestFinalUnrelated() {
        return $inline$interfaceTypeTest(finalUnrelatedField);
    }

    /// CHECK-START: java.lang.String Main.knownTestWithLoadedClass() register (after)
    /// CHECK-NOT: CheckCast
    public static String knownTestWithLoadedClass() {
        return (String)$inline$getString();
    }

    /// CHECK-START: Itf Main.knownTestWithUnloadedClass() register (after)
    /// CHECK: CheckCast
    public static Itf knownTestWithUnloadedClass() {
        return (Itf)$inline$getString();
    }

    public static Object $inline$getString() {
        return new String();
    }

    public static Object $inline$getMain() {
        return new Main();
    }

    /// CHECK-START: void Main.nonNullBoundType() register (after)
    /// CHECK-NOT: NullCheck
    public static void nonNullBoundType() {
        Main main = (Main)$inline$getMain();
        main.getClass();
    }

    public static void main(String[] args) {
        classTypeTestNull();
        try {
            classTypeTestExactMain();
            throw new Error("ClassCastException expected");
        } catch (ClassCastException e) {}
        classTypeTestExactSubMain();

        subMain = null;
        classTypeTestSubMainOrNull();
        subMain = new SubMain();
        classTypeTestSubMainOrNull();

        mainField = null;
        classTypeTestMainOrNull();
        mainField = new Main();
        try {
            classTypeTestMainOrNull();
            throw new Error("ClassCastException expected");
        } catch (ClassCastException e) {}
        mainField = new SubMain();
        classTypeTestMainOrNull();

        unrelatedField = null;
        classTypeTestUnrelated();
        unrelatedField = new Unrelated();
        try {
            classTypeTestUnrelated();
            throw new Error("ClassCastException expected");
        } catch (ClassCastException e) {}

        finalUnrelatedField = null;
        classTypeTestFinalUnrelated();
        finalUnrelatedField = new FinalUnrelated();
        try {
            classTypeTestFinalUnrelated();
            throw new Error("ClassCastException expected");
        } catch (ClassCastException e) {}

        interfaceTypeTestNull();
        try {
            interfaceTypeTestExactMain();
            throw new Error("ClassCastException expected");
        } catch (ClassCastException e) {}
        interfaceTypeTestExactSubMain();

        subMain = null;
        interfaceTypeTestSubMainOrNull();
        subMain = new SubMain();
        interfaceTypeTestSubMainOrNull();

        mainField = null;
        interfaceTypeTestMainOrNull();
        mainField = new Main();
        try {
            interfaceTypeTestMainOrNull();
            throw new Error("ClassCastException expected");
        } catch (ClassCastException e) {}
        mainField = new SubMain();
        interfaceTypeTestMainOrNull();

        unrelatedField = null;
        interfaceTypeTestUnrelated();
        unrelatedField = new Unrelated();
        try {
            interfaceTypeTestUnrelated();
            throw new Error("ClassCastException expected");
        } catch (ClassCastException e) {}

        finalUnrelatedField = null;
        interfaceTypeTestFinalUnrelated();
        finalUnrelatedField = new FinalUnrelated();
        try {
            interfaceTypeTestFinalUnrelated();
            throw new Error("ClassCastException expected");
        } catch (ClassCastException e) {}
    }
}

interface Itf {
}

class SubMain extends Main implements Itf {
}

class Unrelated {
}

final class FinalUnrelated {
}