diff --git a/src/main/java/com/android/tools/r8/CompatProguardCommandBuilder.java b/src/main/java/com/android/tools/r8/CompatProguardCommandBuilder.java
index ddb0244..5755c04 100644
--- a/src/main/java/com/android/tools/r8/CompatProguardCommandBuilder.java
+++ b/src/main/java/com/android/tools/r8/CompatProguardCommandBuilder.java
@@ -33,6 +33,10 @@
       "}"
   );
 
+  public CompatProguardCommandBuilder() {
+    this(true);
+  }
+
   public CompatProguardCommandBuilder(boolean forceProguardCompatibility) {
     super(forceProguardCompatibility);
     setIgnoreDexInArchive(true);
diff --git a/src/main/java/com/android/tools/r8/Version.java b/src/main/java/com/android/tools/r8/Version.java
index ddb4b24..188f6d1 100644
--- a/src/main/java/com/android/tools/r8/Version.java
+++ b/src/main/java/com/android/tools/r8/Version.java
@@ -11,7 +11,7 @@
 
   // This field is accessed from release scripts using simple pattern matching.
   // Therefore, changing this field could break our release scripts.
-  public static final String LABEL = "v0.2.10-dev";
+  public static final String LABEL = "v0.2.11-dev";
 
   private Version() {
   }
diff --git a/src/main/java/com/android/tools/r8/graph/ObjectToOffsetMapping.java b/src/main/java/com/android/tools/r8/graph/ObjectToOffsetMapping.java
index c7fc65d..09d6696 100644
--- a/src/main/java/com/android/tools/r8/graph/ObjectToOffsetMapping.java
+++ b/src/main/java/com/android/tools/r8/graph/ObjectToOffsetMapping.java
@@ -5,14 +5,13 @@
 
 import com.android.tools.r8.dex.Constants;
 import com.android.tools.r8.errors.CompilationError;
-import com.google.common.collect.Sets;
+import it.unimi.dsi.fastutil.objects.Reference2IntArrayMap;
 import it.unimi.dsi.fastutil.objects.Reference2IntLinkedOpenHashMap;
 import it.unimi.dsi.fastutil.objects.Reference2IntMap;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.Comparator;
+import java.util.List;
 import java.util.Map;
-import java.util.Set;
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
 
@@ -91,14 +90,59 @@
     return map;
   }
 
+  /**
+   * Here, 'depth' of a program class is an integer one bigger then the maximum depth of its
+   * superclass and implemented interfaces. The depth of classes without any or without known
+   * superclasses and interfaces is 1.
+   */
+  private static class ProgramClassDepthsMemoized {
+    private final DexApplication application;
+    private final Reference2IntMap<DexProgramClass> depthOfClasses = new Reference2IntArrayMap<>();
+
+    ProgramClassDepthsMemoized(DexApplication application) {
+      this.application = application;
+    }
+
+    int getDepth(DexProgramClass programClass) {
+      return depthOfClasses.computeIfAbsent(
+          programClass,
+          programClassToCompute -> {
+            // Emulating the algorithm of com.android.dx.merge.SortableType.tryAssignDepth().
+            DexType superType = programClassToCompute.superType;
+            int maxDepth;
+            if (superType == null) {
+              maxDepth = 0;
+            } else {
+              maxDepth = 1;
+              DexProgramClass superClass = application.programDefinitionFor(superType);
+              if (superClass != null) {
+                maxDepth = getDepth(superClass);
+              }
+            }
+            for (DexType inf : programClassToCompute.interfaces.values) {
+              DexProgramClass infClass = application.programDefinitionFor(inf);
+              maxDepth = Math.max(maxDepth, infClass == null ? 1 : getDepth(infClass));
+            }
+            return maxDepth + 1;
+          });
+    }
+  }
+
   private static DexProgramClass[] sortClasses(DexApplication application,
       Collection<DexProgramClass> classes) {
-    SortingProgramClassVisitor classVisitor = new SortingProgramClassVisitor(application, classes);
     // Collect classes in subtyping order, based on a sorted list of classes to start with.
-    classVisitor.run(
-        classes.stream().sorted(Comparator.comparing(DexClass::getType))
-            .collect(Collectors.toList()));
-    return classVisitor.getSortedClasses();
+    ProgramClassDepthsMemoized classDepths = new ProgramClassDepthsMemoized(application);
+    List<DexProgramClass> sortedClasses =
+        classes
+            .stream()
+            .sorted(
+                (x, y) -> {
+                  int dx = classDepths.getDepth(x);
+                  int dy = classDepths.getDepth(y);
+                  return dx != dy ? dx - dy : x.type.compareTo(y.type);
+                })
+            .collect(Collectors.toList());
+    return sortedClasses.toArray(new DexProgramClass[sortedClasses.size()]);
   }
 
   private static <T> Collection<T> keysOrEmpty(Map<T, ?> map) {
@@ -179,34 +223,4 @@
   public int getOffsetFor(DexMethodHandle methodHandle) {
     return getOffsetFor(methodHandle, methodHandles);
   }
-
-  private static class SortingProgramClassVisitor extends ProgramClassVisitor {
-    private final Set<DexClass> classSet = Sets.newIdentityHashSet();
-    private final DexProgramClass[] sortedClasses;
-
-    private int index = 0;
-
-    SortingProgramClassVisitor(DexApplication application,
-        Collection<DexProgramClass> classes) {
-      super(application);
-      this.sortedClasses = new DexProgramClass[classes.size()];
-      classSet.addAll(classes);
-    }
-
-    @Override
-    public void visit(DexType type) {}
-
-    @Override
-    public void visit(DexClass clazz) {
-      if (classSet.contains(clazz)) {
-        assert index < sortedClasses.length;
-        sortedClasses[index++] = (DexProgramClass) clazz;
-      }
-    }
-
-    DexProgramClass[] getSortedClasses() {
-      assert index == sortedClasses.length;
-      return sortedClasses;
-    }
-  }
 }
diff --git a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
index 9789c44..870521d 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -536,6 +536,15 @@
       Log.verbose(getClass(), "Method `%s` is targeted.", encodedMethod.method);
     }
     targetedMethods.add(encodedMethod, reason);
+    if (options.forceProguardCompatibility) {
+      // Keep targeted default methods in compatibility mode. The tree pruner will otherwise make
+      // these methods abstract, whereas Proguard does not (seem to) touch their code.
+      DexClass clazz = appInfo.definitionFor(encodedMethod.method.holder);
+      if (!encodedMethod.accessFlags.isAbstract()
+          && clazz.isInterface() && !clazz.isLibraryClass()) {
+        markMethodAsKeptWithCompatRule(encodedMethod);
+      }
+    }
   }
 
   /**
@@ -1179,6 +1188,14 @@
     }
   }
 
+  private void markMethodAsKeptWithCompatRule(DexEncodedMethod method) {
+    ProguardKeepRule rule =
+        ProguardConfigurationUtils.buildDefaultMethodKeepRule(
+            appInfo.definitionFor(method.method.holder), method);
+    proguardCompatibilityWorkList.add(
+        Action.markMethodLive(method, KeepReason.dueToProguardCompatibilityKeepRule(rule)));
+  }
+
   private void handleProguardReflectiveBehavior(DexEncodedMethod method) {
     try {
       IRCode code = method.buildIR(options);
diff --git a/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationUtils.java b/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationUtils.java
index 9fea981..08610aa 100644
--- a/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationUtils.java
+++ b/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationUtils.java
@@ -5,7 +5,11 @@
 package com.android.tools.r8.shaking;
 
 import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexEncodedMethod;
 import com.google.common.collect.ImmutableList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
 
 public class ProguardConfigurationUtils {
   public static ProguardKeepRule buildDefaultInitializerKeepRule(DexClass clazz) {
@@ -27,4 +31,27 @@
     }
     return builder.build();
   }
+
+  public static ProguardKeepRule buildDefaultMethodKeepRule(
+      DexClass clazz, DexEncodedMethod method) {
+    assert clazz.type == method.method.holder;
+    ProguardKeepRule.Builder builder = ProguardKeepRule.builder();
+    builder.setType(ProguardKeepRuleType.KEEP);
+    builder.getModifiersBuilder().allowsObfuscation = true;
+    builder.getModifiersBuilder().allowsOptimization = true;
+    builder.getClassAccessFlags().setPublic();
+    builder.setClassType(ProguardClassType.INTERFACE);
+    builder.setClassNames(
+        ProguardClassNameList.singletonList(ProguardTypeMatcher.create(clazz.type)));
+    ProguardMemberRule.Builder memberRuleBuilder = ProguardMemberRule.builder();
+    memberRuleBuilder.setRuleType(ProguardMemberType.METHOD);
+    memberRuleBuilder.setName(method.method.name.toString());
+    memberRuleBuilder.setTypeMatcher(ProguardTypeMatcher.create(method.method.proto.returnType));
+    List<ProguardTypeMatcher> arguments = Arrays.stream(method.method.proto.parameters.values)
+        .map(ProguardTypeMatcher::create)
+        .collect(Collectors.toList());
+    memberRuleBuilder.setArguments(arguments);
+    builder.getMemberRules().add(memberRuleBuilder.build());
+    return builder.build();
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/shaking/defaultmethods/ClassImplementingInterface.java b/src/test/java/com/android/tools/r8/shaking/defaultmethods/ClassImplementingInterface.java
new file mode 100644
index 0000000..b8261ad
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/defaultmethods/ClassImplementingInterface.java
@@ -0,0 +1,11 @@
+// Copyright (c) 2018, 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.shaking.defaultmethods;
+
+public class ClassImplementingInterface implements InterfaceWithDefaultMethods {
+  public int method() {
+    return 41;
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/shaking/defaultmethods/DefaultMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/defaultmethods/DefaultMethodsTest.java
index 4fac23b..3de225d 100644
--- a/src/test/java/com/android/tools/r8/shaking/defaultmethods/DefaultMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/defaultmethods/DefaultMethodsTest.java
@@ -13,6 +13,7 @@
 import com.android.tools.r8.ToolHelper;
 import com.android.tools.r8.graph.invokesuper.Consumer;
 import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.DexInspector;
 import com.android.tools.r8.utils.DexInspector.ClassSubject;
@@ -26,9 +27,10 @@
       throws Exception {
     R8Command.Builder builder = R8Command.builder();
     builder.addProgramFiles(ToolHelper.getClassFileForTestClass(InterfaceWithDefaultMethods.class));
+    builder.addProgramFiles(ToolHelper.getClassFileForTestClass(ClassImplementingInterface.class));
     builder.addProgramFiles(ToolHelper.getClassFileForTestClass(TestClass.class));
     builder.setProgramConsumer(DexIndexedConsumer.emptyConsumer());
-    builder.setMinApiLevel(26);
+    builder.setMinApiLevel(AndroidApiLevel.O.getLevel());
     // Always keep main in the test class, so the output never becomes empty.
     builder.addProguardConfiguration(ImmutableList.of(
         "-keep class " + TestClass.class.getCanonicalName() + "{",
@@ -59,6 +61,14 @@
     assertFalse(method.isAbstract());
   }
 
+  private void defaultMethodAbstract(DexInspector inspector) {
+    ClassSubject clazz = inspector.clazz(InterfaceWithDefaultMethods.class);
+    assertTrue(clazz.isPresent());
+    MethodSubject method = clazz.method("int", "method", ImmutableList.of());
+    assertTrue(method.isPresent());
+    assertTrue(method.isAbstract());
+  }
+
   @Test
   public void test() throws Exception {
     runTest(ImmutableList.of(), this::interfaceNotKept);
@@ -76,5 +86,18 @@
         "  public int method();",
         "}"
     ), this::defaultMethodKept);
+    runTest(ImmutableList.of(
+        "-keep class " + ClassImplementingInterface.class.getCanonicalName() + "{",
+        "  <methods>;",
+        "}"
+    ), this::defaultMethodNotKept);
+    runTest(ImmutableList.of(
+        "-keep class " + ClassImplementingInterface.class.getCanonicalName() + "{",
+        "  <methods>;",
+        "}",
+        "-keep class " + TestClass.class.getCanonicalName() + "{",
+        "  public void useInterfaceMethod();",
+        "}"
+    ), this::defaultMethodAbstract);
   }
 }
diff --git a/src/test/java/com/android/tools/r8/shaking/defaultmethods/TestClass.java b/src/test/java/com/android/tools/r8/shaking/defaultmethods/TestClass.java
index fcb240a..5e46681 100644
--- a/src/test/java/com/android/tools/r8/shaking/defaultmethods/TestClass.java
+++ b/src/test/java/com/android/tools/r8/shaking/defaultmethods/TestClass.java
@@ -6,6 +6,11 @@
 
 public class TestClass {
 
+  public void useInterfaceMethod() {
+    InterfaceWithDefaultMethods iface = new ClassImplementingInterface();
+    System.out.println(iface.method());
+  }
+
   public static void main(String[] args) {
   }
 }
diff --git a/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/ForceProguardCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/ForceProguardCompatibilityTest.java
index 9679970..085e46c 100644
--- a/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/ForceProguardCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/ForceProguardCompatibilityTest.java
@@ -16,15 +16,21 @@
 import com.android.tools.r8.errors.CompilationError;
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.invokesuper.Consumer;
 import com.android.tools.r8.naming.MemberNaming.MethodSignature;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.shaking.ProguardClassNameList;
 import com.android.tools.r8.shaking.ProguardConfiguration;
 import com.android.tools.r8.shaking.ProguardConfigurationParser;
+import com.android.tools.r8.shaking.ProguardConfigurationRule;
 import com.android.tools.r8.shaking.ProguardKeepAttributes;
 import com.android.tools.r8.shaking.ProguardMemberRule;
 import com.android.tools.r8.shaking.ProguardMemberType;
+import com.android.tools.r8.shaking.forceproguardcompatibility.defaultmethods.ClassImplementingInterface;
+import com.android.tools.r8.shaking.forceproguardcompatibility.defaultmethods.InterfaceWithDefaultMethods;
+import com.android.tools.r8.shaking.forceproguardcompatibility.defaultmethods.TestClass;
 import com.android.tools.r8.shaking.forceproguardcompatibility.keepattributes.TestKeepAttributes;
+import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.DefaultDiagnosticsHandler;
 import com.android.tools.r8.utils.DexInspector;
@@ -373,4 +379,115 @@
     testKeepAttributes(false, false, true);
     testKeepAttributes(false, true, true);
   }
+
+  private void runKeepDefaultMethodsTest(
+      List<String> additionalKeepRules,
+      Consumer<DexInspector> inspection,
+      Consumer<ProguardConfiguration> compatInspection) throws Exception {
+    Class mainClass = TestClass.class;
+    CompatProguardCommandBuilder builder = new CompatProguardCommandBuilder();
+    builder.addProgramFiles(ToolHelper.getClassFilesForTestPackage(mainClass.getPackage()));
+    builder.addProguardConfiguration(ImmutableList.of(
+        "-keep class " + mainClass.getCanonicalName() + "{",
+        "  public <init>();",
+        "  public static void main(java.lang.String[]);",
+        "}",
+        "-dontobfuscate"),
+        Origin.unknown());
+    builder.addProguardConfiguration(additionalKeepRules, Origin.unknown());
+    builder.setProgramConsumer(DexIndexedConsumer.emptyConsumer());
+    builder.setMinApiLevel(AndroidApiLevel.O.getLevel());
+    Path proguardCompatibilityRules = temp.newFile().toPath();
+    builder.setProguardCompatibilityRulesOutput(proguardCompatibilityRules);
+    AndroidApp app = ToolHelper.runR8(builder.build());
+    inspection.accept(new DexInspector(app));
+    // Check the Proguard compatibility configuration generated.
+    ProguardConfigurationParser parser =
+        new ProguardConfigurationParser(new DexItemFactory(),
+            new Reporter(new DefaultDiagnosticsHandler()));
+    parser.parse(proguardCompatibilityRules);
+    ProguardConfiguration configuration = parser.getConfigRawForTesting();
+    compatInspection.accept(configuration);
+  }
+
+  private void noCompatibilityRules(ProguardConfiguration configuration) {
+    assertEquals(0, configuration.getRules().size());
+  }
+
+  private void defaultMethodKept(DexInspector inspector) {
+    ClassSubject clazz = inspector.clazz(InterfaceWithDefaultMethods.class);
+    assertTrue(clazz.isPresent());
+    MethodSubject method = clazz.method("int", "method", ImmutableList.of());
+    assertTrue(method.isPresent());
+    assertFalse(method.isAbstract());
+  }
+
+  private void defaultMethodCompatibilityRules(ProguardConfiguration configuration) {
+    assertEquals(1, configuration.getRules().size());
+    ProguardConfigurationRule rule = configuration.getRules().get(0);
+    Set<ProguardMemberRule> memberRules = rule.getMemberRules();
+    ProguardClassNameList classNames = rule.getClassNames();
+    assertEquals(1, classNames.size());
+    DexType type = classNames.asSpecificDexTypes().get(0);
+    assertEquals(type.toSourceString(), InterfaceWithDefaultMethods.class.getCanonicalName());
+    assertEquals(1, memberRules.size());
+    ProguardMemberRule memberRule = memberRules.iterator().next();
+    assertEquals(ProguardMemberType.METHOD, memberRule.getRuleType());
+    assertTrue(memberRule.getName().matches("method"));
+    assertTrue(memberRule.getType().matches(configuration.getDexItemFactory().intType));
+    assertEquals(0, memberRule.getArguments().size());
+  }
+
+  private void defaultMethod2Kept(DexInspector inspector) {
+    ClassSubject clazz = inspector.clazz(InterfaceWithDefaultMethods.class);
+    assertTrue(clazz.isPresent());
+    MethodSubject method =
+        clazz.method("void", "method2", ImmutableList.of("java.lang.String", "int"));
+    assertTrue(method.isPresent());
+    assertFalse(method.isAbstract());
+  }
+
+  private void defaultMethod2CompatibilityRules(ProguardConfiguration configuration) {
+    assertEquals(1, configuration.getRules().size());
+    ProguardConfigurationRule rule = configuration.getRules().get(0);
+    Set<ProguardMemberRule> memberRules = rule.getMemberRules();
+    ProguardClassNameList classNames = rule.getClassNames();
+    assertEquals(1, classNames.size());
+    DexType type = classNames.asSpecificDexTypes().get(0);
+    assertEquals(type.toSourceString(), InterfaceWithDefaultMethods.class.getCanonicalName());
+    assertEquals(1, memberRules.size());
+    ProguardMemberRule memberRule = memberRules.iterator().next();
+    assertEquals(ProguardMemberType.METHOD, memberRule.getRuleType());
+    assertTrue(memberRule.getName().matches("method2"));
+    assertTrue(memberRule.getType().matches(configuration.getDexItemFactory().voidType));
+    assertEquals(2, memberRule.getArguments().size());
+    assertTrue(
+        memberRule.getArguments().get(0).matches(configuration.getDexItemFactory().stringType));
+    assertTrue(memberRule.getArguments().get(1).matches(configuration.getDexItemFactory().intType));
+  }
+
+  @Test
+  public void keepDefaultMethodsTest() throws Exception {
+    runKeepDefaultMethodsTest(ImmutableList.of(
+        "-keep interface " + InterfaceWithDefaultMethods.class.getCanonicalName() + "{",
+        "  public int method();",
+        "}"
+    ), this::defaultMethodKept, this::noCompatibilityRules);
+    runKeepDefaultMethodsTest(ImmutableList.of(
+        "-keep class " + ClassImplementingInterface.class.getCanonicalName() + "{",
+        "  <methods>;",
+        "}",
+        "-keep class " + TestClass.class.getCanonicalName() + "{",
+        "  public void useInterfaceMethod();",
+        "}"
+    ), this::defaultMethodKept, this::defaultMethodCompatibilityRules);
+    runKeepDefaultMethodsTest(ImmutableList.of(
+        "-keep class " + ClassImplementingInterface.class.getCanonicalName() + "{",
+        "  <methods>;",
+        "}",
+        "-keep class " + TestClass.class.getCanonicalName() + "{",
+        "  public void useInterfaceMethod2();",
+        "}"
+    ), this::defaultMethod2Kept, this::defaultMethod2CompatibilityRules);
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/defaultmethods/ClassImplementingInterface.java b/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/defaultmethods/ClassImplementingInterface.java
new file mode 100644
index 0000000..9b5adfe
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/defaultmethods/ClassImplementingInterface.java
@@ -0,0 +1,13 @@
+// Copyright (c) 2018, 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.shaking.forceproguardcompatibility.defaultmethods;
+
+public class ClassImplementingInterface implements InterfaceWithDefaultMethods {
+  public int method() {
+    return 41;
+  }
+  public void method2(String x, int y) {
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/defaultmethods/InterfaceWithDefaultMethods.java b/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/defaultmethods/InterfaceWithDefaultMethods.java
new file mode 100644
index 0000000..d7503d6
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/defaultmethods/InterfaceWithDefaultMethods.java
@@ -0,0 +1,14 @@
+// Copyright (c) 2018, 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.shaking.forceproguardcompatibility.defaultmethods;
+
+public interface InterfaceWithDefaultMethods {
+  default int method() {
+    return 42;
+  }
+  default void method2(String x, int y) {
+    System.out.println(y + x);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/defaultmethods/TestClass.java b/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/defaultmethods/TestClass.java
new file mode 100644
index 0000000..35ba3c5
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/defaultmethods/TestClass.java
@@ -0,0 +1,21 @@
+// Copyright (c) 2018, 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.shaking.forceproguardcompatibility.defaultmethods;
+
+public class TestClass {
+
+  public void useInterfaceMethod() {
+    InterfaceWithDefaultMethods iface = new ClassImplementingInterface();
+    System.out.println(iface.method());
+  }
+
+  public void useInterfaceMethod2() {
+    InterfaceWithDefaultMethods iface = new ClassImplementingInterface();
+    iface.method2("a", 1);
+  }
+
+  public static void main(String[] args) {
+  }
+}