getList().hashCode());
  }

  /**
   * Returns the {@link Method} instance for {@link #testHashCode()} so that list tests on
   * unhashable objects can suppress it with {@code FeatureSpecificTestSuiteBuilder.suppressing()}.
   */
  @J2ktIncompatible
  @GwtIncompatible // reflection
  public static Method getHashCodeMethod() {
    return getMethod(ListHashCodeTester.class, "testHashCode");
  }

    out.write(data);
    assertTrue(Arrays.equals(data, source.read()));

    out.close();
  }

  private static boolean isAndroid() {
    return System.getProperty("java.runtime.name", "").contains("Android");
  }

  private static boolean isWindows() {
    return OS_NAME.value().startsWith("Windows");
  }

     * @param domsid
     * @param rid
     * @param flags
     * @return the SIDs of the group members
     * @throws CIFSException
     */
    SID[] getGroupMemberSids ( CIFSContext tc, String authorityServerName, SID domsid, int rid, int flags ) throws CIFSException;


    /**
     * @param authorityServerName
     * @param tc
     * @return the server's SID
     * @throws CIFSException
     */

    Double.MAX_VALUE,
    Double.POSITIVE_INFINITY,
    Double.NaN,
    Float.MAX_VALUE,
  };

  /** The notion of equality used by AtomicDoubleArray */
  static boolean bitEquals(double x, double y) {
    return Double.doubleToRawLongBits(x) == Double.doubleToRawLongBits(y);
  }

  static void assertBitEquals(double x, double y) {
    assertEquals(Double.doubleToRawLongBits(x), Double.doubleToRawLongBits(y));
  }

    )

    @BeforeEach
    fun setUp() {
        val stepsCapturer = slot<BuildSteps.() -> Unit>()
        every { buildType.steps } returns steps
        every { buildType.stage } returns buildModel.stages[2]
        every {
            buildType.steps(capture(stepsCapturer))
        } answers {
            stepsCapturer.captured(steps)
            mockk()
        }
    }

	if r.eof {
		return 0, io.EOF
	}
	n = copy(p, r.data)
	r.eof = true
	return n, io.EOF
}

// Return pointer to testOneByteReadNoEOF{}
func newTestReaderNoEOF(data []byte) io.Reader {
	return &testOneByteReadNoEOF{false, data}
}

// testOneByteReadNoEOF - implements io.Reader which returns 1 byte and nil error, but
// returns io.EOF on the next Read().
type testOneByteReadNoEOF struct {

    } catch (Exception e) {
      throw new Error(e);
    }
  }

  /**
   * Returns a sun.misc.Unsafe. Suitable for use in a 3rd party package. Replace with a simple call
   * to Unsafe.getUnsafe when integrating into a jdk.
   *
   * @return a sun.misc.Unsafe
   */
  private static Unsafe getUnsafe() {
    try {
      return Unsafe.getUnsafe();
    } catch (SecurityException tryReflectionInstead) {
    }
    try {

          @Override
          protected Integer initialValue() {
            return 0;
          }
        };

    final Callable<Integer> incrementTask =
        new Callable<Integer>() {
          @Override
          public Integer call() {
            int i = threadLocalCount.get();
            threadLocalCount.set(i + 1);
            return i;
          }
        };

    while (true) {
      val i = responses.iterator()
      while (i.hasNext()) {
        val recordedResponse = i.next()
        if (recordedResponse.request.url.equals(url)) {
          i.remove()
          return recordedResponse
        }
      }
      val nowMillis = TimeUnit.NANOSECONDS.toMillis(System.nanoTime())
      if (nowMillis >= timeoutMillis) break
      (this as Object).wait(timeoutMillis - nowMillis)
    }

   *
   * @param out the output stream to be wrapped
   */
  public CountingOutputStream(OutputStream out) {
    super(checkNotNull(out));
  }

  /** Returns the number of bytes written. */
  public long getCount() {
    return count;
  }

  @Override
  public void write(byte[] b, int off, int len) throws IOException {
    out.write(b, off, len);
    count += len;
  }

  @Override