import javax.inject.Named;
import javax.inject.Singleton;

/**
 * Wagon for testing, for protocols <code>b1</code> and <code>b2</code>
 *
 */
@Named("b")
@Singleton
public class WagonB extends WagonMock {
    public String[] getSupportedProtocols() {
        return new String[] {"b1", "b2"};
    }

     * <pre>
     * a:1.0
     * b:1.0 -&gt; a:2.0
     * </pre>
     */
    @Test
    void testDepth() {
        ResolutionNode a1n = createResolutionNode(a1);
        ResolutionNode b1n = createResolutionNode(b1);
        ResolutionNode a2n = createResolutionNode(a2, b1n);

        assertResolveConflict(a2n, a1n, a2n);
    }

    /**
     * Tests that <code>a:2.0</code> wins in the scenario:
     * <pre>

     * <pre>
     * a:1.0
     * b:1.0 -&gt; a:2.0
     * </pre>
     */
    @Test
    void testDepth() {
        ResolutionNode a1n = createResolutionNode(a1);
        ResolutionNode b1n = createResolutionNode(b1);
        ResolutionNode a2n = createResolutionNode(a2, b1n);

        assertResolveConflict(a1n, a1n, a2n);
    }

    /**
     * Tests that <code>a:1.0</code> wins in the scenario:
     * <pre>

     * <pre>
     * a:1.0
     * b:1.0 -&gt; a:2.0
     * </pre>
     */
    @Test
    void testDepth() {
        ResolutionNode a1n = createResolutionNode(a1);
        ResolutionNode b1n = createResolutionNode(b1);
        ResolutionNode a2n = createResolutionNode(a2, b1n);

        assertResolveConflict(a1n, a1n, a2n);
    }

    /**
     * Tests that <code>a:1.0</code> wins in the scenario:
     * <pre>

     * <pre>
     * a:1.0
     * b:1.0 -&gt; a:2.0
     * </pre>
     */
    @Test
    void testDepth() {
        ResolutionNode a1n = createResolutionNode(a1);
        ResolutionNode b1n = createResolutionNode(b1);
        ResolutionNode a2n = createResolutionNode(a2, b1n);

        assertResolveConflict(a2n, a1n, a2n);
    }

    /**
     * Tests that <code>a:2.0</code> wins in the scenario:
     * <pre>

    private static final String GROUP_ID = "test";

    // fields -----------------------------------------------------------------

    protected Artifact a1;

    protected Artifact a2;

    protected Artifact b1;

    private final String roleHint;

    @Inject
    private ArtifactFactory artifactFactory;

    private ConflictResolver conflictResolver;

    @Inject
    protected PlexusContainer container;

	}

	var w1 writeCountingDiscard
	b1 := NewWriterSize(&w1, 1234)
	b1.WriteString(strings.Repeat("x", 1200))
	b1.Flush()
	if w1 != 1 {
		t.Fatalf("flush 1200 'x's: got %d writes, want 1", w1)
	}
	b1.WriteString(strings.Repeat("x", 89))
	if w1 != 1 {
		t.Fatalf("write 1200 + 89 'x's: got %d writes, want 1", w1)
	}
	io.Copy(b1, onlyReader{strings.NewReader(strings.Repeat("x", 700))})

    TypeWithDuplicates b1 = new TypeWithDuplicates(2, 1);
    TypeWithDuplicates b2 = new TypeWithDuplicates(2, 2);
    TypeWithDuplicates c = new TypeWithDuplicates(3, 1);
    CollectorTester.of(collector, equivalence)
        .expectCollects(
            ImmutableMultiset.<TypeWithDuplicates>builder().add(a).addCopies(b1, 2).add(c).build(),
            a,
            b1,
            c,
            b2);

      <role-hint>a</role-hint>
      <implementation>org.apache.maven.artifact.manager.WagonA</implementation>
    </component>
    <component>
      <role>org.apache.maven.wagon.Wagon</role>
      <role-hint>b1</role-hint>
      <implementation>org.apache.maven.artifact.manager.WagonB</implementation>
    </component>
    <component>
      <role>org.apache.maven.wagon.Wagon</role>
      <role-hint>b2</role-hint>

        assertOrder(X_LT_Y, "1.0-a1", "1.0");
        assertOrder(X_LT_Y, "1.0.a1", "1.0");
        assertOrder(X_LT_Y, "1.0b1", "1.0");
        assertOrder(X_LT_Y, "1.0-b1", "1.0");
        assertOrder(X_LT_Y, "1.0.b1", "1.0");
        assertOrder(X_LT_Y, "1.0m1", "1.0");
        assertOrder(X_LT_Y, "1.0-m1", "1.0");
        assertOrder(X_LT_Y, "1.0.m1", "1.0");

        assertOrder(X_GT_Y, "1.0a.1", "1.0");