testSort(new int[] {}, 0, 0, new int[] {});
    testSort(new int[] {2}, 0, 1, new int[] {2});
    testSort(new int[] {2, 1, 0}, 0, 2, new int[] {1, 2, 0});
    testSort(new int[] {2, GREATEST, 1, LEAST}, 1, 4, new int[] {2, LEAST, 1, GREATEST});
  }

  public void testSortDescending() {
    testSortDescending(new int[] {}, new int[] {});
    testSortDescending(new int[] {1}, new int[] {1});

    testSortDescending(new byte[] {}, 0, 0, new byte[] {});
    testSortDescending(new byte[] {1}, 0, 1, new byte[] {1});
    testSortDescending(new byte[] {1, 2}, 0, 2, new byte[] {2, 1});
    testSortDescending(new byte[] {1, 3, 1}, 0, 2, new byte[] {3, 1, 1});
    testSortDescending(new byte[] {1, 3, 1}, 0, 1, new byte[] {1, 3, 1});
    testSortDescending(
        new byte[] {GREATEST - 1, 1, GREATEST - 2, 2},
        1,

      return new GoodEquals(a, b);
    }

    // instance method ignored
    public Object badIgnored() {
      return new BadEquals();
    }

    // primitive ignored
    public int returnsInt() {
      throw new UnsupportedOperationException();
    }

    // void ignored
    public void voidMethod() {
      throw new UnsupportedOperationException();
    }

    Files.copy(i18nFile, temp1);
    moveHelper(true, new UnmovableFile(temp1, false, true), temp2);
    assertTrue(Files.equal(temp2, i18nFile));
  }

  public void testMoveFailures() throws IOException {
    File temp1 = createTempFile();
    File temp2 = createTempFile();

    moveHelper(false, new UnmovableFile(temp1, false, false), temp2);
    moveHelper(

    // ConcurrentMap implementors. One possibility is to extract most of this class into
    // an AbstractConcurrentMapMultiset.
    return new ConcurrentHashMultiset<>(new ConcurrentHashMap<E, AtomicInteger>());
  }

  /**
   * Creates a new {@code ConcurrentHashMultiset} containing the specified elements, using the
   * default initial capacity, load factor, and concurrency settings.
   *

 *
 * <pre>{@code
 * final WeakHashMap<Object, Object> map = new WeakHashMap<>();
 * map.put(new Object(), Boolean.TRUE);
 * GcFinalization.awaitDone(new FinalizationPredicate() {
 *   public boolean isDone() {
 *     return map.isEmpty();
 *   }
 * });
 * }</pre>
 *
 * <p>Even if your non-test code does not use finalization, you can use this class to test for

        toolchain = new ToolchainModel();
        toolchain.setType("TYPE");
        toolchain.setProvides(props);
        PersistedToolchains globalResult = new PersistedToolchains();
        globalResult.setToolchains(Collections.singletonList(toolchain));

        ToolchainsBuildingRequest request = new DefaultToolchainsBuildingRequest();
        request.setUserToolchainsSource(

        Build build = new Build();
        build.setDirectory(expected.substring(0, expected.length() - "/classes".length()));

        Model model = new Model();
        model.setBuild(build);

        MavenProject project = new MavenProject(model);
        project.setFile(new File("pom.xml").getCanonicalFile());

    testRotate(new short[] {1, 2}, -3, new short[] {2, 1});
    testRotate(new short[] {1, 2}, -1, new short[] {2, 1});
    testRotate(new short[] {1, 2}, -2, new short[] {1, 2});
    testRotate(new short[] {1, 2}, 0, new short[] {1, 2});
    testRotate(new short[] {1, 2}, 1, new short[] {2, 1});
    testRotate(new short[] {1, 2}, 2, new short[] {1, 2});
    testRotate(new short[] {1, 2}, 3, new short[] {2, 1});

    testRotate(new double[] {1, 2}, -3, new double[] {2, 1});
    testRotate(new double[] {1, 2}, -1, new double[] {2, 1});
    testRotate(new double[] {1, 2}, -2, new double[] {1, 2});
    testRotate(new double[] {1, 2}, 0, new double[] {1, 2});
    testRotate(new double[] {1, 2}, 1, new double[] {2, 1});
    testRotate(new double[] {1, 2}, 2, new double[] {1, 2});
    testRotate(new double[] {1, 2}, 3, new double[] {2, 1});