diff --git a/src/test/examples/naming001/A.java b/src/test/examples/naming001/A.java
new file mode 100644
index 0000000..092bcf7
--- /dev/null
+++ b/src/test/examples/naming001/A.java
@@ -0,0 +1,25 @@
+// Copyright (c) 2017, 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 naming001;
+
+public class A {
+
+  A() {
+  }
+
+  A(int i) {
+  }
+
+  static {
+    C.m();
+  }
+
+  void m() {
+  }
+
+  @SuppressWarnings("unused")
+  private void privateFunc() {
+  }
+}
+
diff --git a/src/test/examples/naming001/B.java b/src/test/examples/naming001/B.java
new file mode 100644
index 0000000..30e520c
--- /dev/null
+++ b/src/test/examples/naming001/B.java
@@ -0,0 +1,8 @@
+// Copyright (c) 2017, 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 naming001;
+
+public class B {
+}
+
diff --git a/src/test/examples/naming001/C.java b/src/test/examples/naming001/C.java
new file mode 100644
index 0000000..24cd8ec
--- /dev/null
+++ b/src/test/examples/naming001/C.java
@@ -0,0 +1,13 @@
+// Copyright (c) 2017, 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 naming001;
+
+public class C {
+  static void f() {
+  }
+
+  static void m() {
+  }
+}
+
diff --git a/src/test/examples/naming001/D.java b/src/test/examples/naming001/D.java
new file mode 100644
index 0000000..c1ec759
--- /dev/null
+++ b/src/test/examples/naming001/D.java
@@ -0,0 +1,21 @@
+// Copyright (c) 2017, 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 naming001;
+
+public class D {
+  public void keep() {
+    System.out.println();
+  }
+
+  public static void main(String[] args) {
+    D d = new E();
+    d.keep();
+  }
+
+  public static void main2(String[] args) {
+    D d = new D();
+    d.keep();
+  }
+}
+
diff --git a/src/test/examples/naming001/E.java b/src/test/examples/naming001/E.java
new file mode 100644
index 0000000..b445323
--- /dev/null
+++ b/src/test/examples/naming001/E.java
@@ -0,0 +1,11 @@
+// Copyright (c) 2017, 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 naming001;
+
+public class E extends D {
+  @Override
+  public void keep() {
+  }
+}
+
diff --git a/src/test/examples/naming001/F.java b/src/test/examples/naming001/F.java
new file mode 100644
index 0000000..3ca60f3
--- /dev/null
+++ b/src/test/examples/naming001/F.java
@@ -0,0 +1,11 @@
+// Copyright (c) 2017, 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 naming001;
+
+public class F extends E {
+  @Override
+  public void keep() {
+  }
+}
+
diff --git a/src/test/examples/naming001/G.java b/src/test/examples/naming001/G.java
new file mode 100644
index 0000000..175ae8c
--- /dev/null
+++ b/src/test/examples/naming001/G.java
@@ -0,0 +1,16 @@
+// Copyright (c) 2017, 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 naming001;
+
+public class G implements H {
+  @Override
+  public void m() {
+  }
+
+  public static void main(String[] args) {
+    H i = new G();
+    i.m();
+  }
+}
+
diff --git a/src/test/examples/naming001/H.java b/src/test/examples/naming001/H.java
new file mode 100644
index 0000000..5a82977
--- /dev/null
+++ b/src/test/examples/naming001/H.java
@@ -0,0 +1,8 @@
+// Copyright (c) 2017, 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 naming001;
+
+public interface H extends I {
+}
+
diff --git a/src/test/examples/naming001/I.java b/src/test/examples/naming001/I.java
new file mode 100644
index 0000000..6ee9ef1
--- /dev/null
+++ b/src/test/examples/naming001/I.java
@@ -0,0 +1,9 @@
+// Copyright (c) 2017, 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 naming001;
+
+public interface I {
+  void m();
+}
+
diff --git a/src/test/examples/naming001/J.java b/src/test/examples/naming001/J.java
new file mode 100644
index 0000000..f609989
--- /dev/null
+++ b/src/test/examples/naming001/J.java
@@ -0,0 +1,31 @@
+// Copyright (c) 2017, 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 naming001;
+
+public class J {
+  int[][][] m5(int a, boolean b, long c) {
+    return null;
+  }
+
+  int[][][] m3() {
+    return null;
+  }
+
+  int[][] m2() {
+    return null;
+  }
+
+  int[] m1() {
+    return null;
+  }
+
+  int m0() {
+    return 0;
+  }
+
+  int[][][] m() {
+    return null;
+  }
+}
+
diff --git a/src/test/examples/naming001/K.java b/src/test/examples/naming001/K.java
new file mode 100644
index 0000000..4998773
--- /dev/null
+++ b/src/test/examples/naming001/K.java
@@ -0,0 +1,29 @@
+// Copyright (c) 2017, 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 naming001;
+
+public class K {
+  private int i;
+  private int h;
+  private final int i2 = 7;
+  private static int j;
+  private final static int i3 = 7;
+
+  private static final Object o = "TAG";
+  private static final String TAG = "TAG";
+  private final String TAG2 = "TAG";
+
+  static {
+    j = 6;
+  }
+
+  {
+    i = 6;
+  }
+
+  void keep() {
+    h = 7;
+  }
+}
+
diff --git a/src/test/examples/naming001/L.java b/src/test/examples/naming001/L.java
new file mode 100644
index 0000000..7e8b03a
--- /dev/null
+++ b/src/test/examples/naming001/L.java
@@ -0,0 +1,13 @@
+// Copyright (c) 2017, 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 naming001;
+
+public class L {
+  private static final String TAG = "TAG";
+
+  void onReceive() {
+    System.out.println(TAG);
+  }
+}
+
diff --git a/src/test/examples/naming001/Reflect.java b/src/test/examples/naming001/Reflect.java
new file mode 100644
index 0000000..15b920e
--- /dev/null
+++ b/src/test/examples/naming001/Reflect.java
@@ -0,0 +1,53 @@
+// Copyright (c) 2017, 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 naming001;
+
+import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
+import java.util.concurrent.atomic.AtomicLongFieldUpdater;
+import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
+
+public class Reflect {
+  void keep() throws ClassNotFoundException {
+    Class.forName("naming001.Reflect2");
+    Class.forName("ClassThatDoesNotExists");
+  }
+
+  void keep2() throws NoSuchFieldException, SecurityException {
+    Reflect2.class.getField("fieldPublic");
+    Reflect2.class.getField("fieldPrivate");
+  }
+
+  void keep3() throws NoSuchFieldException, SecurityException {
+    Reflect2.class.getDeclaredField("fieldPublic");
+    Reflect2.class.getDeclaredField("fieldPrivate");
+  }
+
+  void keep4() throws SecurityException, NoSuchMethodException {
+    Reflect2.class.getMethod("m", new Class[] {naming001.Reflect2.A.class});
+    Reflect2.class.getMethod("m", new Class[] {naming001.Reflect2.B.class});
+    Reflect2.class.getMethod("methodThatDoesNotExist",
+        new Class[] {naming001.Reflect2.A.class});
+  }
+
+  void keep5() throws SecurityException, NoSuchMethodException {
+    Reflect2.class.getDeclaredMethod("m", new Class[] {naming001.Reflect2.A.class});
+    Reflect2.class.getDeclaredMethod("m", new Class[] {naming001.Reflect2.B.class});
+  }
+
+  void keep6() throws SecurityException {
+    AtomicIntegerFieldUpdater.newUpdater(Reflect2.class, "fieldPublic");
+  }
+
+  void keep7() throws SecurityException {
+    AtomicLongFieldUpdater.newUpdater(Reflect2.class, "fieldLong");
+    AtomicLongFieldUpdater.newUpdater(Reflect2.class, "fieldLong2");
+  }
+
+  void keep8() throws SecurityException {
+    AtomicReferenceFieldUpdater.newUpdater(Reflect2.class, Reflect2.A.class, "a");
+    AtomicReferenceFieldUpdater.newUpdater(Reflect2.class, Reflect2.A.class, "b");
+    AtomicReferenceFieldUpdater.newUpdater(Reflect2.class, Object.class, "c");
+  }
+}
+
diff --git a/src/test/examples/naming001/Reflect2.java b/src/test/examples/naming001/Reflect2.java
new file mode 100644
index 0000000..42b3075
--- /dev/null
+++ b/src/test/examples/naming001/Reflect2.java
@@ -0,0 +1,40 @@
+// Copyright (c) 2017, 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 naming001;
+
+public class Reflect2 {
+  public volatile int fieldPublic;
+
+  private volatile int fieldPrivate;
+
+  public volatile long fieldLong;
+
+  private volatile long fieldLong2;
+
+  volatile long fieldLong3;
+
+  protected volatile long fieldLong4;
+
+  public volatile A a;
+
+  public volatile B b;
+
+  private volatile Object c;
+
+  private void calledMethod() {
+  }
+
+  public void m(A a) {
+  }
+
+  private void privateMethod(B b) {
+  }
+
+  class A {
+  }
+
+  class B {
+  }
+}
+
diff --git a/src/test/examples/naming001/keep-rules-001.txt b/src/test/examples/naming001/keep-rules-001.txt
new file mode 100644
index 0000000..72be5a2
--- /dev/null
+++ b/src/test/examples/naming001/keep-rules-001.txt
@@ -0,0 +1,7 @@
+# Copyright (c) 2017, 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.
+
+-allowaccessmodification
+
+-keep class naming001.A
diff --git a/src/test/examples/naming001/keep-rules-002.txt b/src/test/examples/naming001/keep-rules-002.txt
new file mode 100644
index 0000000..1554e31
--- /dev/null
+++ b/src/test/examples/naming001/keep-rules-002.txt
@@ -0,0 +1,9 @@
+# Copyright (c) 2017, 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.
+
+-allowaccessmodification
+
+-keep !final class naming001.A {
+  private <methods>;
+}
diff --git a/src/test/examples/naming001/keep-rules-003.txt b/src/test/examples/naming001/keep-rules-003.txt
new file mode 100644
index 0000000..cdcab79
--- /dev/null
+++ b/src/test/examples/naming001/keep-rules-003.txt
@@ -0,0 +1,9 @@
+# Copyright (c) 2017, 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.
+
+-allowaccessmodification
+
+-keep !final class naming001.A {
+  !private <methods>;
+}
diff --git a/src/test/examples/naming001/keep-rules-005.txt b/src/test/examples/naming001/keep-rules-005.txt
new file mode 100644
index 0000000..ef4b5c8
--- /dev/null
+++ b/src/test/examples/naming001/keep-rules-005.txt
@@ -0,0 +1,9 @@
+# Copyright (c) 2017, 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.
+
+-allowaccessmodification
+
+-keep class naming001.D {
+  public static void main(...);
+}
diff --git a/src/test/examples/naming001/keep-rules-006.txt b/src/test/examples/naming001/keep-rules-006.txt
new file mode 100644
index 0000000..7a8e99e
--- /dev/null
+++ b/src/test/examples/naming001/keep-rules-006.txt
@@ -0,0 +1,9 @@
+# Copyright (c) 2017, 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.
+
+-allowaccessmodification
+
+-keep class naming001.G {
+  public static void main(...);
+}
diff --git a/src/test/examples/naming001/keep-rules-014.txt b/src/test/examples/naming001/keep-rules-014.txt
new file mode 100644
index 0000000..6423782
--- /dev/null
+++ b/src/test/examples/naming001/keep-rules-014.txt
@@ -0,0 +1,9 @@
+# Copyright (c) 2017, 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.
+
+-allowaccessmodification
+
+-keep class naming001.Reflect {
+  *** keep6();
+}
diff --git a/src/test/examples/naming001/keep-rules-017.txt b/src/test/examples/naming001/keep-rules-017.txt
new file mode 100644
index 0000000..b146df8
--- /dev/null
+++ b/src/test/examples/naming001/keep-rules-017.txt
@@ -0,0 +1,9 @@
+# Copyright (c) 2017, 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.
+
+-allowaccessmodification
+
+-keep class naming001.K {
+  void keep();
+}
diff --git a/src/test/examples/naming044/A.java b/src/test/examples/naming044/A.java
new file mode 100644
index 0000000..799f765
--- /dev/null
+++ b/src/test/examples/naming044/A.java
@@ -0,0 +1,8 @@
+// Copyright (c) 2017, 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 naming044;
+
+public class A {
+  static int f = 8;
+}
diff --git a/src/test/examples/naming044/B.java b/src/test/examples/naming044/B.java
new file mode 100644
index 0000000..7580945
--- /dev/null
+++ b/src/test/examples/naming044/B.java
@@ -0,0 +1,10 @@
+// Copyright (c) 2017, 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 naming044;
+
+public class B {
+  public static int m() {
+    return A.f;
+  }
+}
diff --git a/src/test/examples/naming044/keep-rules-001.txt b/src/test/examples/naming044/keep-rules-001.txt
new file mode 100644
index 0000000..a191b54
--- /dev/null
+++ b/src/test/examples/naming044/keep-rules-001.txt
@@ -0,0 +1,11 @@
+# Copyright (c) 2017, 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.
+
+-allowaccessmodification
+
+-repackageclasses ''
+
+-keep,allowobfuscation class * {
+  *;
+}
diff --git a/src/test/examples/naming044/keep-rules-002.txt b/src/test/examples/naming044/keep-rules-002.txt
new file mode 100644
index 0000000..c6e495b
--- /dev/null
+++ b/src/test/examples/naming044/keep-rules-002.txt
@@ -0,0 +1,11 @@
+# Copyright (c) 2017, 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.
+
+-allowaccessmodification
+
+-repackageclasses 'p44.x'
+
+-keep,allowobfuscation class * {
+  *;
+}
diff --git a/src/test/java/com/android/tools/r8/ToolHelper.java b/src/test/java/com/android/tools/r8/ToolHelper.java
index 1683557..e4b37f2 100644
--- a/src/test/java/com/android/tools/r8/ToolHelper.java
+++ b/src/test/java/com/android/tools/r8/ToolHelper.java
@@ -11,10 +11,17 @@
 import com.android.tools.r8.dex.Constants;
 import com.android.tools.r8.graph.AppInfoWithSubtyping;
 import com.android.tools.r8.graph.DexApplication;
+import com.android.tools.r8.graph.DexItemFactory;
+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.ProguardRuleParserException;
+import com.android.tools.r8.shaking.RootSetBuilder;
+import com.android.tools.r8.shaking.RootSetBuilder.RootSet;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.ListUtils;
+import com.android.tools.r8.utils.ThreadUtils;
 import com.android.tools.r8.utils.Timing;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
@@ -421,6 +428,17 @@
         .read();
   }
 
+  public static ProguardConfiguration loadProguardConfiguration(
+      DexItemFactory factory, List<Path> configPaths)
+      throws IOException, ProguardRuleParserException {
+    if (configPaths.isEmpty()) {
+      return ProguardConfiguration.defaultConfiguration(factory);
+    }
+    ProguardConfigurationParser parser = new ProguardConfigurationParser(factory);
+    parser.parse(configPaths);
+    return parser.getConfig();
+  }
+
   public static R8Command.Builder prepareR8CommandBuilder(AndroidApp app) {
     return R8Command.builder(app);
   }
diff --git a/src/test/java/com/android/tools/r8/naming/MinifierTest.java b/src/test/java/com/android/tools/r8/naming/MinifierTest.java
new file mode 100644
index 0000000..1124ceb
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/naming/MinifierTest.java
@@ -0,0 +1,200 @@
+// Copyright (c) 2017, 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.naming;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+
+import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.utils.ListUtils;
+import com.android.tools.r8.utils.Timing;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.BiConsumer;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class MinifierTest extends NamingTestBase {
+
+  public MinifierTest(
+      String test,
+      List<String> keepRulesFiles,
+      BiConsumer<DexItemFactory, NamingLens> inspection) {
+    super(test, keepRulesFiles, inspection, new Timing("MinifierTest"));
+  }
+
+  @Test
+  public void minifierTest() throws Exception {
+    NamingLens naming = runMinifier(ListUtils.map(keepRulesFiles, Paths::get));
+    inspection.accept(dexItemFactory, naming);
+  }
+
+  @Parameters(name = "test: {0} keep: {1}")
+  public static Collection<Object[]> data() {
+    List<String> tests = Arrays.asList("naming001");
+
+    Map<String, BiConsumer<DexItemFactory, NamingLens>> inspections = new HashMap<>();
+    inspections.put("naming001:keep-rules-001.txt", MinifierTest::test001_rule001);
+    inspections.put("naming001:keep-rules-002.txt", MinifierTest::test001_rule002);
+    inspections.put("naming001:keep-rules-003.txt", MinifierTest::test001_rule003);
+    inspections.put("naming001:keep-rules-005.txt", MinifierTest::test001_rule005);
+    inspections.put("naming001:keep-rules-006.txt", MinifierTest::test001_rule006);
+    inspections.put("naming001:keep-rules-014.txt", MinifierTest::test001_rule014);
+    inspections.put("naming001:keep-rules-017.txt", MinifierTest::test001_rule017);
+
+    return createTests(tests, inspections);
+  }
+
+  private static void test001_rule001(DexItemFactory dexItemFactory, NamingLens naming) {
+    DexType a = dexItemFactory.createType("Lnaming001/A;");
+    // class naming001.A should be kept, according to the keep rule.
+    assertEquals("Lnaming001/A;", naming.lookupDescriptor(a).toSourceString());
+
+    DexMethod m = dexItemFactory.createMethod(
+        a, dexItemFactory.createProto(dexItemFactory.voidType), "m");
+    // method naming001.A.m would be renamed.
+    assertNotEquals("m", naming.lookupName(m).toSourceString());
+
+    DexMethod p = dexItemFactory.createMethod(
+        a, dexItemFactory.createProto(dexItemFactory.voidType), "privateFunc");
+    // method naming001.A.privateFunc would be renamed.
+    assertNotEquals("privateFunc", naming.lookupName(p).toSourceString());
+
+    DexType k = dexItemFactory.createType("Lnaming001/K;");
+    DexField h = dexItemFactory.createField(k, dexItemFactory.intType, "h");
+    // field naming001.K.h is dead, not renamed; hence returned as same via identityLens.
+    assertEquals("h", naming.lookupName(h).toSourceString());
+  }
+
+  private static void test001_rule002(DexItemFactory dexItemFactory, NamingLens naming) {
+    DexType a = dexItemFactory.createType("Lnaming001/A;");
+    // class naming001.A should be kept, according to the keep rule.
+    assertEquals("Lnaming001/A;", naming.lookupDescriptor(a).toSourceString());
+
+    DexMethod m = dexItemFactory.createMethod(
+        a, dexItemFactory.createProto(dexItemFactory.voidType), "m");
+    // method naming001.A.m would be renamed.
+    assertNotEquals("m", naming.lookupName(m).toSourceString());
+
+    DexMethod p = dexItemFactory.createMethod(
+        a, dexItemFactory.createProto(dexItemFactory.voidType), "privateFunc");
+    // method naming001.A.privateFunc should be kept, according to the keep rule.
+    assertEquals("privateFunc", naming.lookupName(p).toSourceString());
+  }
+
+  private static void test001_rule003(DexItemFactory dexItemFactory, NamingLens naming) {
+    DexType a = dexItemFactory.createType("Lnaming001/A;");
+    // class naming001.A should be kept, according to the keep rule.
+    assertEquals("Lnaming001/A;", naming.lookupDescriptor(a).toSourceString());
+
+    DexMethod m = dexItemFactory.createMethod(
+        a, dexItemFactory.createProto(dexItemFactory.voidType), "m");
+    // method naming001.A.m should be kept, according to the keep rule.
+    assertEquals("m", naming.lookupName(m).toSourceString());
+
+    DexMethod p = dexItemFactory.createMethod(
+        a, dexItemFactory.createProto(dexItemFactory.voidType), "privateFunc");
+    // method naming001.A.privateFunc would be renamed.
+    assertNotEquals("privateFunc", naming.lookupName(p).toSourceString());
+  }
+
+  private static void test001_rule005(DexItemFactory dexItemFactory, NamingLens naming) {
+    DexType d = dexItemFactory.createType("Lnaming001/D;");
+    // class naming001.D should be kept, according to the keep rule.
+    assertEquals("Lnaming001/D;", naming.lookupDescriptor(d).toSourceString());
+
+    DexMethod main = dexItemFactory.createMethod(
+        d,
+        dexItemFactory.createProto(dexItemFactory.voidType, dexItemFactory.stringArrayType),
+        "main");
+    // method naming001.D.main should be kept, according to the keep rule.
+    assertEquals("main", naming.lookupName(main).toSourceString());
+
+    DexMethod k = dexItemFactory.createMethod(
+        d, dexItemFactory.createProto(dexItemFactory.voidType), "keep");
+    // method naming001.D.keep would be renamed.
+    assertNotEquals("keep", naming.lookupName(k).toSourceString());
+
+    // Note that naming001.E extends naming001.D.
+    DexType e = dexItemFactory.createType("Lnaming001/E;");
+    DexMethod inherited_k = dexItemFactory.createMethod(
+        e, dexItemFactory.createProto(dexItemFactory.voidType), "keep");
+    // method naming001.E.keep should be renamed to the same name as naming001.D.keep.
+    assertEquals(
+        naming.lookupName(inherited_k).toSourceString(), naming.lookupName(k).toSourceString());
+  }
+
+  private static void test001_rule006(DexItemFactory dexItemFactory, NamingLens naming) {
+    DexType g = dexItemFactory.createType("Lnaming001/G;");
+    // class naming001.G should be kept, according to the keep rule.
+    assertEquals("Lnaming001/G;", naming.lookupDescriptor(g).toSourceString());
+
+    DexMethod main = dexItemFactory.createMethod(
+        g,
+        dexItemFactory.createProto(dexItemFactory.voidType, dexItemFactory.stringArrayType),
+        "main");
+    // method naming001.G.main should be kept, according to the keep rule.
+    assertEquals("main", naming.lookupName(main).toSourceString());
+
+    DexMethod impl_m = dexItemFactory.createMethod(
+        g, dexItemFactory.createProto(dexItemFactory.voidType), "m");
+    // method naming001.G.m would be renamed.
+    assertNotEquals("m", naming.lookupName(impl_m).toSourceString());
+
+    // Note that naming001.G implements H that extends I, where method m is declared.
+    DexType i = dexItemFactory.createType("Lnaming001/I;");
+    DexMethod def_m = dexItemFactory.createMethod(
+        i, dexItemFactory.createProto(dexItemFactory.voidType), "m");
+    // method naming001.I.m should be renamed to the same name as naming001.G.m.
+    assertEquals(
+        naming.lookupName(impl_m).toSourceString(), naming.lookupName(def_m).toSourceString());
+  }
+
+  private static void test001_rule014(DexItemFactory dexItemFactory, NamingLens naming) {
+    DexType reflect = dexItemFactory.createType("Lnaming001/Reflect;");
+    // class naming001.Reflect should be kept, according to the keep rule.
+    assertEquals("Lnaming001/Reflect;", naming.lookupDescriptor(reflect).toSourceString());
+
+    DexMethod keep6 = dexItemFactory.createMethod(
+        reflect, dexItemFactory.createProto(dexItemFactory.voidType), "keep6");
+    // method naming001.Reflect.keep6 should be kept, according to the keep rule.
+    assertEquals("keep6", naming.lookupName(keep6).toSourceString());
+
+    DexType reflect2 = dexItemFactory.createType("Lnaming001/Reflect2;");
+    DexField fieldPublic = dexItemFactory.createField(
+        reflect2, dexItemFactory.intType, "fieldPublic");
+    // method naming001.Reflect.keep6 accesses to naming001.Reflect2.fieldPublic via reflection.
+    assertEquals("fieldPublic", naming.lookupName(fieldPublic).toSourceString());
+  }
+
+  private static void test001_rule017(DexItemFactory dexItemFactory, NamingLens naming) {
+    DexType k = dexItemFactory.createType("Lnaming001/K;");
+    // class naming001.K should be kept, according to the keep rule.
+    assertEquals("Lnaming001/K;", naming.lookupDescriptor(k).toSourceString());
+
+    DexMethod keep = dexItemFactory.createMethod(
+        k, dexItemFactory.createProto(dexItemFactory.voidType), "keep");
+    // method naming001.K.keep should be kept, according to the keep rule.
+    assertEquals("keep", naming.lookupName(keep).toSourceString());
+
+    DexField i = dexItemFactory.createField(k, dexItemFactory.intType, "i");
+    // field naming001.K.i
+    assertEquals("i", naming.lookupName(i).toSourceString());
+
+    DexField j = dexItemFactory.createField(k, dexItemFactory.intType, "j");
+    // field naming001.K.j
+    assertEquals("j", naming.lookupName(j).toSourceString());
+  }
+
+}
diff --git a/src/test/java/com/android/tools/r8/naming/NamingTestBase.java b/src/test/java/com/android/tools/r8/naming/NamingTestBase.java
new file mode 100644
index 0000000..b0fe113
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/naming/NamingTestBase.java
@@ -0,0 +1,124 @@
+// Copyright (c) 2017, 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.naming;
+
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.graph.AppInfoWithSubtyping;
+import com.android.tools.r8.graph.ClassAndMemberPublicizer;
+import com.android.tools.r8.graph.DexApplication;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.shaking.Enqueuer;
+import com.android.tools.r8.shaking.ProguardConfiguration;
+import com.android.tools.r8.shaking.ProguardRuleParserException;
+import com.android.tools.r8.shaking.RootSetBuilder;
+import com.android.tools.r8.shaking.RootSetBuilder.RootSet;
+import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.ThreadUtils;
+import com.android.tools.r8.utils.Timing;
+import com.google.common.collect.ImmutableList;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.function.BiConsumer;
+import org.junit.Before;
+
+abstract class NamingTestBase {
+
+  private final String appFileName;
+  final List<String> keepRulesFiles;
+  final BiConsumer<DexItemFactory, NamingLens> inspection;
+
+  private final Timing timing;
+
+  private DexApplication program;
+  DexItemFactory dexItemFactory;
+  private AppInfoWithSubtyping appInfo;
+
+  NamingTestBase(
+      String test,
+      List<String> keepRulesFiles,
+      BiConsumer<DexItemFactory, NamingLens> inspection,
+      Timing timing) {
+    appFileName = ToolHelper.EXAMPLES_BUILD_DIR + test + "/classes.dex";
+    this.keepRulesFiles = keepRulesFiles;
+    this.inspection = inspection;
+    this.timing = timing;
+  }
+
+  @Before
+  public void readApp() throws IOException, ExecutionException, ProguardRuleParserException {
+    program = ToolHelper.buildApplication(ImmutableList.of(appFileName));
+    dexItemFactory = program.dexItemFactory;
+    appInfo = new AppInfoWithSubtyping(program);
+  }
+
+  NamingLens runMinifier(List<Path> configPaths)
+      throws IOException, ProguardRuleParserException, ExecutionException {
+    ProguardConfiguration configuration =
+        ToolHelper.loadProguardConfiguration(dexItemFactory, configPaths);
+    InternalOptions options = new InternalOptions();
+    copyProguardConfigurationToInternalOptions(configuration, options);
+
+    if (options.allowAccessModification) {
+      ClassAndMemberPublicizer.run(program);
+    }
+
+    RootSet rootSet = new RootSetBuilder(program, appInfo, configuration.getRules())
+        .run(ThreadUtils.getExecutorService(options));
+    Enqueuer enqueuer = new Enqueuer(appInfo);
+    appInfo = enqueuer.traceApplication(rootSet, timing);
+    return new Minifier(appInfo.withLiveness(), rootSet, options).run(timing);
+  }
+
+  private void copyProguardConfigurationToInternalOptions(
+      ProguardConfiguration config, InternalOptions options) {
+    options.packagePrefix = config.getPackagePrefix();
+    options.allowAccessModification = config.getAllowAccessModification();
+    options.classObfuscationDictionary = config.getClassObfuscationDictionary();
+    options.obfuscationDictionary = config.getObfuscationDictionary();
+    options.keepRules = config.getRules();
+  }
+
+  static <T> Collection<Object[]> createTests(List<String> tests, Map<String, T> inspections) {
+    List<Object[]> testCases = new ArrayList<>();
+    Set<String> usedInspections = new HashSet<>();
+    for (String test : tests) {
+      File[] keepFiles = new File(ToolHelper.EXAMPLES_DIR + test)
+          .listFiles(file -> file.isFile() && file.getName().endsWith(".txt"));
+      for (File keepFile : keepFiles) {
+        String keepName = keepFile.getName();
+        T inspection = getTestOptionalParameter(inspections, usedInspections, test, keepName);
+        if (inspection != null) {
+          testCases.add(new Object[]{test, ImmutableList.of(keepFile.getPath()), inspection});
+        }
+      }
+    }
+    assert usedInspections.size() == inspections.size();
+    return testCases;
+  }
+
+  private static <T> T getTestOptionalParameter(
+      Map<String, T> specifications,
+      Set<String> usedSpecifications,
+      String test,
+      String keepName) {
+    T parameter = specifications.get(test);
+    if (parameter == null) {
+      parameter = specifications.get(test + ":" + keepName);
+      if (parameter != null) {
+        usedSpecifications.add(test + ":" + keepName);
+      }
+    } else {
+      usedSpecifications.add(test);
+    }
+    return parameter;
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/naming/PackageNamingTest.java b/src/test/java/com/android/tools/r8/naming/PackageNamingTest.java
new file mode 100644
index 0000000..3e9b269
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/naming/PackageNamingTest.java
@@ -0,0 +1,72 @@
+// Copyright (c) 2017, 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.naming;
+
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.utils.ListUtils;
+import com.android.tools.r8.utils.Timing;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.BiConsumer;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class PackageNamingTest extends NamingTestBase {
+
+  public PackageNamingTest(
+      String test,
+      List<String> keepRulesFiles,
+      BiConsumer<DexItemFactory, NamingLens> inspection) {
+    super(test, keepRulesFiles, inspection, new Timing("PackageNamingTest"));
+  }
+
+  @Test
+  public void packageNamingTest() throws Exception {
+    NamingLens naming = runMinifier(ListUtils.map(keepRulesFiles, Paths::get));
+    inspection.accept(dexItemFactory, naming);
+  }
+
+  @Parameters(name = "test: {0} keep: {1}")
+  public static Collection<Object[]> data() {
+    List<String> tests = Arrays.asList("naming044");
+
+    Map<String, BiConsumer<DexItemFactory, NamingLens>> inspections = new HashMap<>();
+    inspections.put("naming044:keep-rules-001.txt", PackageNamingTest::test044_rule001);
+    inspections.put("naming044:keep-rules-002.txt", PackageNamingTest::test044_rule002);
+
+    return createTests(tests, inspections);
+  }
+
+  private static void test044_rule001(DexItemFactory dexItemFactory, NamingLens naming) {
+    DexType b = dexItemFactory.createType("Lnaming044/B;");
+    // All classes are moved to the top-level package, hence no package separator.
+    assertFalse(naming.lookupDescriptor(b).toSourceString().contains("/"));
+
+    DexMethod m = dexItemFactory.createMethod(
+        b, dexItemFactory.createProto(dexItemFactory.intType), "m");
+    // method naming044.B.m would be renamed.
+    assertNotEquals("m", naming.lookupName(m).toSourceString());
+  }
+
+  private static void test044_rule002(DexItemFactory dexItemFactory, NamingLens naming) {
+    DexType a = dexItemFactory.createType("Lnaming044/A;");
+    assertTrue(naming.lookupDescriptor(a).toSourceString().startsWith("Lp44/x/"));
+
+    DexType b = dexItemFactory.createType("Lnaming044/B;");
+    assertTrue(naming.lookupDescriptor(b).toSourceString().startsWith("Lp44/x/"));
+  }
+}