diff --git a/src/test/java/com/android/tools/r8/annotations/TypeUseAnnotationPruneTest.java b/src/test/java/com/android/tools/r8/annotations/TypeUseAnnotationPruneTest.java
new file mode 100644
index 0000000..e9fcba0
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/annotations/TypeUseAnnotationPruneTest.java
@@ -0,0 +1,122 @@
+// Copyright (c) 2023, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.annotations;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.ClassFileConsumer;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.annotations.testclasses.MainWithTypeAndGeneric;
+import com.android.tools.r8.annotations.testclasses.NotNullTestClass;
+import com.android.tools.r8.annotations.testclasses.NotNullTestRuntime;
+import com.android.tools.r8.annotations.testclasses.SuperInterface;
+import com.android.tools.r8.annotations.testclasses.TestClassWithTypeAndGenericAnnotations;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.FieldSubject;
+import com.android.tools.r8.utils.codeinspector.FoundAnnotationSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.lang.reflect.AnnotatedType;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class TypeUseAnnotationPruneTest extends TestBase {
+
+  @Parameter() public TestParameters parameters;
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimesAndApiLevels().build();
+  }
+
+  private String getExpected(String notNullTestRuntimeTypeName) {
+    return StringUtils.joinLines(
+        "printAnnotation - Class: " + notNullTestRuntimeTypeName,
+        "printAnnotation - Class: NULL",
+        "printAnnotation - Extends(0): " + notNullTestRuntimeTypeName,
+        "printAnnotation - Implements(0): " + notNullTestRuntimeTypeName,
+        "printAnnotation - Field: NULL",
+        "printAnnotation - Field: NULL",
+        "printAnnotation - Field(0): " + notNullTestRuntimeTypeName,
+        "printAnnotation - Method: NULL",
+        "printAnnotation - Method: NULL",
+        "printAnnotation - MethodReturnType(0): " + notNullTestRuntimeTypeName,
+        "printAnnotation - MethodParameter at 0(0): " + notNullTestRuntimeTypeName,
+        "printAnnotation - MethodParameter at 1(0): " + notNullTestRuntimeTypeName,
+        "printAnnotation - MethodException at 0(0): " + notNullTestRuntimeTypeName,
+        "printAnnotation - MethodException at 1(0): " + notNullTestRuntimeTypeName,
+        "Hello World!");
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    testForR8(parameters.getBackend())
+        .addProgramClasses(
+            MainWithTypeAndGeneric.class,
+            NotNullTestClass.class,
+            NotNullTestRuntime.class,
+            TestClassWithTypeAndGenericAnnotations.class,
+            SuperInterface.class)
+        .setMinApi(parameters)
+        .addKeepClassRules(NotNullTestClass.class, NotNullTestRuntime.class, SuperInterface.class)
+        .addKeepRuntimeVisibleAnnotations()
+        .addKeepRuntimeInvisibleAnnotations()
+        .addKeepRuntimeVisibleParameterAnnotations()
+        .addKeepRuntimeInvisibleParameterAnnotations()
+        .addKeepAttributeSignature()
+        .addKeepAttributeExceptions()
+        .addKeepMainRule(MainWithTypeAndGeneric.class)
+        .addKeepClassAndMembersRules(TestClassWithTypeAndGenericAnnotations.class)
+        .applyIf(parameters.isDexRuntime(), b -> b.addDontWarn(AnnotatedType.class))
+        .compile()
+        .inspectWithOptions(
+            inspector -> {
+              ClassSubject notNullTestClass = inspector.clazz(NotNullTestClass.class);
+              assertThat(notNullTestClass, isPresent());
+              ClassSubject notNullTestRuntime = inspector.clazz(NotNullTestRuntime.class);
+              assertThat(notNullTestRuntime, isPresent());
+              ClassSubject clazz = inspector.clazz(TestClassWithTypeAndGenericAnnotations.class);
+              assertThat(clazz, isPresent());
+              if (parameters.isDexRuntime()) {
+                assertTrue(
+                    clazz.annotations().stream()
+                        .noneMatch(FoundAnnotationSubject::isTypeAnnotation));
+              } else {
+                // TODO(b/271543766): Assert that we have no type annotations
+              }
+              FieldSubject field = clazz.uniqueFieldWithOriginalName("field");
+              assertThat(field, isPresent());
+              if (parameters.isDexRuntime()) {
+                assertEquals(0, field.annotations().size());
+              } else {
+                // TODO(b/271543766): Assert that we have no annotations
+                assertEquals(4, field.annotations().size());
+              }
+              MethodSubject method = clazz.uniqueMethodWithOriginalName("method");
+              assertThat(method, isPresent());
+              // We create a dex annotation for the checked exception.
+              if (parameters.isDexRuntime()) {
+                assertEquals(1, method.annotations().size());
+              } else {
+                // TODO(b/271543766): Assert that we have no annotations
+                assertEquals(17, method.annotations().size());
+              }
+            },
+            options -> options.programConsumer = ClassFileConsumer.emptyConsumer())
+        .run(parameters.getRuntime(), MainWithTypeAndGeneric.class)
+        .assertFailureWithErrorThatThrowsIf(parameters.isDexRuntime(), NoSuchMethodError.class)
+        .assertSuccessWithOutputLinesIf(
+            parameters.isCfRuntime(), getExpected(typeName(NotNullTestRuntime.class)));
+  }
+}