<html devsite>
  <head>
    <title>Compatibility Test Suite Downloads</title>
    <meta name="project_path" value="/_project.yaml" />
    <meta name="book_path" value="/_book.yaml" />
  </head>
  <body>
  <!--
      Copyright 2017 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.
  -->



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

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

<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_r15' tag in the open-source tree.</p>
<ul>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-7.1_r15-linux_x86-arm.zip">Android
7.1 R15 Compatibility Test Suite (CTS) - ARM</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-7.1_r15-linux_x86-x86.zip">Android
7.1 R15 Compatibility Test Suite (CTS) - x86</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-verifier-7.1_r15-linux_x86-arm.zip">Android
7.1 R15 CTS Verifier - ARM</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-verifier-7.1_r15-linux_x86-x86.zip">Android
7.1 R15 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_r19' tag in the open-source tree.</p>
<ul>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-7.0_r19-linux_x86-arm.zip">Android
7.0 R19 Compatibility Test Suite (CTS) - ARM</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-7.0_r19-linux_x86-x86.zip">Android
7.0 R19 Compatibility Test Suite (CTS) - x86</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-verifier-7.0_r19-linux_x86-arm.zip">Android
7.0 R19 CTS Verifier - ARM</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-verifier-7.0_r19-linux_x86-x86.zip">Android
7.0 R19 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_r27' tag in the open-source tree.</p>
<ul>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-6.0_r27-linux_x86-arm.zip">Android
6.0 R27 Compatibility Test Suite (CTS) - ARM</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-6.0_r27-linux_x86-x86.zip">Android
6.0 R27 Compatibility Test Suite (CTS) - x86</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-verifier-6.0_r27-linux_x86-arm.zip">Android
6.0 R27 CTS Verifier - ARM</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-verifier-6.0_r27-linux_x86-x86.zip">Android
6.0 R27 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_r28' tag in the open source tree.</p>
<ul>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-5.1_r28-linux_x86-arm.zip">Android
5.1 R28 Compatibility Test Suite (CTS) - ARM</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-5.1_r28-linux_x86-x86.zip">Android
5.1 R28 Compatibility Test Suite (CTS) - x86</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-verifier-5.1_r28-linux_x86-arm.zip">Android
5.1 R28 CTS Verifier - ARM</a></li>
<li><a
href="https://dl.google.com/dl/android/cts/android-cts-verifier-5.1_r28-linux_x86-x86.zip">Android
5.1 R28 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.4.zip">CTS Media 1.4</a></li>
<li><a href="https://dl.google.com/dl/android/cts/android-cts-media-1.3.zip">CTS Media 1.3</a></li>
<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>

  </body>
</html>
