NetworkExplorer spyExplorer = spy(networkExplorer);
        doNothing().when(spyExplorer).doFile(any(), any(), any());

        // Call the method
        spyExplorer.doFile(request, response, smbFile);

        // Verify the method was called
        verify(spyExplorer).doFile(eq(request), eq(response), eq(smbFile));
    }

    /**
     * Test doDirectory method directly - simplified test

     * @param req the HTTP servlet request
     * @param resp the HTTP servlet response
     * @param file the SMB file to download
     * @throws IOException if an I/O error occurs
     */
    protected void doFile(final HttpServletRequest req, final HttpServletResponse resp, final SmbFile file) throws IOException {
        final byte[] buf = new byte[8192];
        String url, type;
        int n;

     * @param req the HTTP servlet request
     * @param resp the HTTP servlet response
     * @param file the SMB file to download
     * @throws IOException if an I/O error occurs
     */
    protected void doFile(final HttpServletRequest req, final HttpServletResponse resp, final SmbFile file) throws IOException {
        final byte[] buf = new byte[8192];

        @SuppressWarnings("resource")

	files := []usageTestFile{
		{name: "rootfile", size: 10000},
		{name: "rootfile2", size: 10000},
		{name: "dir1/d1file", size: 2000},
		{name: "dir2/d2file", size: 300},
		{name: "dir1/dira/dafile", size: 100000},
		{name: "dir1/dira/dbfile", size: 200000},
		{name: "dir1/dira/dirasub/dcfile", size: 1000000},
		{name: "dir1/dira/dirasub/sublevel3/dccccfile", size: 10},
	}
	createUsageTestFiles(t, base, bucket, files)

   */
  @InlineMe(replacement = "Double.compare(a, b)")
  public static int compare(double a, double b) {
    return Double.compare(a, b);
  }

  /**
   * Returns {@code true} if {@code value} represents a real number. This is equivalent to, but not
   * necessarily implemented as, {@code !(Double.isInfinite(value) || Double.isNaN(value))}.
   *
   * <p>Prefer {@link Double#isFinite(double)} instead.
   *
   * @since 10.0

      Double[] suffix = {86.0, 99.0};
      Double[] all = concat(concat(prefix, elements), suffix);
      return makeArray(all).subArray(2, elements.length + 2).asList();
    }
  }

  @J2ktIncompatible
  @GwtIncompatible // used only from suite
  @AndroidIncompatible
  private static Double[] concat(Double[] a, Double[] b) {
    return ObjectArrays.concat(a, b, Double.class);
  }

    }

    private static Double toDouble(final String s) {
        if (StringUtil.isEmpty(s)) {
            return null;
        }
        return Double.valueOf(DecimalFormatUtil.normalize(s));
    }

    /**
     * Converts to {@literal double}.
     *
     * @param o
     *            The object to convert
     * @return The converted {@literal double}
     */
    public static double toPrimitiveDouble(final Object o) {

  }

  static final ImmutableSet<Double> INTEGRAL_DOUBLE_CANDIDATES;
  static final ImmutableSet<Double> FRACTIONAL_DOUBLE_CANDIDATES;
  static final Iterable<Double> INFINITIES =
      Doubles.asList(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY);
  static final Iterable<Double> FINITE_DOUBLE_CANDIDATES;
  static final Iterable<Double> POSITIVE_FINITE_DOUBLE_CANDIDATES;

  public void testRotate() {
    testRotate(new double[] {}, -1, new double[] {});
    testRotate(new double[] {}, 0, new double[] {});
    testRotate(new double[] {}, 1, new double[] {});

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

     */
    private double calculateSuccessRate() {
        long total = totalRequests.get();
        if (total == 0) {
            return 100.0;
        }
        return (totalSuccesses.get() * 100.0) / total;
    }

    /**
     * Calculate availability
     *
     * @return availability as percentage (0-100)
     */
    private double calculateAvailability() {