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;

    assertSame(s1, s2);

    Long n1 = 42L;
    Long n2 = MoreObjects.firstNonNull(null, n1);
    assertSame(n1, n2);

    Boolean b1 = true;
    Boolean b2 = MoreObjects.firstNonNull(b1, null);
    assertSame(b1, b2);
  }

  public void testFirstNonNull_throwsNullPointerException() {
    try {
      MoreObjects.firstNonNull(null, null);
      fail();

    assertSame(s1, s2);

    Long n1 = 42L;
    Long n2 = MoreObjects.firstNonNull(null, n1);
    assertSame(n1, n2);

    Boolean b1 = true;
    Boolean b2 = MoreObjects.firstNonNull(b1, null);
    assertSame(b1, b2);
  }

  public void testFirstNonNull_throwsNullPointerException() {
    try {
      MoreObjects.firstNonNull(null, null);
      fail();

     * <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>

        });
        return resultBuf.toString();
    }

    protected void addScoreBooster(final ScoreBooster scoreBooster) {
        scoreBoosterList.add(scoreBooster);
        scoreBoosterList.sort((b1, b2) -> b2.getPriority() - b1.getPriority());
    }

        final byte b0 = DECODE_TABLE[inData.charAt(inIndex)];
        final byte b1 = DECODE_TABLE[inData.charAt(inIndex + 1)];
        final byte b2 = DECODE_TABLE[inData.charAt(inIndex + 2)];
        final byte b3 = DECODE_TABLE[inData.charAt(inIndex + 3)];
        outData[outIndex] = (byte) (b0 << 2 & 0xfc | b1 >> 4 & 0x3);
        outData[outIndex + 1] = (byte) (b1 << 4 & 0xf0 | b2 >> 2 & 0xf);

        List<SynonymItem> itemList = new ArrayList<>();
        itemList.add(new SynonymItem(1, new String[] { "a1" }, new String[] { "A1" }));
        itemList.add(new SynonymItem(2, new String[] { "b1", "b2" }, new String[] { "B1" }));
        itemList.add(new SynonymItem(3, new String[] { "c1" }, new String[] { "C1", "C2" }));
        itemList.add(new SynonymItem(4, new String[] { "x1", "X1" }, new String[] { "x1", "X1" }));

    }

    public void test_toLineString() {
        assertEquals("a1,a2,a3=>b1,b2,b3",
                new SynonymItem(1, new String[] { "a1", "a2", "a3" }, new String[] { "b1", "b2", "b3" }).toLineString());
        assertEquals("a=>b", new SynonymItem(1, new String[] { "a" }, new String[] { "b" }).toLineString());

     * <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>