Some more renderscript tests.
Change-Id: I2bf220995af4315d8e91845d6ade561b33416084
diff --git a/tests/tests/renderscript/src/android/renderscript/cts/AllocationTest.java b/tests/tests/renderscript/src/android/renderscript/cts/AllocationTest.java
new file mode 100644
index 0000000..77f61fe
--- /dev/null
+++ b/tests/tests/renderscript/src/android/renderscript/cts/AllocationTest.java
@@ -0,0 +1,197 @@
+/*
+ * Copyright (C) 2011 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 com.android.cts.stub.R;
+
+import android.renderscript.Allocation;
+import android.renderscript.Allocation.MipmapControl;
+import android.renderscript.Element;
+import android.renderscript.RenderScript;
+import android.renderscript.RenderScriptGL;
+import android.renderscript.RenderScriptGL.SurfaceConfig;
+import android.renderscript.Type;
+import android.renderscript.Type.Builder;
+import android.test.AndroidTestCase;
+
+public class AllocationTest extends AndroidTestCase {
+
+ RenderScript mRS;
+ @Override
+ protected void setUp() throws Exception {
+ mRS = new RenderScriptGL(getContext(), new SurfaceConfig());
+ }
+
+ @Override
+ protected void tearDown() throws Exception {
+ mRS.destroy();
+ mRS = null;
+ }
+
+ // Test power of two and non power of two, equal and non-equal sizes
+ void createTypedHelper(Element e) {
+
+ Type.Builder typeBuilder = new Type.Builder(mRS, e);
+ for (int mips = 0; mips <= 1; mips ++) {
+ boolean useMips = (mips == 1);
+
+ for (int faces = 0; faces <= 1; faces++) {
+ boolean useFaces = (faces == 1);
+
+ for (int x = 1; x < 8; x ++) {
+ for (int y = 1; y < 8; y ++) {
+ typeBuilder.setMipmaps(useMips);
+ typeBuilder.setFaces(useFaces);
+ typeBuilder.setX(x).setY(y);
+ Allocation.createTyped(mRS, typeBuilder.create());
+ }
+ }
+ }
+ }
+
+ }
+
+ void createTypedTextureHelper(Element e) {
+ // No mips graphics
+ Type.Builder typeBuilder = new Type.Builder(mRS, e);
+ Allocation.createTyped(mRS, typeBuilder.setX(8).create(),
+ MipmapControl.MIPMAP_NONE,
+ Allocation.USAGE_GRAPHICS_TEXTURE);
+ Allocation.createTyped(mRS, typeBuilder.setY(8).create(),
+ MipmapControl.MIPMAP_NONE,
+ Allocation.USAGE_GRAPHICS_TEXTURE);
+ // No mips graphics and script
+ Allocation.createTyped(mRS, typeBuilder.create(),
+ MipmapControl.MIPMAP_NONE,
+ Allocation.USAGE_GRAPHICS_TEXTURE |
+ Allocation.USAGE_SCRIPT);
+ // With mips
+ Allocation.createTyped(mRS, typeBuilder.create(),
+ MipmapControl.MIPMAP_ON_SYNC_TO_TEXTURE,
+ Allocation.USAGE_GRAPHICS_TEXTURE);
+ Allocation.createTyped(mRS, typeBuilder.create(),
+ MipmapControl.MIPMAP_FULL,
+ Allocation.USAGE_GRAPHICS_TEXTURE |
+ Allocation.USAGE_SCRIPT);
+
+ // Only texture npot
+ Allocation.createTyped(mRS, typeBuilder.setX(7).setY(1).create(),
+ MipmapControl.MIPMAP_NONE,
+ Allocation.USAGE_GRAPHICS_TEXTURE);
+ Allocation.createTyped(mRS, typeBuilder.setX(7).setY(3).create(),
+ MipmapControl.MIPMAP_NONE,
+ Allocation.USAGE_GRAPHICS_TEXTURE);
+ Allocation.createTyped(mRS, typeBuilder.setX(7).setY(7).create(),
+ MipmapControl.MIPMAP_NONE,
+ Allocation.USAGE_GRAPHICS_TEXTURE);
+
+ // Script and texture
+ Allocation.createTyped(mRS, typeBuilder.setX(7).setY(1).create(),
+ MipmapControl.MIPMAP_NONE,
+ Allocation.USAGE_GRAPHICS_TEXTURE |
+ Allocation.USAGE_SCRIPT);
+ Allocation.createTyped(mRS, typeBuilder.setX(7).setY(3).create(),
+ MipmapControl.MIPMAP_NONE,
+ Allocation.USAGE_GRAPHICS_TEXTURE |
+ Allocation.USAGE_SCRIPT);
+ Allocation.createTyped(mRS, typeBuilder.setX(7).setY(7).create(),
+ MipmapControl.MIPMAP_NONE,
+ Allocation.USAGE_GRAPHICS_TEXTURE |
+ Allocation.USAGE_SCRIPT);
+ }
+
+ void createSizedHelper(Element e) {
+ for (int i = 1; i <= 8; i ++) {
+ Allocation.createSized(mRS, e, i);
+ }
+ }
+
+ public void testCreateTyped() {
+ createTypedHelper(Element.A_8(mRS));
+ createTypedHelper(Element.RGB_565(mRS));
+ createTypedHelper(Element.RGB_888(mRS));
+ createTypedHelper(Element.RGBA_8888(mRS));
+ createTypedHelper(Element.F32(mRS));
+ createTypedHelper(Element.F32_2(mRS));
+ createTypedHelper(Element.F32_3(mRS));
+ createTypedHelper(Element.F32_4(mRS));
+ createTypedHelper(Element.BOOLEAN(mRS));
+ createTypedHelper(Element.F64(mRS));
+ createTypedHelper(Element.I8(mRS));
+ createTypedHelper(Element.I16(mRS));
+ createTypedHelper(Element.I32(mRS));
+ createTypedHelper(Element.I64(mRS));
+ createTypedHelper(Element.U8(mRS));
+ createTypedHelper(Element.U8_4(mRS));
+ createTypedHelper(Element.U16(mRS));
+ createTypedHelper(Element.U32(mRS));
+ createTypedHelper(Element.U64(mRS));
+ createTypedHelper(Element.MATRIX_2X2(mRS));
+ createTypedHelper(Element.MATRIX_3X3(mRS));
+ createTypedHelper(Element.MATRIX_4X4(mRS));
+ createTypedHelper(Element.MESH(mRS));
+ createTypedHelper(Element.PROGRAM_FRAGMENT(mRS));
+ createTypedHelper(Element.PROGRAM_RASTER(mRS));
+ createTypedHelper(Element.PROGRAM_STORE(mRS));
+ createTypedHelper(Element.PROGRAM_VERTEX(mRS));
+ createTypedHelper(Element.ALLOCATION(mRS));
+ createTypedHelper(Element.SAMPLER(mRS));
+ createTypedHelper(Element.SCRIPT(mRS));
+ createTypedHelper(Element.TYPE(mRS));
+
+ createTypedTextureHelper(Element.A_8(mRS));
+ createTypedTextureHelper(Element.RGB_565(mRS));
+ createTypedTextureHelper(Element.RGB_888(mRS));
+ createTypedTextureHelper(Element.RGBA_8888(mRS));
+ }
+
+ public void testCreateSized() {
+ createSizedHelper(Element.A_8(mRS));
+ createSizedHelper(Element.RGB_565(mRS));
+ createSizedHelper(Element.RGB_888(mRS));
+ createSizedHelper(Element.RGBA_8888(mRS));
+ createSizedHelper(Element.F32(mRS));
+ createSizedHelper(Element.F32_2(mRS));
+ createSizedHelper(Element.F32_3(mRS));
+ createSizedHelper(Element.F32_4(mRS));
+ createSizedHelper(Element.BOOLEAN(mRS));
+ createSizedHelper(Element.F64(mRS));
+ createSizedHelper(Element.I8(mRS));
+ createSizedHelper(Element.I16(mRS));
+ createSizedHelper(Element.I32(mRS));
+ createSizedHelper(Element.I64(mRS));
+ createSizedHelper(Element.U8(mRS));
+ createSizedHelper(Element.U8_4(mRS));
+ createSizedHelper(Element.U16(mRS));
+ createSizedHelper(Element.U32(mRS));
+ createSizedHelper(Element.U64(mRS));
+ createSizedHelper(Element.MATRIX_2X2(mRS));
+ createSizedHelper(Element.MATRIX_3X3(mRS));
+ createSizedHelper(Element.MATRIX_4X4(mRS));
+ createSizedHelper(Element.MESH(mRS));
+ createSizedHelper(Element.PROGRAM_FRAGMENT(mRS));
+ createSizedHelper(Element.PROGRAM_RASTER(mRS));
+ createSizedHelper(Element.PROGRAM_STORE(mRS));
+ createSizedHelper(Element.PROGRAM_VERTEX(mRS));
+ createSizedHelper(Element.ALLOCATION(mRS));
+ createSizedHelper(Element.SAMPLER(mRS));
+ createSizedHelper(Element.SCRIPT(mRS));
+ createSizedHelper(Element.TYPE(mRS));
+ }
+}
+
+
diff --git a/tests/tests/renderscript/src/android/renderscript/cts/ElementTest.java b/tests/tests/renderscript/src/android/renderscript/cts/ElementTest.java
new file mode 100644
index 0000000..761b9c6
--- /dev/null
+++ b/tests/tests/renderscript/src/android/renderscript/cts/ElementTest.java
@@ -0,0 +1,215 @@
+/*
+ * Copyright (C) 2011 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 com.android.cts.stub.R;
+
+import android.renderscript.Element;
+import android.renderscript.Element.DataType;
+import android.renderscript.Element.DataKind;
+import android.renderscript.RenderScript;
+import android.renderscript.RenderScriptGL;
+import android.renderscript.RenderScriptGL.SurfaceConfig;
+import android.test.AndroidTestCase;
+
+public class ElementTest extends AndroidTestCase {
+
+ RenderScript mRS;
+ @Override
+ protected void setUp() throws Exception {
+ mRS = RenderScript.create(getContext());
+ }
+
+ @Override
+ protected void tearDown() throws Exception {
+ mRS.destroy();
+ mRS = null;
+ }
+
+ 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.I8(mRS) != null);
+ assertTrue(Element.I16(mRS) != null);
+ assertTrue(Element.I32(mRS) != null);
+ assertTrue(Element.I64(mRS) != null);
+ assertTrue(Element.U8(mRS) != null);
+ assertTrue(Element.U8_4(mRS) != null);
+ assertTrue(Element.U16(mRS) != null);
+ assertTrue(Element.U32(mRS) != null);
+ assertTrue(Element.U64(mRS) != null);
+ assertTrue(Element.MATRIX_2X2(mRS) != null);
+ assertTrue(Element.MATRIX_3X3(mRS) != null);
+ assertTrue(Element.MATRIX_4X4(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 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.I8(mRS), "I8", arraySize);
+ eb.add(Element.I16(mRS), "I16", arraySize);
+ eb.add(Element.I32(mRS), "I32", arraySize);
+ eb.add(Element.I64(mRS), "I64", arraySize);
+ eb.add(Element.U8(mRS), "U8", arraySize);
+ eb.add(Element.U8_4(mRS), "U8_4", arraySize);
+ eb.add(Element.U16(mRS), "U16", arraySize);
+ eb.add(Element.U32(mRS), "U32", arraySize);
+ eb.add(Element.U64(mRS), "U64", 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.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.I8(mRS).isComplex());
+ assertFalse(Element.I16(mRS).isComplex());
+ assertFalse(Element.I32(mRS).isComplex());
+ assertFalse(Element.I64(mRS).isComplex());
+ assertFalse(Element.U8(mRS).isComplex());
+ assertFalse(Element.U8_4(mRS).isComplex());
+ assertFalse(Element.U16(mRS).isComplex());
+ assertFalse(Element.U32(mRS).isComplex());
+ assertFalse(Element.U64(mRS).isComplex());
+ assertFalse(Element.MATRIX_2X2(mRS).isComplex());
+ assertFalse(Element.MATRIX_3X3(mRS).isComplex());
+ assertFalse(Element.MATRIX_4X4(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());
+ }
+}
+
+
diff --git a/tests/tests/renderscript/src/android/renderscript/cts/ProgramStoreTest.java b/tests/tests/renderscript/src/android/renderscript/cts/ProgramStoreTest.java
new file mode 100644
index 0000000..d8bb4c8
--- /dev/null
+++ b/tests/tests/renderscript/src/android/renderscript/cts/ProgramStoreTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2011 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 com.android.cts.stub.R;
+
+import android.renderscript.ProgramStore;
+import android.renderscript.ProgramStore.Builder;
+import android.renderscript.ProgramStore.DepthFunc;
+import android.renderscript.ProgramStore.BlendSrcFunc;
+import android.renderscript.ProgramStore.BlendDstFunc;
+import android.renderscript.RenderScript;
+import android.renderscript.RenderScriptGL;
+import android.renderscript.RenderScriptGL.SurfaceConfig;
+import android.test.AndroidTestCase;
+
+public class ProgramStoreTest extends AndroidTestCase {
+
+ RenderScript mRS;
+ @Override
+ protected void setUp() throws Exception {
+ mRS = new RenderScriptGL(getContext(), new SurfaceConfig());
+ }
+
+ @Override
+ protected void tearDown() throws Exception {
+ mRS.destroy();
+ mRS = null;
+ }
+
+ void varyBuilderColorAndDither(ProgramStore.Builder pb) {
+ for (int r = 0; r <= 1; r++) {
+ boolean isR = (r == 1);
+ for (int g = 0; g <= 1; g++) {
+ boolean isG = (g == 1);
+ for (int b = 0; b <= 1; b++) {
+ boolean isB = (b == 1);
+ for (int a = 0; a <= 1; a++) {
+ boolean isA = (a == 1);
+ for (int dither = 0; dither <= 1; dither++) {
+ boolean isDither = (dither == 1);
+ pb.setDepthMaskEnabled(isDither);
+ pb.setColorMaskEnabled(isR, isG, isB, isA);
+ pb.create();
+ }
+ }
+ }
+ }
+ }
+ }
+
+ public void testProgramStoreBuilder() {
+ for (int depth = 0; depth <= 1; depth++) {
+ boolean depthMask = (depth == 1);
+ for (DepthFunc df : DepthFunc.values()) {
+ for (BlendSrcFunc bsf : BlendSrcFunc.values()) {
+ for (BlendDstFunc bdf : BlendDstFunc.values()) {
+ ProgramStore.Builder b = new ProgramStore.Builder(mRS);
+ b.setDepthFunc(df);
+ b.setDepthMaskEnabled(depthMask);
+ b.setBlendFunc(bsf, bdf);
+ varyBuilderColorAndDither(b);
+ }
+ }
+ }
+ }
+ }
+
+ public void testPrebuiltProgramStore() {
+ assertTrue(ProgramStore.BLEND_ALPHA_DEPTH_NONE(mRS) != null);
+ assertTrue(ProgramStore.BLEND_ALPHA_DEPTH_TEST(mRS) != null);
+ assertTrue(ProgramStore.BLEND_NONE_DEPTH_NONE(mRS) != null);
+ assertTrue(ProgramStore.BLEND_NONE_DEPTH_TEST(mRS) != null);
+ }
+}
+
+
diff --git a/tests/tests/renderscript/src/android/renderscript/cts/TypeTest.java b/tests/tests/renderscript/src/android/renderscript/cts/TypeTest.java
new file mode 100644
index 0000000..dd1b9f1
--- /dev/null
+++ b/tests/tests/renderscript/src/android/renderscript/cts/TypeTest.java
@@ -0,0 +1,148 @@
+/*
+ * Copyright (C) 2011 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 com.android.cts.stub.R;
+
+import android.renderscript.Element;
+import android.renderscript.Element.DataType;
+import android.renderscript.Element.DataKind;
+import android.renderscript.RenderScript;
+import android.renderscript.RenderScriptGL;
+import android.renderscript.RenderScriptGL.SurfaceConfig;
+import android.renderscript.Type;
+import android.renderscript.Type.Builder;
+import android.test.AndroidTestCase;
+
+public class TypeTest extends AndroidTestCase {
+
+ RenderScript mRS;
+ @Override
+ protected void setUp() throws Exception {
+ mRS = RenderScript.create(getContext());
+ }
+
+ @Override
+ protected void tearDown() throws Exception {
+ mRS.destroy();
+ mRS = null;
+ }
+
+ void testBuilderSizes(Type.Builder b, int min, int max) {
+ for (int x = min; x < max; x ++) {
+ for (int y = min; y < max; y ++) {
+ b.setX(x).setY(y);
+ b.create();
+ }
+ }
+ }
+
+ void testTypeBuilderHelper(Element e) {
+ Type.Builder b = new Type.Builder(mRS, e);
+ for (int mips = 0; mips <= 1; mips ++) {
+ boolean useMips = (mips == 1);
+
+ for (int faces = 0; faces <= 1; faces++) {
+ boolean useFaces = (faces == 1);
+
+ b.setMipmaps(useMips);
+ b.setFaces(useFaces);
+ testBuilderSizes(b, 1, 8);
+ }
+ }
+ }
+
+ public void testTypeBuilder() {
+ testTypeBuilderHelper(Element.A_8(mRS));
+ testTypeBuilderHelper(Element.RGB_565(mRS));
+ testTypeBuilderHelper(Element.RGB_888(mRS));
+ testTypeBuilderHelper(Element.RGBA_8888(mRS));
+ testTypeBuilderHelper(Element.F32(mRS));
+ testTypeBuilderHelper(Element.F32_2(mRS));
+ testTypeBuilderHelper(Element.F32_3(mRS));
+ testTypeBuilderHelper(Element.F32_4(mRS));
+ testTypeBuilderHelper(Element.BOOLEAN(mRS));
+ testTypeBuilderHelper(Element.F64(mRS));
+ testTypeBuilderHelper(Element.I8(mRS));
+ testTypeBuilderHelper(Element.I16(mRS));
+ testTypeBuilderHelper(Element.I32(mRS));
+ testTypeBuilderHelper(Element.I64(mRS));
+ testTypeBuilderHelper(Element.U8(mRS));
+ testTypeBuilderHelper(Element.U8_4(mRS));
+ testTypeBuilderHelper(Element.U16(mRS));
+ testTypeBuilderHelper(Element.U32(mRS));
+ testTypeBuilderHelper(Element.U64(mRS));
+ testTypeBuilderHelper(Element.MATRIX_2X2(mRS));
+ testTypeBuilderHelper(Element.MATRIX_3X3(mRS));
+ testTypeBuilderHelper(Element.MATRIX_4X4(mRS));
+ testTypeBuilderHelper(Element.MESH(mRS));
+ testTypeBuilderHelper(Element.PROGRAM_FRAGMENT(mRS));
+ testTypeBuilderHelper(Element.PROGRAM_RASTER(mRS));
+ testTypeBuilderHelper(Element.PROGRAM_STORE(mRS));
+ testTypeBuilderHelper(Element.PROGRAM_VERTEX(mRS));
+ testTypeBuilderHelper(Element.ALLOCATION(mRS));
+ testTypeBuilderHelper(Element.SAMPLER(mRS));
+ testTypeBuilderHelper(Element.SCRIPT(mRS));
+ testTypeBuilderHelper(Element.TYPE(mRS));
+
+ // Add some complex and struct types to test here
+ }
+
+ public void testGetCount() {
+ Type.Builder b = new Type.Builder(mRS, Element.F32(mRS));
+ for (int faces = 0; faces <= 1; faces++) {
+ boolean useFaces = faces == 1;
+ int faceMultiplier = useFaces ? 6 : 1;
+ for (int x = 1; x < 8; x ++) {
+ for (int y = 1; y < 8; y ++) {
+ b.setFaces(useFaces);
+ b.setX(x).setY(y);
+ Type t = b.create();
+ assertTrue(t.getCount() == x * y * faceMultiplier);
+ }
+ }
+ }
+
+ // Test mipmaps
+ b.setFaces(false);
+ b.setMipmaps(true);
+ Type t = b.setX(8).setY(1).create();
+ int expectedCount = 8 + 4 + 2 + 1;
+ assertTrue(t.getCount() == expectedCount);
+
+ t = b.setX(8).setY(8).create();
+ expectedCount = 8*8 + 4*4 + 2*2 + 1;
+ assertTrue(t.getCount() == expectedCount);
+
+ t = b.setX(8).setY(4).create();
+ expectedCount = 8*4 + 4*2 + 2*1 + 1;
+ assertTrue(t.getCount() == expectedCount);
+
+ t = b.setX(4).setY(8).create();
+ assertTrue(t.getCount() == expectedCount);
+
+ t = b.setX(7).setY(1).create();
+ expectedCount = 7 + 3 + 1;
+ assertTrue(t.getCount() == expectedCount);
+
+ t = b.setX(7).setY(3).create();
+ expectedCount = 7*3 + 3*1 + 1;
+ assertTrue(t.getCount() == expectedCount);
+ }
+}
+
+
