xref: /packages/apps/Gallery2/tests/src/com/android/gallery3d/common/UtilsTest.java

/*
 * Copyright (C) 2010 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.gallery3d.common;

import android.test.AndroidTestCase;
import android.test.suitebuilder.annotation.SmallTest;
import android.util.Log;

public class UtilsTest extends AndroidTestCase {
    private static final String TAG = "UtilsTest";

    private static final int [] testData = new int [] {
        /* outWidth, outHeight, minSideLength, maxNumOfPixels, sample size */
        1, 1, BitmapUtils.UNCONSTRAINED, BitmapUtils.UNCONSTRAINED, 1,
        1, 1, 1, 1, 1,
        100, 100, 100, 10000, 1,
        100, 100, 100, 2500, 2,
        99, 66, 33, 10000, 2,
        66, 99, 33, 10000, 2,
        99, 66, 34, 10000, 1,
        99, 66, 22, 10000, 4,
        99, 66, 16, 10000, 4,

        10000, 10000, 20000, 1000000, 16,

        100, 100, 100, 10000, 1, // 1
        100, 100, 50, 10000, 2,  // 2
        100, 100, 30, 10000, 4,  // 3->4
        100, 100, 22, 10000, 4,  // 4
        100, 100, 20, 10000, 8,  // 5->8
        100, 100, 11, 10000, 16, // 9->16
        100, 100, 5,  10000, 24, // 20->24
        100, 100, 2,  10000, 56, // 50->56

        100, 100, 100, 10000 - 1, 2,                  // a bit less than 1
        100, 100, 100, 10000 / (2 * 2) - 1, 4,        // a bit less than 2
        100, 100, 100, 10000 / (3 * 3) - 1, 4,        // a bit less than 3
        100, 100, 100, 10000 / (4 * 4) - 1, 8,        // a bit less than 4
        100, 100, 100, 10000 / (8 * 8) - 1, 16,       // a bit less than 8
        100, 100, 100, 10000 / (16 * 16) - 1, 24,     // a bit less than 16
        100, 100, 100, 10000 / (24 * 24) - 1, 32,     // a bit less than 24
        100, 100, 100, 10000 / (32 * 32) - 1, 40,     // a bit less than 32

        640, 480, 480, BitmapUtils.UNCONSTRAINED, 1,  // 1
        640, 480, 240, BitmapUtils.UNCONSTRAINED, 2,  // 2
        640, 480, 160, BitmapUtils.UNCONSTRAINED, 4,  // 3->4
        640, 480, 120, BitmapUtils.UNCONSTRAINED, 4,  // 4
        640, 480, 96, BitmapUtils.UNCONSTRAINED,  8,  // 5->8
        640, 480, 80, BitmapUtils.UNCONSTRAINED,  8,  // 6->8
        640, 480, 60, BitmapUtils.UNCONSTRAINED,  8,  // 8
        640, 480, 48, BitmapUtils.UNCONSTRAINED, 16,  // 10->16
        640, 480, 40, BitmapUtils.UNCONSTRAINED, 16,  // 12->16
        640, 480, 30, BitmapUtils.UNCONSTRAINED, 16,  // 16
        640, 480, 24, BitmapUtils.UNCONSTRAINED, 24,  // 20->24
        640, 480, 20, BitmapUtils.UNCONSTRAINED, 24,  // 24
        640, 480, 16, BitmapUtils.UNCONSTRAINED, 32,  // 30->32
        640, 480, 12, BitmapUtils.UNCONSTRAINED, 40,  // 40
        640, 480, 10, BitmapUtils.UNCONSTRAINED, 48,  // 48
        640, 480, 8, BitmapUtils.UNCONSTRAINED,  64,  // 60->64
        640, 480, 6, BitmapUtils.UNCONSTRAINED,  80,  // 80
        640, 480, 4, BitmapUtils.UNCONSTRAINED, 120,  // 120
        640, 480, 3, BitmapUtils.UNCONSTRAINED, 160,  // 160
        640, 480, 2, BitmapUtils.UNCONSTRAINED, 240,  // 240
        640, 480, 1, BitmapUtils.UNCONSTRAINED, 480,  // 480

        640, 480, BitmapUtils.UNCONSTRAINED, BitmapUtils.UNCONSTRAINED, 1,
        640, 480, BitmapUtils.UNCONSTRAINED, 640 * 480, 1,                  // 1
        640, 480, BitmapUtils.UNCONSTRAINED, 640 * 480 - 1, 2,              // a bit less than 1
        640, 480, BitmapUtils.UNCONSTRAINED, 640 * 480 / 4, 2,              // 2
        640, 480, BitmapUtils.UNCONSTRAINED, 640 * 480 / 4 - 1, 4,          // a bit less than 2
        640, 480, BitmapUtils.UNCONSTRAINED, 640 * 480 / 9, 4,              // 3
        640, 480, BitmapUtils.UNCONSTRAINED, 640 * 480 / 9 - 1, 4,          // a bit less than 3
        640, 480, BitmapUtils.UNCONSTRAINED, 640 * 480 / 16, 4,             // 4
        640, 480, BitmapUtils.UNCONSTRAINED, 640 * 480 / 16 - 1, 8,         // a bit less than 4
        640, 480, BitmapUtils.UNCONSTRAINED, 640 * 480 / 64, 8,             // 8
        640, 480, BitmapUtils.UNCONSTRAINED, 640 * 480 / 64 - 1, 16,        // a bit less than 8
        640, 480, BitmapUtils.UNCONSTRAINED, 640 * 480 / 256, 16,           // 16
        640, 480, BitmapUtils.UNCONSTRAINED, 640 * 480 / 256 - 1, 24,       // a bit less than 16
        640, 480, BitmapUtils.UNCONSTRAINED, 640 * 480 / (24 * 24) - 1, 32, // a bit less than 24
    };

    @SmallTest
    public void testComputeSampleSize() {

        for (int i = 0; i < testData.length; i += 5) {
            int w = testData[i];
            int h = testData[i + 1];
            int minSide = testData[i + 2];
            int maxPixels = testData[i + 3];
            int sampleSize = testData[i + 4];
            int result = BitmapUtils.computeSampleSize(w, h, minSide, maxPixels);
            if (result != sampleSize) {
                Log.v(TAG, w + "x" + h + ", minSide = " + minSide + ", maxPixels = "
                        + maxPixels + ", sampleSize = " + sampleSize + ", result = "
                        + result);
            }
            assertTrue(sampleSize == result);
        }
    }

    public void testAssert() {
        // This should not throw an exception.
        Utils.assertTrue(true);

        // This should throw an exception.
        try {
            Utils.assertTrue(false);
            fail();
        } catch (AssertionError ex) {
            // expected.
        }
    }

    public void testCheckNotNull() {
        // These should not throw an expection.
        Utils.checkNotNull(new Object());
        Utils.checkNotNull(0);
        Utils.checkNotNull("");

        // This should throw an expection.
        try {
            Utils.checkNotNull(null);
            fail();
        } catch (NullPointerException ex) {
            // expected.
        }
    }

    public void testEquals() {
        Object a = new Object();
        Object b = new Object();

        assertTrue(Utils.equals(null, null));
        assertTrue(Utils.equals(a, a));
        assertFalse(Utils.equals(null, a));
        assertFalse(Utils.equals(a, null));
        assertFalse(Utils.equals(a, b));
    }

    public void testNextPowerOf2() {
        int[] q = new int[] {1, 2, 3, 4, 5, 6, 10, 65535, (1 << 30) - 1, (1 << 30)};
        int[] a = new int[] {1, 2, 4, 4, 8, 8, 16, 65536, (1 << 30)    , (1 << 30)};

        for (int i = 0; i < q.length; i++) {
            assertEquals(a[i], Utils.nextPowerOf2(q[i]));
        }

        int[] e = new int[] {0, -1, -2, -4, -65536, (1 << 30) + 1, Integer.MAX_VALUE};

        for (int v : e) {
            try {
                Utils.nextPowerOf2(v);
                fail();
            } catch (IllegalArgumentException ex) {
                // expected.
            }
        }
    }

    public void testClamp() {
        assertEquals(1000, Utils.clamp(300, 1000, 2000));
        assertEquals(1300, Utils.clamp(1300, 1000, 2000));
        assertEquals(2000, Utils.clamp(2300, 1000, 2000));

        assertEquals(0.125f, Utils.clamp(0.1f, 0.125f, 0.5f));
        assertEquals(0.25f, Utils.clamp(0.25f, 0.125f, 0.5f));
        assertEquals(0.5f, Utils.clamp(0.9f, 0.125f, 0.5f));
    }

    public void testIsOpaque() {
        assertTrue(Utils.isOpaque(0xFF000000));
        assertTrue(Utils.isOpaque(0xFFFFFFFF));
        assertTrue(Utils.isOpaque(0xFF123456));

        assertFalse(Utils.isOpaque(0xFEFFFFFF));
        assertFalse(Utils.isOpaque(0x8FFFFFFF));
        assertFalse(Utils.isOpaque(0x00FF0000));
        assertFalse(Utils.isOpaque(0x5500FF00));
        assertFalse(Utils.isOpaque(0xAA0000FF));
    }

    public static void assertFloatEq(float expected, float actual) {
        if (Math.abs(actual - expected) > 1e-6) {
            Log.v(TAG, "expected: " + expected + ", actual: " + actual);
            fail();
        }
    }
}