*   / \   / \
   *  /   \ /   \
   * c     d     e
   *        \   /
   *         \ /
   *          f
   * }
   *
   * <p><b>Note on binary trees</b>
   *
   * <p>This method can be used to traverse over a binary tree. Given methods {@code
   * leftChild(node)} and {@code rightChild(node)}, this method can be called as
   *
   * {@snippet :

     * </p>
     *
     * @param chars
     *            the char array
     * @return a new String, or null if the input is null
     * @deprecated This method originally used internal JDK APIs (sun.misc.SharedSecrets) for
     *             performance optimization, but those APIs have been removed for safety and
     *             compatibility with modern Java versions. This method now simply calls

  private final transient ConcurrentMap<E, AtomicInteger> countMap;

  /**
   * An instance created in {@link #readObject} to be returned from {@link #readResolve}. This field
   * is used only by those methods, and it is never set in a "normal" instance.
   *
   * <p>This class needs to write deserialized data into fields that are {@code final transient}.

            // remove whitespaces at the end
            expectedChecksum = expectedChecksum.trim();

            // check for 'ALGO (name) = CHECKSUM' like used by openssl
            if (expectedChecksum.regionMatches(true, 0, "MD", 0, 2)
                    || expectedChecksum.regionMatches(true, 0, "SHA", 0, 3)) {
                int lastSpacePos = expectedChecksum.lastIndexOf(' ');

func NewChecksumString(alg, value string) *Checksum {
	return NewChecksumWithType(NewChecksumType(alg, ""), value)
}

// AppendTo will append the checksum to b.
// 'parts' is used when checksum has ChecksumMultipart set.
// ReadCheckSums reads the values back.
func (c *Checksum) AppendTo(b []byte, parts []byte) []byte {
	if c == nil {
		return nil
	}
	var tmp [binary.MaxVarintLen32]byte

 * encoding} may be viewed as a {@code CharSource} using {@link ByteSource#asCharSource(Charset)}.
 *
 * <p><b>Note:</b> In general, {@code CharSource} is intended to be used for "file-like" sources
 * that provide readers that are:
 *
 * <ul>
 *   <li><b>Finite:</b> Many operations, such as {@link #length()} and {@link #read()}, will either

			if globalDNSConfig != nil {
				// if global DNS is already configured, indicate with a warning, in case
				// users are confused.
				configLogIf(ctx, fmt.Errorf("DNS store is already configured with %s, etcd is not used for DNS store", globalDNSConfig))
			} else {
				globalDNSConfig, err = dns.NewCoreDNS(etcdCfg.Config,
					dns.DomainNames(globalDomainNames),
					dns.DomainIPs(globalDomainIPs),
					dns.DomainPort(globalMinioPort),

  /**
   * Returns a "nefarious" map entry with the specified key and value, meaning an entry that is
   * suitable for testing that map entries cannot be modified via a nefarious implementation of
   * equals. This is used for testing unmodifiable collections of map entries; for example, it
   * should not be possible to access the raw (modifiable) map entry via a nefarious equals method.
   */

            assertEquals(FileSystemInformation.FS_SIZE_INFO, allocInfo.getFileSystemInformationClass());
        }

        @Test
        @DisplayName("Should calculate used space correctly")
        void shouldCalculateUsedSpaceCorrectly() throws SMBProtocolDecodingException {
            // Given
            ByteBuffer buffer = ByteBuffer.allocate(24);

  float* values = new float[1];
  values[0] = v;
  return TF_NewTensor(TF_FLOAT, nullptr, 0, values, num_bytes,
                      &FloatDeallocator, nullptr);
}

// All the *Helper methods are used as a workaround for the restrictions that
// one cannot call ASSERT_* methods in non-void-returning functions (when
// exceptions are disabled during compilation)