<?xml version='1.0' encoding='UTF-8' standalone='no' ?>
<SubPlan version="2.0">
  <!--
    Unless there's special reason, the entries can be removed only
    when the DEV version bundle's provisional version number (like 9.0r13)
    is incremented. Otherwise the computation for the canonical list
    of test cases is confused. See b/151779432.
  -->
  <Entry include="CtsAppSecurityHostTestCases android.appsecurity.cts.DocumentsTest#testRestrictStorageAccessFrameworkDisabled_notBlockFromTree" />
  <Entry include="CtsDeqpTestCases dEQP-VK.api.external.memory.android_hardware_buffer.dedicated.host_visible#import_multiple_times" />
  <Entry include="CtsDeqpTestCases dEQP-VK.api.external.memory.android_hardware_buffer.dedicated.image#bind_export_import_bind" />
  <Entry include="CtsDeqpTestCases dEQP-VK.api.external.memory.android_hardware_buffer.dedicated.image#export_bind_import_bind" />
  <Entry include="CtsDeqpTestCases dEQP-VK.api.external.memory.android_hardware_buffer.dedicated.image#export_import_bind_bind" />
  <Entry include="CtsDeqpTestCases dEQP-VK.api.external.memory.android_hardware_buffer.dedicated.image#info" />
  <Entry include="CtsDeqpTestCases dEQP-VK.api.external.memory.android_hardware_buffer.image_formats#a2b10g10r10_unorm_pack32" />
  <Entry include="CtsDeqpTestCases dEQP-VK.api.external.memory.android_hardware_buffer.image_formats#r16g16b16a16_sfloat" />
  <Entry include="CtsDeqpTestCases dEQP-VK.api.external.memory.android_hardware_buffer.image_formats#r5g6b5_unorm_pack16" />
  <Entry include="CtsDeqpTestCases dEQP-VK.api.external.memory.android_hardware_buffer.image_formats#r8g8b8a8_unorm" />
  <Entry include="CtsDeqpTestCases dEQP-VK.api.external.memory.android_hardware_buffer.suballocated.host_visible#import_multiple_times" />
  <Entry include="CtsDeqpTestCases dEQP-VK.api.external.memory.android_hardware_buffer.suballocated.image#info" />
  <Entry include="CtsDeqpTestCases dEQP-VK.memory.pipeline_barrier.all#1024_vertex_buffer_stride_2" />
  <Entry include="CtsDeqpTestCases dEQP-VK.memory.pipeline_barrier.all#1024_vertex_buffer_stride_4" />
  <Entry include="CtsDeqpTestCases dEQP-VK.memory.pipeline_barrier.all_device#1024_vertex_buffer_stride_2" />
  <Entry include="CtsDeqpTestCases dEQP-VK.memory.pipeline_barrier.all_device#1024_vertex_buffer_stride_4" />
  <Entry include="CtsDeqpTestCases dEQP-VK.memory.pipeline_barrier.transfer_dst_image_sampled#1024" />
  <Entry include="CtsDeqpTestCases dEQP-VK.memory.pipeline_barrier.transfer_dst_storage_image#1024" />
  <Entry include="CtsDeqpTestCases dEQP-VK.memory.pipeline_barrier.transfer_src_transfer_dst#1024" />
  <Entry include="CtsDeqpTestCases dEQP-VK.sparse_resources.shader_intrinsics.2d_array_sparse_sample_implicit_lod.r32ui#11_37_3" />
  <Entry include="CtsDeqpTestCases dEQP-VK.sparse_resources.shader_intrinsics.2d_sparse_fetch.r32i#512_256_1" />
  <Entry include="CtsDeqpTestCases dEQP-VK.sparse_resources.shader_intrinsics.2d_sparse_fetch.r32ui#512_256_1" />
  <Entry include="CtsDeqpTestCases dEQP-VK.sparse_resources.shader_intrinsics.2d_sparse_sample_explicit_lod.r32ui#128_128_1" />
  <Entry include="CtsDeqpTestCases dEQP-VK.sparse_resources.shader_intrinsics.2d_sparse_sample_explicit_lod.r32ui#512_256_1" />
  <Entry include="CtsHardwareTestCases android.hardware.input.cts.tests.MicrosoftSculpttouchTest#testAllMotions" />
  <Entry include="CtsOsTestCases android.os.cts.EnvironmentTest#testHidePid2" />
  <Entry include="CtsWifiTestCases android.net.wifi.cts.WifiManagerTest#testWifiScanTimestamp" />
  <Entry include="CtsWindowManagerDeviceTestCases android.server.wm.AssistantStackTests#testAssistantStackFinishToPreviousApp" />
  <Entry include="CtsWindowManagerDeviceTestCases android.server.wm.AssistantStackTests#testAssistantStackLaunchNewTask" />
</SubPlan>
