diff --git a/maven-dependency-analyzer/src/main/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzer.java b/maven-dependency-analyzer/src/main/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzer.java
index f0e92c409..35b26ebd9 100644
--- a/maven-dependency-analyzer/src/main/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzer.java
+++ b/maven-dependency-analyzer/src/main/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzer.java
@@ -24,10 +24,13 @@
 import java.net.URL;
 import java.util.Collections;
 import java.util.Enumeration;
+import java.util.HashMap;
 import java.util.HashSet;
+import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Set;
 import java.util.jar.JarEntry;
 import java.util.jar.JarFile;
@@ -71,20 +74,21 @@ public ProjectDependencyAnalysis analyze( MavenProject project )
         {
             Map<Artifact, Set<String>> artifactClassMap = buildArtifactClassMap( project );
 
-            Set<String> dependencyClasses = buildDependencyClasses( project );
+            Set<DependencyUsage> dependencyUsages = buildDependencyUsages( project );
 
             Set<Artifact> declaredArtifacts = buildDeclaredArtifacts( project );
 
-            Set<Artifact> usedArtifacts = buildUsedArtifacts( artifactClassMap, dependencyClasses );
+            Map<Artifact, Set<DependencyUsage>> usedArtifacts = buildArtifactToUsageMap( artifactClassMap,
+                                                                                         dependencyUsages );
 
-            Set<Artifact> usedDeclaredArtifacts = new LinkedHashSet<Artifact>( declaredArtifacts );
-            usedDeclaredArtifacts.retainAll( usedArtifacts );
+            Map<Artifact, Set<DependencyUsage>> usedDeclaredArtifacts = buildMutableCopy( usedArtifacts );
+            usedDeclaredArtifacts.keySet().retainAll( declaredArtifacts );
 
-            Set<Artifact> usedUndeclaredArtifacts = new LinkedHashSet<Artifact>( usedArtifacts );
-            usedUndeclaredArtifacts = removeAll( usedUndeclaredArtifacts, declaredArtifacts );
+            Map<Artifact, Set<DependencyUsage>> usedUndeclaredArtifacts = buildMutableCopy( usedArtifacts );
+            removeAll( usedUndeclaredArtifacts.keySet(), declaredArtifacts );
 
             Set<Artifact> unusedDeclaredArtifacts = new LinkedHashSet<Artifact>( declaredArtifacts );
-            unusedDeclaredArtifacts = removeAll( unusedDeclaredArtifacts, usedArtifacts );
+            removeAll( unusedDeclaredArtifacts, usedArtifacts.keySet() );
 
             return new ProjectDependencyAnalysis( usedDeclaredArtifacts, usedUndeclaredArtifacts,
                                                   unusedDeclaredArtifacts );
@@ -101,32 +105,22 @@ public ProjectDependencyAnalysis analyze( MavenProject project )
      * 
      * @param start initial set
      * @param remove set to exclude
-     * @return set with remove excluded
      */
-    private Set<Artifact> removeAll( Set<Artifact> start, Set<Artifact> remove )
+    private void removeAll( Set<Artifact> start, Set<Artifact> remove )
     {
-        Set<Artifact> results = new LinkedHashSet<Artifact>( start.size() );
-
-        for ( Artifact artifact : start )
+        for ( Iterator<Artifact> iterator = start.iterator(); iterator.hasNext(); )
         {
-            boolean found = false;
+            Artifact artifact = iterator.next();
 
             for ( Artifact artifact2 : remove )
             {
                 if ( artifact.getDependencyConflictId().equals( artifact2.getDependencyConflictId() ) )
                 {
-                    found = true;
+                    iterator.remove();
                     break;
                 }
             }
-
-            if ( !found )
-            {
-                results.add( artifact );
-            }
         }
-
-        return results;
     }
 
     protected Map<Artifact, Set<String>> buildArtifactClassMap( MavenProject project )
@@ -189,26 +183,26 @@ else if ( file != null && file.isDirectory() )
         return artifactClassMap;
     }
 
-    protected Set<String> buildDependencyClasses( MavenProject project )
+    protected Set<DependencyUsage> buildDependencyUsages( MavenProject project )
         throws IOException
     {
-        Set<String> dependencyClasses = new HashSet<String>();
+        Set<DependencyUsage> dependencyUsages = new HashSet<DependencyUsage>();
 
         String outputDirectory = project.getBuild().getOutputDirectory();
-        dependencyClasses.addAll( buildDependencyClasses( outputDirectory ) );
+        dependencyUsages.addAll( buildDependencyUsages( outputDirectory ) );
 
         String testOutputDirectory = project.getBuild().getTestOutputDirectory();
-        dependencyClasses.addAll( buildDependencyClasses( testOutputDirectory ) );
+        dependencyUsages.addAll( buildDependencyUsages( testOutputDirectory ) );
 
-        return dependencyClasses;
+        return dependencyUsages;
     }
 
-    private Set<String> buildDependencyClasses( String path )
+    private Set<DependencyUsage> buildDependencyUsages( String path )
         throws IOException
     {
         URL url = new File( path ).toURI().toURL();
 
-        return dependencyAnalyzer.analyze( url );
+        return dependencyAnalyzer.analyzeWithUsages( url );
     }
 
     protected Set<Artifact> buildDeclaredArtifacts( MavenProject project )
@@ -224,22 +218,29 @@ protected Set<Artifact> buildDeclaredArtifacts( MavenProject project )
         return declaredArtifacts;
     }
 
-    protected Set<Artifact> buildUsedArtifacts( Map<Artifact, Set<String>> artifactClassMap,
-                                              Set<String> dependencyClasses )
+    protected Map<Artifact, Set<DependencyUsage>> buildArtifactToUsageMap( Map<Artifact, Set<String>> artifactClassMap,
+                                                                           Set<DependencyUsage> dependencyUsages )
     {
-        Set<Artifact> usedArtifacts = new HashSet<Artifact>();
+        Map<String, Set<DependencyUsage>> dependencyClassToUsages = buildDependencyClassToUsageMap( dependencyUsages );
+
+        Map<Artifact, Set<DependencyUsage>> artifactToUsages = new HashMap<Artifact, Set<DependencyUsage>>();
 
-        for ( String className : dependencyClasses )
+        for ( Entry<String, Set<DependencyUsage>> entry : dependencyClassToUsages.entrySet() )
         {
-            Artifact artifact = findArtifactForClassName( artifactClassMap, className );
+            Artifact artifact = findArtifactForClassName( artifactClassMap, entry.getKey() );
 
             if ( artifact != null )
             {
-                usedArtifacts.add( artifact );
+                if ( !artifactToUsages.containsKey( artifact ) )
+                {
+                    artifactToUsages.put( artifact, new HashSet<DependencyUsage>() );
+                }
+
+                artifactToUsages.get( artifact ).addAll( entry.getValue() );
             }
         }
 
-        return usedArtifacts;
+        return artifactToUsages;
     }
 
     protected Artifact findArtifactForClassName( Map<Artifact, Set<String>> artifactClassMap, String className )
@@ -254,4 +255,35 @@ protected Artifact findArtifactForClassName( Map<Artifact, Set<String>> artifact
 
         return null;
     }
+
+    private Map<String, Set<DependencyUsage>> buildDependencyClassToUsageMap( Set<DependencyUsage> dependencyUsages )
+    {
+        Map<String, Set<DependencyUsage>> dependencyClassToUsages = new HashMap<String, Set<DependencyUsage>>();
+
+        for ( DependencyUsage dependencyUsage : dependencyUsages )
+        {
+            String dependencyClass = dependencyUsage.getDependencyClass();
+
+            if ( !dependencyClassToUsages.containsKey( dependencyClass ) )
+            {
+                dependencyClassToUsages.put( dependencyClass, new HashSet<DependencyUsage>() );
+            }
+
+            dependencyClassToUsages.get( dependencyClass ).add( dependencyUsage );
+        }
+
+        return dependencyClassToUsages;
+    }
+
+    private Map<Artifact, Set<DependencyUsage>> buildMutableCopy( Map<Artifact, Set<DependencyUsage>> map )
+    {
+        Map<Artifact, Set<DependencyUsage>> copy = new LinkedHashMap<Artifact, Set<DependencyUsage>>();
+
+        for ( Entry<Artifact, Set<DependencyUsage>> entry : map.entrySet() )
+        {
+            copy.put( entry.getKey(), new LinkedHashSet<DependencyUsage>( entry.getValue() ) );
+        }
+
+        return copy;
+    }
 }
diff --git a/maven-dependency-analyzer/src/main/java/org/apache/maven/shared/dependency/analyzer/DependencyAnalyzer.java b/maven-dependency-analyzer/src/main/java/org/apache/maven/shared/dependency/analyzer/DependencyAnalyzer.java
index 5de91e978..542ba0b7a 100644
--- a/maven-dependency-analyzer/src/main/java/org/apache/maven/shared/dependency/analyzer/DependencyAnalyzer.java
+++ b/maven-dependency-analyzer/src/main/java/org/apache/maven/shared/dependency/analyzer/DependencyAnalyzer.java
@@ -39,4 +39,7 @@ public interface DependencyAnalyzer
 
     Set<String> analyze( URL url )
         throws IOException;
+
+    Set<DependencyUsage> analyzeWithUsages( URL url )
+        throws IOException;
 }
diff --git a/maven-dependency-analyzer/src/main/java/org/apache/maven/shared/dependency/analyzer/DependencyUsage.java b/maven-dependency-analyzer/src/main/java/org/apache/maven/shared/dependency/analyzer/DependencyUsage.java
new file mode 100644
index 000000000..e973133df
--- /dev/null
+++ b/maven-dependency-analyzer/src/main/java/org/apache/maven/shared/dependency/analyzer/DependencyUsage.java
@@ -0,0 +1,103 @@
+package org.apache.maven.shared.dependency.analyzer;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ */
+
+/**
+ * Usage of a dependency class by a project class.
+ *
+ * @author <a href="mailto:hijon89@gmail.com">Jonathan Haber</a>
+ */
+public class DependencyUsage
+{
+  // fields -----------------------------------------------------------------
+
+  private final String dependencyClass;
+
+  private final String usedBy;
+
+  // constructors -----------------------------------------------------------
+
+  public DependencyUsage( String dependencyClass, String usedBy )
+  {
+    this.dependencyClass = dependencyClass;
+    this.usedBy = usedBy;
+  }
+
+  // public methods ---------------------------------------------------------
+
+
+  public String getDependencyClass()
+  {
+    return dependencyClass;
+  }
+
+  public String getUsedBy()
+  {
+    return usedBy;
+  }
+
+  // Object methods ---------------------------------------------------------
+
+  /*
+   * @see java.lang.Object#hashCode()
+   */
+  public int hashCode()
+  {
+    int hashCode = dependencyClass.hashCode();
+    hashCode = ( hashCode * 37 ) + usedBy.hashCode();
+
+    return hashCode;
+  }
+
+  /*
+   * @see java.lang.Object#equals(java.lang.Object)
+   */
+  public boolean equals( Object object )
+  {
+    if ( object instanceof DependencyUsage )
+    {
+      DependencyUsage usage = (DependencyUsage) object;
+
+      return getDependencyClass().equals( usage.getDependencyClass() )
+          && getUsedBy().equals( usage.getUsedBy() );
+    }
+
+    return false;
+  }
+
+  /*
+   * @see java.lang.Object#toString()
+   */
+  public String toString()
+  {
+    StringBuilder buffer = new StringBuilder();
+
+    buffer.append( "dependencyClass=" ).append( getDependencyClass() );
+    buffer.append( "," );
+    buffer.append( "usedBy=" ).append( getUsedBy() );
+
+    buffer.insert( 0, "[" );
+    buffer.insert( 0, getClass().getName() );
+
+    buffer.append( "]" );
+
+    return buffer.toString();
+  }
+}
diff --git a/maven-dependency-analyzer/src/main/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysis.java b/maven-dependency-analyzer/src/main/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysis.java
index ebfdec243..830536d4d 100644
--- a/maven-dependency-analyzer/src/main/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysis.java
+++ b/maven-dependency-analyzer/src/main/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysis.java
@@ -21,9 +21,13 @@
 
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
+import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Set;
 
 import org.apache.maven.artifact.Artifact;
@@ -38,9 +42,9 @@ public class ProjectDependencyAnalysis
 {
     // fields -----------------------------------------------------------------
 
-    private final Set<Artifact> usedDeclaredArtifacts;
+    private final Map<Artifact, Set<DependencyUsage>> usedDeclaredArtifacts;
 
-    private final Set<Artifact> usedUndeclaredArtifacts;
+    private final Map<Artifact, Set<DependencyUsage>> usedUndeclaredArtifacts;
 
     private final Set<Artifact> unusedDeclaredArtifacts;
 
@@ -48,11 +52,18 @@ public class ProjectDependencyAnalysis
 
     public ProjectDependencyAnalysis()
     {
-        this( null, null, null );
+        this( (Set<Artifact>) null, null, null );
     }
 
     public ProjectDependencyAnalysis( Set<Artifact> usedDeclaredArtifacts, Set<Artifact> usedUndeclaredArtifacts,
                                       Set<Artifact> unusedDeclaredArtifacts )
+    {
+        this( toMap( usedDeclaredArtifacts ), toMap( usedUndeclaredArtifacts ), unusedDeclaredArtifacts );
+    }
+
+    public ProjectDependencyAnalysis( Map<Artifact, Set<DependencyUsage>> usedDeclaredArtifacts,
+                                      Map<Artifact, Set<DependencyUsage>> usedUndeclaredArtifacts,
+                                      Set<Artifact> unusedDeclaredArtifacts )
     {
         this.usedDeclaredArtifacts = safeCopy( usedDeclaredArtifacts );
         this.usedUndeclaredArtifacts = safeCopy( usedUndeclaredArtifacts );
@@ -65,6 +76,14 @@ public ProjectDependencyAnalysis( Set<Artifact> usedDeclaredArtifacts, Set<Artif
      * Used and declared artifacts.
      */
     public Set<Artifact> getUsedDeclaredArtifacts()
+    {
+        return usedDeclaredArtifacts.keySet();
+    }
+
+    /**
+     * Used and declared artifacts mapped to usages.
+     */
+    public Map<Artifact, Set<DependencyUsage>> getUsedDeclaredArtifactToUsageMap()
     {
         return usedDeclaredArtifacts;
     }
@@ -73,6 +92,14 @@ public Set<Artifact> getUsedDeclaredArtifacts()
      * Used but not declared artifacts.
      */
     public Set<Artifact> getUsedUndeclaredArtifacts()
+    {
+        return usedUndeclaredArtifacts.keySet();
+    }
+
+    /**
+     * Used but not declared artifacts mapped to usages.
+     */
+    public Map<Artifact, Set<DependencyUsage>> getUsedUndeclaredArtifactToUsageMap()
     {
         return usedUndeclaredArtifacts;
     }
@@ -123,7 +150,9 @@ public ProjectDependencyAnalysis forceDeclaredDependenciesUsage( String[] forceU
         Set<String> forced = new HashSet<String>( Arrays.asList( forceUsedDependencies ) );
 
         Set<Artifact> forcedUnusedDeclared = new HashSet<Artifact>( unusedDeclaredArtifacts );
-        Set<Artifact> forcedUsedDeclared = new HashSet<Artifact>( usedDeclaredArtifacts );
+        Map<Artifact, Set<DependencyUsage>> forcedUsedDeclared = new HashMap<Artifact, Set<DependencyUsage>>(
+            usedDeclaredArtifacts
+        );
 
         for ( Iterator<Artifact> iter = forcedUnusedDeclared.iterator(); iter.hasNext(); )
         {
@@ -133,7 +162,10 @@ public ProjectDependencyAnalysis forceDeclaredDependenciesUsage( String[] forceU
             {
                 // ok, change artifact status from unused-declared to used-declared
                 iter.remove();
-                forcedUsedDeclared.add( artifact );
+                if ( !forcedUsedDeclared.containsKey( artifact ) )
+                {
+                    forcedUsedDeclared.put( artifact, Collections.<DependencyUsage>emptySet() );
+                }
             }
         }
 
@@ -141,7 +173,7 @@ public ProjectDependencyAnalysis forceDeclaredDependenciesUsage( String[] forceU
         {
             // trying to force dependencies as used-declared which were not declared or already detected as used
             Set<String> used = new HashSet<String>();
-            for ( Artifact artifact : usedDeclaredArtifacts )
+            for ( Artifact artifact : usedDeclaredArtifacts.keySet() )
             {
                 String id = artifact.getGroupId() + ':' + artifact.getArtifactId();
                 if ( forced.remove( id ) )
@@ -242,9 +274,40 @@ public String toString()
 
     // private methods --------------------------------------------------------
 
-    private Set<Artifact> safeCopy( Set<Artifact> set )
+    private <T> Set<T> safeCopy( Set<T> set )
+    {
+        return ( set == null ) ? Collections.<T>emptySet()
+                        : Collections.unmodifiableSet( new LinkedHashSet<T>( set ) );
+    }
+
+    private Map<Artifact, Set<DependencyUsage>> safeCopy( Map<Artifact, Set<DependencyUsage>> map )
+    {
+        Map<Artifact, Set<DependencyUsage>> copy = new LinkedHashMap<Artifact, Set<DependencyUsage>>();
+
+        for ( Entry<Artifact, Set<DependencyUsage>> entry : map.entrySet() )
+        {
+            copy.put( entry.getKey(), safeCopy( entry.getValue() ) );
+        }
+
+        return Collections.unmodifiableMap( copy );
+    }
+
+    private static Map<Artifact, Set<DependencyUsage>> toMap( Set<Artifact> set )
     {
-        return ( set == null ) ? Collections.<Artifact>emptySet()
-                        : Collections.unmodifiableSet( new LinkedHashSet<Artifact>( set ) );
+        if ( set == null )
+        {
+            return Collections.<Artifact, Set<DependencyUsage>>emptyMap();
+        }
+        else
+        {
+            Map<Artifact, Set<DependencyUsage>> map = new HashMap<Artifact, Set<DependencyUsage>>();
+
+            for ( Artifact artifact : set )
+            {
+                map.put( artifact, Collections.<DependencyUsage>emptySet() );
+            }
+
+            return map;
+        }
     }
 }
diff --git a/maven-dependency-analyzer/src/main/java/org/apache/maven/shared/dependency/analyzer/asm/ASMDependencyAnalyzer.java b/maven-dependency-analyzer/src/main/java/org/apache/maven/shared/dependency/analyzer/asm/ASMDependencyAnalyzer.java
index facad0967..c36aa853b 100644
--- a/maven-dependency-analyzer/src/main/java/org/apache/maven/shared/dependency/analyzer/asm/ASMDependencyAnalyzer.java
+++ b/maven-dependency-analyzer/src/main/java/org/apache/maven/shared/dependency/analyzer/asm/ASMDependencyAnalyzer.java
@@ -25,6 +25,7 @@
 
 import org.apache.maven.shared.dependency.analyzer.ClassFileVisitorUtils;
 import org.apache.maven.shared.dependency.analyzer.DependencyAnalyzer;
+import org.apache.maven.shared.dependency.analyzer.DependencyUsage;
 import org.codehaus.plexus.component.annotations.Component;
 
 /**
@@ -51,4 +52,17 @@ public Set<String> analyze( URL url )
 
         return visitor.getDependencies();
     }
+
+    /*
+     * @see org.apache.maven.shared.dependency.analyzer.DependencyAnalyzer#analyze(java.net.URL)
+     */
+    public Set<DependencyUsage> analyzeWithUsages( URL url )
+        throws IOException
+    {
+        DependencyClassFileVisitor visitor = new DependencyClassFileVisitor();
+
+        ClassFileVisitorUtils.accept( url, visitor );
+
+        return visitor.getDependencyUsages();
+    }
 }
diff --git a/maven-dependency-analyzer/src/main/java/org/apache/maven/shared/dependency/analyzer/asm/DependencyClassFileVisitor.java b/maven-dependency-analyzer/src/main/java/org/apache/maven/shared/dependency/analyzer/asm/DependencyClassFileVisitor.java
index 1c594aeb9..225451119 100644
--- a/maven-dependency-analyzer/src/main/java/org/apache/maven/shared/dependency/analyzer/asm/DependencyClassFileVisitor.java
+++ b/maven-dependency-analyzer/src/main/java/org/apache/maven/shared/dependency/analyzer/asm/DependencyClassFileVisitor.java
@@ -20,6 +20,7 @@
  */
 
 import org.apache.maven.shared.dependency.analyzer.ClassFileVisitor;
+import org.apache.maven.shared.dependency.analyzer.DependencyUsage;
 import org.objectweb.asm.AnnotationVisitor;
 import org.objectweb.asm.ClassReader;
 import org.objectweb.asm.ClassVisitor;
@@ -29,6 +30,7 @@
 
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.HashSet;
 import java.util.Set;
 
 /**
@@ -44,7 +46,9 @@ public class DependencyClassFileVisitor
 {
     // fields -----------------------------------------------------------------
 
-    private final ResultCollector resultCollector = new ResultCollector();
+    private final Set<String> dependencies = new HashSet<String>();
+
+    private final Set<DependencyUsage> dependencyUsages = new HashSet<DependencyUsage>();
 
     // constructors -----------------------------------------------------------
 
@@ -60,6 +64,7 @@ public DependencyClassFileVisitor()
      */
     public void visitClass( String className, InputStream in )
     {
+        ResultCollector resultCollector = new ResultCollector();
         try
         {
             ClassReader reader = new ClassReader( in );
@@ -89,6 +94,12 @@ public void visitClass( String className, InputStream in )
             // this happens when the class isn't valid.
             System.out.println( "Unable to process: " + className );
         }
+
+        for ( String dependencyClass : resultCollector.getDependencies() )
+        {
+            dependencies.add( dependencyClass );
+            dependencyUsages.add( new DependencyUsage( dependencyClass, className ) );
+        }
     }
 
     // public methods ---------------------------------------------------------
@@ -98,6 +109,14 @@ public void visitClass( String className, InputStream in )
      */
     public Set<String> getDependencies()
     {
-        return resultCollector.getDependencies();
+        return dependencies;
+    }
+
+    /**
+     * @return the set of dependency usages for visited class files
+     */
+    public Set<DependencyUsage> getDependencyUsages()
+    {
+        return dependencyUsages;
     }
 }
diff --git a/maven-dependency-analyzer/src/test/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzerTest.java b/maven-dependency-analyzer/src/test/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzerTest.java
index 1e2466b08..7feaff23e 100644
--- a/maven-dependency-analyzer/src/test/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzerTest.java
+++ b/maven-dependency-analyzer/src/test/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzerTest.java
@@ -3,8 +3,10 @@
 import java.io.File;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Properties;
 import java.util.Set;
 
@@ -116,6 +118,8 @@ public void testJarWithNoDependencies()
         ProjectDependencyAnalysis expectedAnalysis = new ProjectDependencyAnalysis();
 
         assertEquals( expectedAnalysis, actualAnalysis );
+        assertEquals( Collections.emptyMap(), actualAnalysis.getUsedDeclaredArtifactToUsageMap() );
+        assertEquals( Collections.emptyMap(), actualAnalysis.getUsedUndeclaredArtifactToUsageMap() );
     }
 
     public void testJava8methodRefs()
@@ -141,6 +145,19 @@ public void testJava8methodRefs()
             new ProjectDependencyAnalysis( usedDeclaredArtifacts, new HashSet<Artifact>(), new HashSet<Artifact>() );
 
         assertEquals( expectedAnalysis, actualAnalysis );
+        assertEquals( Collections.emptyMap(), actualAnalysis.getUsedUndeclaredArtifactToUsageMap() );
+
+        Map<Artifact, Set<DependencyUsage>> actualDependencyUsageMap =
+            actualAnalysis.getUsedDeclaredArtifactToUsageMap();
+
+        Map<Artifact, Set<DependencyUsage>> expectedDependencyUsageMap =
+            new HashMap<Artifact, Set<DependencyUsage>>();
+        expectedDependencyUsageMap.put( project1, createDependencyUsage(
+            "org.apache.commons.io.FileUtils", "inlinedStaticReference.Project" ) );
+        expectedDependencyUsageMap.put( project2, createDependencyUsage(
+            "org.apache.commons.lang.CharUtils", "inlinedStaticReference.Project" ) );
+
+        assertEquals( expectedDependencyUsageMap, actualDependencyUsageMap );
     }
 
     public void testInlinedStaticReference()
@@ -165,6 +182,17 @@ public void testInlinedStaticReference()
             new ProjectDependencyAnalysis( usedDeclaredArtifacts, new HashSet<Artifact>(), new HashSet<Artifact>() );
 
         assertEquals( expectedAnalysis, actualAnalysis );
+        assertEquals( Collections.emptyMap(), actualAnalysis.getUsedUndeclaredArtifactToUsageMap() );
+
+        Map<Artifact, Set<DependencyUsage>> actualDependencyUsageMap =
+            actualAnalysis.getUsedDeclaredArtifactToUsageMap();
+
+        Map<Artifact, Set<DependencyUsage>> expectedDependencyUsageMap =
+            new HashMap<Artifact, Set<DependencyUsage>>();
+        expectedDependencyUsageMap.put( project1, createDependencyUsage(
+            "org.dom4j.Node", "inlinedStaticReference.Project" ) );
+
+        assertEquals( expectedDependencyUsageMap, actualDependencyUsageMap );
     }
 
     public void testJarWithCompileDependency()
@@ -189,6 +217,17 @@ public void testJarWithCompileDependency()
         ProjectDependencyAnalysis expectedAnalysis = new ProjectDependencyAnalysis( usedDeclaredArtifacts, null, null );
 
         assertEquals( expectedAnalysis, actualAnalysis );
+        assertEquals( Collections.emptyMap(), actualAnalysis.getUsedUndeclaredArtifactToUsageMap() );
+
+        Map<Artifact, Set<DependencyUsage>> actualDependencyUsageMap =
+            actualAnalysis.getUsedDeclaredArtifactToUsageMap();
+
+        Map<Artifact, Set<DependencyUsage>> expectedDependencyUsageMap =
+            new HashMap<Artifact, Set<DependencyUsage>>();
+        expectedDependencyUsageMap.put( project1, createDependencyUsage(
+            "jarWithCompileDependency.project1.Project1", "jarWithCompileDependency.project2.Project2" ) );
+
+        assertEquals( expectedDependencyUsageMap, actualDependencyUsageMap );
     }
 
     public void testForceDeclaredDependenciesUsage()
@@ -253,6 +292,22 @@ public void testJarWithTestDependency()
         }
 
         assertEquals( expectedAnalysis, actualAnalysis );
+        assertEquals( Collections.emptyMap(), actualAnalysis.getUsedUndeclaredArtifactToUsageMap() );
+
+        Map<Artifact, Set<DependencyUsage>> actualDependencyUsageMap =
+            actualAnalysis.getUsedDeclaredArtifactToUsageMap();
+
+        Map<Artifact, Set<DependencyUsage>> expectedDependencyUsageMap =
+            new HashMap<Artifact, Set<DependencyUsage>>();
+        expectedDependencyUsageMap.put( project1, createDependencyUsage(
+            "jarWithTestDependency.project1.Project1", "jarWithTestDependency.project2.Project2" ) );
+        if ( SystemUtils.isJavaVersionAtLeast( JavaVersion.JAVA_1_8 ) )
+        {
+            expectedDependencyUsageMap.put( junit, createDependencyUsage(
+                "junit.runner.TestRunListener", "jarWithTestDependency.project2.Project2" ) );
+        }
+
+        assertEquals( expectedDependencyUsageMap, actualDependencyUsageMap );
     }
 
     public void testJarWithXmlTransitiveDependency()
@@ -300,6 +355,17 @@ public void testMultimoduleProject()
         ProjectDependencyAnalysis expectedAnalysis = new ProjectDependencyAnalysis( usedDeclaredArtifacts, null, null );
 
         assertEquals( expectedAnalysis, actualAnalysis );
+        assertEquals( Collections.emptyMap(), actualAnalysis.getUsedUndeclaredArtifactToUsageMap() );
+
+        Map<Artifact, Set<DependencyUsage>> actualDependencyUsageMap =
+            actualAnalysis.getUsedDeclaredArtifactToUsageMap();
+
+        Map<Artifact, Set<DependencyUsage>> expectedDependencyUsageMap =
+            new HashMap<Artifact, Set<DependencyUsage>>();
+        expectedDependencyUsageMap.put( junit, createDependencyUsage(
+            "foo.Main", "bar.Main" ) );
+
+        assertEquals( expectedDependencyUsageMap, actualDependencyUsageMap );
     }
 
     // private methods --------------------------------------------------------
@@ -342,4 +408,8 @@ private Artifact createArtifact( String groupId, String artifactId, String type,
 
         return new DefaultArtifact( groupId, artifactId, versionRange, scope, type, null, handler );
     }
+
+    private Set<DependencyUsage> createDependencyUsage( String dependencyClass, String usedBy ) {
+        return Collections.singleton( new DependencyUsage( dependencyClass, usedBy ) );
+    }
 }
diff --git a/maven-dependency-analyzer/src/test/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysisTest.java b/maven-dependency-analyzer/src/test/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysisTest.java
index 8c1e3e94f..d3f81455d 100644
--- a/maven-dependency-analyzer/src/test/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysisTest.java
+++ b/maven-dependency-analyzer/src/test/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysisTest.java
@@ -19,7 +19,9 @@
  * under the License.
  */
 
+import java.util.HashMap;
 import java.util.HashSet;
+import java.util.Map;
 import java.util.Set;
 
 import org.apache.maven.artifact.Artifact;
@@ -41,14 +43,18 @@ public class ProjectDependencyAnalysisTest
     public void testConstructor()
     {
         Set<Artifact> usedDeclaredArtifacts = new HashSet<Artifact>();
+        Map<Artifact, Set<DependencyUsage>> usedDeclaredArtifactToUsageMap = new HashMap<Artifact, Set<DependencyUsage>>();
         Set<Artifact> usedUndeclaredArtifacts = new HashSet<Artifact>();
+        Map<Artifact, Set<DependencyUsage>> usedUndeclaredArtifactToUsageMap = new HashMap<Artifact, Set<DependencyUsage>>();
         Set<Artifact> unusedDeclaredArtifacts = new HashSet<Artifact>();
 
         ProjectDependencyAnalysis analysis =
             new ProjectDependencyAnalysis( usedDeclaredArtifacts, usedUndeclaredArtifacts, unusedDeclaredArtifacts );
 
         assertEquals( usedDeclaredArtifacts, analysis.getUsedDeclaredArtifacts() );
+        assertEquals( usedDeclaredArtifactToUsageMap, analysis.getUsedDeclaredArtifactToUsageMap() );
         assertEquals( usedUndeclaredArtifacts, analysis.getUsedUndeclaredArtifacts() );
+        assertEquals( usedUndeclaredArtifactToUsageMap, analysis.getUsedUndeclaredArtifactToUsageMap() );
         assertEquals( unusedDeclaredArtifacts, analysis.getUnusedDeclaredArtifacts() );
     }
 }