Store data about aspect configurations on Dependencies.

Dependencies are the data structure which needs to propagate the configuration for each
aspect as created by trimConfigurations down to the point where it's actually used. We
need this to store different configurations for different aspects in a world where aspects
have their own configurations, which may have more fragments than the target they're
attached to.

That world is on its way.

Also in this CL:
* Refactor Dependency to be an abstract parent class with separate implementations for
  Attribute.Transitions and BuildConfigurations, as well as null configurations, to avoid
  having to check nullness in various places. Users of the API will not see this, but get
  factory methods instead of constructors. As a consequence of this, refactor Dependency
  to be its own top-level class instead of a nested class in DependencyResolver.

--
MOS_MIGRATED_REVID=113109615

3 files changed, 414 insertions, 105 deletions

diff --git a/src/test/java/com/google/devtools/build/lib/analysis/BuildViewTest.java b/src/test/java/com/google/devtools/build/lib/analysis/BuildViewTest.java
index 64dd49d26e..d09f6fe0b0 100644
--- a/src/test/java/com/google/devtools/build/lib/analysis/BuildViewTest.java
+++ b/src/test/java/com/google/devtools/build/lib/analysis/BuildViewTest.java
@@ -37,8 +37,6 @@ import com.google.devtools.build.lib.actions.Actions;
 import com.google.devtools.build.lib.actions.Artifact;
 import com.google.devtools.build.lib.actions.FailAction;
 import com.google.devtools.build.lib.analysis.BuildView.AnalysisResult;
-import com.google.devtools.build.lib.analysis.DependencyResolver.Dependency;
-import com.google.devtools.build.lib.analysis.config.BuildConfiguration;
 import com.google.devtools.build.lib.analysis.config.InvalidConfigurationException;
 import com.google.devtools.build.lib.analysis.util.BuildViewTestBase;
 import com.google.devtools.build.lib.cmdline.Label;
@@ -330,26 +328,23 @@ public final class BuildViewTest extends BuildViewTestBase {
     Dependency fileDependency;
     if (top.getConfiguration().useDynamicConfigurations()) {
       innerDependency =
-          new Dependency(
+          Dependency.withTransitionAndAspects(
               Label.parseAbsolute("//package:inner"),
               Attribute.ConfigurationTransition.NONE,
               ImmutableSet.<Aspect>of());
       fileDependency =
-          new Dependency(
+          Dependency.withTransitionAndAspects(
               Label.parseAbsolute("//package:file"),
               Attribute.ConfigurationTransition.NONE,
               ImmutableSet.<Aspect>of());
     } else {
       innerDependency =
-          new Dependency(
+          Dependency.withConfiguration(
               Label.parseAbsolute("//package:inner"),
-              getTargetConfiguration(),
-              ImmutableSet.<Aspect>of());
+              getTargetConfiguration());
       fileDependency =
-          new Dependency(
-              Label.parseAbsolute("//package:file"),
-              (BuildConfiguration) null,
-              ImmutableSet.<Aspect>of());
+          Dependency.withNullConfiguration(
+              Label.parseAbsolute("//package:file"));
     }
 
     assertThat(targets).containsExactly(innerDependency, fileDependency);
diff --git a/src/test/java/com/google/devtools/build/lib/analysis/DependencyResolverTest.java b/src/test/java/com/google/devtools/build/lib/analysis/DependencyResolverTest.java
index b231b7c576..19ad653ea8 100644
--- a/src/test/java/com/google/devtools/build/lib/analysis/DependencyResolverTest.java
+++ b/src/test/java/com/google/devtools/build/lib/analysis/DependencyResolverTest.java
@@ -18,10 +18,6 @@ import static org.junit.Assert.assertNotNull;
 
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ListMultimap;
-import com.google.common.testing.EqualsTester;
-import com.google.common.testing.NullPointerTester;
-import com.google.devtools.build.lib.analysis.DependencyResolver.Dependency;
-import com.google.devtools.build.lib.analysis.config.BuildConfiguration;
 import com.google.devtools.build.lib.analysis.config.ConfigMatchingProvider;
 import com.google.devtools.build.lib.analysis.util.AnalysisTestCase;
 import com.google.devtools.build.lib.analysis.util.TestAspects;
@@ -167,94 +163,4 @@ public class DependencyResolverTest extends AnalysisTestCase {
         dependentNodeMap("//a:a", TestAspects.ExtraAttributeAspect.class);
     assertDep(map, "$dep", "//extra:extra");
   }
-
-  @Test
-  public void constructorsForDependencyPassNullableTester() throws Exception {
-    update();
-
-    new NullPointerTester()
-        .setDefault(Label.class, Label.parseAbsolute("//a"))
-        .setDefault(BuildConfiguration.class, getTargetConfiguration())
-        .setDefault(ImmutableSet.class, ImmutableSet.of())
-        .testAllPublicConstructors(Dependency.class);
-  }
-
-  @Test
-  public void equalsOnDependencyPassesEqualsTester() throws Exception {
-    update();
-
-    Label a = Label.parseAbsolute("//a");
-    Label aExplicit = Label.parseAbsolute("//a:a");
-    Label b = Label.parseAbsolute("//b");
-
-    BuildConfiguration host = getHostConfiguration();
-    BuildConfiguration target = getTargetConfiguration();
-
-    ImmutableSet<Aspect> twoAspects =
-        ImmutableSet.of(
-            new Aspect(new NativeAspectClass(TestAspects.SimpleAspect.class)),
-            new Aspect(new NativeAspectClass(TestAspects.AttributeAspect.class)));
-    ImmutableSet<Aspect> inverseAspects =
-        ImmutableSet.of(
-            new Aspect(new NativeAspectClass(TestAspects.AttributeAspect.class)),
-            new Aspect(new NativeAspectClass(TestAspects.SimpleAspect.class)));
-    ImmutableSet<Aspect> differentAspects =
-        ImmutableSet.of(
-            new Aspect(new NativeAspectClass(TestAspects.AttributeAspect.class)),
-            new Aspect(new NativeAspectClass(TestAspects.ErrorAspect.class)));
-
-    new EqualsTester()
-        .addEqualityGroup(
-            // base set: //a, host configuration, normal aspect set
-            new Dependency(a, host, twoAspects),
-            new Dependency(aExplicit, host, twoAspects),
-            new Dependency(a, host, inverseAspects),
-            new Dependency(aExplicit, host, inverseAspects))
-        .addEqualityGroup(
-            // base set but with label //b
-            new Dependency(b, host, twoAspects),
-            new Dependency(b, host, inverseAspects))
-        .addEqualityGroup(
-            // base set but with target configuration
-            new Dependency(a, target, twoAspects),
-            new Dependency(aExplicit, target, twoAspects),
-            new Dependency(a, target, inverseAspects),
-            new Dependency(aExplicit, target, inverseAspects))
-        .addEqualityGroup(
-            // base set but with null configuration
-            new Dependency(a, (BuildConfiguration) null, twoAspects),
-            new Dependency(aExplicit, (BuildConfiguration) null, twoAspects),
-            new Dependency(a, (BuildConfiguration) null, inverseAspects),
-            new Dependency(aExplicit, (BuildConfiguration) null, inverseAspects))
-        .addEqualityGroup(
-            // base set but with different aspects
-            new Dependency(a, host, differentAspects),
-            new Dependency(aExplicit, host, differentAspects))
-        .addEqualityGroup(
-            // base set but with label //b and target configuration
-            new Dependency(b, target, twoAspects),
-            new Dependency(b, target, inverseAspects))
-        .addEqualityGroup(
-            // base set but with label //b and null configuration
-            new Dependency(b, (BuildConfiguration) null, twoAspects),
-            new Dependency(b, (BuildConfiguration) null, inverseAspects))
-        .addEqualityGroup(
-            // base set but with label //b and different aspects
-            new Dependency(b, host, differentAspects))
-        .addEqualityGroup(
-            // base set but with target configuration and different aspects
-            new Dependency(a, target, differentAspects),
-            new Dependency(aExplicit, target, differentAspects))
-        .addEqualityGroup(
-            // base set but with null configuration and different aspects
-            new Dependency(a, (BuildConfiguration) null, differentAspects),
-            new Dependency(aExplicit, (BuildConfiguration) null, differentAspects))
-        .addEqualityGroup(
-            // inverse of base set: //b, target configuration, different aspects
-            new Dependency(b, target, differentAspects))
-        .addEqualityGroup(
-            // inverse of base set: //b, null configuration, different aspects
-            new Dependency(b, (BuildConfiguration) null, differentAspects))
-        .testEquals();
-  }
 }
diff --git a/src/test/java/com/google/devtools/build/lib/analysis/DependencyTest.java b/src/test/java/com/google/devtools/build/lib/analysis/DependencyTest.java
new file mode 100644
index 0000000000..4ea7309b6e
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/analysis/DependencyTest.java
@@ -0,0 +1,408 @@
+// Copyright 2015 The Bazel Authors. All rights reserved.
+//
+// Licensed 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.
+package com.google.devtools.build.lib.analysis;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.testing.EqualsTester;
+import com.google.common.testing.NullPointerTester;
+import com.google.devtools.build.lib.analysis.config.BuildConfiguration;
+import com.google.devtools.build.lib.analysis.util.AnalysisTestCase;
+import com.google.devtools.build.lib.analysis.util.TestAspects;
+import com.google.devtools.build.lib.cmdline.Label;
+import com.google.devtools.build.lib.packages.Aspect;
+import com.google.devtools.build.lib.packages.Attribute.ConfigurationTransition;
+import com.google.devtools.build.lib.packages.NativeAspectClass;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+/**
+ * Tests for {@link Dependency}.
+ *
+ * <p>Although this is just a data class, we need a way to create a configuration.
+ */
+@RunWith(JUnit4.class)
+public class DependencyTest extends AnalysisTestCase {
+  @Test
+  public void withNullConfiguration_BasicAccessors() throws Exception {
+    Dependency nullDep = Dependency.withNullConfiguration(Label.parseAbsolute("//a"));
+
+    assertThat(nullDep.getLabel()).isEqualTo(Label.parseAbsolute("//a"));
+    assertThat(nullDep.hasStaticConfiguration()).isTrue();
+    assertThat(nullDep.getConfiguration()).isNull();
+    assertThat(nullDep.getAspects()).isEmpty();
+    assertThat(nullDep.getAspectConfigurations()).isEmpty();
+
+    try {
+      nullDep.getTransition();
+      fail("withNullConfiguration-created Dependencies should throw ISE on getTransition()");
+    } catch (IllegalStateException ex) {
+      // good. expected.
+    }
+  }
+
+  @Test
+  public void withConfiguration_BasicAccessors() throws Exception {
+    update();
+    Dependency targetDep =
+        Dependency.withConfiguration(Label.parseAbsolute("//a"), getTargetConfiguration());
+
+    assertThat(targetDep.getLabel()).isEqualTo(Label.parseAbsolute("//a"));
+    assertThat(targetDep.hasStaticConfiguration()).isTrue();
+    assertThat(targetDep.getConfiguration()).isEqualTo(getTargetConfiguration());
+    assertThat(targetDep.getAspects()).isEmpty();
+    assertThat(targetDep.getAspectConfigurations()).isEmpty();
+
+    try {
+      targetDep.getTransition();
+      fail("withConfiguration-created Dependencies should throw ISE on getTransition()");
+    } catch (IllegalStateException ex) {
+      // good. expected.
+    }
+  }
+
+  @Test
+  public void withConfigurationAndAspects_BasicAccessors() throws Exception {
+    update();
+    Aspect simpleAspect = new Aspect(
+        new NativeAspectClass<TestAspects.SimpleAspect>(TestAspects.SimpleAspect.class));
+    Aspect attributeAspect = new Aspect(
+        new NativeAspectClass<TestAspects.AttributeAspect>(TestAspects.AttributeAspect.class));
+    ImmutableSet<Aspect> twoAspects = ImmutableSet.of(simpleAspect, attributeAspect);
+    Dependency targetDep =
+        Dependency.withConfigurationAndAspects(
+            Label.parseAbsolute("//a"), getTargetConfiguration(), twoAspects);
+
+    assertThat(targetDep.getLabel()).isEqualTo(Label.parseAbsolute("//a"));
+    assertThat(targetDep.hasStaticConfiguration()).isTrue();
+    assertThat(targetDep.getConfiguration()).isEqualTo(getTargetConfiguration());
+    assertThat(targetDep.getAspects()).containsExactlyElementsIn(twoAspects);
+    assertThat(targetDep.getAspectConfigurations())
+        .containsExactlyEntriesIn(
+            ImmutableMap.of(
+                simpleAspect, getTargetConfiguration(),
+                attributeAspect, getTargetConfiguration()));
+
+    try {
+      targetDep.getTransition();
+      fail("withConfigurationAndAspects-created Dependencies should throw ISE on getTransition()");
+    } catch (IllegalStateException ex) {
+      // good. that's what I WANTED to happen.
+    }
+  }
+
+  @Test
+  public void withConfigurationAndAspects_RejectsNullAspectsWithNPE() throws Exception {
+    update();
+    Set<Aspect> nullSet = new LinkedHashSet<>();
+    nullSet.add(null);
+
+    try {
+      Dependency.withConfigurationAndAspects(
+          Label.parseAbsolute("//a"), getTargetConfiguration(), nullSet);
+      fail("should not be allowed to create a dependency with a null aspect");
+    } catch (NullPointerException expected) {
+      // good. just as planned.
+    }
+  }
+
+  @Test
+  public void withConfigurationAndAspects_RejectsNullConfigWithNPE() throws Exception {
+    // Although the NullPointerTester should check this, this test invokes a different code path,
+    // because it includes aspects (which the NPT test will not).
+    Aspect simpleAspect = new Aspect(
+        new NativeAspectClass<TestAspects.SimpleAspect>(TestAspects.SimpleAspect.class));
+    Aspect attributeAspect = new Aspect(
+        new NativeAspectClass<TestAspects.AttributeAspect>(TestAspects.AttributeAspect.class));
+    ImmutableSet<Aspect> twoAspects = ImmutableSet.of(simpleAspect, attributeAspect);
+
+    try {
+      Dependency.withConfigurationAndAspects(Label.parseAbsolute("//a"), null, twoAspects);
+      fail("should not be allowed to create a dependency with a null configuration");
+    } catch (NullPointerException expected) {
+      // good. you fell rrrrright into my trap.
+    }
+  }
+
+  @Test
+  public void withConfigurationAndAspects_AllowsEmptyAspectSet() throws Exception {
+    update();
+    Dependency dep =
+        Dependency.withConfigurationAndAspects(
+            Label.parseAbsolute("//a"), getTargetConfiguration(), ImmutableSet.<Aspect>of());
+    // Here we're also checking that this doesn't throw an exception. No boom? OK. Good.
+    assertThat(dep.getAspects()).isEmpty();
+    assertThat(dep.getAspectConfigurations()).isEmpty();
+  }
+
+  @Test
+  public void withConfiguredAspects_BasicAccessors() throws Exception {
+    update();
+    Aspect simpleAspect = new Aspect(
+        new NativeAspectClass<TestAspects.SimpleAspect>(TestAspects.SimpleAspect.class));
+    Aspect attributeAspect = new Aspect(
+        new NativeAspectClass<TestAspects.AttributeAspect>(TestAspects.AttributeAspect.class));
+    ImmutableMap<Aspect, BuildConfiguration> twoAspectMap = ImmutableMap.of(
+        simpleAspect, getTargetConfiguration(), attributeAspect, getHostConfiguration());
+    Dependency targetDep =
+        Dependency.withConfiguredAspects(
+            Label.parseAbsolute("//a"), getTargetConfiguration(), twoAspectMap);
+
+    assertThat(targetDep.getLabel()).isEqualTo(Label.parseAbsolute("//a"));
+    assertThat(targetDep.hasStaticConfiguration()).isTrue();
+    assertThat(targetDep.getConfiguration()).isEqualTo(getTargetConfiguration());
+    assertThat(targetDep.getAspects())
+        .containsExactlyElementsIn(ImmutableSet.of(simpleAspect, attributeAspect));
+    assertThat(targetDep.getAspectConfigurations()).containsExactlyEntriesIn(twoAspectMap);
+
+    try {
+      targetDep.getTransition();
+      fail("withConfiguredAspects-created Dependencies should throw ISE on getTransition()");
+    } catch (IllegalStateException ex) {
+      // good. all according to keikaku. (TL note: keikaku means plan)
+    }
+  }
+
+
+  @Test
+  public void withConfiguredAspects_AllowsEmptyAspectMap() throws Exception {
+    update();
+    Dependency dep =
+        Dependency.withConfiguredAspects(
+            Label.parseAbsolute("//a"), getTargetConfiguration(),
+            ImmutableMap.<Aspect, BuildConfiguration>of());
+    // Here we're also checking that this doesn't throw an exception. No boom? OK. Good.
+    assertThat(dep.getAspects()).isEmpty();
+    assertThat(dep.getAspectConfigurations()).isEmpty();
+  }
+
+  @Test
+  public void withTransitionAndAspects_BasicAccessors() throws Exception {
+    Aspect simpleAspect = new Aspect(
+        new NativeAspectClass<TestAspects.SimpleAspect>(TestAspects.SimpleAspect.class));
+    Aspect attributeAspect = new Aspect(
+        new NativeAspectClass<TestAspects.AttributeAspect>(TestAspects.AttributeAspect.class));
+    ImmutableSet<Aspect> twoAspects = ImmutableSet.of(simpleAspect, attributeAspect);
+    Dependency hostDep =
+        Dependency.withTransitionAndAspects(
+            Label.parseAbsolute("//a"), ConfigurationTransition.HOST, twoAspects);
+
+    assertThat(hostDep.getLabel()).isEqualTo(Label.parseAbsolute("//a"));
+    assertThat(hostDep.hasStaticConfiguration()).isFalse();
+    assertThat(hostDep.getAspects()).containsExactlyElementsIn(twoAspects);
+    assertThat(hostDep.getTransition()).isEqualTo(ConfigurationTransition.HOST);
+
+    try {
+      hostDep.getConfiguration();
+      fail("withTransitionAndAspects-created Dependencies should throw ISE on getConfiguration()");
+    } catch (IllegalStateException ex) {
+      // good. I knew you would do that.
+    }
+
+    try {
+      hostDep.getAspectConfigurations();
+      fail("withTransitionAndAspects-created Dependencies should throw ISE on "
+          + "getAspectConfigurations()");
+    } catch (IllegalStateException ex) {
+      // good. you're so predictable.
+    }
+  }
+
+  @Test
+  public void withTransitionAndAspects_AllowsEmptyAspectSet() throws Exception {
+    update();
+    Dependency dep =
+        Dependency.withTransitionAndAspects(
+            Label.parseAbsolute("//a"), ConfigurationTransition.HOST, ImmutableSet.<Aspect>of());
+    // Here we're also checking that this doesn't throw an exception. No boom? OK. Good.
+    assertThat(dep.getAspects()).isEmpty();
+  }
+
+  @Test
+  public void factoriesPassNullableTester() throws Exception {
+    update();
+
+    new NullPointerTester()
+        .setDefault(Label.class, Label.parseAbsolute("//a"))
+        .setDefault(BuildConfiguration.class, getTargetConfiguration())
+        .testAllPublicStaticMethods(Dependency.class);
+  }
+
+  @Test
+  public void equalsPassesEqualsTester() throws Exception {
+    update();
+
+    Label a = Label.parseAbsolute("//a");
+    Label aExplicit = Label.parseAbsolute("//a:a");
+    Label b = Label.parseAbsolute("//b");
+
+    BuildConfiguration host = getHostConfiguration();
+    BuildConfiguration target = getTargetConfiguration();
+
+    Aspect simpleAspect = new Aspect(
+        new NativeAspectClass<TestAspects.SimpleAspect>(TestAspects.SimpleAspect.class));
+    Aspect attributeAspect = new Aspect(
+        new NativeAspectClass<TestAspects.AttributeAspect>(TestAspects.AttributeAspect.class));
+    Aspect errorAspect = new Aspect(
+        new NativeAspectClass<TestAspects.ErrorAspect>(TestAspects.ErrorAspect.class));
+
+    ImmutableSet<Aspect> twoAspects = ImmutableSet.of(simpleAspect, attributeAspect);
+    ImmutableSet<Aspect> inverseAspects = ImmutableSet.of(attributeAspect, simpleAspect);
+    ImmutableSet<Aspect> differentAspects = ImmutableSet.of(attributeAspect, errorAspect);
+    ImmutableSet<Aspect> noAspects = ImmutableSet.<Aspect>of();
+
+    ImmutableMap<Aspect, BuildConfiguration> twoAspectsHostMap =
+        ImmutableMap.of(simpleAspect, host, attributeAspect, host);
+    ImmutableMap<Aspect, BuildConfiguration> twoAspectsTargetMap =
+        ImmutableMap.of(simpleAspect, target, attributeAspect, target);
+    ImmutableMap<Aspect, BuildConfiguration> differentAspectsHostMap =
+        ImmutableMap.of(attributeAspect, host, errorAspect, host);
+    ImmutableMap<Aspect, BuildConfiguration> differentAspectsTargetMap =
+        ImmutableMap.of(attributeAspect, target, errorAspect, target);
+    ImmutableMap<Aspect, BuildConfiguration> noAspectsMap =
+        ImmutableMap.<Aspect, BuildConfiguration>of();
+
+    new EqualsTester()
+        .addEqualityGroup(
+            // base set: //a, host configuration, normal aspect set
+            Dependency.withConfigurationAndAspects(a, host, twoAspects),
+            Dependency.withConfigurationAndAspects(aExplicit, host, twoAspects),
+            Dependency.withConfigurationAndAspects(a, host, inverseAspects),
+            Dependency.withConfigurationAndAspects(aExplicit, host, inverseAspects),
+            Dependency.withConfiguredAspects(a, host, twoAspectsHostMap),
+            Dependency.withConfiguredAspects(aExplicit, host, twoAspectsHostMap))
+        .addEqualityGroup(
+            // base set but with label //b
+            Dependency.withConfigurationAndAspects(b, host, twoAspects),
+            Dependency.withConfigurationAndAspects(b, host, inverseAspects),
+            Dependency.withConfiguredAspects(b, host, twoAspectsHostMap))
+        .addEqualityGroup(
+            // base set but with target configuration
+            Dependency.withConfigurationAndAspects(a, target, twoAspects),
+            Dependency.withConfigurationAndAspects(aExplicit, target, twoAspects),
+            Dependency.withConfigurationAndAspects(a, target, inverseAspects),
+            Dependency.withConfigurationAndAspects(aExplicit, target, inverseAspects),
+            Dependency.withConfiguredAspects(a, target, twoAspectsTargetMap),
+            Dependency.withConfiguredAspects(aExplicit, target, twoAspectsTargetMap))
+        .addEqualityGroup(
+            // base set but with null configuration
+            Dependency.withNullConfiguration(a),
+            Dependency.withNullConfiguration(aExplicit))
+        .addEqualityGroup(
+            // base set but with different aspects
+            Dependency.withConfigurationAndAspects(a, host, differentAspects),
+            Dependency.withConfigurationAndAspects(aExplicit, host, differentAspects),
+            Dependency.withConfiguredAspects(a, host, differentAspectsHostMap),
+            Dependency.withConfiguredAspects(aExplicit, host, differentAspectsHostMap))
+        .addEqualityGroup(
+            // base set but with label //b and target configuration
+            Dependency.withConfigurationAndAspects(b, target, twoAspects),
+            Dependency.withConfigurationAndAspects(b, target, inverseAspects),
+            Dependency.withConfiguredAspects(b, target, twoAspectsTargetMap))
+        .addEqualityGroup(
+            // base set but with label //b and null configuration
+            Dependency.withNullConfiguration(b))
+        .addEqualityGroup(
+            // base set but with label //b and different aspects
+            Dependency.withConfigurationAndAspects(b, host, differentAspects),
+            Dependency.withConfiguredAspects(b, host, differentAspectsHostMap))
+        .addEqualityGroup(
+            // base set but with target configuration and different aspects
+            Dependency.withConfigurationAndAspects(a, target, differentAspects),
+            Dependency.withConfigurationAndAspects(aExplicit, target, differentAspects),
+            Dependency.withConfiguredAspects(a, target, differentAspectsTargetMap),
+            Dependency.withConfiguredAspects(aExplicit, target, differentAspectsTargetMap))
+        .addEqualityGroup(
+            // inverse of base set: //b, target configuration, different aspects
+            Dependency.withConfigurationAndAspects(b, target, differentAspects),
+            Dependency.withConfiguredAspects(b, target, differentAspectsTargetMap))
+        .addEqualityGroup(
+            // base set but with no aspects
+            Dependency.withConfiguration(a, host),
+            Dependency.withConfiguration(aExplicit, host),
+            Dependency.withConfigurationAndAspects(a, host, noAspects),
+            Dependency.withConfigurationAndAspects(aExplicit, host, noAspects),
+            Dependency.withConfiguredAspects(a, host, noAspectsMap),
+            Dependency.withConfiguredAspects(aExplicit, host, noAspectsMap))
+        .addEqualityGroup(
+            // base set but with label //b and no aspects
+            Dependency.withConfiguration(b, host),
+            Dependency.withConfigurationAndAspects(b, host, noAspects),
+            Dependency.withConfiguredAspects(b, host, noAspectsMap))
+        .addEqualityGroup(
+            // base set but with target configuration and no aspects
+            Dependency.withConfiguration(a, target),
+            Dependency.withConfiguration(aExplicit, target),
+            Dependency.withConfigurationAndAspects(a, target, noAspects),
+            Dependency.withConfigurationAndAspects(aExplicit, target, noAspects),
+            Dependency.withConfiguredAspects(a, target, noAspectsMap),
+            Dependency.withConfiguredAspects(aExplicit, target, noAspectsMap))
+        .addEqualityGroup(
+            // inverse of base set: //b, target configuration, no aspects
+            Dependency.withConfiguration(b, target),
+            Dependency.withConfigurationAndAspects(b, target, noAspects),
+            Dependency.withConfiguredAspects(b, target, noAspectsMap))
+        .addEqualityGroup(
+            // base set but with transition HOST
+            Dependency.withTransitionAndAspects(a, ConfigurationTransition.HOST, twoAspects),
+            Dependency.withTransitionAndAspects(
+                aExplicit, ConfigurationTransition.HOST, twoAspects),
+            Dependency.withTransitionAndAspects(a, ConfigurationTransition.HOST, inverseAspects),
+            Dependency.withTransitionAndAspects(
+                aExplicit, ConfigurationTransition.HOST, inverseAspects))
+        .addEqualityGroup(
+            // base set but with transition HOST and different aspects
+            Dependency.withTransitionAndAspects(a, ConfigurationTransition.HOST, differentAspects),
+            Dependency.withTransitionAndAspects(
+                aExplicit, ConfigurationTransition.HOST, differentAspects))
+        .addEqualityGroup(
+            // base set but with transition HOST and label //b
+            Dependency.withTransitionAndAspects(b, ConfigurationTransition.HOST, twoAspects),
+            Dependency.withTransitionAndAspects(b, ConfigurationTransition.HOST, inverseAspects))
+        .addEqualityGroup(
+            // inverse of base set: transition HOST, label //b, different aspects
+            Dependency.withTransitionAndAspects(b, ConfigurationTransition.HOST, differentAspects),
+            Dependency.withTransitionAndAspects(b, ConfigurationTransition.HOST, differentAspects))
+        .addEqualityGroup(
+            // base set but with transition NONE
+            Dependency.withTransitionAndAspects(a, ConfigurationTransition.NONE, twoAspects),
+            Dependency.withTransitionAndAspects(
+                aExplicit, ConfigurationTransition.NONE, twoAspects),
+            Dependency.withTransitionAndAspects(a, ConfigurationTransition.NONE, inverseAspects),
+            Dependency.withTransitionAndAspects(
+                aExplicit, ConfigurationTransition.NONE, inverseAspects))
+        .addEqualityGroup(
+            // base set but with transition NONE and different aspects
+            Dependency.withTransitionAndAspects(a, ConfigurationTransition.NONE, differentAspects),
+            Dependency.withTransitionAndAspects(
+                aExplicit, ConfigurationTransition.NONE, differentAspects))
+        .addEqualityGroup(
+            // base set but with transition NONE and label //b
+            Dependency.withTransitionAndAspects(b, ConfigurationTransition.NONE, twoAspects),
+            Dependency.withTransitionAndAspects(b, ConfigurationTransition.NONE, inverseAspects))
+        .addEqualityGroup(
+            // inverse of base set: transition NONE, label //b, different aspects
+            Dependency.withTransitionAndAspects(b, ConfigurationTransition.NONE, differentAspects),
+            Dependency.withTransitionAndAspects(b, ConfigurationTransition.NONE, differentAspects))
+        .testEquals();
+  }
+}