diff --git a/suite/pts/deviceTests/opengl/jni/primitive/fullpipeline/FullPipelineMesh.cpp b/suite/pts/deviceTests/opengl/jni/graphics/BasicMeshNode.cpp
similarity index 83%
rename from suite/pts/deviceTests/opengl/jni/primitive/fullpipeline/FullPipelineMesh.cpp
rename to suite/pts/deviceTests/opengl/jni/graphics/BasicMeshNode.cpp
index bf1b9d2..273517a 100644
--- a/suite/pts/deviceTests/opengl/jni/primitive/fullpipeline/FullPipelineMesh.cpp
+++ b/suite/pts/deviceTests/opengl/jni/graphics/BasicMeshNode.cpp
@@ -12,20 +12,21 @@
  * the License.
  */
 
-#include "FullPipelineMesh.h"
+#include "BasicMeshNode.h"
 
-#include <graphics/BasicProgram.h>
+#include "BasicProgram.h"
 
-FullPipelineMesh::FullPipelineMesh(const Mesh* mesh) :
-        MeshNode(mesh) {
+BasicMeshNode::BasicMeshNode(const Mesh* mesh, const GLuint textureId) :
+        MeshNode(mesh),
+        mTextureId(textureId) {
 }
 
-void FullPipelineMesh::before(Program& program, Matrix& model, Matrix& view, Matrix& projection) {
+void BasicMeshNode::before(Program& program, Matrix& model, Matrix& view, Matrix& projection) {
     BasicProgram& prog = (BasicProgram&) program;
 
     glActiveTexture(GL_TEXTURE0);
     // Bind the texture to this unit.
-    glBindTexture(GL_TEXTURE_2D, mMesh->mTextureId);
+    glBindTexture(GL_TEXTURE_2D, mTextureId);
     // Tell the texture uniform sampler to use this texture in the shader by binding to texture
     // unit 0.
     glUniform1i(prog.mTextureUniformHandle, 0);
@@ -58,5 +59,5 @@
     glDrawArrays(GL_TRIANGLES, 0, mMesh->mNumVertices);
 }
 
-void FullPipelineMesh::after(Program& program, Matrix& model, Matrix& view, Matrix& projection) {
+void BasicMeshNode::after(Program& program, Matrix& model, Matrix& view, Matrix& projection) {
 }
diff --git a/suite/pts/deviceTests/opengl/jni/primitive/fullpipeline/FullPipelineMesh.h b/suite/pts/deviceTests/opengl/jni/graphics/BasicMeshNode.h
similarity index 73%
rename from suite/pts/deviceTests/opengl/jni/primitive/fullpipeline/FullPipelineMesh.h
rename to suite/pts/deviceTests/opengl/jni/graphics/BasicMeshNode.h
index 3fcb8ae..97cd24b 100644
--- a/suite/pts/deviceTests/opengl/jni/primitive/fullpipeline/FullPipelineMesh.h
+++ b/suite/pts/deviceTests/opengl/jni/graphics/BasicMeshNode.h
@@ -12,23 +12,24 @@
  * the License.
  */
 
-#ifndef FULLPIPELINEMESH_H
-#define FULLPIPELINEMESH_H
+#ifndef BASICMESHNODE_H
+#define BASICMESHNODE_H
 
-#include <graphics/Matrix.h>
-#include <graphics/Mesh.h>
-#include <graphics/MeshNode.h>
-#include <graphics/Program.h>
+#include "Matrix.h"
+#include "Mesh.h"
+#include "MeshNode.h"
+#include "Program.h"
 
-class FullPipelineMesh: public MeshNode {
+class BasicMeshNode: public MeshNode {
 public:
-    FullPipelineMesh(const Mesh* mesh);
-    virtual ~FullPipelineMesh() {};
+    BasicMeshNode(const Mesh* mesh, const GLuint textureId);
+    virtual ~BasicMeshNode() {};
 protected:
     virtual void before(Program& program, Matrix& model, Matrix& view,
             Matrix& projection);
     virtual void after(Program& program, Matrix& model, Matrix& view,
             Matrix& projection);
+    const GLuint mTextureId;
 };
 
 #endif
diff --git a/suite/pts/deviceTests/opengl/jni/graphics/GLUtils.cpp b/suite/pts/deviceTests/opengl/jni/graphics/GLUtils.cpp
index ed6f84b6..2484153 100644
--- a/suite/pts/deviceTests/opengl/jni/graphics/GLUtils.cpp
+++ b/suite/pts/deviceTests/opengl/jni/graphics/GLUtils.cpp
@@ -101,7 +101,7 @@
     return x + 1;
 }
 
-GLuint GLUtils::genRandTex(int texWidth, int texHeight) {
+GLuint GLUtils::genTexture(int texWidth, int texHeight, int fill) {
     GLuint textureId = 0;
     int w = roundUpToSmallestPowerOf2(texWidth);
     int h = roundUpToSmallestPowerOf2(texHeight);
@@ -110,8 +110,11 @@
         uint32_t* d = m;
         for (int y = 0; y < h; y++) {
             for (int x = 0; x < w; x++) {
-                *d = 0xff000000 | ((y & 0xff) << 16) | ((x & 0xff) << 8)
-                        | ((x + y) & 0xff);
+                if (fill == RANDOM_FILL) {
+                    *d = 0xff000000 | ((y & 0xff) << 16) | ((x & 0xff) << 8) | ((x + y) & 0xff);
+                } else {
+                    *d = 0xff000000 | fill;
+                }
                 d++;
             }
         }
diff --git a/suite/pts/deviceTests/opengl/jni/graphics/GLUtils.h b/suite/pts/deviceTests/opengl/jni/graphics/GLUtils.h
index 3d3bafd..16060ed 100644
--- a/suite/pts/deviceTests/opengl/jni/graphics/GLUtils.h
+++ b/suite/pts/deviceTests/opengl/jni/graphics/GLUtils.h
@@ -26,8 +26,11 @@
     static double currentTimeMillis();
     // Rounds a number up to the smallest power of 2 that is greater than the original number.
     static int roundUpToSmallestPowerOf2(int x);
-    // Generates a random texture of the given dimensions.
-    static GLuint genRandTex(int texWidth, int texHeight);
+    static const int RANDOM_FILL = -1;
+    // Generates a texture of the given dimensions. The texture can either be filled with the
+    // specified fill color, else if RANDOM_FILL is passed in the texture will be filled with
+    // random values.
+    static GLuint genTexture(int texWidth, int texHeight, int fill);
     static bool createFBO(GLuint& fboId, GLuint& rboId, GLuint& cboId, int width, int height);
 };
 
diff --git a/suite/pts/deviceTests/opengl/jni/graphics/Mesh.cpp b/suite/pts/deviceTests/opengl/jni/graphics/Mesh.cpp
index b92551c..858ec6b 100644
--- a/suite/pts/deviceTests/opengl/jni/graphics/Mesh.cpp
+++ b/suite/pts/deviceTests/opengl/jni/graphics/Mesh.cpp
@@ -14,11 +14,10 @@
 #include "Mesh.h"
 
 Mesh::Mesh(const float* vertices, const float* normals, const float* texCoords,
-           const int numVertices, const GLuint textureId)
+           const int numVertices)
     : mVertices(vertices),
       mNormals(normals),
       mTexCoords(texCoords),
-      mNumVertices(numVertices),
-      mTextureId(textureId) {
+      mNumVertices(numVertices) {
 
 }
diff --git a/suite/pts/deviceTests/opengl/jni/graphics/Mesh.h b/suite/pts/deviceTests/opengl/jni/graphics/Mesh.h
index 5f5ac7d..9ff4103 100644
--- a/suite/pts/deviceTests/opengl/jni/graphics/Mesh.h
+++ b/suite/pts/deviceTests/opengl/jni/graphics/Mesh.h
@@ -21,13 +21,12 @@
 class Mesh {
 public:
     Mesh(const float* vertices, const float* normals, const float* texCoords,
-            const int numVertices, const GLuint textureId);
+            const int numVertices);
     virtual ~Mesh() {};
     const float* mVertices;
     const float* mNormals;
     const float* mTexCoords;
     const int mNumVertices;
-    const GLuint mTextureId;
 };
 
 #endif
diff --git a/suite/pts/deviceTests/opengl/jni/graphics/Renderer.cpp b/suite/pts/deviceTests/opengl/jni/graphics/Renderer.cpp
index ece115e..e9d083d 100644
--- a/suite/pts/deviceTests/opengl/jni/graphics/Renderer.cpp
+++ b/suite/pts/deviceTests/opengl/jni/graphics/Renderer.cpp
@@ -74,20 +74,20 @@
         return false;
     }
 
-    if (!eglQuerySurface(mEglDisplay, mEglSurface, EGL_WIDTH, &width)
+    if (!eglQuerySurface(mEglDisplay, mEglSurface, EGL_WIDTH, &mWidth)
             || EGL_SUCCESS != eglGetError()) {
         return false;
     }
-    if (!eglQuerySurface(mEglDisplay, mEglSurface, EGL_HEIGHT, &height)
+    if (!eglQuerySurface(mEglDisplay, mEglSurface, EGL_HEIGHT, &mHeight)
             || EGL_SUCCESS != eglGetError()) {
         return false;
     }
 
-    glViewport(0, 0, width, height);
+    glViewport(0, 0, mWidth, mHeight);
 
     if (mOffscreen) {
-        mFboWidth = GLUtils::roundUpToSmallestPowerOf2(width);
-        mFboHeight = GLUtils::roundUpToSmallestPowerOf2(height);
+        mFboWidth = GLUtils::roundUpToSmallestPowerOf2(mWidth);
+        mFboHeight = GLUtils::roundUpToSmallestPowerOf2(mHeight);
         if (!GLUtils::createFBO(mFboId, mRboId, mCboId, mFboWidth, mFboHeight)) {
             return false;
         }
diff --git a/suite/pts/deviceTests/opengl/jni/graphics/Renderer.h b/suite/pts/deviceTests/opengl/jni/graphics/Renderer.h
index cbe9419..8da504d 100644
--- a/suite/pts/deviceTests/opengl/jni/graphics/Renderer.h
+++ b/suite/pts/deviceTests/opengl/jni/graphics/Renderer.h
@@ -40,8 +40,8 @@
     GLuint mCboId;// Color buffer id
     GLushort* mBuffer;// Used for FBO read back
     GLuint mProgramId;
-    EGLint width;
-    EGLint height;
+    EGLint mWidth;
+    EGLint mHeight;
     bool mOffscreen;
     int mWorkload;
 };
diff --git a/suite/pts/deviceTests/opengl/jni/graphics/Vector2D.cpp b/suite/pts/deviceTests/opengl/jni/graphics/Vector2D.cpp
new file mode 100644
index 0000000..d4a8c18
--- /dev/null
+++ b/suite/pts/deviceTests/opengl/jni/graphics/Vector2D.cpp
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2013 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.
+ */
+#include "Vector2D.h"
+
+#include <math.h>
+
+Vector2D::Vector2D() :
+        mX(0), mY(0) {
+}
+
+Vector2D::Vector2D(float x, float y) :
+        mX(x), mY(y) {
+}
+
+Vector2D Vector2D::copy() {
+    Vector2D v(mX, mY);
+    return v;
+}
+
+void Vector2D::add(const Vector2D& v) {
+    mX += v.mX;
+    mY += v.mY;
+}
+
+void Vector2D::sub(const Vector2D& v) {
+    mX -= v.mX;
+    mY -= v.mY;
+}
+
+void Vector2D::scale(float s) {
+    mX *= s;
+    mY *= s;
+}
+
+float Vector2D::distance(const Vector2D& v) {
+    float dx = mX - v.mX;
+    float dy = mY - v.mY;
+    return (float) sqrt(dx * dx + dy * dy);
+}
+
+void Vector2D::normalize() {
+    float m = magnitude();
+    if (m > 0) {
+        scale(1 / m);
+    }
+}
+
+void Vector2D::limit(float max) {
+    if (magnitude() > max) {
+        normalize();
+        scale(max);
+    }
+}
+
+float Vector2D::magnitude() {
+    return (float) sqrt(mX * mX + mY * mY);
+}
diff --git a/suite/pts/deviceTests/opengl/jni/graphics/Vector2D.h b/suite/pts/deviceTests/opengl/jni/graphics/Vector2D.h
new file mode 100644
index 0000000..5110975
--- /dev/null
+++ b/suite/pts/deviceTests/opengl/jni/graphics/Vector2D.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2013 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.
+ */
+#ifndef VECTOR2D_H
+#define VECTOR2D_H
+
+class Vector2D {
+public:
+    Vector2D();
+    Vector2D(float x, float y);
+    Vector2D copy();
+    void normalize();
+    void add(const Vector2D& v);
+    void sub(const Vector2D& v);
+    void scale(float s);
+    void limit(float max);
+    void limit(float maxX, float maxY);
+    float magnitude();
+    float distance(const Vector2D& v);
+    float mX;
+    float mY;
+};
+#endif
diff --git a/suite/pts/deviceTests/opengl/jni/primitive/contextswitch/ContextSwitchRenderer.cpp b/suite/pts/deviceTests/opengl/jni/primitive/contextswitch/ContextSwitchRenderer.cpp
index 44e8909..8865c99 100644
--- a/suite/pts/deviceTests/opengl/jni/primitive/contextswitch/ContextSwitchRenderer.cpp
+++ b/suite/pts/deviceTests/opengl/jni/primitive/contextswitch/ContextSwitchRenderer.cpp
@@ -25,11 +25,14 @@
 
 #include <Trace.h>
 
-static const EGLint contextAttribs[] =
-        { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
+static const EGLint contextAttribs[] = {
+        EGL_CONTEXT_CLIENT_VERSION, 2,
+        EGL_NONE };
 
 static const int NUM_WORKER_CONTEXTS = 7;
 
+static const int CS_TEXTURE_SIZE = 64;
+
 static const int CS_NUM_VERTICES = 6;
 
 static const float CS_VERTICES[CS_NUM_VERTICES * 3] = {
@@ -78,7 +81,7 @@
     }
 
     // Setup texture.
-    mTextureId = GLUtils::genRandTex(64, 64);
+    mTextureId = GLUtils::genTexture(CS_TEXTURE_SIZE, CS_TEXTURE_SIZE, GLUtils::RANDOM_FILL);
     if (mTextureId == 0) {
         return false;
     }
diff --git a/suite/pts/deviceTests/opengl/jni/primitive/fullpipeline/FullPipelineRenderer.cpp b/suite/pts/deviceTests/opengl/jni/primitive/fullpipeline/FullPipelineRenderer.cpp
index da65420..01b143b 100644
--- a/suite/pts/deviceTests/opengl/jni/primitive/fullpipeline/FullPipelineRenderer.cpp
+++ b/suite/pts/deviceTests/opengl/jni/primitive/fullpipeline/FullPipelineRenderer.cpp
@@ -15,11 +15,11 @@
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 
-#include "FullPipelineMesh.h"
 #include "FullPipelineRenderer.h"
 
-#include <graphics/TransformationNode.h>
+#include <graphics/BasicMeshNode.h>
 #include <graphics/GLUtils.h>
+#include <graphics/TransformationNode.h>
 
 #include <Trace.h>
 
@@ -104,8 +104,9 @@
     }
 
     mProgramId = GLUtils::createProgram(&FP_VERTEX, &FP_FRAGMENT);
-    if (mProgramId == 0)
+    if (mProgramId == 0) {
         return false;
+    }
     mProgram = new BasicProgram(mProgramId);
 
     mModelMatrix = new Matrix();
@@ -130,7 +131,7 @@
 
     // Create a new perspective projection matrix. The height will stay the same
     // while the width will vary as per aspect ratio.
-    float ratio = (float) width / height;
+    float ratio = (float) mWidth / mHeight;
     float left = -ratio;
     float right = ratio;
     float bottom = -1.0f;
@@ -141,7 +142,7 @@
     mProjectionMatrix = Matrix::newFrustum(left, right, bottom, top, near, far);
 
     // Setup texture.
-    mTextureId = GLUtils::genRandTex(width, height);
+    mTextureId = GLUtils::genTexture(mWidth, mHeight, GLUtils::RANDOM_FILL);
     if (mTextureId == 0) {
         return false;
     }
@@ -150,7 +151,7 @@
     float middle = count / 2.0f;
     float scale = 2.0f / count;
 
-    mMesh = new Mesh(FP_VERTICES, FP_NORMALS, FP_TEX_COORDS, FP_NUM_VERTICES, mTextureId);
+    mMesh = new Mesh(FP_VERTICES, FP_NORMALS, FP_TEX_COORDS, FP_NUM_VERTICES);
     mSceneGraph = new ProgramNode();
 
     for (int i = 0; i < count; i++) {
@@ -159,7 +160,7 @@
             transformMatrix->translate(i - middle, j - middle, 0.0f);
             TransformationNode* transformNode = new TransformationNode(transformMatrix);
             mSceneGraph->addChild(transformNode);
-            FullPipelineMesh* meshNode = new FullPipelineMesh(mMesh);
+            BasicMeshNode* meshNode = new BasicMeshNode(mMesh, mTextureId);
             transformNode->addChild(meshNode);
         }
     }
diff --git a/suite/pts/deviceTests/opengl/jni/primitive/pixeloutput/PixelOutputRenderer.cpp b/suite/pts/deviceTests/opengl/jni/primitive/pixeloutput/PixelOutputRenderer.cpp
index 321235d..3fdafca 100644
--- a/suite/pts/deviceTests/opengl/jni/primitive/pixeloutput/PixelOutputRenderer.cpp
+++ b/suite/pts/deviceTests/opengl/jni/primitive/pixeloutput/PixelOutputRenderer.cpp
@@ -62,15 +62,16 @@
 
     // Create program.
     mProgramId = GLUtils::createProgram(&PO_VERTEX, &PO_FRAGMENT);
-    if (mProgramId == 0)
+    if (mProgramId == 0) {
         return false;
+    }
     // Bind attributes.
     mTextureUniformHandle = glGetUniformLocation(mProgramId, "u_Texture");
     mPositionHandle = glGetAttribLocation(mProgramId, "a_Position");
     mTexCoordHandle = glGetAttribLocation(mProgramId, "a_TexCoord");
 
     // Setup texture.
-    mTextureId = GLUtils::genRandTex(width, height);
+    mTextureId = GLUtils::genTexture(mWidth, mHeight, GLUtils::RANDOM_FILL);
     if (mTextureId == 0) {
         return false;
     }
diff --git a/suite/pts/deviceTests/opengl/jni/primitive/shaderperf/ShaderPerfRenderer.cpp b/suite/pts/deviceTests/opengl/jni/primitive/shaderperf/ShaderPerfRenderer.cpp
index cff8599..85e6af3 100644
--- a/suite/pts/deviceTests/opengl/jni/primitive/shaderperf/ShaderPerfRenderer.cpp
+++ b/suite/pts/deviceTests/opengl/jni/primitive/shaderperf/ShaderPerfRenderer.cpp
@@ -112,8 +112,9 @@
     // Create program.
     mProgramId = GLUtils::createProgram(&SP_VERTEX, const_cast<const char**>(&spFragment));
     delete[] spFragment;
-    if (mProgramId == 0)
+    if (mProgramId == 0) {
         return false;
+    }
     // Bind attributes.
     mTextureUniformHandle = glGetUniformLocation(mProgramId, "u_Texture");
     mSeedUniformHandle = glGetUniformLocation(mProgramId, "u_Seed");
diff --git a/suite/pts/deviceTests/opengl/jni/reference/GLReference.cpp b/suite/pts/deviceTests/opengl/jni/reference/GLReference.cpp
index 53a262e..333e0da 100644
--- a/suite/pts/deviceTests/opengl/jni/reference/GLReference.cpp
+++ b/suite/pts/deviceTests/opengl/jni/reference/GLReference.cpp
@@ -13,10 +13,46 @@
  */
 #include <jni.h>
 
+#include <android/native_window.h>
+#include <android/native_window_jni.h>
+
+#include <graphics/GLUtils.h>
+#include <graphics/Renderer.h>
+
+#include "ReferenceRenderer.h"
+
 extern "C" JNIEXPORT jboolean JNICALL
 Java_com_android_pts_opengl_reference_GLGameActivity_startBenchmark(
         JNIEnv* env, jclass clazz, jobject surface, jint numFrames,
         jdoubleArray setUpTimes, jdoubleArray updateTimes, jdoubleArray renderTimes) {
-    // TODO
-    return true;
+
+    if (numFrames > (ReferenceRenderer::FRAMES_PER_SCENE * ReferenceRenderer::NUM_SCENES)) {
+        return false;
+    }
+
+    ReferenceRenderer* gRenderer = new ReferenceRenderer(ANativeWindow_fromSurface(env, surface));
+
+    bool success = gRenderer->setUp();
+    env->SetDoubleArrayRegion(
+            setUpTimes, 0, ReferenceRenderer::NUM_SETUP_TIMES, gRenderer->mSetUpTimes);
+
+    double updates[numFrames];
+    double renders[numFrames];
+    for (int i = 0; i < numFrames && success; i++) {
+        double t0 = GLUtils::currentTimeMillis();
+        success = gRenderer->update(i);
+        double t1 = GLUtils::currentTimeMillis();
+        success = success && gRenderer->draw();
+        double t2 = GLUtils::currentTimeMillis();
+        updates[i] = t1 - t0;
+        renders[i] = t2 - t1;
+    }
+
+    env->SetDoubleArrayRegion(updateTimes, 0, numFrames, updates);
+    env->SetDoubleArrayRegion(renderTimes, 0, numFrames, renders);
+
+    success = gRenderer->tearDown() && success;
+    delete gRenderer;
+    gRenderer = NULL;
+    return success;
 }
diff --git a/suite/pts/deviceTests/opengl/jni/reference/ReferenceRenderer.cpp b/suite/pts/deviceTests/opengl/jni/reference/ReferenceRenderer.cpp
new file mode 100644
index 0000000..a168246
--- /dev/null
+++ b/suite/pts/deviceTests/opengl/jni/reference/ReferenceRenderer.cpp
@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2013 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.
+ */
+#include "ReferenceRenderer.h"
+
+#include "scene/flocking/FlockingScene.h"
+
+#include <graphics/GLUtils.h>
+#include <graphics/ProgramNode.h>
+
+#include <Trace.h>
+
+ReferenceRenderer::ReferenceRenderer(ANativeWindow* window) :
+        Renderer(window, false, 0) {
+}
+
+bool ReferenceRenderer::setUp() {
+    SCOPED_TRACE();
+    // Reset the times.
+    for (int i = 0; i < NUM_SETUP_TIMES; i++) {
+        mSetUpTimes[i] = 0;
+    }
+    // Set up OpenGLES.
+    double start = GLUtils::currentTimeMillis();
+    if (!Renderer::setUp()) {
+        return false;
+    }
+    mSetUpTimes[0] = GLUtils::currentTimeMillis() - start;
+
+    // Create the scenes.
+    mScenes[0] = new FlockingScene(mWidth, mHeight);
+    // TODO add more scenes to do a comprehensive test.
+
+    // Set up the scenes.
+    double times[NUM_SETUP_TIMES];
+    for (int i = 0; i < NUM_SCENES; i++) {
+        times[0] = GLUtils::currentTimeMillis();
+        mScenes[i]->setUpContext();
+        times[1] = GLUtils::currentTimeMillis();
+        mScenes[i]->setUpTextures();
+        times[2] = GLUtils::currentTimeMillis();
+        mScenes[i]->setUpMeshes();
+        times[3] = GLUtils::currentTimeMillis();
+
+        for (int i = 1; i < NUM_SETUP_TIMES; i++) {
+            // Add on the set up times.
+            mSetUpTimes[i] += times[i] - times[i - 1];
+        }
+    }
+    return true;
+}
+
+bool ReferenceRenderer::tearDown() {
+    SCOPED_TRACE();
+    for (int i = 0; i < NUM_SCENES; i++) {
+        mScenes[i]->tearDown();
+        delete mScenes[i];
+    }
+    mCurrentScene = NULL;
+    if (!Renderer::tearDown()) {
+        return false;
+    }
+    return true;
+}
+
+bool ReferenceRenderer::update(int frame) {
+    SCOPED_TRACE();
+    int sceneId = frame / ReferenceRenderer::FRAMES_PER_SCENE;
+    int localFrame = frame % ReferenceRenderer::FRAMES_PER_SCENE;
+    mCurrentScene = mScenes[sceneId];
+    mCurrentScene->update(localFrame);
+    return true;
+}
+
+bool ReferenceRenderer::draw() {
+    SCOPED_TRACE();
+    if (mOffscreen) {
+        glBindFramebuffer(GL_FRAMEBUFFER, mFboId);
+    }
+    // Set the background clear color to black.
+    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+    // Use culling to remove back faces.
+    glEnable(GL_CULL_FACE);
+    // Use depth testing.
+    glEnable(GL_DEPTH_TEST);
+    glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
+    mCurrentScene->draw();
+
+    return Renderer::draw();
+}
diff --git a/suite/pts/deviceTests/opengl/jni/reference/ReferenceRenderer.h b/suite/pts/deviceTests/opengl/jni/reference/ReferenceRenderer.h
new file mode 100644
index 0000000..fa77ec1
--- /dev/null
+++ b/suite/pts/deviceTests/opengl/jni/reference/ReferenceRenderer.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2013 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.
+ */
+#ifndef REFERENCERENDERER_H
+#define REFERENCERENDERER_H
+
+#include "scene/Scene.h"
+
+#include <graphics/Mesh.h>
+#include <graphics/Renderer.h>
+
+class ReferenceRenderer: public Renderer {
+public:
+    ReferenceRenderer(ANativeWindow* window);
+    virtual ~ReferenceRenderer() {};
+    bool setUp();
+    bool tearDown();
+    bool update(int frame);
+    bool draw();
+    double mSetUpTimes[4];
+    static const int FRAMES_PER_SCENE = 500;
+    static const int NUM_SCENES = 1;
+    static const int NUM_SETUP_TIMES = 4;
+private:
+    Scene* mScenes[NUM_SCENES];
+    Scene* mCurrentScene;
+
+};
+
+#endif
diff --git a/suite/pts/deviceTests/opengl/jni/reference/scene/Scene.cpp b/suite/pts/deviceTests/opengl/jni/reference/scene/Scene.cpp
new file mode 100644
index 0000000..7ea889b
--- /dev/null
+++ b/suite/pts/deviceTests/opengl/jni/reference/scene/Scene.cpp
@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2013 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.
+ */
+#include "Scene.h"
+
+#include <graphics/GLUtils.h>
+#include <graphics/ProgramNode.h>
+
+#include <Trace.h>
+
+Scene::Scene(int width, int height) :
+        mWidth(width), mHeight(height), mSceneGraph(NULL) {
+}
+
+bool Scene::setUpContext() {
+    SCOPED_TRACE();
+    mProgram = setUpProgram();
+    if (mProgram == NULL) {
+        return false;
+    }
+    mModelMatrix = setUpModelMatrix();
+    if (mModelMatrix == NULL) {
+        return false;
+    }
+    mViewMatrix = setUpViewMatrix();
+    if (mViewMatrix == NULL) {
+        return false;
+    }
+    mProjectionMatrix = setUpProjectionMatrix();
+    if (mProjectionMatrix == NULL) {
+        return false;
+    }
+    return true;
+}
+
+bool Scene::tearDown() {
+    SCOPED_TRACE();
+    for (size_t i = 0; i < mTextureIds.size(); i++) {
+        glDeleteTextures(1, &(mTextureIds[i]));
+    }
+    for (size_t i = 0; i < mMeshes.size(); i++) {
+        delete mMeshes[i];
+    }
+    delete mProgram;
+    mProgram = NULL;
+    delete mSceneGraph;
+    mSceneGraph = NULL;
+    delete mModelMatrix;
+    mModelMatrix = NULL;
+    delete mViewMatrix;
+    mViewMatrix = NULL;
+    delete mProjectionMatrix;
+    mProjectionMatrix = NULL;
+    return true;
+}
+
+bool Scene::update(int frame) {
+    SCOPED_TRACE();
+    delete mSceneGraph; // Delete the old scene graph.
+    mSceneGraph = updateSceneGraph();
+    if (mSceneGraph == NULL) {
+        return false;
+    }
+    return true;
+}
+
+bool Scene::draw() {
+    SCOPED_TRACE();
+    mSceneGraph->draw(*mProgram, *mModelMatrix, *mViewMatrix, *mProjectionMatrix);
+    return true;
+}
diff --git a/suite/pts/deviceTests/opengl/jni/reference/scene/Scene.h b/suite/pts/deviceTests/opengl/jni/reference/scene/Scene.h
new file mode 100644
index 0000000..1adb850
--- /dev/null
+++ b/suite/pts/deviceTests/opengl/jni/reference/scene/Scene.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2013 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.
+ */
+#ifndef SCENE_H
+#define SCENE_H
+
+#include <graphics/Matrix.h>
+#include <graphics/Mesh.h>
+#include <graphics/Program.h>
+#include <graphics/SceneGraphNode.h>
+
+#include <utils/Vector.h>
+
+class Scene {
+public:
+    Scene(int width, int height);
+    virtual ~Scene() {};
+    virtual bool setUpContext();
+    virtual bool setUpTextures() = 0;
+    virtual bool setUpMeshes() = 0;
+    virtual bool tearDown();
+    virtual bool update(int frame);
+    virtual bool draw();
+protected:
+    virtual Program* setUpProgram() = 0;
+    virtual Matrix* setUpModelMatrix() = 0;
+    virtual Matrix* setUpViewMatrix() = 0;
+    virtual Matrix* setUpProjectionMatrix() = 0;
+    virtual SceneGraphNode* updateSceneGraph() = 0;
+    int mWidth;
+    int mHeight;
+    android::Vector<Mesh*> mMeshes;
+    android::Vector<GLuint> mTextureIds;
+private:
+    Program* mProgram;
+    SceneGraphNode* mSceneGraph;
+    Matrix* mModelMatrix;
+    Matrix* mViewMatrix;
+    Matrix* mProjectionMatrix;
+};
+#endif
diff --git a/suite/pts/deviceTests/opengl/jni/reference/scene/flocking/Boid.cpp b/suite/pts/deviceTests/opengl/jni/reference/scene/flocking/Boid.cpp
new file mode 100644
index 0000000..74eef81
--- /dev/null
+++ b/suite/pts/deviceTests/opengl/jni/reference/scene/flocking/Boid.cpp
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2013 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.
+ */
+#include "Boid.h"
+
+Boid::Boid(float x, float y) :
+        mPosition(x, y) {
+}
+
+void Boid::flock(const Boid* boids[], int numBoids, int index, float limitX, float limitY) {
+    // Reset the acceleration.
+    mAcceleration.mX = 0;
+    mAcceleration.mY = 0;
+    Vector2D separation;
+    int separationCount = 0;
+    Vector2D alignment;
+    int alignmentCount = 0;
+    Vector2D cohesion;
+    int cohesionCount = 0;
+    for (int i = 0; i < numBoids; i++) {
+        if (i != index) {
+            const Boid* b = boids[i];
+            float dist = mPosition.distance(b->mPosition);
+            if (dist != 0) {
+                // Separation.
+                if (dist < DESIRED_BOID_DIST) {
+                    Vector2D tmp = mPosition.copy();
+                    tmp.sub(b->mPosition);
+                    tmp.normalize();
+                    tmp.scale(1.0f / dist);
+                    separation.add(tmp);
+                    separationCount++;
+                }
+                if (dist < NEIGHBOUR_RADIUS) {
+                    // Alignment.
+                    alignment.add(b->mVelocity);
+                    alignmentCount++;
+                    // Cohesion.
+                    cohesion.add(b->mPosition);
+                    cohesionCount++;
+                }
+            }
+        }
+    }
+
+    if (separationCount > 0) {
+        separation.scale(1.0f / separationCount);
+        separation.scale(SEPARATION_WEIGHT);
+        mAcceleration.add(separation);
+    }
+    if (alignmentCount > 0) {
+        alignment.scale(1.0f / alignmentCount);
+        alignment.limit(MAX_FORCE);
+        alignment.scale(ALIGNMENT_WEIGHT);
+        mAcceleration.add(alignment);
+    }
+    if (cohesionCount > 0) {
+        cohesion.scale(1.0f / cohesionCount);
+        cohesion.scale(COHESION_WEIGHT);
+        Vector2D desired = cohesion.copy();
+        desired.sub(mPosition);
+        float d = desired.magnitude();
+        if (d > 0) {
+            desired.normalize();
+            desired.scale(MAX_SPEED * ((d < 100.0f) ? d / 100.0f : 1));
+            desired.sub(mVelocity);
+            desired.limit(MAX_FORCE);
+            mAcceleration.add(desired);
+        }
+    }
+
+    mVelocity.add(mAcceleration);
+    mVelocity.limit(MAX_SPEED);
+    mPosition.add(mVelocity);
+    // Wrap around.
+    if (mPosition.mX < -limitX) {
+        mPosition.mX = limitX;
+    } else if (mPosition.mX > limitX) {
+        mPosition.mX = -limitX;
+    }
+    if (mPosition.mY < -limitY) {
+        mPosition.mY = limitY;
+    } else if (mPosition.mY > limitY) {
+        mPosition.mY = -limitY;
+    }
+}
diff --git a/suite/pts/deviceTests/opengl/jni/reference/scene/flocking/Boid.h b/suite/pts/deviceTests/opengl/jni/reference/scene/flocking/Boid.h
new file mode 100644
index 0000000..955b891
--- /dev/null
+++ b/suite/pts/deviceTests/opengl/jni/reference/scene/flocking/Boid.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2013 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.
+ */
+// An implementation of Craig Reynold's Boid Simulation.
+#ifndef BOID_H
+#define BOID_H
+
+#include <graphics/Vector2D.h>
+
+class Boid {
+public:
+    Boid(float x, float y);
+    void resetAcceleration();
+    void flock(const Boid* boids[], int numBoids, int index, float limitX, float limitY);
+    static const float MAX_SPEED = 2.0f;
+    static const float MAX_FORCE = 0.05f;
+    static const float NEIGHBOUR_RADIUS = 70.0f;//50
+    static const float DESIRED_BOID_DIST = 30.0f;//25
+    static const float SEPARATION_WEIGHT = 2.0f;
+    static const float ALIGNMENT_WEIGHT = 1.0f;
+    static const float COHESION_WEIGHT = 1.0f;
+    Vector2D mPosition;
+    Vector2D mVelocity;
+    Vector2D mAcceleration;
+};
+#endif
diff --git a/suite/pts/deviceTests/opengl/jni/reference/scene/flocking/FlockingScene.cpp b/suite/pts/deviceTests/opengl/jni/reference/scene/flocking/FlockingScene.cpp
new file mode 100644
index 0000000..933891a
--- /dev/null
+++ b/suite/pts/deviceTests/opengl/jni/reference/scene/flocking/FlockingScene.cpp
@@ -0,0 +1,211 @@
+/*
+ * Copyright (C) 2013 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.
+ */
+#include "FlockingScene.h"
+
+#include <cstdlib>
+
+#include <Trace.h>
+
+#include <graphics/BasicMeshNode.h>
+#include <graphics/BasicProgram.h>
+#include <graphics/GLUtils.h>
+#include <graphics/Matrix.h>
+#include <graphics/Mesh.h>
+#include <graphics/ProgramNode.h>
+#include <graphics/TransformationNode.h>
+
+static const int FS_NUM_VERTICES = 6;
+
+static const float FS_VERTICES[FS_NUM_VERTICES * 3] = {
+        1.0f, 1.0f, 0.0f,
+        -1.0f, 1.0f, 0.0f,
+        -1.0f, -1.0f, 0.0f,
+        -1.0f, -1.0f, 0.0f,
+        1.0f, -1.0f, 0.0f,
+        1.0f, 1.0f, 0.0f };
+
+static const float FS_NORMALS[FS_NUM_VERTICES * 3] = {
+        0.0f, 0.0f, 1.0f,
+        0.0f, 0.0f, 1.0f,
+        0.0f, 0.0f, 1.0f,
+        0.0f, 0.0f, 1.0f,
+        0.0f, 0.0f, 1.0f,
+        0.0f, 0.0f, 1.0f };
+
+static const float FS_TEX_COORDS[FS_NUM_VERTICES * 2] = {
+        1.0f, 1.0f,
+        0.0f, 1.0f,
+        0.0f, 0.0f,
+        0.0f, 0.0f,
+        1.0f, 0.0f,
+        1.0f, 1.0f };
+
+static const char* FS_VERTEX =
+        "uniform mat4 u_MVPMatrix;"
+        "uniform mat4 u_MVMatrix;"
+        "attribute vec4 a_Position;"
+        "attribute vec3 a_Normal;"
+        "attribute vec2 a_TexCoordinate;"
+        "varying vec3 v_Position;"
+        "varying vec3 v_Normal;"
+        "varying vec2 v_TexCoordinate;"
+        "void main() {\n"
+        "  // Transform the vertex into eye space.\n"
+        "  v_Position = vec3(u_MVMatrix * a_Position);\n"
+        "  // Pass through the texture coordinate.\n"
+        "  v_TexCoordinate = a_TexCoordinate;\n"
+        "  // Transform the normal\'s orientation into eye space.\n"
+        "  v_Normal = vec3(u_MVMatrix * vec4(a_Normal, 0.0));\n"
+        "  // Multiply to get the final point in normalized screen coordinates.\n"
+        "  gl_Position = u_MVPMatrix * a_Position;\n"
+        "}";
+
+static const char* FS_FRAGMENT =
+        "precision mediump float;"
+        "uniform vec3 u_LightPos;"
+        "uniform sampler2D u_Texture;"
+        "varying vec3 v_Position;"
+        "varying vec3 v_Normal;"
+        "varying vec2 v_TexCoordinate;"
+        "void main() {\n"
+        "  // Will be used for attenuation.\n"
+        "  float distance = length(u_LightPos - v_Position);\n"
+        "  // Get a lighting direction vector from the light to the vertex.\n"
+        "  vec3 lightVector = normalize(u_LightPos - v_Position);\n"
+        "  // Calculate the dot product of the light vector and vertex normal.\n"
+        "  float diffuse = max(dot(v_Normal, lightVector), 0.0);\n"
+        "  // Add attenuation.\n"
+        "  diffuse = diffuse * (1.0 / (1.0 + (0.01 * distance)));\n"
+        "  // Add ambient lighting\n"
+        "  diffuse = diffuse + 0.25;\n"
+        "  // Multiply the diffuse illumination and texture to get final output color.\n"
+        "  gl_FragColor = (diffuse * texture2D(u_Texture, v_TexCoordinate));\n"
+        "}";
+
+FlockingScene::FlockingScene(int width, int height) :
+        Scene(width, height) {
+    for (int i = 0; i < NUM_BOIDS; i++) {
+        // Generate a boid with a random position.
+        float x = ((rand() % 10) / 5.0f) - 0.1f;
+        float y = ((rand() % 10) / 5.0f) - 0.1f;
+        mBoids[i] = new Boid(x, y);
+    }
+}
+
+Program* FlockingScene::setUpProgram() {
+    // TODO Enable loading programs from file.
+    // mProgramId = GLUtils::loadProgram("flocking");
+    GLuint programId = GLUtils::createProgram(&FS_VERTEX, &FS_FRAGMENT);
+    if (programId == 0) {
+        return NULL;
+    }
+    return new BasicProgram(programId);
+}
+
+Matrix* FlockingScene::setUpModelMatrix() {
+    return new Matrix();
+}
+
+Matrix* FlockingScene::setUpViewMatrix() {
+    // Position the eye in front of the origin.
+    float eyeX = 0.0f;
+    float eyeY = 0.0f;
+    float eyeZ = 2.0f;
+
+    // We are looking at the origin
+    float centerX = 0.0f;
+    float centerY = 0.0f;
+    float centerZ = 0.0f;
+
+    // Set our up vector.
+    float upX = 0.0f;
+    float upY = 1.0f;
+    float upZ = 0.0f;
+
+    // Set the view matrix.
+    return Matrix::newLookAt(eyeX, eyeY, eyeZ, centerX, centerY, centerZ, upX, upY, upZ);
+}
+
+Matrix* FlockingScene::setUpProjectionMatrix() {
+    // Create a new perspective projection matrix. The height will stay the same
+    // while the width will vary as per aspect ratio.
+    mDisplayRatio = ((float) mWidth) / ((float) mHeight);
+    mBoardHeight = 1000.0f;
+    mBoardWidth = mDisplayRatio * mBoardHeight;
+    float left = -mDisplayRatio;
+    float right = mDisplayRatio;
+    float bottom = -1.0f;
+    float top = 1.0f;
+    float near = 1.0f;
+    float far = 3.0f;
+    // Set board dimensions
+
+    return Matrix::newFrustum(left, right, bottom, top, near, far);
+}
+
+bool FlockingScene::setUpTextures() {
+    SCOPED_TRACE();
+    mTextureIds.add(GLUtils::genTexture(256, 256, GLUtils::RANDOM_FILL));
+    mTextureIds.add(GLUtils::genTexture(1, 1, 0xc0c0c0));
+    // TODO Enable loading textures from file.
+    // mTextureIds.add(GLUtils::loadTexture("knight.jpg"));
+    return true;
+}
+
+bool FlockingScene::setUpMeshes() {
+    SCOPED_TRACE();
+    mMeshes.add(new Mesh(FS_VERTICES, FS_NORMALS, FS_TEX_COORDS, FS_NUM_VERTICES));
+    // TODO Enable loading meshes from file.
+    // mMeshes.add(GLUtils::loadMesh("knight.obj", mTextureIds[0]));
+    return true;
+}
+
+bool FlockingScene::tearDown() {
+    SCOPED_TRACE();
+    for (int i = 0; i < NUM_BOIDS; i++) {
+        delete mBoids[i];
+    }
+    return Scene::tearDown();
+}
+
+SceneGraphNode* FlockingScene::updateSceneGraph() {
+    const float MAIN_SCALE = 2.0f; // Scale up as the camera is far away.
+    const float LIMIT_X = mBoardWidth / 2.0f;
+    const float LIMIT_Y = mBoardHeight / 2.0f;
+    SceneGraphNode* sceneGraph = new ProgramNode();
+    Matrix* transformMatrix = Matrix::newScale(MAIN_SCALE * mDisplayRatio, MAIN_SCALE, MAIN_SCALE);
+    TransformationNode* transformNode = new TransformationNode(transformMatrix);
+    sceneGraph->addChild(transformNode);
+    BasicMeshNode* meshNode = new BasicMeshNode(mMeshes[0], mTextureIds[1]);
+    transformNode->addChild(meshNode);
+    for (int i = 0; i < NUM_BOIDS; i++) {
+        Boid* b = mBoids[i];
+        b->flock((const Boid**) &mBoids, NUM_BOIDS, i, LIMIT_X, LIMIT_Y);
+        Vector2D* pos = &(b->mPosition);
+        Vector2D* vel = &(b->mVelocity);
+
+        // Normalize to (-1,1)
+        float x = pos->mX / (LIMIT_X * BOID_SCALE) * mDisplayRatio;
+        float y = pos->mY / (LIMIT_Y * BOID_SCALE);
+
+        // TODO need to include rotation.
+        transformMatrix = Matrix::newScale(BOID_SCALE * MAIN_SCALE, BOID_SCALE * MAIN_SCALE, 1.0f);
+        transformMatrix->translate(x, y, 0.01f);
+        transformNode = new TransformationNode(transformMatrix);
+        sceneGraph->addChild(transformNode);
+        meshNode = new BasicMeshNode(mMeshes[0], mTextureIds[0]);
+        transformNode->addChild(meshNode);
+    }
+    return sceneGraph;
+}
diff --git a/suite/pts/deviceTests/opengl/jni/reference/scene/flocking/FlockingScene.h b/suite/pts/deviceTests/opengl/jni/reference/scene/flocking/FlockingScene.h
new file mode 100644
index 0000000..6433f94
--- /dev/null
+++ b/suite/pts/deviceTests/opengl/jni/reference/scene/flocking/FlockingScene.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2013 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.
+ */
+#ifndef FLOCKINGSCENE_H
+#define FLOCKINGSCENE_H
+
+#include "../Scene.h"
+#include "Boid.h"
+
+class FlockingScene : public Scene {
+public:
+    FlockingScene(int width, int height);
+    virtual ~FlockingScene() {};
+    bool setUpTextures();
+    bool setUpMeshes();
+    bool tearDown();
+    static const int NUM_BOIDS = 100;
+protected:
+    Program* setUpProgram();
+    Matrix* setUpModelMatrix();
+    Matrix* setUpViewMatrix();
+    Matrix* setUpProjectionMatrix();
+    SceneGraphNode* updateSceneGraph();
+private:
+    Boid* mBoids[NUM_BOIDS];
+    float mDisplayRatio;
+    float mBoardWidth;
+    float mBoardHeight;
+    static const float BOID_SCALE = 1.0f / 50.0f;
+};
+#endif
diff --git a/suite/pts/deviceTests/opengl/src/com/android/pts/opengl/reference/GLReferenceBenchmark.java b/suite/pts/deviceTests/opengl/src/com/android/pts/opengl/reference/GLReferenceBenchmark.java
index 14b247a..9c56e8e 100644
--- a/suite/pts/deviceTests/opengl/src/com/android/pts/opengl/reference/GLReferenceBenchmark.java
+++ b/suite/pts/deviceTests/opengl/src/com/android/pts/opengl/reference/GLReferenceBenchmark.java
@@ -31,13 +31,16 @@
  */
 public class GLReferenceBenchmark extends PtsActivityInstrumentationTestCase2<GLReferenceActivity> {
 
-    private static final int NUM_FRAMES = 100;
+    private static final int NUM_FRAMES_PER_SCENE = 500;
+    private static final int NUM_SCENES = 1;
+    private static final int NUM_FRAMES = NUM_FRAMES_PER_SCENE * NUM_SCENES;
     private static final int TIMEOUT = 1000000;
     // Reference values collected by averaging across n4, n7, n10.
-    private static final double NEXUS_REF_UI_LOAD = 40;// Milliseconds.
-    private static final double[] NEXUS_REF_SET_UP = {40, 0, 0, 0};// Milliseconds.
-    private static final double NEXUS_REF_UPDATE_AVG = 40;// Milliseconds.
-    private static final double NEXUS_REF_RENDER_AVG = 1;// As fraction of display refresh rate.
+    private static final double NEXUS_REF_UI_LOAD = 39.67f;// Milliseconds.
+    // (GL, Context, Textures, Meshes).
+    private static final double[] NEXUS_REF_SET_UP = {22.58f, 44.49f, 2.47f, 0.02f};// MS.
+    private static final double NEXUS_REF_UPDATE_AVG = 9.8f;// MS.
+    private static final double NEXUS_REF_RENDER_AVG = 0.44f;// Fraction of display refresh rate.
 
     public GLReferenceBenchmark() {
         super(GLReferenceActivity.class);
@@ -117,10 +120,16 @@
                             "Set Up Score", setUpScore, ResultType.HIGHER_BETTER, ResultUnit.SCORE);
                     getReportLog().printArray(
                             "Update Times", updateTimes, ResultType.LOWER_BETTER, ResultUnit.MS);
+                    getReportLog().printValue(
+                            "Update Time Average", updateAverage, ResultType.LOWER_BETTER,
+                            ResultUnit.MS);
                     getReportLog().printValue("Update Score", updateScore, ResultType.HIGHER_BETTER,
                             ResultUnit.SCORE);
                     getReportLog().printArray(
                             "Render Times", renderTimes, ResultType.LOWER_BETTER, ResultUnit.MS);
+                    getReportLog().printValue(
+                            "Render Time Average", renderAverage, ResultType.LOWER_BETTER,
+                            ResultUnit.MS);
                     getReportLog().printValue("Render Score", renderScore, ResultType.HIGHER_BETTER,
                             ResultUnit.SCORE);
                     getReportLog().printValue(
diff --git a/tests/accessibilityservice/res/xml/accessibilityservice.xml b/tests/accessibilityservice/res/xml/accessibilityservice.xml
index 69e0651..6d48f9b 100644
--- a/tests/accessibilityservice/res/xml/accessibilityservice.xml
+++ b/tests/accessibilityservice/res/xml/accessibilityservice.xml
@@ -18,6 +18,6 @@
     android:accessibilityFeedbackType="feedbackGeneric"
     android:accessibilityFlags="flagDefault|flagRequestTouchExplorationMode"
     android:canRetrieveWindowContent="true"
-    android:notificationTimeout="50"
+    android:notificationTimeout="0"
     android:settingsActivity="android.accessibilityservice.delegate.SomeActivity"
     android:description="@string/title_delegating_accessibility_service" />
diff --git a/tests/src/android/renderscript/cts/global_sync.rs b/tests/src/android/renderscript/cts/global_sync.rs
new file mode 100644
index 0000000..c947fa2
--- /dev/null
+++ b/tests/src/android/renderscript/cts/global_sync.rs
@@ -0,0 +1,32 @@
+#pragma version(1)
+#pragma rs java_package_name(android.renderscript.cts)
+
+int gInt;
+static int sInt;
+
+rs_allocation aFailed;
+
+void test_global(int expected) {
+    if (gInt != expected) {
+        rsSetElementAt_uchar(aFailed, 1, 0);
+    }
+}
+
+void test_static_global(int expected) {
+    if (sInt != expected) {
+        rsSetElementAt_uchar(aFailed, 1, 0);
+    }
+}
+
+void __attribute__((kernel)) write_global(int ain, uint32_t x) {
+    if (x == 0) {
+        gInt = ain;
+    }
+}
+
+void __attribute__((kernel)) write_static_global(int ain, uint32_t x) {
+    if (x == 0) {
+        sInt = ain;
+    }
+}
+
diff --git a/tests/src/android/renderscript/cts/large_global.rs b/tests/src/android/renderscript/cts/large_global.rs
new file mode 100644
index 0000000..3f2da69
--- /dev/null
+++ b/tests/src/android/renderscript/cts/large_global.rs
@@ -0,0 +1,24 @@
+// Copyright (C) 2013 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.
+
+#pragma version(1)
+#pragma rs java_package_name(android.renderscript.cts)
+
+char buf[2*1024*1024];
+
+// Never called, just present to ensure that buf does not get optimized away.
+void __attribute__((kernel)) root(char c) {
+    buf[0] = c;
+}
+
diff --git a/tests/tests/accessibilityservice/src/android/accessibilityservice/cts/AccessibilityActivityTestCase.java b/tests/tests/accessibilityservice/src/android/accessibilityservice/cts/AccessibilityActivityTestCase.java
index a5d92ee..affc9ec 100644
--- a/tests/tests/accessibilityservice/src/android/accessibilityservice/cts/AccessibilityActivityTestCase.java
+++ b/tests/tests/accessibilityservice/src/android/accessibilityservice/cts/AccessibilityActivityTestCase.java
@@ -66,7 +66,7 @@
     /**
      * The timeout after the last accessibility event to consider the device idle.
      */
-    public static final long TIMEOUT_ACCESSIBILITY_STATE_IDLE = 100;
+    public static final long TIMEOUT_ACCESSIBILITY_STATE_IDLE = 200;
 
     /**
      * Instance for detecting the next accessibility event.
@@ -130,9 +130,12 @@
             public boolean accept(AccessibilityEvent event) {
                 final int eventType = event.getEventType();
                 CharSequence packageName = event.getPackageName();
-                Context targetContext = getInstrumentation().getTargetContext();
-                return (eventType == AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED
-                        && targetContext.getPackageName().equals(packageName));
+                // Do not check the package name since an event of this type may
+                // come concurrently from the app and from the IME (since input
+                // focus goes to the first focusable) but we dispatch one event
+                // of each type within a timeout. Hence, sometimes the window
+                // change event from the IME may override the one from the app.
+                return (eventType == AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED);
             }
         },
         TIMEOUT_ASYNC_PROCESSING);
@@ -520,6 +523,8 @@
                 mEventQueue.clear();
                 // Prepare to wait for an event.
                 mWaitingForEventDelivery = true;
+                // We will ignore events from previous interactions.
+                final long executionStartTimeMillis = SystemClock.uptimeMillis();
                 // Execute the command.
                 command.run();
                 try {
@@ -529,11 +534,16 @@
                         // Drain the event queue
                         while (!mEventQueue.isEmpty()) {
                             AccessibilityEvent event = mEventQueue.remove(0);
+
+                            // Ignore events from previous interactions.
+                            if (event.getEventTime() < executionStartTimeMillis) {
+                                continue;
+                            }
                             if (filter.accept(event)) {
                                 return event;
-                            } else {
-                                event.recycle();
                             }
+                            
+                            event.recycle();
                         }
                         // Check if timed out and if not wait.
                         final long elapsedTimeMillis = SystemClock.uptimeMillis() - startTimeMillis;
diff --git a/tests/tests/accessibilityservice/src/android/accessibilityservice/cts/AccessibilityServiceInfoTest.java b/tests/tests/accessibilityservice/src/android/accessibilityservice/cts/AccessibilityServiceInfoTest.java
index 1d28470..ad2dca4 100644
--- a/tests/tests/accessibilityservice/src/android/accessibilityservice/cts/AccessibilityServiceInfoTest.java
+++ b/tests/tests/accessibilityservice/src/android/accessibilityservice/cts/AccessibilityServiceInfoTest.java
@@ -113,7 +113,7 @@
         assertSame(AccessibilityServiceInfo.DEFAULT
                 | AccessibilityServiceInfo.FLAG_REQUEST_TOUCH_EXPLORATION_MODE,
                 speakingService.flags);
-        assertSame(50l, speakingService.notificationTimeout);
+        assertSame(0l, speakingService.notificationTimeout);
         assertEquals("Delegating Accessibility Service", speakingService.getDescription());
         assertNull(speakingService.packageNames /*all packages*/);
         assertNotNull(speakingService.getId());
diff --git a/tests/tests/accessibilityservice/src/android/accessibilityservice/cts/AccessibilityTextTraversalTest.java b/tests/tests/accessibilityservice/src/android/accessibilityservice/cts/AccessibilityTextTraversalTest.java
index 17c7ebd..c8f8a48 100644
--- a/tests/tests/accessibilityservice/src/android/accessibilityservice/cts/AccessibilityTextTraversalTest.java
+++ b/tests/tests/accessibilityservice/src/android/accessibilityservice/cts/AccessibilityTextTraversalTest.java
@@ -1246,6 +1246,261 @@
     }
 
     @MediumTest
+    public void testActionNextAndPreviousAtGranularityWordOverEditTextWithContentDescription()
+            throws Exception {
+
+        final EditText editText = (EditText) getActivity().findViewById(R.id.edit);
+
+        getInstrumentation().runOnMainSync(new Runnable() {
+            @Override
+            public void run() {
+                editText.setText(getString(R.string.foo_bar_baz));
+                editText.setContentDescription(getString(R.string.android_wiki));
+            }
+        });
+
+        final AccessibilityNodeInfo text = getInteractionBridge()
+               .findAccessibilityNodeInfoByTextFromRoot(getString(R.string.foo_bar_baz));
+
+        final int granularities = text.getMovementGranularities();
+        assertEquals(granularities, AccessibilityNodeInfo.MOVEMENT_GRANULARITY_CHARACTER
+                | AccessibilityNodeInfo.MOVEMENT_GRANULARITY_WORD
+                | AccessibilityNodeInfo.MOVEMENT_GRANULARITY_LINE
+                | AccessibilityNodeInfo.MOVEMENT_GRANULARITY_PARAGRAPH
+                | AccessibilityNodeInfo.MOVEMENT_GRANULARITY_PAGE);
+
+        final Bundle arguments = new Bundle();
+        arguments.putInt(AccessibilityNodeInfo.ACTION_ARGUMENT_MOVEMENT_GRANULARITY_INT,
+                AccessibilityNodeInfo.MOVEMENT_GRANULARITY_WORD);
+
+        // Move to the next word and wait for an event.
+        AccessibilityEvent firstExpected = getInteractionBridge()
+                .executeCommandAndWaitForAccessibilityEvent(new Runnable() {
+            @Override
+            public void run() {
+                getInteractionBridge().performAction(text,
+                        AccessibilityNodeInfo.ACTION_NEXT_AT_MOVEMENT_GRANULARITY, arguments);
+            }
+        }, new AccessibilityEventFilter() {
+            @Override
+            public boolean accept(AccessibilityEvent event) {
+                return
+                (event.getEventType() ==
+                    AccessibilityEvent.TYPE_VIEW_TEXT_TRAVERSED_AT_MOVEMENT_GRANULARITY
+                        && event.getAction() ==
+                                AccessibilityNodeInfo.ACTION_NEXT_AT_MOVEMENT_GRANULARITY
+                        && event.getPackageName().equals(getActivity().getPackageName())
+                        && event.getClassName().equals(EditText.class.getName())
+                        && event.getText().size() > 0
+                        && event.getText().get(0).toString().equals(getString(R.string.foo_bar_baz))
+                        && event.getContentDescription().equals(getString(R.string.android_wiki))
+                        && event.getFromIndex() == 0
+                        && event.getToIndex() == 3
+                        && event.getMovementGranularity() ==
+                                AccessibilityNodeInfo.MOVEMENT_GRANULARITY_WORD);
+            }
+        }, TIMEOUT_ASYNC_PROCESSING);
+
+        // Make sure we got the expected event.
+        assertNotNull(firstExpected);
+
+        // Verify the selection position.
+        assertEquals(3, editText.getSelectionStart());
+        assertEquals(3, editText.getSelectionEnd());
+
+        // Move to the next word and wait for an event.
+        AccessibilityEvent secondExpected = getInteractionBridge()
+                .executeCommandAndWaitForAccessibilityEvent(new Runnable() {
+            @Override
+            public void run() {
+                getInteractionBridge().performAction(text,
+                        AccessibilityNodeInfo.ACTION_NEXT_AT_MOVEMENT_GRANULARITY, arguments);
+            }
+        }, new AccessibilityEventFilter() {
+            @Override
+            public boolean accept(AccessibilityEvent event) {
+                return
+                (event.getEventType() ==
+                    AccessibilityEvent.TYPE_VIEW_TEXT_TRAVERSED_AT_MOVEMENT_GRANULARITY
+                        && event.getAction() ==
+                                AccessibilityNodeInfo.ACTION_NEXT_AT_MOVEMENT_GRANULARITY
+                        && event.getPackageName().equals(getActivity().getPackageName())
+                        && event.getClassName().equals(EditText.class.getName())
+                        && event.getText().size() > 0
+                        && event.getText().get(0).toString().equals(getString(R.string.foo_bar_baz))
+                        && event.getContentDescription().equals(getString(R.string.android_wiki))
+                        && event.getFromIndex() == 4
+                        && event.getToIndex() == 7
+                        && event.getMovementGranularity() ==
+                                AccessibilityNodeInfo.MOVEMENT_GRANULARITY_WORD);
+            }
+        }, TIMEOUT_ASYNC_PROCESSING);
+
+        // Make sure we got the expected event.
+        assertNotNull(secondExpected);
+
+        // Verify the selection position.
+        assertEquals(7, editText.getSelectionStart());
+        assertEquals(7, editText.getSelectionEnd());
+
+        // Move to the next word and wait for an event.
+        AccessibilityEvent thirdExpected = getInteractionBridge()
+                .executeCommandAndWaitForAccessibilityEvent(new Runnable() {
+            @Override
+            public void run() {
+                getInteractionBridge().performAction(text,
+                        AccessibilityNodeInfo.ACTION_NEXT_AT_MOVEMENT_GRANULARITY, arguments);
+            }
+        }, new AccessibilityEventFilter() {
+            @Override
+            public boolean accept(AccessibilityEvent event) {
+                return
+                (event.getEventType() ==
+                    AccessibilityEvent.TYPE_VIEW_TEXT_TRAVERSED_AT_MOVEMENT_GRANULARITY
+                        && event.getAction() ==
+                                AccessibilityNodeInfo.ACTION_NEXT_AT_MOVEMENT_GRANULARITY
+                        && event.getPackageName().equals(getActivity().getPackageName())
+                        && event.getClassName().equals(EditText.class.getName())
+                        && event.getText().size() > 0
+                        && event.getText().get(0).toString().equals(getString(R.string.foo_bar_baz))
+                        && event.getContentDescription().equals(getString(R.string.android_wiki))
+                        && event.getFromIndex() == 8
+                        && event.getToIndex() == 11
+                        && event.getMovementGranularity() ==
+                                 AccessibilityNodeInfo.MOVEMENT_GRANULARITY_WORD);
+            }
+        }, TIMEOUT_ASYNC_PROCESSING);
+
+        // Make sure we got the expected event.
+        assertNotNull(thirdExpected);
+
+        // Verify the selection position.
+        assertEquals(11, editText.getSelectionStart());
+        assertEquals(11, editText.getSelectionEnd());
+
+        // Make sure there is no next.
+        assertFalse(getInteractionBridge().performAction(text,
+                AccessibilityNodeInfo.ACTION_NEXT_AT_MOVEMENT_GRANULARITY, arguments));
+
+        // Verify the selection position.
+        assertEquals(11, editText.getSelectionStart());
+        assertEquals(11, editText.getSelectionEnd());
+
+        // Move to the next word and wait for an event.
+        AccessibilityEvent fourthExpected = getInteractionBridge()
+                .executeCommandAndWaitForAccessibilityEvent(new Runnable() {
+            @Override
+            public void run() {
+                getInteractionBridge().performAction(text,
+                        AccessibilityNodeInfo.ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY, arguments);
+            }
+        }, new AccessibilityEventFilter() {
+            @Override
+            public boolean accept(AccessibilityEvent event) {
+                return
+                (event.getEventType() ==
+                    AccessibilityEvent.TYPE_VIEW_TEXT_TRAVERSED_AT_MOVEMENT_GRANULARITY
+                        && event.getAction() ==
+                                AccessibilityNodeInfo.ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY
+                        && event.getPackageName().equals(getActivity().getPackageName())
+                        && event.getClassName().equals(EditText.class.getName())
+                        && event.getText().size() > 0
+                        && event.getText().get(0).toString().equals(getString(R.string.foo_bar_baz))
+                        && event.getContentDescription().equals(getString(R.string.android_wiki))
+                        && event.getFromIndex() == 8
+                        && event.getToIndex() == 11
+                        && event.getMovementGranularity() ==
+                                AccessibilityNodeInfo.MOVEMENT_GRANULARITY_WORD);
+            }
+        }, TIMEOUT_ASYNC_PROCESSING);
+
+        // Make sure we got the expected event.
+        assertNotNull(fourthExpected);
+
+        // Verify the selection position.
+        assertEquals(8, editText.getSelectionStart());
+        assertEquals(8, editText.getSelectionEnd());
+
+        // Move to the next word and wait for an event.
+        AccessibilityEvent fifthExpected = getInteractionBridge()
+                .executeCommandAndWaitForAccessibilityEvent(new Runnable() {
+            @Override
+            public void run() {
+                getInteractionBridge().performAction(text,
+                        AccessibilityNodeInfo.ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY, arguments);
+            }
+        }, new AccessibilityEventFilter() {
+            @Override
+            public boolean accept(AccessibilityEvent event) {
+                return
+                (event.getEventType() ==
+                    AccessibilityEvent.TYPE_VIEW_TEXT_TRAVERSED_AT_MOVEMENT_GRANULARITY
+                        && event.getAction() ==
+                                AccessibilityNodeInfo.ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY
+                        && event.getPackageName().equals(getActivity().getPackageName())
+                        && event.getClassName().equals(EditText.class.getName())
+                        && event.getText().size() > 0
+                        && event.getText().get(0).toString().equals(getString(R.string.foo_bar_baz))
+                        && event.getContentDescription().equals(getString(R.string.android_wiki))
+                        && event.getFromIndex() == 4
+                        && event.getToIndex() == 7
+                        && event.getMovementGranularity() ==
+                                AccessibilityNodeInfo.MOVEMENT_GRANULARITY_WORD);
+            }
+        }, TIMEOUT_ASYNC_PROCESSING);
+
+        // Make sure we got the expected event.
+        assertNotNull(fifthExpected);
+
+        // Verify the selection position.
+        assertEquals(4, editText.getSelectionStart());
+        assertEquals(4, editText.getSelectionEnd());
+
+        // Move to the next character and wait for an event.
+        AccessibilityEvent sixthExpected = getInteractionBridge()
+                .executeCommandAndWaitForAccessibilityEvent(new Runnable() {
+            @Override
+            public void run() {
+                getInteractionBridge().performAction(text,
+                        AccessibilityNodeInfo.ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY, arguments);
+            }
+        }, new AccessibilityEventFilter() {
+            @Override
+            public boolean accept(AccessibilityEvent event) {
+                return
+                (event.getEventType() ==
+                    AccessibilityEvent.TYPE_VIEW_TEXT_TRAVERSED_AT_MOVEMENT_GRANULARITY
+                        && event.getAction() ==
+                                AccessibilityNodeInfo.ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY
+                        && event.getPackageName().equals(getActivity().getPackageName())
+                        && event.getClassName().equals(EditText.class.getName())
+                        && event.getText().size() > 0
+                        && event.getText().get(0).toString().equals(getString(R.string.foo_bar_baz))
+                        && event.getContentDescription().equals(getString(R.string.android_wiki))
+                        && event.getFromIndex() == 0
+                        && event.getToIndex() == 3
+                        && event.getMovementGranularity() ==
+                                AccessibilityNodeInfo.MOVEMENT_GRANULARITY_WORD);
+            }
+        }, TIMEOUT_ASYNC_PROCESSING);
+
+        // Make sure we got the expected event.
+        assertNotNull(sixthExpected);
+
+        // Verify the selection position.
+        assertEquals(0, editText.getSelectionStart());
+        assertEquals(0, editText.getSelectionEnd());
+
+        // Make sure there is no previous.
+        assertFalse(getInteractionBridge().performAction(text,
+                AccessibilityNodeInfo.ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY, arguments));
+
+        // Verify the selection position.
+        assertEquals(0, editText.getSelectionStart());
+        assertEquals(0, editText.getSelectionEnd());
+    }
+    
+    @MediumTest
     public void testActionNextAndPreviousAtGranularityWordOverTextExtend() throws Exception {
         final EditText editText = (EditText) getActivity().findViewById(R.id.edit);
 
diff --git a/tests/tests/media/res/raw/loudsoftaac.aac b/tests/tests/media/res/raw/loudsoftaac.aac
new file mode 100644
index 0000000..1534ef2
--- /dev/null
+++ b/tests/tests/media/res/raw/loudsoftaac.aac
Binary files differ
diff --git a/tests/tests/media/res/raw/loudsoftfaac.m4a b/tests/tests/media/res/raw/loudsoftfaac.m4a
new file mode 100644
index 0000000..b4895b5
--- /dev/null
+++ b/tests/tests/media/res/raw/loudsoftfaac.m4a
Binary files differ
diff --git a/tests/tests/media/res/raw/loudsoftitunes.m4a b/tests/tests/media/res/raw/loudsoftitunes.m4a
new file mode 100644
index 0000000..b01b36b
--- /dev/null
+++ b/tests/tests/media/res/raw/loudsoftitunes.m4a
Binary files differ
diff --git a/tests/tests/media/res/raw/loudsoftmp3.mp3 b/tests/tests/media/res/raw/loudsoftmp3.mp3
new file mode 100644
index 0000000..b32c8bd
--- /dev/null
+++ b/tests/tests/media/res/raw/loudsoftmp3.mp3
Binary files differ
diff --git a/tests/tests/media/res/raw/loudsoftogg.ogg b/tests/tests/media/res/raw/loudsoftogg.ogg
new file mode 100644
index 0000000..dc122d9
--- /dev/null
+++ b/tests/tests/media/res/raw/loudsoftogg.ogg
Binary files differ
diff --git a/tests/tests/media/res/raw/loudsoftwav.wav b/tests/tests/media/res/raw/loudsoftwav.wav
new file mode 100644
index 0000000..9930dcb
--- /dev/null
+++ b/tests/tests/media/res/raw/loudsoftwav.wav
Binary files differ
diff --git a/tests/tests/media/src/android/media/cts/DecoderTest.java b/tests/tests/media/src/android/media/cts/DecoderTest.java
index 54a670d..ab7410b 100644
--- a/tests/tests/media/src/android/media/cts/DecoderTest.java
+++ b/tests/tests/media/src/android/media/cts/DecoderTest.java
@@ -30,17 +30,37 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.ByteBuffer;
+import java.util.Arrays;
 import java.util.zip.CRC32;
 
 public class DecoderTest extends MediaPlayerTestBase {
     private static final String TAG = "DecoderTest";
 
     private Resources mResources;
+    short[] mMasterBuffer;
 
     @Override
     protected void setUp() throws Exception {
         super.setUp();
         mResources = mContext.getResources();
+
+        // read master file into memory
+        AssetFileDescriptor masterFd = mResources.openRawResourceFd(R.raw.sinesweepraw);
+        long masterLength = masterFd.getLength();
+        mMasterBuffer = new short[(int) (masterLength / 2)];
+        InputStream is = masterFd.createInputStream();
+        BufferedInputStream bis = new BufferedInputStream(is);
+        for (int i = 0; i < mMasterBuffer.length; i++) {
+            int lo = bis.read();
+            int hi = bis.read();
+            if (hi >= 128) {
+                hi -= 256;
+            }
+            int sample = hi * 256 + lo;
+            mMasterBuffer[i] = (short) sample;
+        }
+        bis.close();
+        masterFd.close();
     }
 
     // The allowed errors in the following tests are the actual maximum measured
@@ -48,22 +68,22 @@
     // This should allow for some variation in decoders, while still detecting
     // phase and delay errors, channel swap, etc.
     public void testDecodeMp3Lame() throws Exception {
-        decode(R.raw.sinesweepmp3lame, R.raw.sinesweepraw, 804.f);
+        decode(R.raw.sinesweepmp3lame, 804.f);
     }
     public void testDecodeMp3Smpb() throws Exception {
-        decode(R.raw.sinesweepmp3smpb, R.raw.sinesweepraw, 413.f);
+        decode(R.raw.sinesweepmp3smpb, 413.f);
     }
     public void testDecodeM4a() throws Exception {
-        decode(R.raw.sinesweepm4a, R.raw.sinesweepraw, 124.f);
+        decode(R.raw.sinesweepm4a, 124.f);
     }
     public void testDecodeOgg() throws Exception {
-        decode(R.raw.sinesweepogg, R.raw.sinesweepraw, 168.f);
+        decode(R.raw.sinesweepogg, 168.f);
     }
     public void testDecodeWav() throws Exception {
-        decode(R.raw.sinesweepwav, R.raw.sinesweepraw, 0.0f);
+        decode(R.raw.sinesweepwav, 0.0f);
     }
     public void testDecodeFlac() throws Exception {
-        decode(R.raw.sinesweepflac, R.raw.sinesweepraw, 0.0f);
+        decode(R.raw.sinesweepflac, 0.0f);
     }
 
     /**
@@ -72,25 +92,30 @@
      * @param maxerror the maximum allowed root mean squared error
      * @throws IOException
      */
-    private void decode(int testinput, int master, float maxerror) throws IOException {
+    private void decode(int testinput, float maxerror) throws IOException {
 
-        // read master file into memory
-        AssetFileDescriptor masterFd = mResources.openRawResourceFd(master);
-        long masterLength = masterFd.getLength();
-        short[] masterBuffer = new short[(int) (masterLength / 2)];
-        InputStream is = masterFd.createInputStream();
-        BufferedInputStream bis = new BufferedInputStream(is);
-        for (int i = 0; i < masterBuffer.length; i++) {
-            int lo = bis.read();
-            int hi = bis.read();
-            if (hi >= 128) {
-                hi -= 256;
-            }
-            int sample = hi * 256 + lo;
-            masterBuffer[i] = (short) sample;
+        short [] decoded = decodeToMemory(testinput);
+
+        assertEquals("wrong data size", mMasterBuffer.length, decoded.length);
+
+        long totalErrorSquared = 0;
+
+        for (int i = 0; i < decoded.length; i++) {
+            short sample = decoded[i];
+            short mastersample = mMasterBuffer[i];
+            int d = sample - mastersample;
+            totalErrorSquared += d * d;
         }
-        bis.close();
-        masterFd.close();
+
+        long avgErrorSquared = (totalErrorSquared / decoded.length);
+        double rmse = Math.sqrt(avgErrorSquared);
+        assertTrue("decoding error too big: " + rmse, rmse <= maxerror);
+     }
+
+    private short[] decodeToMemory(int testinput) throws IOException {
+
+        short [] decoded = new short[1024];
+        int decodedIdx = 0;
 
         AssetFileDescriptor testFd = mResources.openRawResourceFd(testinput);
 
@@ -118,9 +143,6 @@
         extractor.selectTrack(0);
 
         // start decoding
-        int numBytesDecoded = 0;
-        int maxdelta = 0;
-        long totalErrorSquared = 0;
         final long kTimeOutUs = 5000;
         MediaCodec.BufferInfo info = new MediaCodec.BufferInfo();
         boolean sawInputEOS = false;
@@ -164,17 +186,13 @@
                 int outputBufIndex = res;
                 ByteBuffer buf = codecOutputBuffers[outputBufIndex];
 
-                // check the waveform matches within the specified max error
-                for (int i = 0; i < info.size; i += 2) {
-                    short sample = buf.getShort(i);
-                    int idx = (numBytesDecoded + i) / 2;
-                    assertTrue("decoder returned too much data", idx < masterBuffer.length);
-                    short mastersample = masterBuffer[idx];
-                    int d = sample - mastersample;
-                    totalErrorSquared += d * d;
+                if (decodedIdx + (info.size / 2) >= decoded.length) {
+                    decoded = Arrays.copyOf(decoded, decodedIdx + (info.size / 2));
                 }
 
-                numBytesDecoded += info.size;
+                for (int i = 0; i < info.size; i += 2) {
+                    decoded[decodedIdx++] = buf.getShort(i);
+                }
 
                 codec.releaseOutputBuffer(outputBufIndex, false /* render */);
 
@@ -195,11 +213,7 @@
 
         codec.stop();
         codec.release();
-
-        assertEquals("wrong data size", masterLength, numBytesDecoded);
-        long avgErrorSquared = (totalErrorSquared / (numBytesDecoded / 2));
-        double rmse = Math.sqrt(avgErrorSquared); 
-        assertTrue("decoding error too big: " + rmse, rmse <= maxerror);
+        return decoded;
     }
 
     public void testCodecBasicH264() throws Exception {
@@ -691,5 +705,110 @@
         return crc.getValue();
     }
 
+    public void testFlush() throws Exception {
+        testFlush(R.raw.loudsoftwav);
+        testFlush(R.raw.loudsoftogg);
+        testFlush(R.raw.loudsoftmp3);
+        testFlush(R.raw.loudsoftaac);
+        testFlush(R.raw.loudsoftfaac);
+        testFlush(R.raw.loudsoftitunes);
+    }
+
+    private void testFlush(int resource) throws Exception {
+
+        AssetFileDescriptor testFd = mResources.openRawResourceFd(resource);
+
+        MediaExtractor extractor;
+        MediaCodec codec;
+        ByteBuffer[] codecInputBuffers;
+        ByteBuffer[] codecOutputBuffers;
+
+        extractor = new MediaExtractor();
+        extractor.setDataSource(testFd.getFileDescriptor(), testFd.getStartOffset(),
+                testFd.getLength());
+        testFd.close();
+
+        assertEquals("wrong number of tracks", 1, extractor.getTrackCount());
+        MediaFormat format = extractor.getTrackFormat(0);
+        String mime = format.getString(MediaFormat.KEY_MIME);
+        assertTrue("not an audio file", mime.startsWith("audio/"));
+
+        codec = MediaCodec.createDecoderByType(mime);
+        codec.configure(format, null /* surface */, null /* crypto */, 0 /* flags */);
+        codec.start();
+        codecInputBuffers = codec.getInputBuffers();
+        codecOutputBuffers = codec.getOutputBuffers();
+
+        extractor.selectTrack(0);
+
+        // decode a bit of the first part of the file, and verify the amplitude
+        short maxvalue1 = getAmplitude(extractor, codec);
+
+        // flush the codec and seek the extractor a different position, then decode a bit more
+        // and check the amplitude
+        extractor.seekTo(8000000, 0);
+        codec.flush();
+        short maxvalue2 = getAmplitude(extractor, codec);
+
+        assertTrue(maxvalue1 > 20000);
+        assertTrue(maxvalue2 < 5000);
+        codec.stop();
+        codec.release();
+
+    }
+    
+    private short getAmplitude(MediaExtractor extractor, MediaCodec codec) {
+        short maxvalue = 0;
+        int numBytesDecoded = 0;
+        final long kTimeOutUs = 5000;
+        ByteBuffer[] codecInputBuffers = codec.getInputBuffers();
+        ByteBuffer[] codecOutputBuffers = codec.getOutputBuffers();
+        MediaCodec.BufferInfo info = new MediaCodec.BufferInfo();
+
+        while(numBytesDecoded < 44100 * 2) {
+            int inputBufIndex = codec.dequeueInputBuffer(kTimeOutUs);
+
+            if (inputBufIndex >= 0) {
+                ByteBuffer dstBuf = codecInputBuffers[inputBufIndex];
+
+                int sampleSize = extractor.readSampleData(dstBuf, 0 /* offset */);
+                long presentationTimeUs = extractor.getSampleTime();
+
+                codec.queueInputBuffer(
+                        inputBufIndex,
+                        0 /* offset */,
+                        sampleSize,
+                        presentationTimeUs,
+                        0 /* flags */);
+
+                extractor.advance();
+            }
+            int res = codec.dequeueOutputBuffer(info, kTimeOutUs);
+
+            if (res >= 0) {
+
+                int outputBufIndex = res;
+                ByteBuffer buf = codecOutputBuffers[outputBufIndex];
+
+                for (int i = 0; i < info.size; i += 2) {
+                    short sample = buf.getShort(i);
+                    if (maxvalue < sample) {
+                        maxvalue = sample;
+                    }
+                    int idx = (numBytesDecoded + i) / 2;
+                }
+
+                numBytesDecoded += info.size;
+
+                codec.releaseOutputBuffer(outputBufIndex, false /* render */);
+            } else if (res == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
+                codecOutputBuffers = codec.getOutputBuffers();
+            } else if (res == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
+                MediaFormat oformat = codec.getOutputFormat();
+            }
+        }
+        return maxvalue; 
+    }
+    
 }
 
diff --git a/tests/tests/media/src/android/media/cts/MediaMuxerTest.java b/tests/tests/media/src/android/media/cts/MediaMuxerTest.java
index b44321c..42ae7a7 100644
--- a/tests/tests/media/src/android/media/cts/MediaMuxerTest.java
+++ b/tests/tests/media/src/android/media/cts/MediaMuxerTest.java
@@ -295,7 +295,7 @@
      * makes sure the samples match.
      */
     private void verifySamplesMatch(int srcMedia, String testMediaPath,
-            int seekToUs) {
+            int seekToUs) throws IOException {
         AssetFileDescriptor testFd = mResources.openRawResourceFd(srcMedia);
         MediaExtractor extractorSrc = new MediaExtractor();
         extractorSrc.setDataSource(testFd.getFileDescriptor(),
diff --git a/tests/tests/net/src/android/net/cts/ConnectivityManagerTest.java b/tests/tests/net/src/android/net/cts/ConnectivityManagerTest.java
index 4fa69a8..c244159 100644
--- a/tests/tests/net/src/android/net/cts/ConnectivityManagerTest.java
+++ b/tests/tests/net/src/android/net/cts/ConnectivityManagerTest.java
@@ -23,6 +23,7 @@
 import android.content.IntentFilter;
 import android.content.pm.PackageManager;
 import android.net.ConnectivityManager;
+import android.net.NetworkConfig;
 import android.net.NetworkInfo;
 import android.net.NetworkInfo.DetailedState;
 import android.net.NetworkInfo.State;
@@ -30,7 +31,10 @@
 import android.test.AndroidTestCase;
 import android.util.Log;
 
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
@@ -51,6 +55,9 @@
     private ConnectivityManager mCm;
     private WifiManager mWifiManager;
     private PackageManager mPackageManager;
+    private final HashMap<Integer, NetworkConfig> mNetworks =
+            new HashMap<Integer, NetworkConfig>();
+    private final List<Integer>mProtectedNetworks = new ArrayList<Integer>();
 
     @Override
     protected void setUp() throws Exception {
@@ -58,45 +65,115 @@
         mCm = (ConnectivityManager) getContext().getSystemService(Context.CONNECTIVITY_SERVICE);
         mWifiManager = (WifiManager) getContext().getSystemService(Context.WIFI_SERVICE);
         mPackageManager = getContext().getPackageManager();
-    }
 
-    public void testGetNetworkInfo() {
-        assertTrue(mCm.getAllNetworkInfo().length >= MIN_NUM_NETWORK_TYPES);
-        NetworkInfo ni = mCm.getNetworkInfo(TYPE_WIFI);
-        if (ni != null) {
-            State state = ni.getState();
-            assertTrue(State.UNKNOWN.ordinal() >= state.ordinal()
-                       && state.ordinal() >= State.CONNECTING.ordinal());
-            DetailedState ds = ni.getDetailedState();
-            assertTrue(DetailedState.FAILED.ordinal() >= ds.ordinal()
-                       && ds.ordinal() >= DetailedState.IDLE.ordinal());
+        String[] naStrings = getContext().getResources().getStringArray(
+                com.android.internal.R.array.networkAttributes);
+        for (String naString : naStrings) {
+            try {
+                NetworkConfig n = new NetworkConfig(naString);
+                mNetworks.put(n.type, n);
+            } catch (Exception e) {}
         }
-        ni = mCm.getNetworkInfo(TYPE_MOBILE);
-        if (ni != null) {
-            State state = ni.getState();
-            assertTrue(State.UNKNOWN.ordinal() >= state.ordinal()
-                    && state.ordinal() >= State.CONNECTING.ordinal());
-            DetailedState ds = ni.getDetailedState();
-            assertTrue(DetailedState.FAILED.ordinal() >= ds.ordinal()
-                    && ds.ordinal() >= DetailedState.IDLE.ordinal());
+
+        int[] protectedNetworks = getContext().getResources().getIntArray(
+                com.android.internal.R.array.config_protectedNetworks);
+        for (int p : protectedNetworks) {
+            mProtectedNetworks.add(p);
         }
-        ni = mCm.getNetworkInfo(-1);
-        assertNull(ni);
     }
 
     public void testIsNetworkTypeValid() {
+        assertTrue(ConnectivityManager.isNetworkTypeValid(ConnectivityManager.TYPE_MOBILE));
+        assertTrue(ConnectivityManager.isNetworkTypeValid(ConnectivityManager.TYPE_WIFI));
+        assertTrue(ConnectivityManager.isNetworkTypeValid(ConnectivityManager.TYPE_MOBILE_MMS));
+        assertTrue(ConnectivityManager.isNetworkTypeValid(ConnectivityManager.TYPE_MOBILE_SUPL));
+        assertTrue(ConnectivityManager.isNetworkTypeValid(ConnectivityManager.TYPE_MOBILE_DUN));
+        assertTrue(ConnectivityManager.isNetworkTypeValid(ConnectivityManager.TYPE_MOBILE_HIPRI));
+        assertTrue(ConnectivityManager.isNetworkTypeValid(ConnectivityManager.TYPE_WIMAX));
+        assertTrue(ConnectivityManager.isNetworkTypeValid(ConnectivityManager.TYPE_BLUETOOTH));
+        assertTrue(ConnectivityManager.isNetworkTypeValid(ConnectivityManager.TYPE_DUMMY));
+        assertTrue(ConnectivityManager.isNetworkTypeValid(ConnectivityManager.TYPE_ETHERNET));
+        assertTrue(mCm.isNetworkTypeValid(ConnectivityManager.TYPE_MOBILE_FOTA));
+        assertTrue(mCm.isNetworkTypeValid(ConnectivityManager.TYPE_MOBILE_IMS));
+        assertTrue(mCm.isNetworkTypeValid(ConnectivityManager.TYPE_MOBILE_CBS));
+        assertTrue(mCm.isNetworkTypeValid(ConnectivityManager.TYPE_WIFI_P2P));
+        assertFalse(mCm.isNetworkTypeValid(-1));
+        assertTrue(mCm.isNetworkTypeValid(0));
+        assertTrue(mCm.isNetworkTypeValid(ConnectivityManager.MAX_NETWORK_TYPE));
+        assertFalse(ConnectivityManager.isNetworkTypeValid(ConnectivityManager.MAX_NETWORK_TYPE+1));
 
         NetworkInfo[] ni = mCm.getAllNetworkInfo();
 
-        for (NetworkInfo n : ni) {
+        for (NetworkInfo n: ni) {
             assertTrue(ConnectivityManager.isNetworkTypeValid(n.getType()));
         }
-        assertFalse(ConnectivityManager.isNetworkTypeValid(-1));
+
+    }
+
+    public void testSetNetworkPreference() {
+        // verify swtiching between two default networks - need to connectable networks though
+        // could use test and whatever the current active network is
+        NetworkInfo active = mCm.getActiveNetworkInfo();
+        int originalPref = mCm.getNetworkPreference();
+        int currentPref = originalPref;
+        for (int type = -1; type <= ConnectivityManager.MAX_NETWORK_TYPE+1; type++) {
+            mCm.setNetworkPreference(type);
+            NetworkConfig c = mNetworks.get(type);
+            boolean expectWorked = (c != null && c.isDefault());
+            try {
+                Thread.currentThread().sleep(100);
+            } catch (InterruptedException e) {}
+            int foundType = mCm.getNetworkPreference();
+            if (expectWorked) {
+                assertTrue("We should have been able to switch prefered type " + type,
+                        foundType == type);
+                currentPref = foundType;
+            } else {
+                assertTrue("We should not have been able to switch type " + type,
+                        foundType == currentPref);
+            }
+        }
+        mCm.setNetworkPreference(originalPref);
+    }
+
+    public void testGetActiveNetworkInfo() {
+        NetworkInfo ni = mCm.getActiveNetworkInfo();
+
+        assertTrue("You must have an active network connection to complete CTS", ni != null);
+        assertTrue(ConnectivityManager.isNetworkTypeValid(ni.getType()));
+        assertTrue(ni.getState() == State.CONNECTED);
+    }
+
+    public void testGetNetworkInfo() {
+        for (int type = -1; type <= ConnectivityManager.MAX_NETWORK_TYPE+1; type++) {
+            if (isSupported(type)) {
+                NetworkInfo ni = mCm.getNetworkInfo(type);
+                assertTrue("Info shouldn't be null for " + type, ni != null);
+                State state = ni.getState();
+                assertTrue("Bad state for " + type, State.UNKNOWN.ordinal() >= state.ordinal()
+                           && state.ordinal() >= State.CONNECTING.ordinal());
+                DetailedState ds = ni.getDetailedState();
+                assertTrue("Bad detailed state for " + type,
+                           DetailedState.FAILED.ordinal() >= ds.ordinal()
+                           && ds.ordinal() >= DetailedState.IDLE.ordinal());
+            } else {
+                assertNull("Info should be null for " + type, mCm.getNetworkInfo(type));
+            }
+        }
     }
 
     public void testGetAllNetworkInfo() {
         NetworkInfo[] ni = mCm.getAllNetworkInfo();
         assertTrue(ni.length >= MIN_NUM_NETWORK_TYPES);
+        for (int type = 0; type <= ConnectivityManager.MAX_NETWORK_TYPE; type++) {
+            int desiredFoundCount = (isSupported(type) ? 1 : 0);
+            int foundCount = 0;
+            for (NetworkInfo i : ni) {
+                if (i.getType() == type) foundCount++;
+            }
+            assertTrue("Unexpected foundCount of " + foundCount + " for type " + type,
+                    foundCount == desiredFoundCount);
+        }
     }
 
     public void testStartUsingNetworkFeature() {
@@ -130,35 +207,46 @@
         }
     }
 
-    public void testRequestRouteToHost() {
-        Set<Integer> exceptionFreeTypes = new HashSet<Integer>();
-        exceptionFreeTypes.add(ConnectivityManager.TYPE_BLUETOOTH);
-        exceptionFreeTypes.add(ConnectivityManager.TYPE_ETHERNET);
-        exceptionFreeTypes.add(ConnectivityManager.TYPE_MOBILE);
-        exceptionFreeTypes.add(ConnectivityManager.TYPE_MOBILE_DUN);
-        exceptionFreeTypes.add(ConnectivityManager.TYPE_MOBILE_HIPRI);
-        exceptionFreeTypes.add(ConnectivityManager.TYPE_MOBILE_MMS);
-        exceptionFreeTypes.add(ConnectivityManager.TYPE_MOBILE_SUPL);
+    private boolean isSupported(int networkType) {
+        return mNetworks.containsKey(networkType);
+    }
 
-        NetworkInfo[] ni = mCm.getAllNetworkInfo();
-        for (NetworkInfo n : ni) {
-            if (n.isConnected() && exceptionFreeTypes.contains(n.getType())) {
-                assertTrue("Network type: " + n.getType(), mCm.requestRouteToHost(n.getType(),
-                        HOST_ADDRESS));
+    // true if only the system can turn it on
+    private boolean isNetworkProtected(int networkType) {
+        return mProtectedNetworks.contains(networkType);
+    }
+
+    public void testIsNetworkSupported() {
+        for (int type = -1; type <= ConnectivityManager.MAX_NETWORK_TYPE; type++) {
+            boolean supported = mCm.isNetworkSupported(type);
+            if (isSupported(type)) {
+                assertTrue(supported);
+            } else {
+                assertFalse(supported);
             }
         }
+    }
+
+    public void testRequestRouteToHost() {
+        for (int type = -1 ; type <= ConnectivityManager.MAX_NETWORK_TYPE; type++) {
+            NetworkInfo ni = mCm.getNetworkInfo(type);
+            boolean expectToWork = isSupported(type) && !isNetworkProtected(type) &&
+                    ni != null && ni.isConnected();
+
+            try {
+                assertTrue("Network type " + type,
+                        mCm.requestRouteToHost(type, HOST_ADDRESS) == expectToWork);
+            } catch (Exception e) {
+                Log.d(TAG, "got exception in requestRouteToHost for type " + type);
+                assertFalse("Exception received for type " + type, expectToWork);
+            }
+
+            //TODO verify route table
+        }
 
         assertFalse(mCm.requestRouteToHost(-1, HOST_ADDRESS));
     }
 
-    public void testGetActiveNetworkInfo() {
-        NetworkInfo ni = mCm.getActiveNetworkInfo();
-
-        if (ni != null) {
-            assertTrue(ni.getType() >= 0);
-        }
-    }
-
     public void testTest() {
         mCm.getBackgroundDataSetting();
     }
@@ -197,12 +285,16 @@
 
             assertTrue("Couldn't requestRouteToHost using HIPRI.",
                     mCm.requestRouteToHost(ConnectivityManager.TYPE_MOBILE_HIPRI, HOST_ADDRESS));
-
+            // TODO check dns selection
+            // TODO check routes
         } catch (InterruptedException e) {
             fail("Broadcast receiver waiting for ConnectivityManager interrupted.");
         } finally {
             mCm.stopUsingNetworkFeature(ConnectivityManager.TYPE_MOBILE,
                     FEATURE_ENABLE_HIPRI);
+            // TODO wait for HIPRI to go
+            // TODO check dns selection
+            // TODO check routes
             if (!isWifiConnected) {
                 mWifiManager.setWifiEnabled(false);
             }
diff --git a/tests/tests/provider/src/android/provider/cts/ContactsContract_DataUsageTest.java b/tests/tests/provider/src/android/provider/cts/ContactsContract_DataUsageTest.java
new file mode 100644
index 0000000..a684e41
--- /dev/null
+++ b/tests/tests/provider/src/android/provider/cts/ContactsContract_DataUsageTest.java
@@ -0,0 +1,173 @@
+/*
+ * Copyright (C) 2013 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.provider.cts;
+
+import static android.provider.ContactsContract.CommonDataKinds;
+import static android.provider.ContactsContract.DataUsageFeedback;
+
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.net.Uri;
+import android.provider.ContactsContract;
+import android.provider.cts.contacts.DataUtil;
+import android.provider.cts.contacts.DatabaseAsserts;
+import android.provider.cts.contacts.RawContactUtil;
+import android.test.AndroidTestCase;
+import android.text.TextUtils;
+
+public class ContactsContract_DataUsageTest extends AndroidTestCase {
+
+    private ContentResolver mResolver;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        mResolver = getContext().getContentResolver();
+    }
+
+    public void testSingleDataUsageFeedback_incrementsCorrectDataItems() {
+        DatabaseAsserts.ContactIdPair ids = DatabaseAsserts.assertAndCreateContact(mResolver);
+
+        long[] dataIds = setupRawContactDataItems(ids.mRawContactId);
+
+        // Update just 1 data item at a time.
+        updateDataUsageAndAssert(dataIds[1], 1);
+        updateDataUsageAndAssert(dataIds[1], 2);
+
+        updateDataUsageAndAssert(dataIds[2], 1);
+        updateDataUsageAndAssert(dataIds[2], 2);
+        updateDataUsageAndAssert(dataIds[2], 3);
+
+        // Go back and update the previous data item again.
+        updateDataUsageAndAssert(dataIds[1], 3);
+
+        deleteDataUsage();
+        RawContactUtil.delete(mResolver, ids.mRawContactId, true);
+    }
+
+    public void testMultiIdDataUsageFeedback_incrementsCorrectDataItems() {
+        DatabaseAsserts.ContactIdPair ids = DatabaseAsserts.assertAndCreateContact(mResolver);
+
+        long[] dataIds = setupRawContactDataItems(ids.mRawContactId);
+
+        assertDataUsageEquals(dataIds, 0, 0, 0, 0);
+
+        updateMultipleAndAssertUpdateSuccess(new long[] {dataIds[1], dataIds[2]});
+        assertDataUsageEquals(dataIds, 0, 1, 1, 0);
+
+        updateMultipleAndAssertUpdateSuccess(new long[]{dataIds[1], dataIds[2]});
+        assertDataUsageEquals(dataIds, 0, 2, 2, 0);
+
+        updateDataUsageAndAssert(dataIds[1], 3);
+        assertDataUsageEquals(dataIds, 0, 3, 2, 0);
+
+        updateMultipleAndAssertUpdateSuccess(new long[]{dataIds[0], dataIds[1]});
+        assertDataUsageEquals(dataIds, 1, 4, 2, 0);
+
+        deleteDataUsage();
+        RawContactUtil.delete(mResolver, ids.mRawContactId, true);
+    }
+
+    private long[] setupRawContactDataItems(long rawContactId) {
+        // Create 4 data items.
+        long[] dataIds = new long[4];
+
+        ContentValues values = new ContentValues();
+        values.put(ContactsContract.Data.MIMETYPE, CommonDataKinds.Phone.CONTENT_ITEM_TYPE);
+        values.put(CommonDataKinds.Phone.NUMBER, "555-5555");
+        dataIds[0] = DataUtil.insertData(mResolver, rawContactId, values);
+
+        values.clear();
+        values.put(ContactsContract.Data.MIMETYPE, CommonDataKinds.Phone.CONTENT_ITEM_TYPE);
+        values.put(CommonDataKinds.Phone.NUMBER, "555-5554");
+        dataIds[1] = DataUtil.insertData(mResolver, rawContactId, values);
+
+        values.clear();
+        values.put(ContactsContract.Data.MIMETYPE, CommonDataKinds.Email.CONTENT_ITEM_TYPE);
+        values.put(CommonDataKinds.Email.ADDRESS, "test@thisisfake.com");
+        dataIds[2] = DataUtil.insertData(mResolver, rawContactId, values);
+
+        values.clear();
+        values.put(ContactsContract.Data.MIMETYPE, CommonDataKinds.Email.CONTENT_ITEM_TYPE);
+        values.put(CommonDataKinds.Phone.NUMBER, "555-5556");
+        dataIds[3] = DataUtil.insertData(mResolver, rawContactId, values);
+
+        return dataIds;
+    }
+
+    /**
+     * Updates multiple data ids at once.  And asserts the update returned success.
+     */
+    private void updateMultipleAndAssertUpdateSuccess(long[] dataIds) {
+        String[] ids = new String[dataIds.length];
+        for (int i = 0; i < dataIds.length; i++) {
+            ids[i] = String.valueOf(dataIds[i]);
+        }
+        Uri uri = DataUsageFeedback.FEEDBACK_URI.buildUpon().appendPath(TextUtils.join(",", ids))
+                .appendQueryParameter(DataUsageFeedback.USAGE_TYPE,
+                        DataUsageFeedback.USAGE_TYPE_CALL).build();
+        int result = mResolver.update(uri, new ContentValues(), null, null);
+        assertTrue(result > 0);
+    }
+
+    /**
+     * Updates a single data item usage.  Asserts the update was successful.  Asserts the usage
+     * number is equal to expected value.
+     */
+    private void updateDataUsageAndAssert(long dataId, int assertValue) {
+        Uri uri = DataUsageFeedback.FEEDBACK_URI.buildUpon().appendPath(String.valueOf(dataId))
+                .appendQueryParameter(DataUsageFeedback.USAGE_TYPE,
+                        DataUsageFeedback.USAGE_TYPE_CALL).build();
+        int result = mResolver.update(uri, new ContentValues(), null, null);
+        assertTrue(result > 0);
+
+        assertDataUsageEquals(dataId, assertValue);
+    }
+
+    /**
+     * Assert that the given data ids have usage values in the respective order.
+     */
+    private void assertDataUsageEquals(long[] dataIds, int... expectedValues) {
+        if (dataIds.length != expectedValues.length) {
+            throw new IllegalArgumentException("dataIds and expectedValues must be the same size");
+        }
+
+        for (int i = 0; i < dataIds.length; i++) {
+            assertDataUsageEquals(dataIds[i], expectedValues[i]);
+        }
+    }
+
+    /**
+     * Assert a single data item has a specific usage value.
+     */
+    private void assertDataUsageEquals(long dataId, int expectedValue) {
+        // Query and assert value is expected.
+        String[] projection = new String[]{ContactsContract.Data.TIMES_USED};
+        String[] record = DataUtil.queryById(mResolver, dataId, projection);
+        assertNotNull(record);
+        long actual = 0;
+        // Tread null as 0
+        if (record[0] != null) {
+            actual = Long.parseLong(record[0]);
+        }
+        assertEquals(expectedValue, actual);
+    }
+
+    private void deleteDataUsage() {
+        mResolver.delete(DataUsageFeedback.DELETE_USAGE_URI, null, null);
+    }
+}
diff --git a/tests/tests/provider/src/android/provider/cts/contacts/DataUtil.java b/tests/tests/provider/src/android/provider/cts/contacts/DataUtil.java
index adb253c..ae2812e 100644
--- a/tests/tests/provider/src/android/provider/cts/contacts/DataUtil.java
+++ b/tests/tests/provider/src/android/provider/cts/contacts/DataUtil.java
@@ -19,6 +19,7 @@
 import android.content.ContentResolver;
 import android.content.ContentUris;
 import android.content.ContentValues;
+import android.database.Cursor;
 import android.net.Uri;
 import android.provider.ContactsContract;
 
@@ -29,6 +30,12 @@
 
     private static final Uri URI = ContactsContract.Data.CONTENT_URI;
 
+    public static String[] queryById(ContentResolver resolver, long dataId, String[] projection) {
+        Uri uri = ContentUris.withAppendedId(URI, dataId);
+        Cursor cursor = resolver.query(uri, projection, null, null, null);
+        return CommonDatabaseUtils.singleRecordToArray(cursor);
+    }
+
     public static void insertName(ContentResolver resolver, long rawContactId) {
         ContentValues values = new ContentValues();
         values.put(ContactsContract.Data.MIMETYPE,
diff --git a/tests/tests/provider/src/android/provider/cts/contacts/RawContactUtil.java b/tests/tests/provider/src/android/provider/cts/contacts/RawContactUtil.java
index 8f9e7bd5..c87dc01 100644
--- a/tests/tests/provider/src/android/provider/cts/contacts/RawContactUtil.java
+++ b/tests/tests/provider/src/android/provider/cts/contacts/RawContactUtil.java
@@ -49,14 +49,13 @@
         ContentValues values = new ContentValues();
         values.put(ContactsContract.RawContacts.ACCOUNT_NAME, StaticAccountAuthenticator.NAME);
         values.put(ContactsContract.RawContacts.ACCOUNT_TYPE, StaticAccountAuthenticator.TYPE);
-        Uri uri = resolver.insert(ContactsContract.RawContacts.CONTENT_URI, values);
+        Uri uri = resolver.insert(URI, values);
         return ContentUris.parseId(uri);
     }
 
     public static String[] queryByRawContactId(ContentResolver resolver,
             long rawContactId, String[] projection) {
-        Uri uri = ContentUris.withAppendedId(ContactsContract.RawContacts.CONTENT_URI,
-                rawContactId);
+        Uri uri = ContentUris.withAppendedId(URI, rawContactId);
         Cursor cursor = resolver.query(uri, projection, null, null, null);
         return CommonDatabaseUtils.singleRecordToArray(cursor);
     }
@@ -68,14 +67,14 @@
      */
     public static List<String[]> queryByContactId(ContentResolver resolver, long contactId,
             String[] projection) {
-        Uri uri = ContentUris.withAppendedId(ContactsContract.RawContacts.CONTENT_URI, contactId);
+        Uri uri = ContentUris.withAppendedId(URI, contactId);
         Cursor cursor = resolver.query(uri, projection, null, null, null);
         return CommonDatabaseUtils.multiRecordToArray(cursor);
     }
 
     public static void delete(ContentResolver resolver, long rawContactId,
             boolean isSyncAdapter) {
-        Uri uri = ContentUris.withAppendedId(ContactsContract.RawContacts.CONTENT_URI, rawContactId)
+        Uri uri = ContentUris.withAppendedId(URI, rawContactId)
                 .buildUpon()
                 .appendQueryParameter(ContactsContract.CALLER_IS_SYNCADAPTER, isSyncAdapter + "")
                 .build();
diff --git a/tests/tests/renderscript/src/android/renderscript/cts/GlobalSync.java b/tests/tests/renderscript/src/android/renderscript/cts/GlobalSync.java
new file mode 100644
index 0000000..f895661
--- /dev/null
+++ b/tests/tests/renderscript/src/android/renderscript/cts/GlobalSync.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2013 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.Allocation;
+import android.renderscript.Element;
+import android.renderscript.RenderScript;
+import android.renderscript.Type;
+
+public class GlobalSync extends RSBaseCompute {
+    Allocation AFailed;
+    int [] Failed;
+    Allocation AIn;
+
+    protected void setupGlobalSync(RenderScript mRS, ScriptC_global_sync gs, int v) {
+        Type.Builder typeBuilder = new Type.Builder(mRS, Element.I32(mRS));
+        Type t = typeBuilder.setX(1).create();
+
+        AFailed = Allocation.createTyped(mRS, t);
+        Failed = new int [1];
+        Failed[0] = 0;
+        AFailed.copyFrom(Failed);
+        gs.set_aFailed(AFailed);
+
+        AIn = Allocation.createTyped(mRS, t);
+        int [] In = new int [1];
+        In[0] = v;
+        AIn.copyFrom(In);
+
+    }
+
+    /**
+     * Test whether we are properly synchronizing extern global data
+     * when dealing with mixed kernels/invokables.
+     */
+    public void testGlobalSync() {
+        ScriptC_global_sync gs = new ScriptC_global_sync(mRS);
+
+        int v = 7;
+        setupGlobalSync(mRS, gs, v);
+        gs.forEach_write_global(AIn);
+        gs.invoke_test_global(v);
+
+        AFailed.copyTo(Failed);
+        if (Failed[0] != 0) {
+            FoundError = true;
+        }
+
+        gs.destroy();
+        checkForErrors();
+    }
+
+    /**
+     * Test whether we are properly synchronizing static global data
+     * when dealing with mixed kernels/invokables.
+     */
+    public void testStaticGlobalSync() {
+        ScriptC_global_sync gs = new ScriptC_global_sync(mRS);
+
+        int v = 9;
+        setupGlobalSync(mRS, gs, v);
+        gs.forEach_write_static_global(AIn);
+        gs.invoke_test_static_global(v);
+
+        AFailed.copyTo(Failed);
+        if (Failed[0] != 0) {
+            FoundError = true;
+        }
+
+        gs.destroy();
+        checkForErrors();
+    }
+}
+
diff --git a/tests/tests/renderscript/src/android/renderscript/cts/GlobalTest.java b/tests/tests/renderscript/src/android/renderscript/cts/GlobalTest.java
new file mode 100644
index 0000000..b0c3b63
--- /dev/null
+++ b/tests/tests/renderscript/src/android/renderscript/cts/GlobalTest.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2013 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;
+
+public class GlobalTest extends RSBaseCompute {
+    /**
+     * Test whether we properly clean up after large global arrays are
+     * allocated/deallocated.
+     */
+    public void testLargeGlobal() {
+        for (int i = 0; i < 1000; i++) {
+            ScriptC_large_global lg = new ScriptC_large_global(mRS);
+            lg.destroy();
+        }
+        checkForErrors();
+    }
+}
diff --git a/tests/tests/text/src/android/text/format/cts/DateUtilsTest.java b/tests/tests/text/src/android/text/format/cts/DateUtilsTest.java
index 52f0d3f..14e01e8 100644
--- a/tests/tests/text/src/android/text/format/cts/DateUtilsTest.java
+++ b/tests/tests/text/src/android/text/format/cts/DateUtilsTest.java
@@ -189,11 +189,11 @@
                 fixedTime, java.text.DateFormat.SHORT, java.text.DateFormat.FULL));
 
         final long HOUR_DURATION = 2 * 60 * 60 * 1000;
-        assertEquals("5:30:15 AM GMT", DateUtils.formatSameDayTime(fixedTime + HOUR_DURATION,
+        assertEquals("5:30:15 AM GMT+00:00", DateUtils.formatSameDayTime(fixedTime + HOUR_DURATION,
                 fixedTime, java.text.DateFormat.FULL, java.text.DateFormat.FULL));
         assertEquals("5:30:15 AM", DateUtils.formatSameDayTime(fixedTime + HOUR_DURATION,
                 fixedTime, java.text.DateFormat.FULL, java.text.DateFormat.DEFAULT));
-        assertEquals("5:30:15 AM GMT", DateUtils.formatSameDayTime(fixedTime + HOUR_DURATION,
+        assertEquals("5:30:15 AM GMT+00:00", DateUtils.formatSameDayTime(fixedTime + HOUR_DURATION,
                 fixedTime, java.text.DateFormat.FULL, java.text.DateFormat.LONG));
         assertEquals("5:30:15 AM", DateUtils.formatSameDayTime(fixedTime + HOUR_DURATION,
                 fixedTime, java.text.DateFormat.FULL, java.text.DateFormat.MEDIUM));