/*
 * Copyright (C) 2017 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.
 */

package com.android.dx.mockito.inline.tests;

import org.junit.Test;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;

public class MockNonPublic {
    private interface SingleMethodInterface {
        String returnA();
    }

    private static <T extends Class> void mockSingleMethod(T clazz) {
        SingleMethodInterface c = (SingleMethodInterface) mock(clazz);
        assertNull(c.returnA());

        when(c.returnA()).thenReturn("fakeA");
        assertEquals("fakeA", c.returnA());
    }

    private static <T extends Class> void spySingleMethod(T clazz) {
        SingleMethodInterface c = (SingleMethodInterface) spy(clazz);
        assertEquals("A", c.returnA());

        when(c.returnA()).thenReturn("fakeA");
        assertEquals("fakeA", c.returnA());
    }

    private static <T extends SingleMethodInterface> void spyWrappedSingleMethod(T original) {
        T c = spy(original);
        assertEquals("A", c.returnA());

        when(c.returnA()).thenReturn("fakeA");
        assertEquals("fakeA", c.returnA());

        // original is unaffected
        assertEquals("A", original.returnA());
    }

    private interface DualMethodInterface {
        String returnA();
        String returnB();
    }

    private static <T extends Class> void mockDualMethod(T clazz) {
        DualMethodInterface c = (DualMethodInterface) mock(clazz);
        assertNull(c.returnA());
        assertNull(c.returnB());

        when(c.returnA()).thenReturn("fakeA");
        assertEquals("fakeA", c.returnA());
        assertNull(c.returnB());

        when(c.returnB()).thenReturn("fakeB");
        assertEquals("fakeA", c.returnA());
        assertEquals("fakeB", c.returnB());
    }

    private static <T extends Class> void spyDualMethod(T clazz) {
        DualMethodInterface c = (DualMethodInterface) spy(clazz);
        assertEquals("A", c.returnA());
        assertEquals("B", c.returnB());

        when(c.returnA()).thenReturn("fakeA");
        assertEquals("fakeA", c.returnA());
        assertEquals("B", c.returnB());

        when(c.returnB()).thenReturn("fakeB");
        assertEquals("fakeA", c.returnA());
        assertEquals("fakeB", c.returnB());
    }

    private static <T extends DualMethodInterface> void spyWrappedDualMethod(T original) {
        T c = spy(original);
        assertEquals("A", c.returnA());
        assertEquals("B", c.returnB());

        when(c.returnA()).thenReturn("fakeA");
        assertEquals("fakeA", c.returnA());
        assertEquals("B", c.returnB());

        when(c.returnB()).thenReturn("fakeB");
        assertEquals("fakeA", c.returnA());
        assertEquals("fakeB", c.returnB());

        // original is unaffected
        assertEquals("A", original.returnA());
        assertEquals("B", original.returnB());
    }

    private static class PrivateClass implements SingleMethodInterface {
        @Override
        public String returnA() {
            return "A";
        }
    }

    @Test
    public void mockPrivateClass() {
        mockSingleMethod(PrivateClass.class);
    }

    @Test
    public void spyPrivateClass() {
        spySingleMethod(PrivateClass.class);
    }

    @Test
    public void spyWrappedPrivateClass() {
        spyWrappedSingleMethod(new PrivateClass());
    }

    private interface PrivateInterface extends SingleMethodInterface {
        @Override
        String returnA();
    }

    @Test
    public void mockPrivateInterface() {
        mockSingleMethod(PrivateInterface.class);
    }

    private static class SubOfPrivateInterface implements PrivateInterface {
        @Override
        public String returnA() {
            return "A";
        }
    }

    @Test
    public void mockSubOfPrivateInterface() {
        mockSingleMethod(SubOfPrivateInterface.class);
    }

    @Test
    public void spySubOfPrivateInterface() {
        spySingleMethod(SubOfPrivateInterface.class);
    }

    @Test
    public void spyWrappedSubOfPrivateInterface() {
        spyWrappedSingleMethod(new SubOfPrivateInterface());
    }

    private static abstract class PrivateAbstractClass implements DualMethodInterface {
        @Override
        public String returnA() {
            return "A";
        }

        @Override
        public abstract String returnB();
    }

    @Test
    public void mockPrivateAbstractClass() {
        mockDualMethod(PrivateAbstractClass.class);
    }

    private static class SubOfPrivateAbstractClass extends PrivateAbstractClass {
        @Override
        public String returnB() {
            return "B";
        }
    }

    @Test
    public void mockSubOfPrivateAbstractClass() {
        mockDualMethod(SubOfPrivateAbstractClass.class);
    }

    @Test
    public void spySubOfPrivateAbstractClass() {
        spyDualMethod(SubOfPrivateAbstractClass.class);
    }

    @Test
    public void spyWrappedSubOfPrivateAbstractClass() {
        spyWrappedDualMethod(new SubOfPrivateAbstractClass());
    }

    static class PackagePrivateClass implements SingleMethodInterface {
        @Override
        public String returnA() {
            return "A";
        }
    }

    @Test
    public void mockPackagePrivateClass() {
        mockSingleMethod(PackagePrivateClass.class);
    }

    static abstract class PackagePrivateAbstractClass implements DualMethodInterface {
        @Override
        public String returnA() {
            return "A";
        }

        @Override
        public abstract String returnB();
    }

    @Test
    public void mockPackagePrivateAbstractClass() {
        mockDualMethod(PackagePrivateAbstractClass.class);
    }

    static class SubOfPackagePrivateAbstractClass extends PackagePrivateAbstractClass {
        @Override
        public String returnB() {
            return "B";
        }
    }

    @Test
    public void mockSubOfPackagePrivateAbstractClass() {
        mockDualMethod(SubOfPackagePrivateAbstractClass.class);
    }

    @Test
    public void spySubOfPackagePrivateAbstractClass() {
        spyDualMethod(SubOfPackagePrivateAbstractClass.class);
    }

    @Test
    public void spyWrappedSubOfPackagePrivateAbstractClass() {
        spyWrappedDualMethod(new SubOfPackagePrivateAbstractClass());
    }

    interface PackagePrivateInterface extends SingleMethodInterface {
        @Override
        String returnA();
    }

    @Test
    public void mockPackagePrivateInterface() {
        mockSingleMethod(PackagePrivateInterface.class);
    }

    static class SubOfPackagePrivateInterface implements PackagePrivateInterface {
        @Override
        public String returnA() {
            return "A";
        }
    }

    @Test
    public void mockSubOfPackagePrivateInterface() {
        mockSingleMethod(SubOfPackagePrivateInterface.class);
    }

    @Test
    public void spySubOfPackagePrivateInterface() {
        spySingleMethod(SubOfPackagePrivateInterface.class);
    }

    @Test
    public void spyWrappedSubOfPackagePrivateInterface() {
        spyWrappedSingleMethod(new SubOfPackagePrivateInterface());
    }

    // Cannot implement SingleMethodInterface as returnA would have to be public
    public static class ClassWithPackagePrivateMethod {
        String returnA() {
            return "A";
        }
    }

    @Test
    public void mockClassWithPackagePrivateMethod() {
        ClassWithPackagePrivateMethod c = mock(ClassWithPackagePrivateMethod.class);
        assertNull(c.returnA());

        when(c.returnA()).thenReturn("fakeA");
        assertEquals("fakeA", c.returnA());
    }

    @Test
    public void spyClassWithPackagePrivateMethod() {
        ClassWithPackagePrivateMethod c = spy(ClassWithPackagePrivateMethod.class);
        assertEquals("A", c.returnA());

        when(c.returnA()).thenReturn("fakeA");
        assertEquals("fakeA", c.returnA());
    }

    @Test
    public void spyWrappedClassWithPackagePrivateMethod() {
        ClassWithPackagePrivateMethod original = new ClassWithPackagePrivateMethod();
        ClassWithPackagePrivateMethod c = spy(original);
        assertEquals("A", c.returnA());

        when(c.returnA()).thenReturn("fakeA");
        assertEquals("fakeA", c.returnA());

        // original is unaffected
        assertEquals("A", original.returnA());
    }

    // Cannot implement DualMethodInterface as returnA/returnB would have to be public
    public static abstract class AbstractClassWithPackagePrivateMethod {
        String returnA() {
            return "A";
        }

        abstract String returnB();
    }

    @Test
    public void mockAbstractClassWithPackagePrivateMethod() {
        AbstractClassWithPackagePrivateMethod c = mock(AbstractClassWithPackagePrivateMethod.class);
        assertNull(c.returnA());
        assertNull(c.returnB());

        when(c.returnA()).thenReturn("fakeA");
        assertEquals("fakeA", c.returnA());
        assertNull(c.returnB());

        when(c.returnB()).thenReturn("fakeB");
        assertEquals("fakeA", c.returnA());
        assertEquals("fakeB", c.returnB());
    }

    public static class SubOfAbstractClassWithPackagePrivateMethod extends
            AbstractClassWithPackagePrivateMethod {
        @Override
        String returnB() {
            return "B";
        }
    }

    @Test
    public void mockSubOfAbstractClassWithPackagePrivateMethod() {
        SubOfAbstractClassWithPackagePrivateMethod c = mock
                (SubOfAbstractClassWithPackagePrivateMethod.class);
        assertNull(c.returnA());
        assertNull(c.returnB());

        when(c.returnA()).thenReturn("fakeA");
        assertEquals("fakeA", c.returnA());
        assertNull(c.returnB());

        when(c.returnB()).thenReturn("fakeB");
        assertEquals("fakeA", c.returnA());
        assertEquals("fakeB", c.returnB());
    }

    @Test
    public void spySubOfAbstractClassWithPackagePrivateMethod() {
        SubOfAbstractClassWithPackagePrivateMethod c = spy
                (SubOfAbstractClassWithPackagePrivateMethod.class);
        assertEquals("A", c.returnA());
        assertEquals("B", c.returnB());

        when(c.returnA()).thenReturn("fakeA");
        assertEquals("fakeA", c.returnA());
        assertEquals("B", c.returnB());

        when(c.returnB()).thenReturn("fakeB");
        assertEquals("fakeA", c.returnA());
        assertEquals("fakeB", c.returnB());
    }

    @Test
    public void spyWrappedSubOfAbstractClassWithPackagePrivateMethod() {
        SubOfAbstractClassWithPackagePrivateMethod original = new
                SubOfAbstractClassWithPackagePrivateMethod();
        SubOfAbstractClassWithPackagePrivateMethod c = spy(original);
        assertEquals("A", c.returnA());
        assertEquals("B", c.returnB());

        when(c.returnA()).thenReturn("fakeA");
        assertEquals("fakeA", c.returnA());
        assertEquals("B", c.returnB());

        when(c.returnB()).thenReturn("fakeB");
        assertEquals("fakeA", c.returnA());
        assertEquals("fakeB", c.returnB());

        // original is unaffected
        assertEquals("A", original.returnA());
        assertEquals("B", original.returnB());
    }
}