/*
 * Copyright (C) 2011-2012 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.renderscript.cts;

import android.renderscript.Element;
import android.renderscript.Element.DataType;
import android.renderscript.Element.DataKind;
import android.renderscript.RSIllegalArgumentException;

public class ElementTest extends RSBaseCompute {

    public void testCreatePixel() {
        assertTrue(Element.createPixel(mRS,
                                       DataType.UNSIGNED_8,
                                       DataKind.PIXEL_A) != null);
        assertTrue(Element.createPixel(mRS,
                                       DataType.UNSIGNED_5_6_5,
                                       DataKind.PIXEL_RGB) != null);
        assertTrue(Element.createPixel(mRS,
                                       DataType.UNSIGNED_8,
                                       DataKind.PIXEL_RGB) != null);
        assertTrue(Element.createPixel(mRS,
                                       DataType.UNSIGNED_5_5_5_1,
                                       DataKind.PIXEL_RGBA) != null);
        assertTrue(Element.createPixel(mRS,
                                       DataType.UNSIGNED_4_4_4_4,
                                       DataKind.PIXEL_RGBA) != null);
        assertTrue(Element.createPixel(mRS,
                                       DataType.UNSIGNED_8,
                                       DataKind.PIXEL_RGBA) != null);
    }

    public void testCreateVector() {

        Element e = null;
        for (int len = 2; len <= 4; len ++) {
            assertTrue(Element.createVector(mRS, DataType.FLOAT_32, len) != null);
            assertTrue(Element.createVector(mRS, DataType.FLOAT_64, len) != null);
            assertTrue(Element.createVector(mRS, DataType.SIGNED_8, len) != null);
            assertTrue(Element.createVector(mRS, DataType.SIGNED_16, len) != null);
            assertTrue(Element.createVector(mRS, DataType.SIGNED_32, len) != null);
            assertTrue(Element.createVector(mRS, DataType.SIGNED_64, len) != null);
            assertTrue(Element.createVector(mRS, DataType.UNSIGNED_8, len) != null);
            assertTrue(Element.createVector(mRS, DataType.UNSIGNED_16, len) != null);
            assertTrue(Element.createVector(mRS, DataType.UNSIGNED_32, len) != null);
            assertTrue(Element.createVector(mRS, DataType.UNSIGNED_64, len) != null);
        }
    }

    public void testPrebuiltElements() {
        assertTrue(Element.A_8(mRS) != null);
        assertTrue(Element.RGBA_4444(mRS) != null);
        assertTrue(Element.RGBA_5551(mRS) != null);
        assertTrue(Element.RGB_565(mRS) != null);
        assertTrue(Element.RGB_888(mRS) != null);
        assertTrue(Element.RGBA_8888(mRS) != null);
        assertTrue(Element.F32(mRS) != null);
        assertTrue(Element.F32_2(mRS) != null);
        assertTrue(Element.F32_3(mRS) != null);
        assertTrue(Element.F32_4(mRS) != null);
        assertTrue(Element.F64(mRS) != null);
        assertTrue(Element.F64_2(mRS) != null);
        assertTrue(Element.F64_3(mRS) != null);
        assertTrue(Element.F64_4(mRS) != null);
        assertTrue(Element.I8(mRS) != null);
        assertTrue(Element.I8_2(mRS) != null);
        assertTrue(Element.I8_3(mRS) != null);
        assertTrue(Element.I8_4(mRS) != null);
        assertTrue(Element.I16(mRS) != null);
        assertTrue(Element.I16_2(mRS) != null);
        assertTrue(Element.I16_3(mRS) != null);
        assertTrue(Element.I16_4(mRS) != null);
        assertTrue(Element.I32(mRS) != null);
        assertTrue(Element.I32_2(mRS) != null);
        assertTrue(Element.I32_3(mRS) != null);
        assertTrue(Element.I32_4(mRS) != null);
        assertTrue(Element.I64(mRS) != null);
        assertTrue(Element.I64_2(mRS) != null);
        assertTrue(Element.I64_3(mRS) != null);
        assertTrue(Element.I64_4(mRS) != null);
        assertTrue(Element.U8(mRS) != null);
        assertTrue(Element.U8_2(mRS) != null);
        assertTrue(Element.U8_3(mRS) != null);
        assertTrue(Element.U8_4(mRS) != null);
        assertTrue(Element.U16(mRS) != null);
        assertTrue(Element.U16_2(mRS) != null);
        assertTrue(Element.U16_3(mRS) != null);
        assertTrue(Element.U16_4(mRS) != null);
        assertTrue(Element.U32(mRS) != null);
        assertTrue(Element.U32_2(mRS) != null);
        assertTrue(Element.U32_3(mRS) != null);
        assertTrue(Element.U32_4(mRS) != null);
        assertTrue(Element.U64(mRS) != null);
        assertTrue(Element.U64_2(mRS) != null);
        assertTrue(Element.U64_3(mRS) != null);
        assertTrue(Element.U64_4(mRS) != null);
        assertTrue(Element.MATRIX_2X2(mRS) != null);
        assertTrue(Element.MATRIX_3X3(mRS) != null);
        assertTrue(Element.MATRIX_4X4(mRS) != null);
        assertTrue(Element.MATRIX4X4(mRS) != null);
        assertTrue(Element.MESH(mRS) != null);
        assertTrue(Element.PROGRAM_FRAGMENT(mRS) != null);
        assertTrue(Element.PROGRAM_RASTER(mRS) != null);
        assertTrue(Element.PROGRAM_STORE(mRS) != null);
        assertTrue(Element.PROGRAM_VERTEX(mRS) != null);
        assertTrue(Element.ALLOCATION(mRS) != null);
        assertTrue(Element.SAMPLER(mRS) != null);
        assertTrue(Element.SCRIPT(mRS) != null);
        assertTrue(Element.TYPE(mRS) != null);
        assertTrue(Element.BOOLEAN(mRS) != null);
        assertTrue(Element.ELEMENT(mRS) != null);
    }

    public void testEquals() {
        assertTrue(Element.A_8(mRS).equals(Element.A_8(mRS)));
        assertFalse(Element.A_8(mRS).equals(Element.U8(mRS)));

        // Compatible elements
        assertTrue(Element.A_8(mRS).isCompatible(Element.U8(mRS)));
        assertTrue(Element.U8(mRS).isCompatible(Element.A_8(mRS)));

        // Verify equivalence of user-built Elements
        Element.Builder eb1 = new Element.Builder(mRS);
        eb1.add(Element.I8(mRS), "Test");
        Element e1 = eb1.add(Element.U8(mRS), "UTest").create();

        assertTrue(e1.equals(e1));

        Element.Builder eb2 = new Element.Builder(mRS);
        eb2.add(Element.I8(mRS), "Test");
        Element e2 = eb2.add(Element.U8(mRS), "UTest").create();

        assertTrue(e1.equals(e2));
        assertTrue(e2.equals(e1));
        assertTrue(e1.hashCode() == e2.hashCode());
        assertTrue(e1.isCompatible(e2));
        assertTrue(e2.isCompatible(e1));

        // Check name differences
        Element.Builder eb3 = new Element.Builder(mRS);
        eb3.add(Element.I8(mRS), "Test");
        Element e3 = eb3.add(Element.U8(mRS), "NotUTest").create();

        assertFalse(e1.equals(e3));
        assertFalse(e3.equals(e1));
        assertFalse(e1.isCompatible(e3));
        assertFalse(e3.isCompatible(e1));

        eb1.add(Element.I8(mRS), "Another");
        assertFalse(e1.equals(eb1.create()));
        assertFalse(eb1.create().equals(e1));

        // Compatible sub-elements but neither equal nor compatible
        Element.Builder eb4 = new Element.Builder(mRS);
        eb4.add(Element.I8(mRS), "Test");
        Element e4 = eb4.add(Element.A_8(mRS), "UTest").create();

        assertFalse(e1.equals(e4));
        assertFalse(e4.equals(e1));
        assertFalse(e1.isCompatible(e4));
        assertFalse(e4.isCompatible(e1));

        // Check identity from same builder
        assertTrue(eb1.create().isCompatible(eb1.create()));
    }

    public void testIsCompatible() {
        Element[] ALLOCATION = { Element.ALLOCATION(mRS) };
        // A_8 is in U8
        Element[] BOOLEAN = { Element.BOOLEAN(mRS) };
        Element[] ELEMENT = { Element.ELEMENT(mRS) };
        Element[] F32 = { Element.F32(mRS) };
        Element[] F32_2 = { Element.F32_2(mRS),
            Element.createVector(mRS, Element.DataType.FLOAT_32, 2) };
        Element[] F32_3 = { Element.F32_3(mRS),
            Element.createVector(mRS, Element.DataType.FLOAT_32, 3) };
        Element[] F32_4 = { Element.F32_4(mRS),
            Element.createVector(mRS, Element.DataType.FLOAT_32, 4) };
        Element[] F64 = { Element.F64(mRS) };
        Element[] I16 = { Element.I16(mRS) };
        Element[] I32 = { Element.I32(mRS) };
        Element[] I64 = { Element.I64(mRS) };
        Element[] I8 = { Element.I8(mRS) };
        // MATRIX4X4 is in MATRIX_4X4
        Element[] MATRIX_2X2 = { Element.MATRIX_2X2(mRS) };
        Element[] MATRIX_3X3 = { Element.MATRIX_3X3(mRS) };
        Element[] MATRIX_4X4 = { Element.MATRIX4X4(mRS),
                                 Element.MATRIX_4X4(mRS) };
        Element[] MESH = { Element.MESH(mRS) };
        Element[] PROGRAM_FRAGMENT = { Element.PROGRAM_FRAGMENT(mRS) };
        Element[] PROGRAM_RASTER = { Element.PROGRAM_RASTER(mRS) };
        Element[] PROGRAM_STORE = { Element.PROGRAM_STORE(mRS) };
        Element[] PROGRAM_VERTEX = { Element.PROGRAM_VERTEX(mRS) };
        Element[] RGBA_4444 = { Element.RGBA_4444(mRS),
            Element.createPixel(mRS, Element.DataType.UNSIGNED_4_4_4_4,
                                Element.DataKind.PIXEL_RGBA) };
        Element[] RGBA_5551 = { Element.RGBA_5551(mRS),
            Element.createPixel(mRS, Element.DataType.UNSIGNED_5_5_5_1,
                                Element.DataKind.PIXEL_RGBA) };
        // RGBA_8888 is in U8_4
        Element[] RGB_565 = { Element.RGB_565(mRS),
            Element.createPixel(mRS, Element.DataType.UNSIGNED_5_6_5,
                                Element.DataKind.PIXEL_RGB) };
        // RGB_888 is in U8_3
        Element[] SAMPLER = { Element.SAMPLER(mRS) };
        Element[] SCRIPT = { Element.SCRIPT(mRS) };
        Element[] TYPE = { Element.TYPE(mRS) };
        Element[] U16 = { Element.U16(mRS) };
        Element[] U32 = { Element.U32(mRS) };
        Element[] U64 = { Element.U64(mRS) };
        Element[] U8 = { Element.A_8(mRS),
                         Element.U8(mRS),
            Element.createPixel(mRS, Element.DataType.UNSIGNED_8,
                                Element.DataKind.PIXEL_A) };
        Element[] U8_3 = { Element.RGB_888(mRS),
            Element.createVector(mRS, Element.DataType.UNSIGNED_8, 3),
            Element.createPixel(mRS, Element.DataType.UNSIGNED_8,
                                Element.DataKind.PIXEL_RGB) };
        Element[] U8_4 = { Element.U8_4(mRS),
                           Element.RGBA_8888(mRS),
            Element.createVector(mRS, Element.DataType.UNSIGNED_8, 4),
            Element.createPixel(mRS, Element.DataType.UNSIGNED_8,
                                Element.DataKind.PIXEL_RGBA) };

        Element[][] ElementArrs = { ALLOCATION, BOOLEAN, ELEMENT, F32, F32_2,
                                    F32_3, F32_4, F64, I16, I32, I64, I8,
                                    MATRIX_2X2, MATRIX_3X3, MATRIX_4X4, MESH,
                                    PROGRAM_FRAGMENT, PROGRAM_RASTER,
                                    PROGRAM_STORE, PROGRAM_VERTEX, RGBA_4444,
                                    RGBA_5551, RGB_565, SAMPLER, SCRIPT, TYPE,
                                    U16, U32, U64, U8, U8_3, U8_4 };

        int ElementArrsLen = ElementArrs.length;
        for (int i = 0; i < ElementArrsLen; i++) {
            for (int j = 0; j < ElementArrsLen; j++) {
                for (Element el : ElementArrs[i]) {
                    for (Element er : ElementArrs[j]) {
                        if (i == j) {
                            // Elements within a group are compatible
                            assertTrue(el.isCompatible(er));
                        } else {
                            // Elements from different groups are incompatible
                            assertFalse(el.isCompatible(er));
                        }
                    }
                }
            }
        }
    }

    public void testElementBuilder() {
        for (int arraySize = 1; arraySize <= 3; arraySize++) {
            // Now test array size
            Element.Builder eb = new Element.Builder(mRS);
            eb.add(Element.A_8(mRS), "A_8", arraySize);
            eb.add(Element.RGBA_4444(mRS), "RGBA_4444", arraySize);
            eb.add(Element.RGBA_5551(mRS), "RGBA_5551", arraySize);
            eb.add(Element.RGB_565(mRS), "RGB_565", arraySize);
            eb.add(Element.RGB_888(mRS), "RGB_888", arraySize);
            eb.add(Element.RGBA_8888(mRS), "RGBA_8888", arraySize);
            eb.add(Element.F32(mRS), "F32", arraySize);
            eb.add(Element.F32_2(mRS), "F32_2", arraySize);
            eb.add(Element.F32_3(mRS), "F32_3", arraySize);
            eb.add(Element.F32_4(mRS), "F32_4", arraySize);
            eb.add(Element.F64(mRS), "F64", arraySize);
            eb.add(Element.F64_2(mRS), "F64_2", arraySize);
            eb.add(Element.F64_3(mRS), "F64_3", arraySize);
            eb.add(Element.F64_4(mRS), "F64_4", arraySize);
            eb.add(Element.I8(mRS), "I8", arraySize);
            eb.add(Element.I8_2(mRS), "I8_2", arraySize);
            eb.add(Element.I8_3(mRS), "I8_3", arraySize);
            eb.add(Element.I8_4(mRS), "I8_4", arraySize);
            eb.add(Element.I16(mRS), "I16", arraySize);
            eb.add(Element.I16_2(mRS), "I16_2", arraySize);
            eb.add(Element.I16_3(mRS), "I16_3", arraySize);
            eb.add(Element.I16_4(mRS), "I16_4", arraySize);
            eb.add(Element.I32(mRS), "I32", arraySize);
            eb.add(Element.I32_2(mRS), "I32_2", arraySize);
            eb.add(Element.I32_3(mRS), "I32_3", arraySize);
            eb.add(Element.I32_4(mRS), "I32_4", arraySize);
            eb.add(Element.I64(mRS), "I64", arraySize);
            eb.add(Element.I64_2(mRS), "I64_2", arraySize);
            eb.add(Element.I64_3(mRS), "I64_3", arraySize);
            eb.add(Element.I64_4(mRS), "I64_4", arraySize);
            eb.add(Element.U8(mRS), "U8", arraySize);
            eb.add(Element.U8_2(mRS), "U8_2", arraySize);
            eb.add(Element.U8_3(mRS), "U8_3", arraySize);
            eb.add(Element.U8_4(mRS), "U8_4", arraySize);
            eb.add(Element.U16(mRS), "U16", arraySize);
            eb.add(Element.U16_2(mRS), "U16_2", arraySize);
            eb.add(Element.U16_3(mRS), "U16_3", arraySize);
            eb.add(Element.U16_4(mRS), "U16_4", arraySize);
            eb.add(Element.U32(mRS), "U32", arraySize);
            eb.add(Element.U32_2(mRS), "U32_2", arraySize);
            eb.add(Element.U32_3(mRS), "U32_3", arraySize);
            eb.add(Element.U32_4(mRS), "U32_4", arraySize);
            eb.add(Element.U64(mRS), "U64", arraySize);
            eb.add(Element.U64_2(mRS), "U64_2", arraySize);
            eb.add(Element.U64_3(mRS), "U64_3", arraySize);
            eb.add(Element.U64_4(mRS), "U64_4", arraySize);
            eb.add(Element.MATRIX_2X2(mRS), "MATRIX_2X2", arraySize);
            eb.add(Element.MATRIX_3X3(mRS), "MATRIX_3X3", arraySize);
            eb.add(Element.MATRIX_4X4(mRS), "MATRIX_4X4", arraySize);
            eb.add(Element.MATRIX4X4(mRS), "MATRIX4X4", arraySize);
            eb.add(Element.MESH(mRS), "MESH", arraySize);
            eb.add(Element.PROGRAM_FRAGMENT(mRS), "PROGRAM_FRAGMENT", arraySize);
            eb.add(Element.PROGRAM_RASTER(mRS), "PROGRAM_RASTER", arraySize);
            eb.add(Element.PROGRAM_STORE(mRS), "PROGRAM_STORE", arraySize);
            eb.add(Element.PROGRAM_VERTEX(mRS), "PROGRAM_VERTEX", arraySize);
            eb.add(Element.ALLOCATION(mRS), "ALLOCATION", arraySize);
            eb.add(Element.SAMPLER(mRS), "SAMPLER", arraySize);
            eb.add(Element.SCRIPT(mRS), "SCRIPT", arraySize);
            eb.add(Element.TYPE(mRS), "TYPE", arraySize);
            eb.add(Element.BOOLEAN(mRS), "BOOLEAN", arraySize);
            eb.add(Element.ELEMENT(mRS), "ELEMENT", arraySize);
            assertTrue(eb.create() != null);
        }
    }

    public void testIsComplex() {
        assertFalse(Element.A_8(mRS).isComplex());
        assertFalse(Element.RGBA_4444(mRS).isComplex());
        assertFalse(Element.RGBA_5551(mRS).isComplex());
        assertFalse(Element.RGB_565(mRS).isComplex());
        assertFalse(Element.RGB_888(mRS).isComplex());
        assertFalse(Element.RGBA_8888(mRS).isComplex());
        assertFalse(Element.F32(mRS).isComplex());
        assertFalse(Element.F32_2(mRS).isComplex());
        assertFalse(Element.F32_3(mRS).isComplex());
        assertFalse(Element.F32_4(mRS).isComplex());
        assertFalse(Element.F64(mRS).isComplex());
        assertFalse(Element.F64_2(mRS).isComplex());
        assertFalse(Element.F64_3(mRS).isComplex());
        assertFalse(Element.F64_4(mRS).isComplex());
        assertFalse(Element.I8(mRS).isComplex());
        assertFalse(Element.I8_2(mRS).isComplex());
        assertFalse(Element.I8_3(mRS).isComplex());
        assertFalse(Element.I8_4(mRS).isComplex());
        assertFalse(Element.I16(mRS).isComplex());
        assertFalse(Element.I16_2(mRS).isComplex());
        assertFalse(Element.I16_3(mRS).isComplex());
        assertFalse(Element.I16_4(mRS).isComplex());
        assertFalse(Element.I32(mRS).isComplex());
        assertFalse(Element.I32_2(mRS).isComplex());
        assertFalse(Element.I32_3(mRS).isComplex());
        assertFalse(Element.I32_4(mRS).isComplex());
        assertFalse(Element.I64(mRS).isComplex());
        assertFalse(Element.I64_2(mRS).isComplex());
        assertFalse(Element.I64_3(mRS).isComplex());
        assertFalse(Element.I64_4(mRS).isComplex());
        assertFalse(Element.U8(mRS).isComplex());
        assertFalse(Element.U8_2(mRS).isComplex());
        assertFalse(Element.U8_3(mRS).isComplex());
        assertFalse(Element.U8_4(mRS).isComplex());
        assertFalse(Element.U16(mRS).isComplex());
        assertFalse(Element.U16_2(mRS).isComplex());
        assertFalse(Element.U16_3(mRS).isComplex());
        assertFalse(Element.U16_4(mRS).isComplex());
        assertFalse(Element.U32(mRS).isComplex());
        assertFalse(Element.U32_2(mRS).isComplex());
        assertFalse(Element.U32_3(mRS).isComplex());
        assertFalse(Element.U32_4(mRS).isComplex());
        assertFalse(Element.U64(mRS).isComplex());
        assertFalse(Element.U64_2(mRS).isComplex());
        assertFalse(Element.U64_3(mRS).isComplex());
        assertFalse(Element.U64_4(mRS).isComplex());
        assertFalse(Element.MATRIX_2X2(mRS).isComplex());
        assertFalse(Element.MATRIX_3X3(mRS).isComplex());
        assertFalse(Element.MATRIX_4X4(mRS).isComplex());
        assertFalse(Element.MATRIX4X4(mRS).isComplex());
        assertFalse(Element.MESH(mRS).isComplex());
        assertFalse(Element.PROGRAM_FRAGMENT(mRS).isComplex());
        assertFalse(Element.PROGRAM_RASTER(mRS).isComplex());
        assertFalse(Element.PROGRAM_STORE(mRS).isComplex());
        assertFalse(Element.PROGRAM_VERTEX(mRS).isComplex());
        assertFalse(Element.ALLOCATION(mRS).isComplex());
        assertFalse(Element.SAMPLER(mRS).isComplex());
        assertFalse(Element.SCRIPT(mRS).isComplex());
        assertFalse(Element.TYPE(mRS).isComplex());
        assertFalse(Element.BOOLEAN(mRS).isComplex());
        assertFalse(Element.ELEMENT(mRS).isComplex());

        Element.Builder eb = new Element.Builder(mRS);
        eb.add(Element.F32(mRS), "FLOAT");
        eb.add(Element.SAMPLER(mRS), "SAMPLER");
        Element e1 = eb.create();
        assertFalse(e1.isComplex());

        eb = new Element.Builder(mRS);
        eb.add(Element.A_8(mRS), "A_8");
        eb.add(Element.RGBA_4444(mRS), "RGBA_4444");
        Element e2 = eb.create();
        assertFalse(e2.isComplex());

        eb = new Element.Builder(mRS);
        eb.add(e1, "e1");
        eb.add(e2, "e2");
        assertTrue(eb.create().isComplex());
    }

    public void testDataType() {
        // Uncomment when NONE is no longer hidden.
        //assertEquals(DataType.NONE, DataType.valueOf("NONE"));

        assertEquals(DataType.FLOAT_32, DataType.valueOf("FLOAT_32"));
        assertEquals(DataType.FLOAT_64, DataType.valueOf("FLOAT_64"));
        assertEquals(DataType.SIGNED_8, DataType.valueOf("SIGNED_8"));
        assertEquals(DataType.SIGNED_16, DataType.valueOf("SIGNED_16"));
        assertEquals(DataType.SIGNED_32, DataType.valueOf("SIGNED_32"));
        assertEquals(DataType.SIGNED_64, DataType.valueOf("SIGNED_64"));
        assertEquals(DataType.UNSIGNED_8, DataType.valueOf("UNSIGNED_8"));
        assertEquals(DataType.UNSIGNED_16, DataType.valueOf("UNSIGNED_16"));
        assertEquals(DataType.UNSIGNED_32, DataType.valueOf("UNSIGNED_32"));
        assertEquals(DataType.UNSIGNED_64, DataType.valueOf("UNSIGNED_64"));

        assertEquals(DataType.BOOLEAN, DataType.valueOf("BOOLEAN"));

        assertEquals(DataType.UNSIGNED_5_6_5, DataType.valueOf("UNSIGNED_5_6_5"));
        assertEquals(DataType.UNSIGNED_5_5_5_1, DataType.valueOf("UNSIGNED_5_5_5_1"));
        assertEquals(DataType.UNSIGNED_4_4_4_4, DataType.valueOf("UNSIGNED_4_4_4_4"));

        assertEquals(DataType.MATRIX_4X4, DataType.valueOf("MATRIX_4X4"));
        assertEquals(DataType.MATRIX_3X3, DataType.valueOf("MATRIX_3X3"));
        assertEquals(DataType.MATRIX_2X2, DataType.valueOf("MATRIX_2X2"));

        assertEquals(DataType.RS_ELEMENT, DataType.valueOf("RS_ELEMENT"));
        assertEquals(DataType.RS_TYPE, DataType.valueOf("RS_TYPE"));
        assertEquals(DataType.RS_ALLOCATION, DataType.valueOf("RS_ALLOCATION"));
        assertEquals(DataType.RS_SAMPLER, DataType.valueOf("RS_SAMPLER"));
        assertEquals(DataType.RS_SCRIPT, DataType.valueOf("RS_SCRIPT"));
        assertEquals(DataType.RS_MESH, DataType.valueOf("RS_MESH"));
        assertEquals(DataType.RS_PROGRAM_FRAGMENT, DataType.valueOf("RS_PROGRAM_FRAGMENT"));
        assertEquals(DataType.RS_PROGRAM_VERTEX, DataType.valueOf("RS_PROGRAM_VERTEX"));
        assertEquals(DataType.RS_PROGRAM_RASTER, DataType.valueOf("RS_PROGRAM_RASTER"));
        assertEquals(DataType.RS_PROGRAM_STORE, DataType.valueOf("RS_PROGRAM_STORE"));
        // Make sure no new enums are added
        assertEquals(30, DataType.values().length);

        for (DataType dt : DataType.values()) {
            switch (dt) {
            case FLOAT_32:
            case FLOAT_64:
            case SIGNED_8:
            case SIGNED_16:
            case SIGNED_32:
            case SIGNED_64:
            case UNSIGNED_8:
            case UNSIGNED_16:
            case UNSIGNED_32:
            case UNSIGNED_64:
            case BOOLEAN:
                Element.createVector(mRS, dt, 2);
                break;

            default: {
                try {
                    Element.createVector(mRS, dt, 2);
                    fail("should throw RSIllegalArgumentException");
                } catch (RSIllegalArgumentException e) {
                }
                break;
            }
            }
        }
    }

    public void testDataKind() {
        assertEquals(DataKind.USER, DataKind.valueOf("USER"));

        assertEquals(DataKind.PIXEL_L, DataKind.valueOf("PIXEL_L"));
        assertEquals(DataKind.PIXEL_A, DataKind.valueOf("PIXEL_A"));
        assertEquals(DataKind.PIXEL_LA, DataKind.valueOf("PIXEL_LA"));
        assertEquals(DataKind.PIXEL_RGB, DataKind.valueOf("PIXEL_RGB"));
        assertEquals(DataKind.PIXEL_RGBA, DataKind.valueOf("PIXEL_RGBA"));
        assertEquals(DataKind.PIXEL_DEPTH, DataKind.valueOf("PIXEL_DEPTH"));
        assertEquals(DataKind.PIXEL_YUV, DataKind.valueOf("PIXEL_YUV"));
        // Make sure no new enums are added
        assertEquals(8, DataKind.values().length);

        for (DataKind dk : DataKind.values()) {
            if (dk != DataKind.USER && dk != DataKind.PIXEL_YUV) {
                Element.createPixel(mRS, DataType.UNSIGNED_8, dk);
            }
        }
    }
}