diff --git a/CtsTestCaseList.mk b/CtsTestCaseList.mk
index 8386124..4e1e008 100644
--- a/CtsTestCaseList.mk
+++ b/CtsTestCaseList.mk
@@ -67,6 +67,7 @@
 cts_support_packages := \
     CtsAccelerationTestStubs \
     CtsAppTestStubs \
+    CtsAtraceTestApp \
     CtsCertInstallerApp \
     CtsDeviceAdmin \
     CtsDeviceOpenGl \
diff --git a/apps/CtsVerifier/AndroidManifest.xml b/apps/CtsVerifier/AndroidManifest.xml
index 6c515fd..98e8acd 100644
--- a/apps/CtsVerifier/AndroidManifest.xml
+++ b/apps/CtsVerifier/AndroidManifest.xml
@@ -1495,6 +1495,18 @@
             -->
         </activity>
 
+        <activity android:name=".audio.AudioRoutingNotificationsActivity"
+                  android:label="@string/audio_routingnotifications_test">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.cts.intent.category.MANUAL_TEST" />
+            </intent-filter>
+            <meta-data android:name="test_category" android:value="@string/test_category_audio" />
+            <!--
+            <meta-data android:name="test_required_features" android:value="android.hardware.microphone" />
+            -->
+        </activity>
+
         <service android:name=".tv.MockTvInputService"
             android:permission="android.permission.BIND_TV_INPUT">
             <intent-filter>
diff --git a/apps/CtsVerifier/res/layout/audio_routingnotifications_test.xml b/apps/CtsVerifier/res/layout/audio_routingnotifications_test.xml
new file mode 100644
index 0000000..cef30d6
--- /dev/null
+++ b/apps/CtsVerifier/res/layout/audio_routingnotifications_test.xml
@@ -0,0 +1,99 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 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.
+-->
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:padding="10dip"
+        android:orientation="vertical">
+
+  <TextView
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:scrollbars="vertical"
+      android:gravity="bottom"
+      android:id="@+id/info_text"
+      android:text="@string/audio_dev_routingnotification_instructions" />
+
+  <LinearLayout
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:orientation="vertical"
+      android:id="@+id/audioTrackRoutingLayout">
+      <TextView
+          android:layout_width="match_parent"
+          android:layout_height="wrap_content"
+              android:text="@string/audio_routingnotification_playHeader"/>
+
+      <TextView
+          android:layout_width="match_parent"
+          android:layout_height="wrap_content"
+          android:id="@+id/audio_routingnotification_audioTrack_change"/>
+
+      <LinearLayout
+          android:layout_width="wrap_content"
+          android:layout_height="wrap_content"
+          android:orientation="horizontal">
+          <Button
+              android:layout_width="wrap_content"
+              android:layout_height="wrap_content"
+              android:id="@+id/audio_routingnotification_playBtn"
+              android:text="@string/audio_routingnotification_playBtn"/>
+
+          <Button
+              android:layout_width="match_parent"
+              android:layout_height="wrap_content"
+              android:id="@+id/audio_routingnotification_playStopBtn"
+              android:text="@string/audio_routingnotification_playStopBtn"/>
+      </LinearLayout>
+    </LinearLayout>
+
+  <LinearLayout
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:orientation="vertical"
+      android:id="@+id/audioRecordRoutingLayout">
+      <TextView
+          android:layout_width="match_parent"
+          android:layout_height="wrap_content"
+              android:text="@string/audio_routingnotification_recHeader"/>
+
+      <TextView
+          android:layout_width="match_parent"
+          android:layout_height="wrap_content"
+          android:id="@+id/audio_routingnotification_audioRecord_change"/>
+
+      <LinearLayout
+          android:layout_width="wrap_content"
+          android:layout_height="wrap_content"
+          android:orientation="horizontal">
+          <Button
+              android:layout_width="wrap_content"
+              android:layout_height="wrap_content"
+              android:id="@+id/audio_routingnotification_recordBtn"
+              android:text="@string/audio_routingnotification_recBtn"/>
+
+          <Button
+              android:layout_width="match_parent"
+              android:layout_height="wrap_content"
+              android:id="@+id/audio_routingnotification_recordStopBtn"
+              android:text="@string/audio_routingnotification_recStopBtn"/>
+      </LinearLayout>
+    </LinearLayout>
+
+  <include layout="@layout/pass_fail_buttons" />
+
+</LinearLayout>
\ No newline at end of file
diff --git a/apps/CtsVerifier/res/values/strings.xml b/apps/CtsVerifier/res/values/strings.xml
index 1ccd6b7..d22f5ec 100644
--- a/apps/CtsVerifier/res/values/strings.xml
+++ b/apps/CtsVerifier/res/values/strings.xml
@@ -1615,4 +1615,23 @@
     <string name="audio_dev_notification_clearmsgs">Clear Messages</string>
     <string name="audio_dev_notification_connectMsg">CONNECT DETECTED</string>
     <string name="audio_dev_notification_disconnectMsg">DISCONNECT DETECTED</string>
+
+    <!--  Audio Routing Notifcations Test -->
+    <string name="audio_routingnotifications_test">Audio Routing Notifications Test</string>
+    <string name="audio_dev_routingnotification_instructions">
+          Click on the "Play" button in the AudioTrack Routing Notifictions section below to
+          start (silent) playback. Insert a wired headset. Observe a message acknowledging the
+          rerouting event below. Remove the wired headset and observe the new routing message.
+          Click on the "Stop" button to stop playback.\n
+          Repeat the process with "Record" and "Stop" button in the AudioRecord Routing
+          Notifications section below.
+    </string>
+    <string name="audio_routingnotification_playBtn">Play</string>
+    <string name="audio_routingnotification_playStopBtn">Stop</string>
+    <string name="audio_routingnotification_recBtn">Record</string>
+    <string name="audio_routingnotification_recStopBtn">Stop</string>
+    <string name="audio_routingnotification_playHeader">AudioTrack Routing Notifications</string>
+    <string name="audio_routingnotification_recHeader">AudioRecord Routing Notifications</string>
+    <string name="audio_routingnotification_trackRoutingMsg">AudioTrack rerouting</string>
+    <string name="audio_routingnotification_recordRoutingMsg">AudioRecord rerouting</string>
 </resources>
diff --git a/apps/CtsVerifier/src/com/android/cts/verifier/audio/AudioRoutingNotificationsActivity.java b/apps/CtsVerifier/src/com/android/cts/verifier/audio/AudioRoutingNotificationsActivity.java
new file mode 100644
index 0000000..b6a4255
--- /dev/null
+++ b/apps/CtsVerifier/src/com/android/cts/verifier/audio/AudioRoutingNotificationsActivity.java
@@ -0,0 +1,146 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.cts.verifier.audio;
+
+import com.android.cts.verifier.PassFailButtons;
+import com.android.cts.verifier.R;
+
+import android.content.Context;
+
+import android.media.AudioDeviceCallback;
+import android.media.AudioDeviceInfo;
+import android.media.AudioManager;
+import android.media.AudioRecord;
+import android.media.AudioTrack;
+
+import android.os.Bundle;
+import android.os.Handler;
+
+import android.util.Log;
+
+import android.view.View;
+import android.view.View.OnClickListener;
+
+import android.widget.Button;
+import android.widget.TextView;
+
+/**
+ * Tests AudioTrack and AudioRecord (re)Routing messages.
+ */
+public class AudioRoutingNotificationsActivity extends PassFailButtons.Activity {
+    private static final String TAG = "AudioRoutingNotificationsActivity";
+
+    Context mContext;
+
+    OnBtnClickListener mBtnClickListener = new OnBtnClickListener();
+
+    int mNumTrackNotifications = 0;
+    int mNumRecordNotifications = 0;
+
+    TrivialPlayer mAudioPlayer = new TrivialPlayer();
+    TrivialRecorder mAudioRecorder = new TrivialRecorder();
+
+    private class OnBtnClickListener implements OnClickListener {
+        @Override
+        public void onClick(View v) {
+            switch (v.getId()) {
+                case R.id.audio_routingnotification_playBtn:
+                    Log.i(TAG, "audio_routingnotification_playBtn");
+                    mAudioPlayer.start();
+                    break;
+
+                case R.id.audio_routingnotification_playStopBtn:
+                    Log.i(TAG, "audio_routingnotification_playStopBtn");
+                    mAudioPlayer.stop();
+                    break;
+
+                case R.id.audio_routingnotification_recordBtn:
+                    break;
+
+                case R.id.audio_routingnotification_recordStopBtn:
+                    break;
+            }
+        }
+    }
+
+    private class AudioTrackRoutingChangeListener implements AudioTrack.OnRoutingChangedListener {
+        public void onRoutingChanged(AudioTrack audioTrack) {
+            mNumTrackNotifications++;
+            TextView textView =
+                (TextView)findViewById(R.id.audio_routingnotification_audioTrack_change);
+            String msg = mContext.getResources().getString(
+                    R.string.audio_routingnotification_trackRoutingMsg);
+            AudioDeviceInfo routedDevice = audioTrack.getRoutedDevice();
+            CharSequence deviceName = routedDevice != null ? routedDevice.getProductName() : "none";
+            int deviceType = routedDevice != null ? routedDevice.getType() : -1;
+            textView.setText(msg + " - " +
+                             deviceName + " [0x" + Integer.toHexString(deviceType) + "]" +
+                             " - " + mNumTrackNotifications);
+        }
+    }
+
+    private class AudioRecordRoutingChangeListener implements AudioRecord.OnRoutingChangedListener {
+        public void onRoutingChanged(AudioRecord audioRecord) {
+            mNumRecordNotifications++;
+            TextView textView =
+                    (TextView)findViewById(R.id.audio_routingnotification_audioRecord_change);
+            String msg = mContext.getResources().getString(
+                    R.string.audio_routingnotification_recordRoutingMsg);
+            AudioDeviceInfo routedDevice = audioRecord.getRoutedDevice();
+            CharSequence deviceName = routedDevice != null ? routedDevice.getProductName() : "none";
+            int deviceType = routedDevice != null ? routedDevice.getType() : -1;
+            textView.setText(msg + " - " +
+                             deviceName + " [0x" + Integer.toHexString(deviceType) + "]" +
+                             " - " + mNumRecordNotifications);
+        }
+    }
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.audio_routingnotifications_test);
+
+        Button btn;
+        btn = (Button)findViewById(R.id.audio_routingnotification_playBtn);
+        btn.setOnClickListener(mBtnClickListener);
+        btn = (Button)findViewById(R.id.audio_routingnotification_playStopBtn);
+        btn.setOnClickListener(mBtnClickListener);
+        btn = (Button)findViewById(R.id.audio_routingnotification_recordBtn);
+        btn.setOnClickListener(mBtnClickListener);
+        btn = (Button)findViewById(R.id.audio_routingnotification_recordStopBtn);
+        btn.setOnClickListener(mBtnClickListener);
+
+        mContext = this;
+
+        AudioTrack audioTrack = mAudioPlayer.getAudioTrack();
+        audioTrack.addOnRoutingChangedListener(
+            new AudioTrackRoutingChangeListener(), new Handler());
+
+        AudioRecord audioRecord = mAudioRecorder.getAudioRecord();
+        audioRecord.addOnRoutingChangedListener(
+            new AudioRecordRoutingChangeListener(), new Handler());
+
+        setPassFailButtonClickListeners();
+    }
+
+    @Override
+    public void onBackPressed () {
+        mAudioPlayer.shutDown();
+        mAudioRecorder.shutDown();
+        super.onBackPressed();
+    }
+}
diff --git a/apps/CtsVerifier/src/com/android/cts/verifier/audio/TrivialPlayer.java b/apps/CtsVerifier/src/com/android/cts/verifier/audio/TrivialPlayer.java
new file mode 100644
index 0000000..af09504
--- /dev/null
+++ b/apps/CtsVerifier/src/com/android/cts/verifier/audio/TrivialPlayer.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.cts.verifier.audio;
+
+import android.media.AudioFormat;
+import android.media.AudioManager;
+import android.media.AudioTrack;
+
+import java.lang.InterruptedException;
+import java.lang.Math;
+import java.lang.Runnable;
+
+public class TrivialPlayer implements Runnable {
+    AudioTrack mAudioTrack;
+    int mBufferSize;
+
+    boolean mPlay;
+    boolean mIsPlaying;
+
+    short[] mAudioData;
+
+    Thread mFillerThread = null;
+
+    public TrivialPlayer() {
+        mBufferSize =
+                AudioTrack.getMinBufferSize(
+                    41000,
+                    AudioFormat.CHANNEL_OUT_STEREO,
+                    AudioFormat.ENCODING_PCM_16BIT);
+        mAudioTrack =
+            new AudioTrack(
+                AudioManager.STREAM_MUSIC,
+                41000,
+                AudioFormat.CHANNEL_OUT_STEREO,
+                AudioFormat.ENCODING_PCM_16BIT,
+                mBufferSize,
+                AudioTrack.MODE_STREAM);
+
+        mPlay = false;
+        mIsPlaying = false;
+
+        // setup audio data (silence will suffice)
+        mAudioData = new short[mBufferSize];
+        for (int index = 0; index < mBufferSize; index++) {
+            // mAudioData[index] = 0;
+            // keep this code since one might want to hear the playnig audio
+            // for debugging/verification.
+            mAudioData[index] =
+                (short)(((Math.random() * 2.0) - 1.0) * (double)Short.MAX_VALUE/2.0);
+        }
+    }
+
+    public AudioTrack getAudioTrack() { return mAudioTrack; }
+
+    public boolean isPlaying() {
+        synchronized (this) {
+            return mIsPlaying;
+        }
+    }
+
+    public void start() {
+        mPlay = true;
+        mFillerThread = new Thread(this);
+        mFillerThread.start();
+    }
+
+    public void stop() {
+        mPlay = false;
+        mFillerThread = null;
+    }
+
+    public void shutDown() {
+        stop();
+        while (isPlaying()) {
+            try {
+                Thread.sleep(10);
+            } catch (InterruptedException ex) {
+            }
+        }
+        mAudioTrack.release();
+    }
+
+    @Override
+    public void run() {
+        mAudioTrack.play();
+        synchronized (this) {
+            mIsPlaying = true;
+        }
+        while (mAudioTrack != null && mPlay) {
+            mAudioTrack.write(mAudioData, 0, mBufferSize);
+        }
+        synchronized (this) {
+            mIsPlaying = false;
+        }
+        mAudioTrack.stop();
+    }
+}
diff --git a/apps/CtsVerifier/src/com/android/cts/verifier/audio/TrivialRecorder.java b/apps/CtsVerifier/src/com/android/cts/verifier/audio/TrivialRecorder.java
new file mode 100644
index 0000000..f684681
--- /dev/null
+++ b/apps/CtsVerifier/src/com/android/cts/verifier/audio/TrivialRecorder.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.cts.verifier.audio;
+
+import android.media.AudioFormat;
+import android.media.AudioManager;
+import android.media.AudioRecord;
+
+import android.media.MediaRecorder;
+
+import java.lang.InterruptedException;
+import java.lang.Runnable;
+
+public class TrivialRecorder implements Runnable {
+    AudioRecord mAudioRecord;
+    int mBufferSize;
+
+    boolean mRecord;
+    boolean mIsRecording;
+
+    short[] mAudioData;
+
+    Thread mReaderThread = null;
+
+    public TrivialRecorder() {
+        mBufferSize =
+                AudioRecord.getMinBufferSize(
+                    41000,
+                    AudioFormat.CHANNEL_IN_MONO,
+                    AudioFormat.ENCODING_PCM_16BIT);
+        mAudioRecord =
+            new AudioRecord(
+                MediaRecorder.AudioSource.DEFAULT,
+                41000,
+                AudioFormat.CHANNEL_IN_MONO,
+                AudioFormat.ENCODING_PCM_16BIT,
+                mBufferSize);
+
+        mRecord = false;
+        mIsRecording = false;
+
+        // setup audio data (silence will suffice)
+        mAudioData = new short[mBufferSize];
+    }
+
+    public AudioRecord getAudioRecord() { return mAudioRecord; }
+
+    public boolean mIsRecording() {
+        synchronized (this) {
+            return mIsRecording;
+        }
+    }
+
+    public void start() {
+        mRecord = true;
+        mReaderThread = new Thread(this);
+        mReaderThread.start();
+    }
+
+    public void stop() {
+        mRecord = false;
+        mReaderThread = null;
+    }
+
+    public void shutDown() {
+        stop();
+        while (mIsRecording()) {
+            try {
+                Thread.sleep(10);
+            } catch (InterruptedException ex) {
+            }
+        }
+        mAudioRecord.release();
+    }
+
+    @Override
+    public void run() {
+        mAudioRecord.startRecording();
+        synchronized (this) {
+            mIsRecording = true;
+        }
+       while (mRecord) {
+            mAudioRecord.read(mAudioData, 0, mBufferSize);
+        }
+        mAudioRecord.stop();
+        synchronized (this) {
+            mIsRecording = false;
+        }
+    }
+}
diff --git a/hostsidetests/atrace/AtraceTestApp/Android.mk b/hostsidetests/atrace/AtraceTestApp/Android.mk
new file mode 100644
index 0000000..0eb7cfd
--- /dev/null
+++ b/hostsidetests/atrace/AtraceTestApp/Android.mk
@@ -0,0 +1,33 @@
+# Copyright (C) 2009 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.
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := tests
+
+LOCAL_SRC_FILES := $(call all-java-files-under, src)
+
+LOCAL_SDK_VERSION := current
+LOCAL_STATIC_JAVA_LIBRARIES := android-support-test
+
+LOCAL_PACKAGE_NAME := CtsAtraceTestApp
+
+# sign this app with a different cert than CtsSimpleAppInstallDiffCert
+#LOCAL_CERTIFICATE := cts/hostsidetests/appsecurity/certs/cts-testkey1
+
+#LOCAL_DEX_PREOPT := false
+
+include $(BUILD_CTS_SUPPORT_PACKAGE)
diff --git a/hostsidetests/atrace/AtraceTestApp/AndroidManifest.xml b/hostsidetests/atrace/AtraceTestApp/AndroidManifest.xml
new file mode 100644
index 0000000..a86f7f0
--- /dev/null
+++ b/hostsidetests/atrace/AtraceTestApp/AndroidManifest.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 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.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+       package="com.android.cts.atracetestapp">
+    <!--
+    A simple app with a tracing section to test that apps tracing signals are
+    emitted by atrace.
+    -->
+    <application>
+        <activity android:name=".AtraceTestAppActivity">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+</manifest>
diff --git a/hostsidetests/atrace/AtraceTestApp/src/com/android/cts/atracetestapp/AtraceTestAppActivity.java b/hostsidetests/atrace/AtraceTestApp/src/com/android/cts/atracetestapp/AtraceTestAppActivity.java
new file mode 100644
index 0000000..0269d0d
--- /dev/null
+++ b/hostsidetests/atrace/AtraceTestApp/src/com/android/cts/atracetestapp/AtraceTestAppActivity.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.cts.atracetestapp;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.os.Trace;
+
+public class AtraceTestAppActivity extends Activity {
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        Trace.beginSection("traceable-app-test-section");
+        super.onCreate(savedInstanceState);
+        Trace.endSection();
+    }
+}
diff --git a/hostsidetests/atrace/src/android/atrace/cts/AtraceHostTest.java b/hostsidetests/atrace/src/android/atrace/cts/AtraceHostTest.java
index f7af31c..ee0511d 100644
--- a/hostsidetests/atrace/src/android/atrace/cts/AtraceHostTest.java
+++ b/hostsidetests/atrace/src/android/atrace/cts/AtraceHostTest.java
@@ -16,27 +16,40 @@
 
 package android.atrace.cts;
 
+import com.android.cts.tradefed.build.CtsBuildHelper;
 import com.android.ddmlib.Log;
+import com.android.tradefed.build.IBuildInfo;
 import com.android.tradefed.device.ITestDevice;
 import com.android.tradefed.testtype.DeviceTestCase;
+import com.android.tradefed.testtype.IBuildReceiver;
 
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.StringReader;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 /**
  * Test to check that atrace is usable, to enable usage of systrace.
  */
-public class AtraceHostTest extends DeviceTestCase {
+public class AtraceHostTest extends DeviceTestCase implements IBuildReceiver {
     private static final String TAG = "AtraceHostTest";
 
-    private ITestDevice mDevice;
+    private static final String TEST_APK = "CtsAtraceTestApp.apk";
+    private static final String TEST_PKG = "com.android.cts.atracetestapp";
 
+    private CtsBuildHelper mCtsBuild;
+
+    /**
+     * {@inheritDoc}
+     */
     @Override
-    protected void setUp() throws Exception {
-        super.setUp();
-        mDevice = getDevice();
+    public void setBuild(IBuildInfo buildInfo) {
+        mCtsBuild = CtsBuildHelper.createBuildHelper(buildInfo);
     }
 
     // Collection of all userspace tags, and 'sched'
@@ -65,7 +78,7 @@
      * Tests that atrace exists and is runnable with no args
      */
     public void testSimpleRun() throws Exception {
-        String output = mDevice.executeShellCommand("atrace");
+        String output = getDevice().executeShellCommand("atrace");
         String[] lines = output.split("\\r?\\n");
 
         // check for expected stdout
@@ -80,7 +93,7 @@
      * Tests the output of "atrace --list_categories" to ensure required categories exist.
      */
     public void testCategories() throws Exception {
-        String output = mDevice.executeShellCommand("atrace --list_categories");
+        String output = getDevice().executeShellCommand("atrace --list_categories");
         String[] categories = output.split("\\r?\\n");
 
         Set<String> requiredCategories = new HashSet<String>(sRequiredCategoriesList);
@@ -101,4 +114,120 @@
             fail("Expected categories missing from atrace");
         }
     }
+
+
+    private static final String TRACE_MARKER_REGEX =
+            "\\s*(\\S+)-(\\d+)\\s+\\(\\s*(\\d+)\\).*tracing_mark_write:\\s*(B|E)(.*)";
+    /**
+     * Tests that atrace captures app launch, including app level tracing
+     */
+    public void testTracingContent() throws Exception {
+        String atraceOutput = null;
+        try {
+            // cleanup test apps that might be installed from previous partial test run
+            getDevice().uninstallPackage(TEST_PKG);
+
+            // install the test app
+            File testAppFile = mCtsBuild.getTestApp(TEST_APK);
+            String installResult = getDevice().installPackage(testAppFile, false);
+            assertNull(
+                    String.format("failed to install simple app. Reason: %s", installResult),
+                    installResult);
+
+            // capture a launch of the app with async tracing
+            String atraceArgs = "-a " + TEST_PKG + " -c -b 16000 view"; // TODO: zipping
+            getDevice().executeShellCommand("atrace --async_stop " + atraceArgs);
+            getDevice().executeShellCommand("atrace --async_start " + atraceArgs);
+            String start = getDevice().executeShellCommand("am start " + TEST_PKG);
+            getDevice().executeShellCommand("sleep 1");
+            atraceOutput = getDevice().executeShellCommand("atrace --async_dump " + atraceArgs);
+        } finally {
+            getDevice().uninstallPackage(TEST_PKG);
+        }
+        assertNotNull(atraceOutput);
+
+
+        // now parse the trace data (see external/chromium-trace/systrace.py)
+        final String MARKER = "TRACE:";
+        int dataStart = atraceOutput.indexOf(MARKER);
+        assertTrue(dataStart >= 0);
+        String traceData = atraceOutput.substring(dataStart + MARKER.length());
+
+        /**
+         * Pattern that matches standard begin/end userspace tracing.
+         *
+         * Groups are:
+         * 1 - truncated thread name
+         * 2 - tid
+         * 3 - pid
+         * 4 - B/E
+         * 5 - ignored, for grouping
+         * 6 - if B, section title, else null
+         */
+        final Pattern beginEndPattern = Pattern.compile(
+                "\\s*(\\S+)-(\\d+)\\s+\\(\\s*(\\d+)\\).*tracing_mark_write:\\s*(B|E)(\\|\\d+\\|(.+))?");
+
+        int appPid = -1;
+        String line;
+
+        // list of tags expected to be seen on app launch, in order.
+        String[] requiredSectionList = {
+                "traceable-app-test-section",
+                "inflate",
+                "performTraversals",
+                "measure",
+                "layout",
+                "draw",
+                "Record View#draw()"
+        };
+        int nextSectionIndex = 0;
+        int matches = 0;
+        try (BufferedReader reader = new BufferedReader(new StringReader(traceData))) {
+            while ((line = reader.readLine()) != null) {
+                Matcher matcher = beginEndPattern.matcher(line);
+                if (matcher.find()) {
+                    matches++;
+
+                    String truncatedThreadName = matcher.group(1);
+                    assertNotNull(truncatedThreadName);
+
+                    int tid = assertInt(matcher.group(2));
+                    assertTrue(tid > 0);
+                    int pid = assertInt(matcher.group(3));
+                    assertTrue(pid > 0);
+
+                    if (TEST_PKG.endsWith(truncatedThreadName)) {
+                        // should be something like "s.aptracetestapp" since beginning may be truncated
+                        if (appPid == -1) {
+                            appPid = pid;
+                        } else {
+                            assertEquals(appPid, pid);
+                        }
+
+                        if ("B".equals(matcher.group(4))) {
+                            String sectionTitle = matcher.group(6);
+                            if (nextSectionIndex < requiredSectionList.length
+                                    && requiredSectionList[nextSectionIndex].equals(sectionTitle)) {
+                                nextSectionIndex++;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        assertTrue("Unable to parse any userspace sections from atrace output",
+                matches != 0);
+        assertEquals("Didn't see required list of traced sections, in order",
+                requiredSectionList.length, nextSectionIndex);
+    }
+
+    private static int assertInt(String input) {
+        try {
+            return Integer.parseInt(input);
+        } catch (NumberFormatException e) {
+            fail("Expected an integer but found \"" + input + "\"");
+            // Won't be hit, above throws AssertException
+            return -1;
+        }
+    }
 }
diff --git a/hostsidetests/devicepolicy/app/IntentSender/Android.mk b/hostsidetests/devicepolicy/app/IntentSender/Android.mk
index 21d2866..e5246c5 100644
--- a/hostsidetests/devicepolicy/app/IntentSender/Android.mk
+++ b/hostsidetests/devicepolicy/app/IntentSender/Android.mk
@@ -24,7 +24,9 @@
 
 LOCAL_SRC_FILES := $(call all-java-files-under, src)
 
-LOCAL_JAVA_LIBRARIES := android.test.runner android-support-v4
+LOCAL_JAVA_LIBRARIES := android.test.runner
+
+LOCAL_STATIC_JAVA_LIBRARIES := android-support-v4 ctstestrunner
 
 LOCAL_SDK_VERSION := current
 
diff --git a/hostsidetests/devicepolicy/app/ManagedProfile/Android.mk b/hostsidetests/devicepolicy/app/ManagedProfile/Android.mk
index b74a7b6..f4adb31 100644
--- a/hostsidetests/devicepolicy/app/ManagedProfile/Android.mk
+++ b/hostsidetests/devicepolicy/app/ManagedProfile/Android.mk
@@ -24,9 +24,9 @@
 
 LOCAL_SRC_FILES := $(call all-java-files-under, src)
 
-LOCAL_JAVA_LIBRARIES := android.test.runner cts-junit android-support-v4
+LOCAL_JAVA_LIBRARIES := android.test.runner cts-junit
 
-LOCAL_STATIC_JAVA_LIBRARIES := ctstestrunner
+LOCAL_STATIC_JAVA_LIBRARIES = android-support-v4 ctstestrunner
 
 LOCAL_SDK_VERSION := current
 
diff --git a/hostsidetests/devicepolicy/app/ManagedProfile/src/com/android/cts/managedprofile/PermissionsTest.java b/hostsidetests/devicepolicy/app/ManagedProfile/src/com/android/cts/managedprofile/PermissionsTest.java
new file mode 100644
index 0000000..2faf158
--- /dev/null
+++ b/hostsidetests/devicepolicy/app/ManagedProfile/src/com/android/cts/managedprofile/PermissionsTest.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.cts.managedprofile;
+
+import android.app.admin.DevicePolicyManager;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.os.UserManager;
+
+import com.android.cts.managedprofile.BaseManagedProfileTest;
+
+import org.junit.Ignore;
+
+/**
+ * Test Runtime Permissions APIs in DevicePolicyManager.
+ */
+public class PermissionsTest extends BaseManagedProfileTest {
+
+    private static final String SIMPLE_APP_PACKAGE_NAME = "com.android.cts.launcherapps.simpleapp";
+    private static final String PERMISSION_NAME = "android.permission.READ_CONTACTS";
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        // Make sure we are running in a managed profile, otherwise risk wiping the primary user's
+        // data.
+        assertTrue(mDevicePolicyManager.isAdminActive(ADMIN_RECEIVER_COMPONENT));
+        assertTrue(mDevicePolicyManager.isProfileOwnerApp(
+                ADMIN_RECEIVER_COMPONENT.getPackageName()));
+    }
+
+    public void testPermissionGrantState() {
+        PackageManager pm = mContext.getPackageManager();
+        mDevicePolicyManager.setPermissionGrantState(ADMIN_RECEIVER_COMPONENT,
+                SIMPLE_APP_PACKAGE_NAME, PERMISSION_NAME,
+                DevicePolicyManager.PERMISSION_GRANT_STATE_DENIED);
+        assertTrue(mDevicePolicyManager.getPermissionGrantState(ADMIN_RECEIVER_COMPONENT,
+                SIMPLE_APP_PACKAGE_NAME, PERMISSION_NAME) ==
+                DevicePolicyManager.PERMISSION_GRANT_STATE_DENIED);
+        assertEquals(pm.checkPermission(PERMISSION_NAME, SIMPLE_APP_PACKAGE_NAME),
+                PackageManager.PERMISSION_DENIED);
+
+        mDevicePolicyManager.setPermissionGrantState(ADMIN_RECEIVER_COMPONENT,
+                SIMPLE_APP_PACKAGE_NAME, PERMISSION_NAME,
+                DevicePolicyManager.PERMISSION_GRANT_STATE_DEFAULT);
+        assertTrue(mDevicePolicyManager.getPermissionGrantState(ADMIN_RECEIVER_COMPONENT,
+                SIMPLE_APP_PACKAGE_NAME, PERMISSION_NAME) ==
+                DevicePolicyManager.PERMISSION_GRANT_STATE_DEFAULT);
+        // Should stay denied
+        assertEquals(pm.checkPermission(PERMISSION_NAME, SIMPLE_APP_PACKAGE_NAME),
+                PackageManager.PERMISSION_DENIED);
+
+        mDevicePolicyManager.setPermissionGrantState(ADMIN_RECEIVER_COMPONENT,
+                SIMPLE_APP_PACKAGE_NAME, PERMISSION_NAME,
+                DevicePolicyManager.PERMISSION_GRANT_STATE_GRANTED);
+        assertTrue(mDevicePolicyManager.getPermissionGrantState(ADMIN_RECEIVER_COMPONENT,
+                SIMPLE_APP_PACKAGE_NAME, PERMISSION_NAME) ==
+                DevicePolicyManager.PERMISSION_GRANT_STATE_GRANTED);
+        assertEquals(pm.checkPermission(PERMISSION_NAME, SIMPLE_APP_PACKAGE_NAME),
+                PackageManager.PERMISSION_GRANTED);
+
+        mDevicePolicyManager.setPermissionGrantState(ADMIN_RECEIVER_COMPONENT,
+                SIMPLE_APP_PACKAGE_NAME, PERMISSION_NAME,
+                DevicePolicyManager.PERMISSION_GRANT_STATE_DEFAULT);
+        assertTrue(mDevicePolicyManager.getPermissionGrantState(ADMIN_RECEIVER_COMPONENT,
+                SIMPLE_APP_PACKAGE_NAME, PERMISSION_NAME) ==
+                DevicePolicyManager.PERMISSION_GRANT_STATE_DEFAULT);
+        // Should stay granted
+        assertEquals(pm.checkPermission(PERMISSION_NAME, SIMPLE_APP_PACKAGE_NAME),
+                PackageManager.PERMISSION_GRANTED);
+
+        mDevicePolicyManager.setPermissionPolicy(ADMIN_RECEIVER_COMPONENT,
+                DevicePolicyManager.PERMISSION_POLICY_AUTO_DENY);
+        assertEquals(mDevicePolicyManager.getPermissionPolicy(ADMIN_RECEIVER_COMPONENT),
+                DevicePolicyManager.PERMISSION_POLICY_AUTO_DENY);
+
+        mDevicePolicyManager.setPermissionPolicy(ADMIN_RECEIVER_COMPONENT,
+                DevicePolicyManager.PERMISSION_POLICY_AUTO_GRANT);
+        assertEquals(mDevicePolicyManager.getPermissionPolicy(ADMIN_RECEIVER_COMPONENT),
+                DevicePolicyManager.PERMISSION_POLICY_AUTO_GRANT);
+
+        mDevicePolicyManager.setPermissionPolicy(ADMIN_RECEIVER_COMPONENT,
+                DevicePolicyManager.PERMISSION_POLICY_PROMPT);
+        assertEquals(mDevicePolicyManager.getPermissionPolicy(ADMIN_RECEIVER_COMPONENT),
+                DevicePolicyManager.PERMISSION_POLICY_PROMPT);
+    }
+}
diff --git a/hostsidetests/devicepolicy/app/SimpleApp/AndroidManifest.xml b/hostsidetests/devicepolicy/app/SimpleApp/AndroidManifest.xml
index af74f57..791ae56 100644
--- a/hostsidetests/devicepolicy/app/SimpleApp/AndroidManifest.xml
+++ b/hostsidetests/devicepolicy/app/SimpleApp/AndroidManifest.xml
@@ -18,6 +18,8 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="com.android.cts.launcherapps.simpleapp">
 
+    <uses-permission android:name="android.permission.READ_CONTACTS"/>
+
     <application>
         <activity android:name=".SimpleActivity" >
             <intent-filter>
diff --git a/hostsidetests/devicepolicy/src/com/android/cts/devicepolicy/ManagedProfileTest.java b/hostsidetests/devicepolicy/src/com/android/cts/devicepolicy/ManagedProfileTest.java
index 5c2048e..7d8fa67 100644
--- a/hostsidetests/devicepolicy/src/com/android/cts/devicepolicy/ManagedProfileTest.java
+++ b/hostsidetests/devicepolicy/src/com/android/cts/devicepolicy/ManagedProfileTest.java
@@ -30,6 +30,8 @@
     private static final String MANAGED_PROFILE_PKG = "com.android.cts.managedprofile";
     private static final String MANAGED_PROFILE_APK = "CtsManagedProfileApp.apk";
 
+    private static final String SIMPLE_APP_APK = "CtsSimpleApp.apk";
+
     private static final String INTENT_SENDER_PKG = "com.android.cts.intent.sender";
     private static final String INTENT_SENDER_APK = "CtsIntentSenderApp.apk";
 
@@ -406,6 +408,15 @@
         }
     }
 
+    public void testPermissionGrant() throws Exception {
+        if (!mHasFeature) {
+            return;
+        }
+        installApp(SIMPLE_APP_APK);
+        assertTrue(runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PermissionsTest",
+                "testPermissionGrantState", mUserId));
+    }
+
     private void disableActivityForUser(String activityName, int userId)
             throws DeviceNotAvailableException {
         String command = "am start -W --user " + userId
diff --git a/tests/tests/accounts/AndroidManifest.xml b/tests/tests/accounts/AndroidManifest.xml
index c671ff0..93529d0 100644
--- a/tests/tests/accounts/AndroidManifest.xml
+++ b/tests/tests/accounts/AndroidManifest.xml
@@ -43,10 +43,21 @@
             <intent-filter>
                 <action android:name="android.accounts.AccountAuthenticator" />
             </intent-filter>
-
             <meta-data android:name="android.accounts.AccountAuthenticator"
                        android:resource="@xml/authenticator" />
         </service>
+
+        <service android:name="MockCustomTokenAccountService" android:exported="true"
+                 android:process="android.accounts.cts">
+            <intent-filter>
+                <action android:name="android.accounts.AccountAuthenticator" />
+            </intent-filter>
+            <meta-data android:name="android.accounts.AccountAuthenticator"
+                       android:resource="@xml/custom_token_authenticator" />
+            <meta-data android:name="android.accounts.AccountAuthenticator.customTokens"
+                       android:value="1" />
+
+        </service>
     </application>
 
     <instrumentation android:name="android.support.test.runner.AndroidJUnitRunner"
diff --git a/tests/tests/accounts/res/drawable/ic_cts_minitab_selected_custom_account.png b/tests/tests/accounts/res/drawable/ic_cts_minitab_selected_custom_account.png
new file mode 100644
index 0000000..3fbbc94
--- /dev/null
+++ b/tests/tests/accounts/res/drawable/ic_cts_minitab_selected_custom_account.png
Binary files differ
diff --git a/tests/tests/accounts/res/drawable/ic_cts_selected_custom_account.png b/tests/tests/accounts/res/drawable/ic_cts_selected_custom_account.png
new file mode 100644
index 0000000..70e35c0
--- /dev/null
+++ b/tests/tests/accounts/res/drawable/ic_cts_selected_custom_account.png
Binary files differ
diff --git a/tests/tests/accounts/res/xml/custom_token_authenticator.xml b/tests/tests/accounts/res/xml/custom_token_authenticator.xml
new file mode 100644
index 0000000..3337917
--- /dev/null
+++ b/tests/tests/accounts/res/xml/custom_token_authenticator.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/**
+ * Copyright (c) 2009, 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.
+ */
+-->
+
+<!-- The attributes in this XML file provide configuration information -->
+<!-- for the Account Manager. -->
+
+<account-authenticator xmlns:android="http://schemas.android.com/apk/res/android"
+    android:accountType="android.accounts.cts.custom.account.type"
+    android:icon="@drawable/ic_cts_selected_custom_account"
+    android:smallIcon="@drawable/ic_cts_minitab_selected_custom_account"
+    android:customTokens="true"
+    android:label="@string/label"
+/>
diff --git a/tests/tests/accounts/src/android/accounts/cts/AccountManagerTest.java b/tests/tests/accounts/src/android/accounts/cts/AccountManagerTest.java
index c582c79..0e84fb9 100644
--- a/tests/tests/accounts/src/android/accounts/cts/AccountManagerTest.java
+++ b/tests/tests/accounts/src/android/accounts/cts/AccountManagerTest.java
@@ -26,16 +26,19 @@
 import android.accounts.OperationCanceledException;
 import android.app.Activity;
 import android.content.Context;
-import android.content.Intent;
 import android.os.Bundle;
 import android.os.Handler;
+import android.os.HandlerThread;
 import android.os.Looper;
 import android.os.StrictMode;
 import android.test.ActivityInstrumentationTestCase2;
 
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
 
 /**
  * You can run those unit tests with the following command line:
@@ -52,13 +55,15 @@
     public static final String ACCOUNT_NAME_OTHER = "android.accounts.cts.account.name.other";
 
     public static final String ACCOUNT_TYPE = "android.accounts.cts.account.type";
-    public static final String ACCOUNT_TYPE_OTHER = "android.accounts.cts.account.type.other";
+    public static final String ACCOUNT_TYPE_CUSTOM = "android.accounts.cts.custom.account.type";
+    public static final String ACCOUNT_TYPE_ABSENT = "android.accounts.cts.account.type.absent";
 
     public static final String ACCOUNT_PASSWORD = "android.accounts.cts.account.password";
 
-    public static final String AUTH_TOKEN = "mockAuthToken";
     public static final String AUTH_TOKEN_TYPE = "mockAuthTokenType";
+    public static final String AUTH_EXPIRING_TOKEN_TYPE = "mockAuthExpiringTokenType";
     public static final String AUTH_TOKEN_LABEL = "mockAuthTokenLabel";
+    public static final long AUTH_TOKEN_DURATION_MILLIS = 10000L; // Ten seconds.
 
     public static final String FEATURE_1 = "feature.1";
     public static final String FEATURE_2 = "feature.2";
@@ -86,6 +91,9 @@
             MockAccountAuthenticator.ACCOUNT_NAME_FOR_NEW_REMOVE_API, ACCOUNT_TYPE);
     public static final Account ACCOUNT_SAME_TYPE = new Account(ACCOUNT_NAME_OTHER, ACCOUNT_TYPE);
 
+    public static final Account CUSTOM_TOKEN_ACCOUNT =
+            new Account(ACCOUNT_NAME,ACCOUNT_TYPE_CUSTOM);
+
     private static MockAccountAuthenticator mockAuthenticator;
     private static final int LATCH_TIMEOUT_MS = 500;
     private static AccountManager am;
@@ -130,16 +138,101 @@
         assertTrue(removeAccount(am, ACCOUNT_SAME_TYPE, mActivity, null /* callback */).getBoolean(
                 AccountManager.KEY_BOOLEAN_RESULT));
 
+        // Clean out any other accounts added during the tests.
+        Account[] ctsAccounts = am.getAccountsByType(ACCOUNT_TYPE);
+        Account[] ctsCustomAccounts = am.getAccountsByType(ACCOUNT_TYPE_CUSTOM);
+        ArrayList<Account> accounts = new ArrayList<>(Arrays.asList(ctsAccounts));
+        accounts.addAll(Arrays.asList(ctsCustomAccounts));
+        for (Account ctsAccount : accounts) {
+            removeAccount(am, ctsAccount, mActivity, null /* callback */);
+        }
+
         // need to clean up the authenticator cached data
         mockAuthenticator.clearData();
 
         super.tearDown();
     }
 
-    private void validateAccountAndAuthTokenResult(Bundle result) {
-        assertEquals(ACCOUNT_NAME, result.get(AccountManager.KEY_ACCOUNT_NAME));
-        assertEquals(ACCOUNT_TYPE, result.get(AccountManager.KEY_ACCOUNT_TYPE));
-        assertEquals(AUTH_TOKEN, result.get(AccountManager.KEY_AUTHTOKEN));
+    interface TokenFetcher {
+        public Bundle fetch(String tokenType)
+                throws OperationCanceledException, AuthenticatorException, IOException;
+        public Account getAccount();
+    }
+
+    private void validateSuccessfulTokenFetchingLifecycle(TokenFetcher fetcher, String tokenType)
+            throws OperationCanceledException, AuthenticatorException, IOException {
+        Account account = fetcher.getAccount();
+        Bundle expected = new Bundle();
+        expected.putString(AccountManager.KEY_ACCOUNT_NAME, account.name);
+        expected.putString(AccountManager.KEY_ACCOUNT_TYPE, account.type);
+
+        // First fetch.
+        Bundle actual = fetcher.fetch(tokenType);
+        assertTrue(mockAuthenticator.isRecentlyCalled());
+        validateAccountAndAuthTokenResult(expected, actual);
+
+        /*
+         * On the second fetch the cache will be populated if we are using a authenticator with
+         * customTokens=false or we are using a scope that will cause the authenticator to set an
+         * expiration time (and that expiration time hasn't been reached).
+         */
+        actual = fetcher.fetch(tokenType);
+
+        boolean isCachingExpected =
+                ACCOUNT_TYPE.equals(account.type) || AUTH_EXPIRING_TOKEN_TYPE.equals(tokenType);
+        assertEquals(isCachingExpected, !mockAuthenticator.isRecentlyCalled());
+        validateAccountAndAuthTokenResult(expected, actual);
+
+        try {
+            // Delay further execution until expiring tokens can actually expire.
+            Thread.sleep(mockAuthenticator.getTokenDurationMillis() + 1L);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+
+        /*
+         * With the time shift above, the third request will result in cache hits only from
+         * customToken=false authenticators.
+         */
+        actual = fetcher.fetch(tokenType);
+        isCachingExpected = ACCOUNT_TYPE.equals(account.type);
+        assertEquals(isCachingExpected, !mockAuthenticator.isRecentlyCalled());
+        validateAccountAndAuthTokenResult(expected, actual);
+
+        // invalidate token
+        String token = actual.getString(AccountManager.KEY_AUTHTOKEN);
+        am.invalidateAuthToken(account.type, token);
+
+        /*
+         * Upon invalidating the token, the cache should be clear regardless of authenticator.
+         */
+        actual = fetcher.fetch(tokenType);
+        assertTrue(mockAuthenticator.isRecentlyCalled());
+        validateAccountAndAuthTokenResult(expected, actual);
+    }
+
+    private void validateAccountAndAuthTokenResult(Bundle actual) {
+        assertEquals(
+                ACCOUNT.name,
+                actual.get(AccountManager.KEY_ACCOUNT_NAME));
+        assertEquals(
+                ACCOUNT.type,
+                actual.get(AccountManager.KEY_ACCOUNT_TYPE));
+        assertEquals(
+                mockAuthenticator.getLastTokenServed(),
+                actual.get(AccountManager.KEY_AUTHTOKEN));
+    }
+
+    private void validateAccountAndAuthTokenResult(Bundle expected, Bundle actual) {
+        assertEquals(
+                expected.get(AccountManager.KEY_ACCOUNT_NAME),
+                actual.get(AccountManager.KEY_ACCOUNT_NAME));
+        assertEquals(
+                expected.get(AccountManager.KEY_ACCOUNT_TYPE),
+                actual.get(AccountManager.KEY_ACCOUNT_TYPE));
+        assertEquals(
+                mockAuthenticator.getLastTokenServed(),
+                actual.get(AccountManager.KEY_AUTHTOKEN));
     }
 
     private void validateAccountAndNoAuthTokenResult(Bundle result) {
@@ -224,7 +317,6 @@
     private boolean removeAccount(AccountManager am, Account account,
             AccountManagerCallback<Boolean> callback) throws IOException, AuthenticatorException,
                 OperationCanceledException {
-
         AccountManagerFuture<Boolean> futureBoolean = am.removeAccount(account,
                 callback,
                 null /* handler */);
@@ -357,6 +449,7 @@
         final CountDownLatch latch = new CountDownLatch(1);
 
         AccountManagerCallback<Bundle> callback = new AccountManagerCallback<Bundle>() {
+            @Override
             public void run(AccountManagerFuture<Bundle> bundleFuture) {
                 Bundle resultBundle = null;
                 try {
@@ -483,9 +576,7 @@
     /**
      * Test addAccountExplicitly() and removeAccountExplictly().
      */
-    public void testAddAccountExplicitlyAndRemoveAccountExplicitly() throws IOException,
-            AuthenticatorException, OperationCanceledException {
-
+    public void testAddAccountExplicitlyAndRemoveAccountExplicitly() {
         final int expectedAccountsCount = getAccountsCount();
 
         addAccountExplicitly(ACCOUNT, ACCOUNT_PASSWORD, null /* userData */);
@@ -581,7 +672,7 @@
         assertEquals(2, accounts.length);
 
         // Check if we dont have any account from the other type
-        accounts = am.getAccountsByType(ACCOUNT_TYPE_OTHER);
+        accounts = am.getAccountsByType(ACCOUNT_TYPE_ABSENT);
         assertEquals(0, accounts.length);
     }
 
@@ -684,6 +775,7 @@
         final CountDownLatch latch1 = new CountDownLatch(1);
 
         AccountManagerCallback<Account[]> callback1 = new AccountManagerCallback<Account[]>() {
+            @Override
             public void run(AccountManagerFuture<Account[]> accountsFuture) {
                 try {
                     Account[] accounts = accountsFuture.getResult();
@@ -724,6 +816,7 @@
         final CountDownLatch latch2 = new CountDownLatch(1);
 
         AccountManagerCallback<Account[]> callback2 = new AccountManagerCallback<Account[]>() {
+            @Override
             public void run(AccountManagerFuture<Account[]> accountsFuture) {
                 try {
                     Account[] accounts = accountsFuture.getResult();
@@ -765,25 +858,24 @@
      */
     public void testSetAndPeekAndInvalidateAuthToken() {
         addAccountExplicitly(ACCOUNT, ACCOUNT_PASSWORD, null /* userData */);
-
-        am.setAuthToken(ACCOUNT, AUTH_TOKEN_TYPE, AUTH_TOKEN);
+        String expected = "x";
+        am.setAuthToken(ACCOUNT, AUTH_TOKEN_TYPE, expected);
 
         // Ask for the AuthToken
         String token = am.peekAuthToken(ACCOUNT, AUTH_TOKEN_TYPE);
         assertNotNull(token);
-        assertEquals(AUTH_TOKEN, token);
+        assertEquals(expected, token);
 
-        am.invalidateAuthToken(ACCOUNT_TYPE, AUTH_TOKEN);
+        am.invalidateAuthToken(ACCOUNT_TYPE, token);
         token = am.peekAuthToken(ACCOUNT, AUTH_TOKEN_TYPE);
         assertNull(token);
     }
 
     /**
-     * Test blockingGetAuthToken()
+     * Test successful blockingGetAuthToken() with customTokens=false authenticator.
      */
-    public void testBlockingGetAuthToken() throws IOException, AuthenticatorException,
-            OperationCanceledException {
-
+    public void testBlockingGetAuthToken_DefaultToken_Success()
+            throws IOException, AuthenticatorException, OperationCanceledException {
         addAccountExplicitly(ACCOUNT, ACCOUNT_PASSWORD, null);
 
         String token = am.blockingGetAuthToken(ACCOUNT,
@@ -792,17 +884,61 @@
 
         // Ask for the AuthToken
         assertNotNull(token);
-        assertEquals(AUTH_TOKEN, token);
+        assertEquals(mockAuthenticator.getLastTokenServed(), token);
+    }
+
+    private static class BlockingGetAuthTokenFetcher implements TokenFetcher {
+        private final Account mAccount;
+
+        BlockingGetAuthTokenFetcher(Account account) {
+            mAccount = account;
+        }
+
+        @Override
+        public Bundle fetch(String tokenType)
+                throws OperationCanceledException, AuthenticatorException, IOException {
+            String token = am.blockingGetAuthToken(
+                    getAccount(),
+                    tokenType,
+                    false /* no failure notification */);
+            Bundle result = new Bundle();
+            result.putString(AccountManager.KEY_AUTHTOKEN, token);
+            result.putString(AccountManager.KEY_ACCOUNT_NAME, mAccount.name);
+            result.putString(AccountManager.KEY_ACCOUNT_TYPE, mAccount.type);
+            return result;
+        }
+        @Override
+        public Account getAccount() {
+            return CUSTOM_TOKEN_ACCOUNT;
+        }
     }
 
     /**
-     * Test getAuthToken()
+     * Test successful blockingGetAuthToken() with customTokens=true authenticator.
      */
-    public void testGetAuthToken() throws IOException, AuthenticatorException,
-            OperationCanceledException {
+    public void testBlockingGetAuthToken_CustomToken_NoCaching_Success()
+            throws IOException, AuthenticatorException, OperationCanceledException {
+        addAccountExplicitly(CUSTOM_TOKEN_ACCOUNT, ACCOUNT_PASSWORD, null);
+        TokenFetcher f = new BlockingGetAuthTokenFetcher(CUSTOM_TOKEN_ACCOUNT);
+        validateSuccessfulTokenFetchingLifecycle(f, AUTH_TOKEN_TYPE);
+    }
 
+    /**
+     * Test successful blockingGetAuthToken() with customTokens=true authenticator.
+     */
+    public void testBlockingGetAuthToken_CustomToken_ExpiringCache_Success()
+            throws IOException, AuthenticatorException, OperationCanceledException {
+        addAccountExplicitly(CUSTOM_TOKEN_ACCOUNT, ACCOUNT_PASSWORD, null);
+        TokenFetcher f = new BlockingGetAuthTokenFetcher(CUSTOM_TOKEN_ACCOUNT);
+        validateSuccessfulTokenFetchingLifecycle(f, AUTH_EXPIRING_TOKEN_TYPE);
+    }
+
+    /**
+     * Test successful getAuthToken() using a future with customTokens=false authenticator.
+     */
+    public void testDeprecatedGetAuthTokenWithFuture_NoOptions_DefaultToken_Success()
+            throws IOException, AuthenticatorException, OperationCanceledException {
         addAccountExplicitly(ACCOUNT, ACCOUNT_PASSWORD, null /* userData */);
-
         AccountManagerFuture<Bundle> futureBundle = am.getAuthToken(ACCOUNT,
                 AUTH_TOKEN_TYPE,
                 false /* no failure notification */,
@@ -820,6 +956,226 @@
     }
 
     /**
+     * Test successful getAuthToken() using a future with customTokens=false without
+     * expiring tokens.
+     */
+    public void testDeprecatedGetAuthTokenWithFuture_NoOptions_CustomToken_Success()
+            throws IOException, AuthenticatorException, OperationCanceledException {
+        addAccountExplicitly(CUSTOM_TOKEN_ACCOUNT, ACCOUNT_PASSWORD, null);
+        // validateSuccessfulTokenFetchingLifecycle(AccountManager am, TokenFetcher fetcher, String tokenType)
+        TokenFetcher f = new TokenFetcher() {
+            @Override
+            public Bundle fetch(String tokenType)
+                    throws OperationCanceledException, AuthenticatorException, IOException {
+                AccountManagerFuture<Bundle> futureBundle = am.getAuthToken(
+                        getAccount(),
+                        tokenType,
+                        false /* no failure notification */,
+                        null /* no callback */,
+                        null /* no handler */
+                );
+                Bundle actual = futureBundle.getResult();
+                assertTrue(futureBundle.isDone());
+                assertNotNull(actual);
+                return actual;
+            }
+
+            @Override
+            public Account getAccount() {
+                return CUSTOM_TOKEN_ACCOUNT;
+            }
+        };
+        validateSuccessfulTokenFetchingLifecycle(f, AUTH_EXPIRING_TOKEN_TYPE);
+        validateSuccessfulTokenFetchingLifecycle(f, AUTH_TOKEN_TYPE);
+    }
+
+    /**
+     * Test successful getAuthToken() using a future with customTokens=false without
+     * expiring tokens.
+     */
+    public void testGetAuthTokenWithFuture_Options_DefaultToken_Success()
+            throws IOException, AuthenticatorException, OperationCanceledException {
+        addAccountExplicitly(ACCOUNT, ACCOUNT_PASSWORD, null /* userData */);
+
+        AccountManagerFuture<Bundle> futureBundle = am.getAuthToken(ACCOUNT,
+                AUTH_TOKEN_TYPE,
+                OPTIONS_BUNDLE,
+                mActivity,
+                null /* no callback */,
+                null /* no handler */
+        );
+
+        Bundle resultBundle = futureBundle.getResult();
+
+        assertTrue(futureBundle.isDone());
+        assertNotNull(resultBundle);
+
+        // Assert returned result
+        validateAccountAndAuthTokenResult(resultBundle);
+
+        validateOptions(null, mockAuthenticator.mOptionsAddAccount);
+        validateOptions(null, mockAuthenticator.mOptionsUpdateCredentials);
+        validateOptions(null, mockAuthenticator.mOptionsConfirmCredentials);
+        validateOptions(OPTIONS_BUNDLE, mockAuthenticator.mOptionsGetAuthToken);
+        validateSystemOptions(mockAuthenticator.mOptionsGetAuthToken);
+    }
+
+    /**
+     * Test successful getAuthToken() using a future with customTokens=false without
+     * expiring tokens.
+     */
+    public void testGetAuthTokenWithFuture_Options_CustomToken_Success()
+            throws IOException, AuthenticatorException, OperationCanceledException {
+        addAccountExplicitly(CUSTOM_TOKEN_ACCOUNT, ACCOUNT_PASSWORD, null);
+        TokenFetcher fetcherWithOptions = new TokenFetcher() {
+            @Override
+            public Bundle fetch(String tokenType)
+                    throws OperationCanceledException, AuthenticatorException, IOException {
+                AccountManagerFuture<Bundle> futureBundle = am.getAuthToken(
+                        getAccount(),
+                        tokenType,
+                        OPTIONS_BUNDLE,
+                        false /* no failure notification */,
+                        null /* no callback */,
+                        null /* no handler */
+                );
+                Bundle actual = futureBundle.getResult();
+                assertTrue(futureBundle.isDone());
+                assertNotNull(actual);
+                return actual;
+            }
+
+            @Override
+            public Account getAccount() {
+                return CUSTOM_TOKEN_ACCOUNT;
+            }
+        };
+        validateSuccessfulTokenFetchingLifecycle(fetcherWithOptions, AUTH_TOKEN_TYPE);
+        validateSuccessfulTokenFetchingLifecycle(fetcherWithOptions, AUTH_EXPIRING_TOKEN_TYPE);
+    }
+
+
+    /**
+     * Test successful getAuthToken() using a future with customTokens=false without
+     * expiring tokens.
+     */
+    public void testGetAuthTokenWithCallback_Options_Handler_DefaultToken_Success()
+            throws IOException, AuthenticatorException, OperationCanceledException {
+        addAccountExplicitly(ACCOUNT, ACCOUNT_PASSWORD, null);
+        final HandlerThread handlerThread = new HandlerThread("accounts.test");
+        handlerThread.start();
+        TokenFetcher fetcherWithOptions = new TokenFetcher() {
+            @Override
+            public Bundle fetch(String tokenType)
+                    throws OperationCanceledException, AuthenticatorException, IOException {
+                final AtomicReference<Bundle> actualRef = new AtomicReference<>();
+                final CountDownLatch latch = new CountDownLatch(1);
+
+                AccountManagerCallback<Bundle> callback = new AccountManagerCallback<Bundle>() {
+                    @Override
+                    public void run(AccountManagerFuture<Bundle> bundleFuture) {
+                        Bundle resultBundle = null;
+                        try {
+                            resultBundle = bundleFuture.getResult();
+                            actualRef.set(resultBundle);
+                        } catch (OperationCanceledException e) {
+                            fail("should not throw an OperationCanceledException");
+                        } catch (IOException e) {
+                            fail("should not throw an IOException");
+                        } catch (AuthenticatorException e) {
+                            fail("should not throw an AuthenticatorException");
+                        } finally {
+                            latch.countDown();
+                        }
+                    }
+                };
+
+                am.getAuthToken(getAccount(),
+                        tokenType,
+                        OPTIONS_BUNDLE,
+                        false /* no failure notification */,
+                        callback,
+                        new Handler(handlerThread.getLooper()));
+
+                // Wait with timeout for the callback to do its work
+                try {
+                    latch.await(LATCH_TIMEOUT_MS, TimeUnit.MILLISECONDS);
+                } catch (InterruptedException e) {
+                    fail("should not throw an InterruptedException");
+                }
+                return actualRef.get();
+            }
+
+            @Override
+            public Account getAccount() {
+                return ACCOUNT;
+            }
+        };
+        validateSuccessfulTokenFetchingLifecycle(fetcherWithOptions, AUTH_TOKEN_TYPE);
+        validateSuccessfulTokenFetchingLifecycle(fetcherWithOptions, AUTH_EXPIRING_TOKEN_TYPE);
+    }
+
+    /**
+     * Test successful getAuthToken() using a future with customTokens=false without
+     * expiring tokens.
+     */
+    public void testGetAuthTokenWithCallback_Options_Handler_CustomToken_Success()
+            throws IOException, AuthenticatorException, OperationCanceledException {
+        addAccountExplicitly(CUSTOM_TOKEN_ACCOUNT, ACCOUNT_PASSWORD, null);
+        final HandlerThread handlerThread = new HandlerThread("accounts.test");
+        handlerThread.start();
+        TokenFetcher fetcherWithOptions = new TokenFetcher() {
+            @Override
+            public Bundle fetch(String tokenType)
+                    throws OperationCanceledException, AuthenticatorException, IOException {
+                final AtomicReference<Bundle> actualRef = new AtomicReference<>();
+                final CountDownLatch latch = new CountDownLatch(1);
+
+                AccountManagerCallback<Bundle> callback = new AccountManagerCallback<Bundle>() {
+                    @Override
+                    public void run(AccountManagerFuture<Bundle> bundleFuture) {
+                        Bundle resultBundle = null;
+                        try {
+                            resultBundle = bundleFuture.getResult();
+                            actualRef.set(resultBundle);
+                        } catch (OperationCanceledException e) {
+                            fail("should not throw an OperationCanceledException");
+                        } catch (IOException e) {
+                            fail("should not throw an IOException");
+                        } catch (AuthenticatorException e) {
+                            fail("should not throw an AuthenticatorException");
+                        } finally {
+                            latch.countDown();
+                        }
+                    }
+                };
+
+                am.getAuthToken(getAccount(),
+                        tokenType,
+                        OPTIONS_BUNDLE,
+                        false /* no failure notification */,
+                        callback,
+                        new Handler(handlerThread.getLooper()));
+
+                // Wait with timeout for the callback to do its work
+                try {
+                    latch.await(LATCH_TIMEOUT_MS, TimeUnit.MILLISECONDS);
+                } catch (InterruptedException e) {
+                    fail("should not throw an InterruptedException");
+                }
+                return actualRef.get();
+            }
+
+            @Override
+            public Account getAccount() {
+                return CUSTOM_TOKEN_ACCOUNT;
+            }
+        };
+        validateSuccessfulTokenFetchingLifecycle(fetcherWithOptions, AUTH_TOKEN_TYPE);
+        validateSuccessfulTokenFetchingLifecycle(fetcherWithOptions, AUTH_EXPIRING_TOKEN_TYPE);
+    }
+
+    /**
      * Test getAuthToken() with callback and handler
      */
     public void testGetAuthTokenWithCallbackAndHandler() throws IOException, AuthenticatorException,
@@ -837,6 +1193,7 @@
         final CountDownLatch latch = new CountDownLatch(1);
 
         AccountManagerCallback<Bundle> callback = new AccountManagerCallback<Bundle>() {
+            @Override
             public void run(AccountManagerFuture<Bundle> bundleFuture) {
 
                 Bundle resultBundle = null;
@@ -880,37 +1237,6 @@
     }
 
     /**
-     * test getAuthToken() with options
-     */
-    public void testGetAuthTokenWithOptions() throws IOException, AuthenticatorException,
-            OperationCanceledException {
-
-        addAccountExplicitly(ACCOUNT, ACCOUNT_PASSWORD, null /* userData */);
-
-        AccountManagerFuture<Bundle> futureBundle = am.getAuthToken(ACCOUNT,
-                AUTH_TOKEN_TYPE,
-                OPTIONS_BUNDLE,
-                mActivity,
-                null /* no callback */,
-                null /* no handler */
-        );
-
-        Bundle resultBundle = futureBundle.getResult();
-
-        assertTrue(futureBundle.isDone());
-        assertNotNull(resultBundle);
-
-        // Assert returned result
-        validateAccountAndAuthTokenResult(resultBundle);
-
-        validateOptions(null, mockAuthenticator.mOptionsAddAccount);
-        validateOptions(null, mockAuthenticator.mOptionsUpdateCredentials);
-        validateOptions(null, mockAuthenticator.mOptionsConfirmCredentials);
-        validateOptions(OPTIONS_BUNDLE, mockAuthenticator.mOptionsGetAuthToken);
-        validateSystemOptions(mockAuthenticator.mOptionsGetAuthToken);
-    }
-
-    /**
      * test getAuthToken() with options and callback and handler
      */
     public void testGetAuthTokenWithOptionsAndCallback() throws IOException,
@@ -928,15 +1254,14 @@
         final CountDownLatch latch = new CountDownLatch(1);
 
         AccountManagerCallback<Bundle> callback = new AccountManagerCallback<Bundle>() {
+            @Override
             public void run(AccountManagerFuture<Bundle> bundleFuture) {
 
                 Bundle resultBundle = null;
                 try {
                     resultBundle = bundleFuture.getResult();
-
                     // Assert returned result
                     validateAccountAndAuthTokenResult(resultBundle);
-
                 } catch (OperationCanceledException e) {
                     fail("should not throw an OperationCanceledException");
                 } catch (IOException e) {
@@ -1039,7 +1364,6 @@
         validateOptions(null, mockAuthenticator.mOptionsUpdateCredentials);
         validateOptions(null, mockAuthenticator.mOptionsConfirmCredentials);
         validateOptions(null, mockAuthenticator.mOptionsGetAuthToken);
-
     }
 
     /**
@@ -1154,8 +1478,7 @@
     /**
      * Test confirmCredentials() with callback
      */
-    public void testConfirmCredentialsWithCallbackAndHandler() throws IOException,
-            AuthenticatorException, OperationCanceledException {
+    public void testConfirmCredentialsWithCallbackAndHandler() {
 
         addAccountExplicitly(ACCOUNT, ACCOUNT_PASSWORD, null /* userData */);
 
@@ -1163,12 +1486,10 @@
         testConfirmCredentialsWithCallbackAndHandler(new Handler(Looper.getMainLooper()));
     }
 
-    private void testConfirmCredentialsWithCallbackAndHandler(Handler handler) throws IOException,
-            AuthenticatorException, OperationCanceledException {
-
+    private void testConfirmCredentialsWithCallbackAndHandler(Handler handler) {
         final CountDownLatch latch = new CountDownLatch(1);
-
         AccountManagerCallback<Bundle> callback = new AccountManagerCallback<Bundle>() {
+            @Override
             public void run(AccountManagerFuture<Bundle> bundleFuture) {
 
                 Bundle resultBundle = null;
@@ -1191,15 +1512,11 @@
                 }
             }
         };
-
         AccountManagerFuture<Bundle> futureBundle = am.confirmCredentials(ACCOUNT,
                 OPTIONS_BUNDLE,
                 mActivity,
                 callback,
                 handler);
-
-        // futureBundle.getResult();
-
         // Wait with timeout for the callback to do its work
         try {
             latch.await(3 * LATCH_TIMEOUT_MS, TimeUnit.MILLISECONDS);
@@ -1249,6 +1566,7 @@
         final CountDownLatch latch = new CountDownLatch(1);
 
         AccountManagerCallback<Bundle> callback = new AccountManagerCallback<Bundle>() {
+            @Override
             public void run(AccountManagerFuture<Bundle> bundleFuture) {
 
                 Bundle resultBundle = null;
@@ -1320,6 +1638,7 @@
         final CountDownLatch latch = new CountDownLatch(1);
 
         AccountManagerCallback<Bundle> callback = new AccountManagerCallback<Bundle>() {
+            @Override
             public void run(AccountManagerFuture<Bundle> bundleFuture) {
                 try {
                     // Assert returned result
@@ -1381,6 +1700,7 @@
         final CountDownLatch latch = new CountDownLatch(1);
 
         OnAccountsUpdateListener listener = new OnAccountsUpdateListener() {
+            @Override
             public void onAccountsUpdated(Account[] accounts) {
                 latch.countDown();
             }
@@ -1423,6 +1743,7 @@
         final CountDownLatch latch = new CountDownLatch(1);
 
         OnAccountsUpdateListener listener = new OnAccountsUpdateListener() {
+            @Override
             public void onAccountsUpdated(Account[] accounts) {
                 fail("should not be called");
             }
@@ -1513,6 +1834,7 @@
 
     private AccountManagerCallback<Boolean> getAssertTrueCallback(final CountDownLatch latch) {
         return new AccountManagerCallback<Boolean>() {
+            @Override
             public void run(AccountManagerFuture<Boolean> booleanFuture) {
                 try {
                     // Assert returned result should be TRUE
@@ -1528,6 +1850,7 @@
 
     private AccountManagerCallback<Boolean> getAssertFalseCallback(final CountDownLatch latch) {
         return new AccountManagerCallback<Boolean>() {
+            @Override
             public void run(AccountManagerFuture<Boolean> booleanFuture) {
                 try {
                     // Assert returned result should be FALSE
@@ -1613,7 +1936,7 @@
         Bundle options = new Bundle();
         options.putBoolean(MockAccountAuthenticator.KEY_RETURN_INTENT, true);
         // Not really confirming, but a way to get last authenticated timestamp
-        Bundle result = am.confirmCredentials(ACCOUNT,
+        Bundle result = am.confirmCredentials(account,
                 options,// OPTIONS_BUNDLE,
                 null, /* activity */
                 null /* callback */,
@@ -1631,8 +1954,7 @@
     /**
      * Tests that AccountManagerService is properly caching data.
      */
-    public void testGetsAreCached() throws IOException, AuthenticatorException,
-            OperationCanceledException {
+    public void testGetsAreCached() {
 
         // Add an account,
         assertEquals(false, isAccountPresent(am.getAccounts(), ACCOUNT));
diff --git a/tests/tests/accounts/src/android/accounts/cts/MockAccountAuthenticator.java b/tests/tests/accounts/src/android/accounts/cts/MockAccountAuthenticator.java
index eec4eff..faebd53 100644
--- a/tests/tests/accounts/src/android/accounts/cts/MockAccountAuthenticator.java
+++ b/tests/tests/accounts/src/android/accounts/cts/MockAccountAuthenticator.java
@@ -24,13 +24,17 @@
 import android.content.Context;
 import android.content.Intent;
 import android.os.Bundle;
+import android.util.Log;
 
 import java.util.ArrayList;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
 
 /**
  * A simple Mock Account Authenticator
  */
 public class MockAccountAuthenticator extends AbstractAccountAuthenticator {
+    private static String TAG = "AccountManagerTest";
 
     public static String KEY_ACCOUNT_INFO = "key_account_info";
     public static String KEY_ACCOUNT_AUTHENTICATOR_RESPONSE = "key_account_authenticator_response";
@@ -40,6 +44,9 @@
     public static String ACCOUNT_NAME_FOR_NEW_REMOVE_API1 = "call new removeAccount api";
 
     private final Context mContext;
+    private final AtomicInteger mTokenCounter  = new AtomicInteger(0);
+    private final AtomicBoolean mIsRecentlyCalled = new AtomicBoolean(false);
+
     AccountAuthenticatorResponse mResponse;
     String mAccountType;
     String mAuthTokenType;
@@ -52,6 +59,7 @@
     String[] mFeatures;
 
     final ArrayList<String> mockFeatureList = new ArrayList<String>();
+    private final long mTokenDurationMillis = 1000; // 1 second
 
     public MockAccountAuthenticator(Context context) {
         super(context);
@@ -62,6 +70,18 @@
         mockFeatureList.add(AccountManagerTest.FEATURE_2);
     }
 
+    public long getTokenDurationMillis() {
+        return mTokenDurationMillis;
+    }
+
+    public boolean isRecentlyCalled() {
+        return mIsRecentlyCalled.getAndSet(false);
+    }
+
+    public String getLastTokenServed() {
+        return Integer.toString(mTokenCounter.get());
+    }
+
     public AccountAuthenticatorResponse getResponse() {
         return mResponse;
     }
@@ -113,8 +133,9 @@
         Bundle result = new Bundle();
         result.putString(AccountManager.KEY_ACCOUNT_NAME, AccountManagerTest.ACCOUNT_NAME);
         result.putString(AccountManager.KEY_ACCOUNT_TYPE, AccountManagerTest.ACCOUNT_TYPE);
-        result.putString(AccountManager.KEY_AUTHTOKEN, AccountManagerTest.AUTH_TOKEN);
-
+        result.putString(
+                AccountManager.KEY_AUTHTOKEN,
+                Integer.toString(mTokenCounter.incrementAndGet()));
         return result;
     }
 
@@ -125,13 +146,11 @@
     public Bundle addAccount(AccountAuthenticatorResponse response, String accountType,
             String authTokenType, String[] requiredFeatures, Bundle options)
             throws NetworkErrorException {
-
         this.mResponse = response;
         this.mAccountType = accountType;
         this.mAuthTokenType = authTokenType;
         this.mRequiredFeatures = requiredFeatures;
         this.mOptionsAddAccount = options;
-
         return createResultBundle();
     }
 
@@ -141,12 +160,10 @@
     @Override
     public Bundle updateCredentials(AccountAuthenticatorResponse response, Account account,
             String authTokenType, Bundle options) throws NetworkErrorException {
-
         this.mResponse = response;
         this.mAccount = account;
         this.mAuthTokenType = authTokenType;
         this.mOptionsUpdateCredentials = options;
-
         return createResultBundle();
     }
 
@@ -157,10 +174,8 @@
      */
     @Override
     public Bundle editProperties(AccountAuthenticatorResponse response, String accountType) {
-
         this.mResponse = response;
         this.mAccountType = accountType;
-
         return createResultBundle();
     }
 
@@ -170,11 +185,9 @@
     @Override
     public Bundle confirmCredentials(AccountAuthenticatorResponse response, Account account,
             Bundle options) throws NetworkErrorException {
-
         this.mResponse = response;
         this.mAccount = account;
         this.mOptionsConfirmCredentials = options;
-
         Bundle result = new Bundle();
         if (options.containsKey(KEY_RETURN_INTENT)) {
             Intent intent = new Intent();
@@ -191,15 +204,35 @@
      * Gets the authtoken for an account.
      */
     @Override
-    public Bundle getAuthToken(AccountAuthenticatorResponse response, Account account,
-            String authTokenType, Bundle options) throws NetworkErrorException {
-
+    public Bundle getAuthToken(
+            AccountAuthenticatorResponse response,
+            Account account,
+            String authTokenType,
+            Bundle options) throws NetworkErrorException {
+        Log.w(TAG, "MockAuth - getAuthToken@" + System.currentTimeMillis());
+        mIsRecentlyCalled.set(true);
         this.mResponse = response;
         this.mAccount = account;
         this.mAuthTokenType = authTokenType;
         this.mOptionsGetAuthToken = options;
+        Bundle result = new Bundle();
 
-        return createResultBundle();
+        result.putString(AccountManager.KEY_ACCOUNT_NAME, account.name);
+        result.putString(AccountManager.KEY_ACCOUNT_TYPE, account.type);
+        String token;
+        if (AccountManagerTest.AUTH_EXPIRING_TOKEN_TYPE.equals(authTokenType)) {
+            /*
+             * The resultant token should simply be the expiration timestamp. E.g. the time after
+             * which getting a new AUTH_EXPIRING_TOKEN_TYPE typed token will return a different
+             * value.
+             */
+            long expiry = System.currentTimeMillis() + mTokenDurationMillis;
+            result.putLong(AbstractAccountAuthenticator.KEY_CUSTOM_TOKEN_EXPIRY, expiry);
+        }
+        result.putString(
+                AccountManager.KEY_AUTHTOKEN,
+                Integer.toString(mTokenCounter.incrementAndGet()));
+        return result;
     }
 
     /**
@@ -208,7 +241,6 @@
     @Override
     public String getAuthTokenLabel(String authTokenType) {
         this.mAuthTokenType = authTokenType;
-
         return AccountManagerTest.AUTH_TOKEN_LABEL;
     }
 
@@ -261,4 +293,4 @@
         }
         return result;
     }
-}
\ No newline at end of file
+}
diff --git a/tests/tests/accounts/src/android/accounts/cts/MockCustomTokenAccountService.java b/tests/tests/accounts/src/android/accounts/cts/MockCustomTokenAccountService.java
new file mode 100644
index 0000000..ea06a41
--- /dev/null
+++ b/tests/tests/accounts/src/android/accounts/cts/MockCustomTokenAccountService.java
@@ -0,0 +1,13 @@
+package android.accounts.cts;
+
+import android.app.Service;
+import android.content.Intent;
+import android.os.IBinder;
+
+public class MockCustomTokenAccountService extends Service {
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        return AccountManagerTest.getMockAuthenticator(this).getIBinder();
+    }
+}
diff --git a/tests/tests/content/AndroidManifest.xml b/tests/tests/content/AndroidManifest.xml
index 6cddfd1..a20befb 100644
--- a/tests/tests/content/AndroidManifest.xml
+++ b/tests/tests/content/AndroidManifest.xml
@@ -43,6 +43,12 @@
             android:label="@string/permlab_costMoney"
             android:description="@string/permdesc_costMoney"/>
 
+    <permission android:name="com.android.cts.content.CALL_ABROAD_PERMISSION"
+                android:label="@string/permlab_callAbroad"
+                android:description="@string/permdesc_callAbroad"
+                android:protectionLevel="normal"
+                android:permissionGroup="android.permission-group.COST_MONEY" />
+
     <!-- Used for PackageManager test, don't delete! -->
     <uses-configuration/>
     <uses-feature android:name="android.hardware.camera" />
diff --git a/tests/tests/content/res/values/strings.xml b/tests/tests/content/res/values/strings.xml
index c546d8a..8ffb477 100644
--- a/tests/tests/content/res/values/strings.xml
+++ b/tests/tests/content/res/values/strings.xml
@@ -179,5 +179,7 @@
 
     <string name="permlab_costMoney">Cost money</string>
     <string name="permdesc_costMoney">Do things that can cost you money.</string>
+    <string name="permlab_callAbroad">Call abroad</string>
+    <string name="permdesc_callAbroad">Make calls abroad</string>
 
 </resources>
diff --git a/tests/tests/content/src/android/content/pm/cts/PackageManagerTest.java b/tests/tests/content/src/android/content/pm/cts/PackageManagerTest.java
index aaab8c4..cb3de2a 100644
--- a/tests/tests/content/src/android/content/pm/cts/PackageManagerTest.java
+++ b/tests/tests/content/src/android/content/pm/cts/PackageManagerTest.java
@@ -107,10 +107,10 @@
         checkActivityInfoName(RECEIVER_NAME, broadcastReceivers);
 
         // Test queryPermissionsByGroup, queryContentProviders
-        String testPermissionsGroup = "android.permission-group.NETWORK";
+        String testPermissionsGroup = "android.permission-group.COST_MONEY";
         List<PermissionInfo> permissions = mPackageManager.queryPermissionsByGroup(
                 testPermissionsGroup, PackageManager.GET_META_DATA);
-        checkPermissionInfoName(PERMISSION_NAME, permissions);
+        checkPermissionInfoName("com.android.cts.content.CALL_ABROAD_PERMISSION", permissions);
 
         ApplicationInfo appInfo = mPackageManager.getApplicationInfo(PACKAGE_NAME, 0);
         List<ProviderInfo> providers = mPackageManager.queryContentProviders(PACKAGE_NAME,
@@ -148,17 +148,12 @@
     }
 
     private void checkPermissionInfoName(String expectedName, List<PermissionInfo> permissions) {
-        boolean isContained = false;
-        Iterator<PermissionInfo> infoIterator = permissions.iterator();
-        String current;
-        while (infoIterator.hasNext()) {
-            current = infoIterator.next().name;
-            if (current.equals(expectedName)) {
-                isContained = true;
-                break;
-            }
+        List<String> names = new ArrayList<String>();
+        for (PermissionInfo permission : permissions) {
+            names.add(permission.name);
         }
-        assertTrue(isContained);
+        boolean isContained = names.contains(expectedName);
+        assertTrue("Permission " + expectedName + " not present in " + names, isContained);
     }
 
     private void checkProviderInfoName(String expectedName, List<ProviderInfo> providers) {
diff --git a/tests/tests/graphics/src/android/graphics/drawable/cts/AnimatedVectorDrawableTest.java b/tests/tests/graphics/src/android/graphics/drawable/cts/AnimatedVectorDrawableTest.java
index 4a00adb..769e110 100644
--- a/tests/tests/graphics/src/android/graphics/drawable/cts/AnimatedVectorDrawableTest.java
+++ b/tests/tests/graphics/src/android/graphics/drawable/cts/AnimatedVectorDrawableTest.java
@@ -190,6 +190,19 @@
         assertEquals(originalAlpha, d3.getAlpha());
     }
 
+    public void testReset() {
+        final AnimatedVectorDrawable d1 = (AnimatedVectorDrawable) mResources.getDrawable(mResId);
+        // The AVD has a duration as 100ms.
+        mActivity.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                d1.reset();
+                assertFalse(d1.isRunning());
+            }
+        });
+
+    }
+
     public void testAddCallback() throws InterruptedException {
         MyCallback callback = new MyCallback();
         final AnimatedVectorDrawable d1 = (AnimatedVectorDrawable) mResources.getDrawable(mResId);
diff --git a/tests/tests/graphics/src/android/graphics/drawable/cts/VectorDrawableTest.java b/tests/tests/graphics/src/android/graphics/drawable/cts/VectorDrawableTest.java
index fdb8dae..fdc7b7a 100644
--- a/tests/tests/graphics/src/android/graphics/drawable/cts/VectorDrawableTest.java
+++ b/tests/tests/graphics/src/android/graphics/drawable/cts/VectorDrawableTest.java
@@ -21,6 +21,9 @@
 import android.graphics.BitmapFactory;
 import android.graphics.Canvas;
 import android.graphics.Color;
+import android.graphics.ColorFilter;
+import android.graphics.PorterDuff.Mode;
+import android.graphics.PorterDuffColorFilter;
 import android.graphics.drawable.VectorDrawable;
 import android.graphics.drawable.Drawable.ConstantState;
 import android.test.AndroidTestCase;
@@ -288,4 +291,12 @@
 
         d2.setAlpha(originalAlpha);
     }
+
+    public void testColorFilter() {
+        PorterDuffColorFilter filter = new PorterDuffColorFilter(Color.RED, Mode.SRC_IN);
+        VectorDrawable vectorDrawable = new VectorDrawable();
+        vectorDrawable.setColorFilter(filter);
+
+        assertEquals(filter, vectorDrawable.getColorFilter());
+    }
 }
diff --git a/tests/tests/hardware/src/android/hardware/camera2/cts/rs/RawConverter.java b/tests/tests/hardware/src/android/hardware/camera2/cts/rs/RawConverter.java
index 8ca650f..a9a6fce 100644
--- a/tests/tests/hardware/src/android/hardware/camera2/cts/rs/RawConverter.java
+++ b/tests/tests/hardware/src/android/hardware/camera2/cts/rs/RawConverter.java
@@ -77,7 +77,7 @@
      * polynomial approximates the default tonemapping curve used for ACR3.
      */
     private static final float[] DEFAULT_ACR3_TONEMAP_CURVE_COEFFS = new float[] {
-            1.041f, -2.973f, 2.932f, 0f
+            -1.087f,  1.643f,  0.443f, 0f
     };
 
     /**
diff --git a/tests/tests/keystore/src/android/keystore/cts/AndroidKeyStoreTest.java b/tests/tests/keystore/src/android/keystore/cts/AndroidKeyStoreTest.java
index 577e830..d3f4ccd 100644
--- a/tests/tests/keystore/src/android/keystore/cts/AndroidKeyStoreTest.java
+++ b/tests/tests/keystore/src/android/keystore/cts/AndroidKeyStoreTest.java
@@ -36,9 +36,8 @@
 import java.security.PublicKey;
 import java.security.cert.Certificate;
 import java.security.cert.CertificateFactory;
-import java.security.interfaces.ECPrivateKey;
-import java.security.interfaces.ECPublicKey;
-import java.security.interfaces.RSAPrivateKey;
+import java.security.interfaces.ECKey;
+import java.security.interfaces.RSAKey;
 import java.security.spec.PKCS8EncodedKeySpec;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -1090,14 +1089,18 @@
         final PrivateKey privKey = keyEntry.getPrivateKey();
         final PublicKey pubKey = keyEntry.getCertificate().getPublicKey();
 
-        if (expectedKey instanceof ECPrivateKey) {
+        if (expectedKey instanceof ECKey) {
+            assertTrue("Returned PrivateKey " + privKey.getClass() + " should be instanceof ECKey",
+                    privKey instanceof ECKey);
             assertEquals("Returned PrivateKey should be what we inserted",
-                    ((ECPrivateKey) expectedKey).getParams().getCurve(),
-                    ((ECPublicKey) pubKey).getParams().getCurve());
-        } else if (expectedKey instanceof RSAPrivateKey) {
+                    ((ECKey) expectedKey).getParams().getCurve(),
+                    ((ECKey) privKey).getParams().getCurve());
+        } else if (expectedKey instanceof RSAKey) {
+            assertTrue("Returned PrivateKey " + privKey.getClass() + " should be instanceof RSAKey",
+                    privKey instanceof RSAKey);
             assertEquals("Returned PrivateKey should be what we inserted",
-                    ((RSAPrivateKey) expectedKey).getModulus(),
-                    ((RSAPrivateKey) privKey).getModulus());
+                    ((RSAKey) expectedKey).getModulus(),
+                    ((RSAKey) privKey).getModulus());
         }
 
         assertNull("getFormat() should return null", privKey.getFormat());
@@ -1143,15 +1146,16 @@
         Key key = mKeyStore.getKey(TEST_ALIAS_1, null);
         assertNotNull("Key should exist", key);
 
-        assertTrue("Should be a RSAPrivateKey", key instanceof RSAPrivateKey);
+        assertTrue("Should be a PrivateKey", key instanceof PrivateKey);
+        assertTrue("Should be a RSAKey", key instanceof RSAKey);
 
-        RSAPrivateKey actualKey = (RSAPrivateKey) key;
+        RSAKey actualKey = (RSAKey) key;
 
         KeyFactory keyFact = KeyFactory.getInstance("RSA");
         PrivateKey expectedKey = keyFact.generatePrivate(new PKCS8EncodedKeySpec(FAKE_RSA_KEY_1));
 
         assertEquals("Inserted key should be same as retrieved key",
-                ((RSAPrivateKey) expectedKey).getModulus(), actualKey.getModulus());
+                ((RSAKey) expectedKey).getModulus(), actualKey.getModulus());
     }
 
     public void testKeyStore_GetKey_Certificate_Unencrypted_Failure() throws Exception {
@@ -1893,14 +1897,17 @@
 
         kpg.generateKeyPair();
 
-        RSAPrivateKey key = (RSAPrivateKey) ks.getKey(alias, null);
-        assertNotNull(key);
-        String cipher = key.getAlgorithm() + "/NONE/NOPADDING";
+        PrivateKey privateKey = (PrivateKey) ks.getKey(alias, null);
+        assertNotNull(privateKey);
+        PublicKey publicKey = ks.getCertificate(alias).getPublicKey();
+        assertNotNull(publicKey);
+        String cipher = privateKey.getAlgorithm() + "/NONE/NOPADDING";
         Cipher encrypt = Cipher.getInstance(cipher);
         assertNotNull(encrypt);
-        encrypt.init(Cipher.ENCRYPT_MODE, key);
+        encrypt.init(Cipher.ENCRYPT_MODE, privateKey);
 
-        byte[] plainText = new byte[encrypt.getBlockSize()];
+        int modulusSizeBytes = (((RSAKey) publicKey).getModulus().bitLength() + 7) / 8;
+        byte[] plainText = new byte[modulusSizeBytes];
         Arrays.fill(plainText, (byte) 0xFF);
 
         // We expect a BadPaddingException here as the message size (plaintext)
diff --git a/tests/tests/location/src/android/location/cts/LocationTest.java b/tests/tests/location/src/android/location/cts/LocationTest.java
index b60b8b1..db2820c 100644
--- a/tests/tests/location/src/android/location/cts/LocationTest.java
+++ b/tests/tests/location/src/android/location/cts/LocationTest.java
@@ -437,7 +437,7 @@
         final long timeout = 500;
 
         // should refuse binding
-        IBinder binder = service.onBind(intent);
+        IBinder binder = service.callOnBind(intent);
         assertNull("onBind should always fail.", binder);
 
         // test if result consistent with the truth
@@ -445,7 +445,7 @@
         service.setEnabled(false);
         resultHandler.expectEnabled(false);
         resultHandler.expectMessage(true);
-        ret = service.onStartCommand(intent, SettingInjectorService.START_NOT_STICKY, 0);
+        ret = service.callOnStartCommand(intent, SettingInjectorService.START_NOT_STICKY, 0);
         assertEquals("onStartCommand return value invalid in (enabled == false) case.",
             ret, SettingInjectorService.START_NOT_STICKY);
         assertTrue("Message time out in (enabled == false case).",
@@ -455,7 +455,7 @@
         service.setEnabled(true);
         resultHandler.expectEnabled(true);
         resultHandler.expectMessage(true);
-        ret = service.onStartCommand(intent, SettingInjectorService.START_NOT_STICKY, 0);
+        ret = service.callOnStartCommand(intent, SettingInjectorService.START_NOT_STICKY, 0);
         assertEquals("onStartCommand return value invalid in (enabled == true) case.",
             ret, SettingInjectorService.START_NOT_STICKY);
         assertTrue("Message time out in (enabled == true) case.",
@@ -463,7 +463,7 @@
 
         // should not respond to the deprecated method
         resultHandler.expectMessage(false);
-        service.onStart(intent, 0);
+        service.callOnStart(intent, 0);
         resultHandler.waitForMessage(timeout);
     }
 
@@ -574,6 +574,20 @@
         public void setEnabled(boolean enabled) {
             mEnabled = enabled;
         }
+
+        // API coverage dashboard will not cound method call from derived class.
+        // Thus, it is necessary to make explicit call to SettingInjectorService public methods.
+        public IBinder callOnBind(Intent intent) {
+            return super.onBind(intent);
+        }
+
+        public void callOnStart(Intent intent, int startId) {
+            super.onStart(intent, startId);
+        }
+
+        public int callOnStartCommand(Intent intent, int flags, int startId) {
+            return super.onStartCommand(intent, flags, startId);
+        }
     }
 
 }
diff --git a/tests/tests/media/src/android/media/cts/DecoderTest.java b/tests/tests/media/src/android/media/cts/DecoderTest.java
index 9014f8d..ee40207 100644
--- a/tests/tests/media/src/android/media/cts/DecoderTest.java
+++ b/tests/tests/media/src/android/media/cts/DecoderTest.java
@@ -1134,7 +1134,7 @@
 
     public void testCodecEarlyEOSHEVC() throws Exception {
         testCodecEarlyEOS(
-                R.raw.video_1280x720_mp4_hevc_1150kbps_30fps_aac_stereo_128kbps_48000hz,
+                R.raw.video_480x360_mp4_hevc_650kbps_30fps_aac_stereo_128kbps_48000hz,
                 120 /* eosframe */);
     }
 
diff --git a/tests/tests/telephony/src/android/telephony/cts/SmsManagerTest.java b/tests/tests/telephony/src/android/telephony/cts/SmsManagerTest.java
old mode 100644
new mode 100755
index d3d15a5..26e0c54
--- a/tests/tests/telephony/src/android/telephony/cts/SmsManagerTest.java
+++ b/tests/tests/telephony/src/android/telephony/cts/SmsManagerTest.java
@@ -70,6 +70,7 @@
                     "311660",   // MetroPCS
                     "310120",   // Sprint
                     "44050",    // KDDI
+                    "44051",    // KDDI
                     "44053",    // KDDI
                     "44054",    // KDDI
                     "44070",    // KDDI
@@ -129,6 +130,7 @@
             Arrays.asList(
                     "44010",    // NTT DOCOMO
                     "44020",    // SBM
+                    "44051",    // KDDI
                     "302720",   // Rogers
                     "30272",    // Rogers
                     "302370",   // Fido
@@ -167,6 +169,7 @@
             Arrays.asList(
                     "44010",    // NTT DOCOMO
                     "44020",    // SBM
+                    "44051",    // KDDI
                     "302720",   // Rogers
                     "30272",    // Rogers
                     "302370",   // Fido
diff --git a/tests/tests/text/src/android/text/cts/StaticLayoutTest.java b/tests/tests/text/src/android/text/cts/StaticLayoutTest.java
index 3a64658..e3f0e0a 100644
--- a/tests/tests/text/src/android/text/cts/StaticLayoutTest.java
+++ b/tests/tests/text/src/android/text/cts/StaticLayoutTest.java
@@ -21,6 +21,7 @@
 import android.text.GetChars;
 import android.text.GraphicsOperations;
 import android.text.Layout.Alignment;
+import android.text.TextUtils.TruncateAt;
 import android.text.SpannableString;
 import android.text.SpannableStringBuilder;
 import android.text.SpannedString;
@@ -113,6 +114,104 @@
         }
     }
 
+    public void testBuilder() {
+        {
+            // Obtain.
+            StaticLayout.Builder builder = StaticLayout.Builder.obtain(LAYOUT_TEXT, 0,
+                    LAYOUT_TEXT.length(), mDefaultPaint, DEFAULT_OUTER_WIDTH);
+            StaticLayout layout = builder.build();
+            // Check values passed to obtain().
+            assertEquals(LAYOUT_TEXT, layout.getText());
+            assertEquals(mDefaultPaint, layout.getPaint());
+            assertEquals(DEFAULT_OUTER_WIDTH, layout.getWidth());
+            // Check default values.
+            assertEquals(TextDirectionHeuristics.FIRSTSTRONG_LTR,
+                    layout.getTextDirectionHeuristic());
+            assertEquals(Alignment.ALIGN_NORMAL, layout.getAlignment());
+            assertEquals(0.0f, layout.getSpacingAdd());
+            assertEquals(1.0f, layout.getSpacingMultiplier());
+            assertEquals(DEFAULT_OUTER_WIDTH, layout.getEllipsizedWidth());
+        }
+        {
+            // Obtain with null objects.
+            StaticLayout.Builder builder = StaticLayout.Builder.obtain(null, 0, 0, null, 0);
+            try {
+                StaticLayout layout = builder.build();
+                fail("should throw NullPointerException here");
+            } catch (NullPointerException e) {
+            }
+        }
+        {
+            // setText.
+            StaticLayout.Builder builder = StaticLayout.Builder.obtain(LAYOUT_TEXT, 0,
+                    LAYOUT_TEXT.length(), mDefaultPaint, DEFAULT_OUTER_WIDTH);
+            builder.setText(LAYOUT_TEXT_SINGLE_LINE);
+            StaticLayout layout = builder.build();
+            assertEquals(LAYOUT_TEXT_SINGLE_LINE, layout.getText());
+        }
+        {
+            // setAlignment.
+            StaticLayout.Builder builder = StaticLayout.Builder.obtain(LAYOUT_TEXT, 0,
+                    LAYOUT_TEXT.length(), mDefaultPaint, DEFAULT_OUTER_WIDTH);
+            builder.setAlignment(DEFAULT_ALIGN);
+            StaticLayout layout = builder.build();
+            assertEquals(DEFAULT_ALIGN, layout.getAlignment());
+        }
+        {
+            // setTextDirection.
+            StaticLayout.Builder builder = StaticLayout.Builder.obtain(LAYOUT_TEXT, 0,
+                    LAYOUT_TEXT.length(), mDefaultPaint, DEFAULT_OUTER_WIDTH);
+            builder.setTextDirection(TextDirectionHeuristics.RTL);
+            StaticLayout layout = builder.build();
+            // Always returns TextDirectionHeuristics.FIRSTSTRONG_LTR.
+            assertEquals(TextDirectionHeuristics.FIRSTSTRONG_LTR,
+                    layout.getTextDirectionHeuristic());
+        }
+        {
+            // setLineSpacing.
+            StaticLayout.Builder builder = StaticLayout.Builder.obtain(LAYOUT_TEXT, 0,
+                    LAYOUT_TEXT.length(), mDefaultPaint, DEFAULT_OUTER_WIDTH);
+            builder.setLineSpacing(1.0f, 2.0f);
+            StaticLayout layout = builder.build();
+            assertEquals(1.0f, layout.getSpacingAdd());
+            assertEquals(2.0f, layout.getSpacingMultiplier());
+        }
+        {
+            // setEllipsizedWidth and setEllipsize.
+            StaticLayout.Builder builder = StaticLayout.Builder.obtain(LAYOUT_TEXT, 0,
+                    LAYOUT_TEXT.length(), mDefaultPaint, DEFAULT_OUTER_WIDTH);
+            builder.setEllipsize(TruncateAt.END);
+            builder.setEllipsizedWidth(ELLIPSIZE_WIDTH);
+            StaticLayout layout = builder.build();
+            assertEquals(ELLIPSIZE_WIDTH, layout.getEllipsizedWidth());
+            assertEquals(DEFAULT_OUTER_WIDTH, layout.getWidth());
+            assertTrue(layout.getEllipsisCount(0) == 0);
+            assertTrue(layout.getEllipsisCount(5) > 0);
+        }
+        {
+            // setMaxLines.
+            StaticLayout.Builder builder = StaticLayout.Builder.obtain(LAYOUT_TEXT, 0,
+                    LAYOUT_TEXT.length(), mDefaultPaint, DEFAULT_OUTER_WIDTH);
+            builder.setMaxLines(1);
+            builder.setEllipsize(TruncateAt.END);
+            StaticLayout layout = builder.build();
+            assertTrue(layout.getEllipsisCount(0) > 0);
+            assertEquals(1, layout.getLineCount());
+        }
+        {
+            // Setter methods that cannot be directly tested.
+            // setBreakStrategy, setHyphenationFrequency, setIncludePad, and setIndents.
+            StaticLayout.Builder builder = StaticLayout.Builder.obtain(LAYOUT_TEXT, 0,
+                    LAYOUT_TEXT.length(), mDefaultPaint, DEFAULT_OUTER_WIDTH);
+            builder.setBreakStrategy(StaticLayout.BREAK_STRATEGY_HIGH_QUALITY);
+            builder.setHyphenationFrequency(StaticLayout.HYPHENATION_FREQUENCY_FULL);
+            builder.setIncludePad(true);
+            builder.setIndents(null, null);
+            StaticLayout layout = builder.build();
+            assertNotNull(layout);
+        }
+    }
+
     /*
      * Get the line number corresponding to the specified vertical position.
      *  If you ask for a position above 0, you get 0. above 0 means pixel above the fire line
diff --git a/tests/uiautomator/test-apps/CtsUiAutomatorApp/Android.mk b/tests/uiautomator/test-apps/CtsUiAutomatorApp/Android.mk
index 60a0ba6..3827754 100644
--- a/tests/uiautomator/test-apps/CtsUiAutomatorApp/Android.mk
+++ b/tests/uiautomator/test-apps/CtsUiAutomatorApp/Android.mk
@@ -24,7 +24,7 @@
 LOCAL_SDK_VERSION := current
 
 LOCAL_PACKAGE_NAME := CtsUiAutomatorApp
-LOCAL_JAVA_LIBRARIES = android-support-v4
+LOCAL_STATIC_JAVA_LIBRARIES = android-support-v4
 
 LOCAL_PROGUARD_ENABLED := disabled