Home | History | Annotate | Download | only in cts
      1 /*
      2  * Copyright (C) 2011 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 
     17 package android.renderscript.cts;
     18 
     19 import android.renderscript.Element;
     20 import android.renderscript.Type;
     21 
     22 public class TypeTest extends RSBaseCompute {
     23 
     24     void testBuilderSizes(Type.Builder b, int min, int max) {
     25         for (int x = min; x < max; x ++) {
     26             for (int y = min; y < max; y ++) {
     27                 b.setX(x).setY(y);
     28                 b.create();
     29             }
     30         }
     31     }
     32 
     33     void testTypeBuilderHelper(Element e) {
     34         Type.Builder b = new Type.Builder(mRS, e);
     35         for (int mips = 0; mips <= 1; mips ++) {
     36             boolean useMips = (mips == 1);
     37 
     38             for (int faces = 0; faces <= 1; faces++) {
     39                 boolean useFaces = (faces == 1);
     40 
     41                 b.setMipmaps(useMips);
     42                 b.setFaces(useFaces);
     43                 testBuilderSizes(b, 1, 8);
     44             }
     45         }
     46     }
     47 
     48     public void testTypeBuilder() {
     49         testTypeBuilderHelper(Element.A_8(mRS));
     50         testTypeBuilderHelper(Element.RGB_565(mRS));
     51         testTypeBuilderHelper(Element.RGB_888(mRS));
     52         testTypeBuilderHelper(Element.RGBA_8888(mRS));
     53         testTypeBuilderHelper(Element.F32(mRS));
     54         testTypeBuilderHelper(Element.F32_2(mRS));
     55         testTypeBuilderHelper(Element.F32_3(mRS));
     56         testTypeBuilderHelper(Element.F32_4(mRS));
     57         testTypeBuilderHelper(Element.BOOLEAN(mRS));
     58         testTypeBuilderHelper(Element.F64(mRS));
     59         testTypeBuilderHelper(Element.I8(mRS));
     60         testTypeBuilderHelper(Element.I16(mRS));
     61         testTypeBuilderHelper(Element.I32(mRS));
     62         testTypeBuilderHelper(Element.I64(mRS));
     63         testTypeBuilderHelper(Element.U8(mRS));
     64         testTypeBuilderHelper(Element.U8_4(mRS));
     65         testTypeBuilderHelper(Element.U16(mRS));
     66         testTypeBuilderHelper(Element.U32(mRS));
     67         testTypeBuilderHelper(Element.U64(mRS));
     68         testTypeBuilderHelper(Element.MATRIX_2X2(mRS));
     69         testTypeBuilderHelper(Element.MATRIX_3X3(mRS));
     70         testTypeBuilderHelper(Element.MATRIX_4X4(mRS));
     71         testTypeBuilderHelper(Element.MESH(mRS));
     72         testTypeBuilderHelper(Element.PROGRAM_FRAGMENT(mRS));
     73         testTypeBuilderHelper(Element.PROGRAM_RASTER(mRS));
     74         testTypeBuilderHelper(Element.PROGRAM_STORE(mRS));
     75         testTypeBuilderHelper(Element.PROGRAM_VERTEX(mRS));
     76         testTypeBuilderHelper(Element.ALLOCATION(mRS));
     77         testTypeBuilderHelper(Element.SAMPLER(mRS));
     78         testTypeBuilderHelper(Element.SCRIPT(mRS));
     79         testTypeBuilderHelper(Element.TYPE(mRS));
     80 
     81         // Add some complex and struct types to test here
     82     }
     83 
     84     public void testGetCount() {
     85         Type.Builder b = new Type.Builder(mRS, Element.F32(mRS));
     86         for (int faces = 0; faces <= 1; faces++) {
     87             boolean useFaces = faces == 1;
     88             int faceMultiplier = useFaces ? 6 : 1;
     89             for (int x = 1; x < 8; x ++) {
     90                 for (int y = 1; y < 8; y ++) {
     91                     b.setFaces(useFaces);
     92                     b.setX(x).setY(y);
     93                     Type t = b.create();
     94                     assertTrue(t.getCount() == x * y * faceMultiplier);
     95                 }
     96             }
     97         }
     98 
     99         // Test mipmaps
    100         b.setFaces(false);
    101         b.setMipmaps(true);
    102         Type t = b.setX(8).setY(1).create();
    103         int expectedCount = 8 + 4 + 2 + 1;
    104         assertTrue(t.getCount() == expectedCount);
    105 
    106         t = b.setX(8).setY(8).create();
    107         expectedCount = 8*8 + 4*4 + 2*2 + 1;
    108         assertTrue(t.getCount() == expectedCount);
    109 
    110         t = b.setX(8).setY(4).create();
    111         expectedCount = 8*4 + 4*2 + 2*1 + 1;
    112         assertTrue(t.getCount() == expectedCount);
    113 
    114         t = b.setX(4).setY(8).create();
    115         assertTrue(t.getCount() == expectedCount);
    116 
    117         t = b.setX(7).setY(1).create();
    118         expectedCount = 7 + 3 + 1;
    119         assertTrue(t.getCount() == expectedCount);
    120 
    121         t = b.setX(7).setY(3).create();
    122         expectedCount = 7*3 + 3*1 + 1;
    123         assertTrue(t.getCount() == expectedCount);
    124     }
    125 
    126     public void testGetElement() {
    127         Type.Builder b = new Type.Builder(mRS, Element.F32(mRS));
    128         b.setX(1);
    129         assertTrue(b.create().getElement() == Element.F32(mRS));
    130     }
    131 
    132     public void testGetX() {
    133         Type.Builder b = new Type.Builder(mRS, Element.F32(mRS));
    134         b.setX(3);
    135         assertTrue(b.create().getX() == 3);
    136     }
    137 
    138     public void testGetY() {
    139         Type.Builder b = new Type.Builder(mRS, Element.F32(mRS));
    140         b.setX(3).setY(4);
    141         Type t = b.create();
    142         assertTrue(t.getX() == 3);
    143         assertTrue(t.getY() == 4);
    144     }
    145 
    146     public void testGetZ() {
    147         Type.Builder b = new Type.Builder(mRS, Element.F32(mRS));
    148         b.setX(3).setY(4);
    149         assertTrue(b.create().getZ() == 0);
    150     }
    151 
    152     public void testHasFaces() {
    153         Type.Builder b = new Type.Builder(mRS, Element.F32(mRS));
    154         b.setX(4).setY(4).setFaces(true);
    155         assertTrue(b.create().hasFaces());
    156         b.setFaces(false);
    157         assertFalse(b.create().hasFaces());
    158     }
    159 
    160     public void testGetMipmaps() {
    161         Type.Builder b = new Type.Builder(mRS, Element.F32(mRS));
    162         b.setX(4).setY(4).setMipmaps(true);
    163         assertTrue(b.create().hasMipmaps());
    164         b.setMipmaps(false);
    165         assertFalse(b.create().hasMipmaps());
    166     }
    167 
    168     public void testTypeCubemapFace() {
    169         assertEquals(Type.CubemapFace.NEGATIVE_X, Type.CubemapFace.valueOf("NEGATIVE_X"));
    170         assertEquals(Type.CubemapFace.NEGATIVE_Y, Type.CubemapFace.valueOf("NEGATIVE_Y"));
    171         assertEquals(Type.CubemapFace.NEGATIVE_Z, Type.CubemapFace.valueOf("NEGATIVE_Z"));
    172         assertEquals(Type.CubemapFace.POSITIVE_X, Type.CubemapFace.valueOf("POSITIVE_X"));
    173         assertEquals(Type.CubemapFace.POSITIVE_Y, Type.CubemapFace.valueOf("POSITIVE_Y"));
    174         assertEquals(Type.CubemapFace.POSITIVE_Z, Type.CubemapFace.valueOf("POSITIVE_Z"));
    175         // Legacy typo enums
    176         assertEquals(Type.CubemapFace.POSITVE_X, Type.CubemapFace.valueOf("POSITVE_X"));
    177         assertEquals(Type.CubemapFace.POSITVE_Y, Type.CubemapFace.valueOf("POSITVE_Y"));
    178         assertEquals(Type.CubemapFace.POSITVE_Z, Type.CubemapFace.valueOf("POSITVE_Z"));
    179         // Make sure no new enums are added
    180         assertEquals(9, Type.CubemapFace.values().length);
    181     }
    182 
    183     public void testEquals() {
    184         Type.Builder b1 = new Type.Builder(mRS, Element.F32(mRS));
    185         Type t1 = b1.setX(5).setY(5).create();
    186 
    187         Type.Builder b2 = new Type.Builder(mRS, Element.F32(mRS));
    188         Type t2 = b2.setX(5).setY(5).create();
    189 
    190         assertTrue(t1.equals(t2));
    191         assertTrue(t2.equals(t1));
    192         assertTrue(t1.hashCode() == t2.hashCode());
    193 
    194         t2 = b2.setX(4).create();
    195         assertFalse(t1.equals(t2));
    196         assertFalse(t2.equals(t1));
    197     }
    198 }
    199 
    200 
    201