tests/tests/graphics/src/android/graphics/drawable/cts/DrawableWrapperTest.java

/*
 * 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.
 */

package android.graphics.drawable.cts;

import android.graphics.drawable.DrawableWrapper;
import com.android.cts.graphics.R;


import java.util.Arrays;

import android.graphics.Canvas;
import android.graphics.ColorFilter;
import android.graphics.Rect;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.Drawable.ConstantState;
import android.test.AndroidTestCase;
import android.util.StateSet;

public class DrawableWrapperTest extends AndroidTestCase {

    static class MyWrapper extends DrawableWrapper {
        public MyWrapper(Drawable dr) {
            super(dr);
        }
    }

    @SuppressWarnings("deprecation")
    public void testConstructor() {
        Drawable d = new BitmapDrawable();
        MyWrapper wrapper = new MyWrapper(d);
        assertSame(d, wrapper.getDrawable());

        new MyWrapper(null);
    }

    @SuppressWarnings("deprecation")
    public void testGetDrawable() {
        Drawable d = new BitmapDrawable();
        MyWrapper wrapper = new MyWrapper(d);
        assertSame(d, wrapper.getDrawable());
    }

    @SuppressWarnings("deprecation")
    public void testSetDrawable() {
        Drawable d = new BitmapDrawable();
        MyWrapper wrapper = new MyWrapper(null);
        assertSame(null, wrapper.getDrawable());

        wrapper.setDrawable(d);
        assertSame(d, wrapper.getDrawable());
    }

    @SuppressWarnings("deprecation")
    public void testInvalidateDrawable() {
        MyWrapper wrapper = new MyWrapper(new BitmapDrawable());

        MockCallback cb = new MockCallback();
        wrapper.setCallback(cb);
        wrapper.invalidateDrawable(null);
        assertTrue(cb.hasCalledInvalidate());

        cb.reset();
        wrapper.invalidateDrawable(new BitmapDrawable());
        assertTrue(cb.hasCalledInvalidate());

        cb.reset();
        wrapper.setCallback(null);
        wrapper.invalidateDrawable(null);
        assertFalse(cb.hasCalledInvalidate());
    }

    @SuppressWarnings("deprecation")
    public void testScheduleDrawable() {
        MyWrapper wrapper = new MyWrapper(new BitmapDrawable());

        MockCallback cb = new MockCallback();
        wrapper.setCallback(cb);
        wrapper.scheduleDrawable(null, null, 0);
        assertTrue(cb.hasCalledSchedule());

        cb.reset();
        wrapper.scheduleDrawable(new BitmapDrawable(), new Runnable() {
            public void run() {
            }
        }, 1000L);
        assertTrue(cb.hasCalledSchedule());

        cb.reset();
        wrapper.setCallback(null);
        wrapper.scheduleDrawable(null, null, 0);
        assertFalse(cb.hasCalledSchedule());
    }

    @SuppressWarnings("deprecation")
    public void testUnscheduleDrawable() {
        MyWrapper wrapper = new MyWrapper(new BitmapDrawable());

        MockCallback cb = new MockCallback();
        wrapper.setCallback(cb);
        wrapper.unscheduleDrawable(null, null);
        assertTrue(cb.hasCalledUnschedule());

        cb.reset();
        wrapper.unscheduleDrawable(new BitmapDrawable(), new Runnable() {
            public void run() {
            }
        });
        assertTrue(cb.hasCalledUnschedule());

        cb.reset();
        wrapper.setCallback(null);
        wrapper.unscheduleDrawable(null, null);
        assertFalse(cb.hasCalledUnschedule());
    }

    private static class MockCallback implements Drawable.Callback {
        private boolean mCalledInvalidate;
        private boolean mCalledSchedule;
        private boolean mCalledUnschedule;

        public void invalidateDrawable(Drawable who) {
            mCalledInvalidate = true;
        }

        public void scheduleDrawable(Drawable who, Runnable what, long when) {
            mCalledSchedule = true;
        }

        public void unscheduleDrawable(Drawable who, Runnable what) {
            mCalledUnschedule = true;
        }

        public boolean hasCalledInvalidate() {
            return mCalledInvalidate;
        }

        public boolean hasCalledSchedule() {
            return mCalledSchedule;
        }

        public boolean hasCalledUnschedule() {
            return mCalledUnschedule;
        }

        public int getResolvedLayoutDirection(Drawable who) {
            return 0;
        }

        public void reset() {
            mCalledInvalidate = false;
            mCalledSchedule = false;
            mCalledUnschedule = false;
        }
    }

    public void testDraw() {
        MockDrawable mockDrawable = new MockDrawable();
        MyWrapper wrapper = new MyWrapper(mockDrawable);

        wrapper.draw(new Canvas());
        assertTrue(mockDrawable.hasCalledDraw());

        mockDrawable.reset();
        wrapper.draw(null);
        assertTrue(mockDrawable.hasCalledDraw());
    }

    public void testGetChangingConfigurations() {
        final int SUPER_CONFIG = 1;
        final int CONTAINED_DRAWABLE_CONFIG = 2;

        MockDrawable mockDrawable = new MockDrawable();
        MyWrapper wrapper = new MyWrapper(mockDrawable);

        assertEquals(0, wrapper.getChangingConfigurations());

        mockDrawable.setChangingConfigurations(CONTAINED_DRAWABLE_CONFIG);
        assertEquals(CONTAINED_DRAWABLE_CONFIG, wrapper.getChangingConfigurations());

        wrapper.setChangingConfigurations(SUPER_CONFIG);
        assertEquals(SUPER_CONFIG | CONTAINED_DRAWABLE_CONFIG,
                wrapper.getChangingConfigurations());
    }

    public void testGetPadding() {
        MockDrawable mockDrawable = new MockDrawable();
        MyWrapper wrapper = new MyWrapper(mockDrawable);

        // this method will call contained drawable's getPadding method.
        wrapper.getPadding(new Rect());
        assertTrue(mockDrawable.hasCalledGetPadding());

        // input null as param
        try {
            wrapper.getPadding(null);
            fail("Should throw NullPointerException");
        } catch (NullPointerException e) {
        }
    }

    public void testSetVisible() {
        MockDrawable mockDrawable = new MockDrawable();
        MyWrapper wrapper = new MyWrapper(mockDrawable);
        assertTrue(wrapper.isVisible());

        assertTrue(wrapper.setVisible(false, false));
        assertFalse(wrapper.isVisible());
        assertTrue(mockDrawable.hasCalledSetVisible());

        mockDrawable.reset();
        assertFalse(wrapper.setVisible(false, false));
        assertFalse(wrapper.isVisible());
        assertTrue(mockDrawable.hasCalledSetVisible());

        mockDrawable.reset();
        assertTrue(wrapper.setVisible(true, false));
        assertTrue(wrapper.isVisible());
        assertTrue(mockDrawable.hasCalledSetVisible());
    }

    public void testSetAlpha() {
        MockDrawable mockDrawable = new MockDrawable();
        MyWrapper wrapper = new MyWrapper(mockDrawable);

        // this method will call contained drawable's setAlpha method.
        wrapper.setAlpha(100);
        assertTrue(mockDrawable.hasCalledSetAlpha());

        mockDrawable.reset();
        wrapper.setAlpha(Integer.MAX_VALUE);
        assertTrue(mockDrawable.hasCalledSetAlpha());

        mockDrawable.reset();
        wrapper.setAlpha(-1);
        assertTrue(mockDrawable.hasCalledSetAlpha());
    }

    public void testSetColorFilter() {
        MockDrawable mockDrawable = new MockDrawable();
        MyWrapper wrapper = new MyWrapper(mockDrawable);

        // this method will call contained drawable's setColorFilter method.
        wrapper.setColorFilter(new ColorFilter());
        assertTrue(mockDrawable.hasCalledSetColorFilter());

        mockDrawable.reset();
        wrapper.setColorFilter(null);
        assertTrue(mockDrawable.hasCalledSetColorFilter());
    }

    public void testGetOpacity() {
        MockDrawable mockDrawable = new MockDrawable();
        MyWrapper wrapper = new MyWrapper(mockDrawable);

        // This method will call contained drawable's getOpacity method.
        wrapper.setLevel(1);
        wrapper.getOpacity();
        assertTrue(mockDrawable.hasCalledGetOpacity());
    }

    public void testIsStateful() {
        MockDrawable mockDrawable = new MockDrawable();
        MyWrapper wrapper = new MyWrapper(mockDrawable);

        // this method will call contained drawable's isStateful method.
        wrapper.isStateful();
        assertTrue(mockDrawable.hasCalledIsStateful());
    }

    public void testOnStateChange() {
        Drawable d = new MockDrawable();
        MockDrawableWrapper wrapper = new MockDrawableWrapper(d);
        assertEquals("initial child state is empty", d.getState(), StateSet.WILD_CARD);

        int[] state = new int[] {1, 2, 3};
        assertFalse("child did not change", wrapper.onStateChange(state));
        assertEquals("child state did not change", d.getState(), StateSet.WILD_CARD);

        d = mContext.getDrawable(R.drawable.statelistdrawable);
        wrapper = new MockDrawableWrapper(d);
        assertEquals("initial child state is empty", d.getState(), StateSet.WILD_CARD);
        wrapper.onStateChange(state);
        assertTrue("child state changed", Arrays.equals(state, d.getState()));

        // input null as param
        wrapper.onStateChange(null);
        // expected, no Exception thrown out, test success
    }

    public void testOnLevelChange() {
        MockDrawable mockDrawable = new MockDrawable();
        MockDrawableWrapper mockDrawableWrapper = new MockDrawableWrapper(mockDrawable);

        assertEquals(0, mockDrawable.getLevel());
        assertFalse(mockDrawableWrapper.onLevelChange(0));
        assertFalse(mockDrawable.hasCalledOnLevelChange());

        assertFalse(mockDrawableWrapper.onLevelChange(1000));
        assertTrue(mockDrawable.hasCalledOnLevelChange());
        assertEquals(1000, mockDrawable.getLevel());

        mockDrawable.reset();
        mockDrawableWrapper.reset();
        assertFalse(mockDrawableWrapper.onLevelChange(Integer.MIN_VALUE));
        assertTrue(mockDrawable.hasCalledOnLevelChange());
    }

    public void testOnBoundsChange() {
        MockDrawable mockDrawable = new MockDrawable();
        MockDrawableWrapper mockDrawableWrapper = new MockDrawableWrapper(mockDrawable);
        Rect bounds = new Rect(2, 2, 26, 32);
        mockDrawable.setBounds(bounds);
        mockDrawableWrapper.onBoundsChange(bounds);

        mockDrawableWrapper = new MockDrawableWrapper(mockDrawable);
        mockDrawable.setBounds(bounds);
        mockDrawableWrapper.onBoundsChange(bounds);
        assertEquals(bounds.left, mockDrawable.getBounds().left);
        assertEquals(bounds.top, mockDrawable.getBounds().top);
        assertEquals(bounds.right, mockDrawable.getBounds().right);
        assertEquals(bounds.bottom, mockDrawable.getBounds().bottom);

        bounds = mockDrawable.getBounds();
        assertEquals(2, bounds.left);
        assertEquals(2, bounds.top);
        assertEquals(26, bounds.right);
        assertEquals(32, bounds.bottom);

        // input null as param
        try {
            mockDrawableWrapper.onBoundsChange(null);
            fail("There should be a NullPointerException thrown out.");
        } catch (NullPointerException e) {
            // expected, test success
        }

    }

    public void testGetIntrinsicWidth() {
        MockDrawable mockDrawable = new MockDrawable();
        MyWrapper wrapper = new MyWrapper(mockDrawable);

        // this method will call contained drawable's getIntrinsicWidth method.
        wrapper.getIntrinsicWidth();
        assertTrue(mockDrawable.hasCalledGetIntrinsicWidth());
    }

    public void testGetIntrinsicHeight() {
        MockDrawable mockDrawable = new MockDrawable();
        DrawableWrapper wrapper = new MyWrapper(mockDrawable);

        // this method will call contained drawable's getIntrinsicHeight method.
        wrapper.getIntrinsicHeight();
        assertTrue(mockDrawable.hasCalledGetIntrinsicHeight());
    }

    @SuppressWarnings("deprecation")
    public void testGetConstantState() {
        DrawableWrapper wrapper = new MyWrapper(new BitmapDrawable());
        ConstantState constantState = wrapper.getConstantState();
    }

    private static class MockDrawable extends Drawable {
        private boolean mCalledDraw = false;
        private boolean mCalledGetPadding = false;
        private boolean mCalledSetVisible = false;
        private boolean mCalledSetAlpha = false;
        private boolean mCalledGetOpacity = false;
        private boolean mCalledSetColorFilter = false;
        private boolean mCalledIsStateful = false;
        private boolean mCalledGetIntrinsicWidth = false;
        private boolean mCalledGetIntrinsicHeight = false;
        private boolean mCalledSetState = false;
        private boolean mCalledOnLevelChange = false;

        @Override
        public void draw(Canvas canvas) {
            mCalledDraw = true;
        }

        @Override
        public int getOpacity() {
            mCalledGetOpacity = true;
            return 0;
        }

        @Override
        public void setAlpha(int alpha) {
            mCalledSetAlpha = true;
        }

        @Override
        public void setColorFilter(ColorFilter cf) {
            mCalledSetColorFilter = true;
        }

        @Override
        public boolean getPadding(Rect padding) {
            mCalledGetPadding = true;
            return super.getPadding(padding);
        }

        @Override
        public boolean setVisible(boolean visible, boolean restart) {
            mCalledSetVisible = true;
            return super.setVisible(visible, restart);
        }

        @Override
        public boolean isStateful() {
            mCalledIsStateful = true;
            return super.isStateful();
        }

        @Override
        public int getIntrinsicWidth() {
            mCalledGetIntrinsicWidth = true;
            return super.getIntrinsicWidth();
        }

        @Override
        public int getIntrinsicHeight() {
            mCalledGetIntrinsicHeight = true;
            return super.getIntrinsicHeight();

        }

        @Override
        public boolean setState(final int[] stateSet) {
            mCalledSetState = true;
            return super.setState(stateSet);
        }

        @Override
        protected boolean onLevelChange(int level) {
            mCalledOnLevelChange = true;
            return super.onLevelChange(level);
        }

        public boolean hasCalledDraw() {
            return mCalledDraw;
        }

        public boolean hasCalledGetPadding() {
            return mCalledGetPadding;
        }

        public boolean hasCalledSetVisible() {
            return mCalledSetVisible;
        }

        public boolean hasCalledSetAlpha() {
            return mCalledSetAlpha;
        }

        public boolean hasCalledGetOpacity() {
            return mCalledGetOpacity;
        }

        public boolean hasCalledSetColorFilter() {
            return mCalledSetColorFilter;
        }

        public boolean hasCalledIsStateful() {
            return mCalledIsStateful;
        }

        public boolean hasCalledGetIntrinsicWidth() {
            return mCalledGetIntrinsicWidth;
        }

        public boolean hasCalledGetIntrinsicHeight() {
            return mCalledGetIntrinsicHeight;
        }

        public boolean hasCalledSetState() {
            return mCalledSetState;
        }

        public boolean hasCalledOnLevelChange() {
            return mCalledOnLevelChange;
        }

        public void reset() {
            mCalledDraw = false;
            mCalledGetPadding = false;
            mCalledSetVisible = false;
            mCalledSetAlpha = false;
            mCalledGetOpacity = false;
            mCalledSetColorFilter = false;
            mCalledIsStateful = false;
            mCalledGetIntrinsicWidth = false;
            mCalledGetIntrinsicHeight = false;
            mCalledSetState = false;
            mCalledOnLevelChange = false;
        }
    }

    private static class MockDrawableWrapper extends DrawableWrapper {
        private boolean mCalledOnBoundsChange = false;

        MockDrawableWrapper() {
            super(null);
        }

        public MockDrawableWrapper(Drawable drawable) {
            super(drawable);
        }

        @Override
        protected boolean onStateChange(int[] state) {
            return super.onStateChange(state);
        }

        @Override
        protected boolean onLevelChange(int level) {
            return super.onLevelChange(level);
        }

        @Override
        protected void onBoundsChange(Rect bounds) {
            mCalledOnBoundsChange = true;
            super.onBoundsChange(bounds);
        }

        public boolean hasCalledOnBoundsChange() {
            return mCalledOnBoundsChange;
        }

        public void reset() {
            mCalledOnBoundsChange = false;
        }
    }
}