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"};
    }

     * @param scoreBooster The score booster.
     */
    protected void addScoreBooster(final ScoreBooster scoreBooster) {
        scoreBoosterList.add(scoreBooster);
        scoreBoosterList.sort((b1, b2) -> b2.getPriority() - b1.getPriority());
    }

      <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>
      <implementation>org.apache.maven.artifact.manager.WagonB</implementation>
    </component>
    <component>
      <role>org.apache.maven.wagon.Wagon</role>
      <role-hint>c</role-hint>

func (a BitrotAlgorithm) New() hash.Hash {
	switch a {
	case SHA256:
		return sha256.New()
	case BLAKE2b512:
		b2, _ := blake2b.New512(nil) // New512 never returns an error if the key is nil
		return b2
	case HighwayHash256:
		hh, _ := highwayhash.New(magicHighwayHash256Key) // New will never return error since key is 256 bit
		return hh
	case HighwayHash256S:

    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);
    collector = toImmutableMultiset(e -> e, e -> 1);

      assertThat(it.edit()).isNull()
    }
    assertThat(cache.size()).isEqualTo(0L)
  }

  @Test
  fun iterator() {
    set("a", "a1", "a2")
    set("b", "b1", "b2")
    set("c", "c1", "c2")
    val iterator = cache.snapshots()
    assertThat(iterator.hasNext()).isTrue()
    iterator.next().use {
      assertThat(it.key()).isEqualTo("a")
      it.assertValue(0, "a1")

   * order; equivalent to {@code Chars.fromByteArray(new byte[] {b1, b2})}.
   *
   * @since 7.0
   */
  @GwtIncompatible // doesn't work
  public static char fromBytes(byte b1, byte b2) {
    return (char) ((b1 << 8) | (b2 & 0xFF));
  }

  /**
   * Returns an array containing the same values as {@code array}, but guaranteed to be of a

   * order; equivalent to {@code Shorts.fromByteArray(new byte[] {b1, b2})}.
   *
   * @since 7.0
   */
  @GwtIncompatible // doesn't work
  public static short fromBytes(byte b1, byte b2) {
    return (short) ((b1 << 8) | (b2 & 0xFF));
  }

  private static final class ShortConverter extends Converter<String, Short>
      implements Serializable {

   * order; equivalent to {@code Shorts.fromByteArray(new byte[] {b1, b2})}.
   *
   * @since 7.0
   */
  @GwtIncompatible // doesn't work
  public static short fromBytes(byte b1, byte b2) {
    return (short) ((b1 << 8) | (b2 & 0xFF));
  }

  private static final class ShortConverter extends Converter<String, Short>
      implements Serializable {

        ArtifactSpec d1 = c.addDependency("d", "1.0");
        ArtifactSpec b2 = c.addDependency("b", "2.0");
        ArtifactSpec e = b2.addDependency("e", "1.0");
        ArtifactSpec g = d1.addDependency("g", "1.0");

        ArtifactResolutionResult res = collect(createSet(new Object[] {a.artifact}));
        Object[] artifacts = new Object[] {a.artifact, c.artifact, d1.artifact, b2.artifact, e.artifact, g.artifact};