page.title=Compatibility Test Suite Downloads
@jd:body

<!--
    Copyright 2016 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.
-->
<div id="qv-wrapper">
  <div id="qv">
    <h2>In this document</h2>
    <ol id="auto-toc">
    </ol>
  </div>
</div>

<p>Thank you for your interest in Android Compatibility! The links below give
you access to key documents and information about the program. As CTS is
updated, new versions are added to this page. CTS versions are denoted by
R&lt;number&gt; in the link name.</p>

<h2 id="android-71">Android 7.1</h2>
<p>Android 7.1 is the release of the development milestone code-named Nougat-MR1.
The source code for the following tests can be synced with the
'android-cts-7.1_r3' tag in the open-source tree.</p>
<ul>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-7.1_r3-linux_x86-arm.zip">Android
7.1 R3 Compatibility Test Suite (CTS) - ARM</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-7.1_r3-linux_x86-x86.zip">Android
7.1 R3 Compatibility Test Suite (CTS) - x86</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-verifier-7.1_r3-linux_x86-arm.zip">Android
7.1 R3 CTS Verifier - ARM</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-verifier-7.1_r3-linux_x86-x86.zip">Android
7.1 R3 CTS Verifier - x86</a></li>
</ul>

<h2 id="android-70">Android 7.0</h2>
<p>Android 7.0 is the release of the development milestone code-named Nougat.
The source code for the following tests can be synced with the
'android-cts-7.0_r7' tag in the open-source tree.</p>
<ul>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-7.0_r7-linux_x86-arm.zip">Android
7.0 R7 Compatibility Test Suite (CTS) - ARM</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-7.0_r7-linux_x86-x86.zip">Android
7.0 R7 Compatibility Test Suite (CTS) - x86</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-verifier-7.0_r7-linux_x86-arm.zip">Android
7.0 R7 CTS Verifier - ARM</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-verifier-7.0_r7-linux_x86-x86.zip">Android
7.0 R7 CTS Verifier - x86</a></li>
</ul>

<h2 id="android-60">Android 6.0</h2>
<p>Android 6.0 is the release of the development milestone code-named Marshmallow.
The source code for the following tests can be synced with the
'android-cts-6.0_r16' tag in the open-source tree.</p>
<ul>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-6.0_r16-linux_x86-arm.zip">Android
6.0 R16 Compatibility Test Suite (CTS) - ARM</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-6.0_r16-linux_x86-x86.zip">Android
6.0 R16 Compatibility Test Suite (CTS) - x86</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-verifier-6.0_r16-linux_x86-arm.zip">Android
6.0 R16 CTS Verifier - ARM</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-verifier-6.0_r16-linux_x86-x86.zip">Android
6.0 R16 CTS Verifier - x86</a></li>
</ul>

<h2 id="android-51">Android 5.1</h2>
<p>Android 5.1 is the release of the development milestone code-named Lollipop-MR1.
The source code for the following tests can be synced with the
'android-cts-5.1_r17' tag in the open source tree.</p>
<ul>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-5.1_r17-linux_x86-arm.zip">Android
5.1 R17 Compatibility Test Suite (CTS) - ARM</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-5.1_r17-linux_x86-x86.zip">Android
5.1 R17 Compatibility Test Suite (CTS) - x86</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-verifier-5.1_r17-linux_x86-arm.zip">Android
5.1 R17 CTS Verifier - ARM</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-verifier-5.1_r17-linux_x86-x86.zip">Android
5.1 R17 CTS Verifier - x86</a></li>
</ul>

<h2 id="android-50">Android 5.0</h2>
<p>Android 5.0 is the release of the development milestone code-named Lollipop.
The source code for the following tests can be synced with the
'android-cts-5.0_r9' tag in the open source tree.</p>
<ul>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-5.0_r9-linux_x86-arm.zip">Android
5.0 R9 Compatibility Test Suite (CTS) - ARM</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-5.0_r9-linux_x86-x86.zip">Android
5.0 R9 Compatibility Test Suite (CTS) - x86</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-verifier-5.0_r9-linux_x86-arm.zip">Android
5.0 R9 CTS Verifier - ARM</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-verifier-5.0_r9-linux_x86-x86.zip">Android
5.0 R9 CTS Verifier - x86</a></li>
</ul>

<h2 id="android-44">Android 4.4</h2>
<p>Android 4.4 is the release of the development milestone code-named
KitKat. Source code for Android 4.4 is found in the
'android-cts-4.4_r4' branch in the open source tree.</p>
<ul>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-4.4_r4-linux_x86-arm.zip">Android
4.4 R4 Compatibility Test Suite (CTS) - ARM</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-4.4_r4-linux_x86-x86.zip">Android
4.4 R4 Compatibility Test Suite (CTS) - x86</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-verifier-4.4_r4-linux_x86-arm.zip">Android
4.4 R4 CTS Verifier - ARM</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-verifier-4.4_r4-linux_x86-x86.zip">Android
4.4 R4 CTS Verifier - x86</a></li>
</ul>

<h2 id="android-43">Android 4.3</h2>
<p>Android 4.3 is the release of the development milestone code-named
Jelly Bean-MR2. Source code for Android 4.3 is found in the 'android-4.3_r2.2-cts' branch in the open source tree.</p>
<ul>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-4.3_r2-linux_x86-arm.zip">Android
4.3 R2 Compatibility Test Suite (CTS)</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-verifier-4.3_r1-linux_x86-arm.zip">Android
4.3 R1 CTS Verifier</a></li>
</ul>

<h2 id="android-42">Android 4.2</h2>
<p>Android 4.2 is the release of the development milestone code-named
Jelly Bean-MR1. Source code for Android 4.2 is found in the 'android-4.2.2_r1'
branch in the open source tree.</p>
<ul>
<li><a href="https://dl.google.com/dl/android/cts/android-cts-4.2_r4-linux_x86-arm.zip">Android 4.2 R4 Compatibility Test Suite (CTS)</a></li>
<li><a href="https://dl.google.com/dl/android/cts/android-cts-verifier-4.2_r5-linux_x86-arm.zip">Android 4.2 R5 CTS Verifier</a></li>
</ul>
<h2 id="android-41">Android 4.1</h2>
<p>Android 4.1 is the release of the development milestone code-named Jelly
Bean. The source code of the Compatibility Test Suite revisions below is
available at the 'android-cts-4.1_r4' tag in the open source tree.</p>
<ul>
<li><a href="https://dl.google.com/dl/android/cts/android-cts-4.1_r4-linux_x86-arm.zip">Android 4.1 R4 Compatibility Test Suite (CTS)</a></li>
<li><a href="https://dl.google.com/dl/android/cts/android-cts-verifier-4.1_r7-linux_x86-arm.zip">Android 4.1 R7 CTS Verifier</a></li>
</ul>
<h2 id="android-403">Android 4.0.3</h2>
<p>Android 4.0.3 is the release of the development milestone code-named
Ice Cream Sandwich. Source code for
Android 4.0.3 is found in the 'android-4.0.3_r1' branch in the open source tree.</p>
<ul>
<li><a href="https://dl.google.com/dl/android/cts/android-cts-4.0.3_r3-linux_x86-arm.zip">Android 4.0.3 R3 Compatibility Test Suite (CTS)</a></li>
<li><a href="https://dl.google.com/dl/android/cts/android-cts-verifier-4.0.3_r2-linux_x86-arm.zip">Android 4.0.3 R2 CTS Verifier</a></li>
</ul>
<h2 id="android-23">Android 2.3</h2>
<p>Android 2.3 is the release of the development milestone code-named
Gingerbread. Source code for Android 2.3 is found in the 'gingerbread' branch in 
the open source tree.</p>
<ul>
<li><a href="https://dl.google.com/dl/android/cts/android-cts-2.3_r13-linux_x86-arm.zip">Android 2.3 R13 Compatibility Test Suite (CTS)</a></li>
<li><a href="https://dl.google.com/dl/android/cts/android-cts-verifier-2.3_r3-linux_x86-armv5.zip">Android 2.3 R3 CTS Verifier</a></li>
</ul>
<h2 id="android-22">Android 2.2</h2>
<p>Android 2.2 is the release of the development milestone code-named
FroYo. Source code for Android 2.2 is found in the 'froyo' branch in the
open source tree.</p>
<ul>
<li><a href="https://dl.google.com/dl/android/cts/android-cts-2.2_r8-linux_x86-arm.zip">Android 2.2 R8 Compatibility Test Suite (CTS)</a></li>
</ul>
<h2 id="android-21">Android 2.1</h2>
<p>Android 2.1 is the release of the development milestone code-named
Eclair. Source code for Android 2.1 is found in the 'eclair' branch in the
open source tree. Note that for technical reasons, there is no compatibility
program for Android 2.0 or 2.0.1, and new devices must use Android 2.1.</p>
<ul>
<li><a href="https://dl.google.com/dl/android/cts/android-cts-2.1_r5-x86.zip">Android 2.1 R5 Compatibility Test Suite (CTS)</a></li>
</ul>
<h2 id="android-16">Android 1.6</h2>
<p>Android 1.6 was the release of the development milestone code-named Donut.
Android 1.6 was obsoleted by Android 2.1. Source code for Android 1.6 is found
in the 'donut' branch in the open source tree.</p>
<ul>
<li><a href="https://dl.google.com/dl/android/cts/android-cts-1.6_r1-x86.zip">Android 1.6 R1 Compatibility Test Suite (CTS)</a></li>
</ul>
<h2 id="cts-media-files">CTS Media Files</h2>
<p>These media files are required for the CTS media stress tests.</p>
<ul>
<li><a href="https://dl.google.com/dl/android/cts/android-cts-media-1.2.zip">CTS Media 1.2</a></li>
<li><a href="https://dl.google.com/dl/android/cts/android-cts-media-1.1.zip">CTS Media 1.1</a></li>
<li><a href="https://dl.google.com/dl/android/cts/android-cts-media-1.0.zip">CTS Media 1.0</a></li>
</ul>
<h2 id="older-android-versions">Older Android Versions</h2>
<p>There is no Compatibility Program for older versions of Android, such as Android
1.5 (known in development as Cupcake). New devices intended to be Android
compatible must ship with Android 1.6 or later.</p>
