assertThat(e.getPrevious(), is(nullValue()));
        assertThat(e.getNext().getElement(), is("2"));
        e = list.getLastEntry();
        assertThat(e.getNext(), is(nullValue()));
        assertThat(e.getPrevious().getElement(), is("2"));
        list.getEntry(1).remove();
        assertThat(list.getFirst(), is("1"));
        assertThat(list.getLast(), is("3"));
        list.getLastEntry().remove();

type uint uint

// uintptr is an integer type that is large enough to hold the bit pattern of
// any pointer.
type uintptr uintptr

// byte is an alias for uint8 and is equivalent to uint8 in all ways. It is
// used, by convention, to distinguish byte values from 8-bit unsigned
// integer values.
type byte = uint8

// rune is an alias for int32 and is equivalent to int32 in all ways. It is

            is FirAnnotation -> getSymbolsForAnnotationCall(fir, session, symbolBuilder)
            is FirResolvedImport -> getSymbolsByResolvedImport(expression, symbolBuilder, fir, session)
            is FirPackageDirective -> getSymbolsForPackageDirective(expression, symbolBuilder)
            is FirFile -> getSymbolsByFirFile(symbolBuilder, fir)
            is FirArrayLiteral -> {

        final int result = copy(is, os);
        assertThat(result, is(srcBytes.length));
        assertThat(os.toByteArray(), is(srcBytes));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testReaderToWriter() throws Exception {
        final int result = copy(reader, writer);
        assertThat(result, is(srcString.length()));

        final Map<String, Object> map = BeanUtil.copyBeanToNewMap(hoge);
        assertThat(map.size(), is(4));
        assertThat(map.get("aaa"), is((Object) "1"));
        assertThat(map.get("search_bbb"), is((Object) "2"));
        assertThat(map.get("search_ccc.ddd"), is((Object) "3"));
        assertThat(map.get("employee.name"), is(nullValue()));
    }

    /**
     * @throws Exception
     */
    @Test

		return xhttp.AmzChecksumSHA1
	case c.Is(ChecksumSHA256):
		return xhttp.AmzChecksumSHA256
	}
	return ""
}

// RawByteLen returns the size of the un-encoded checksum.
func (c ChecksumType) RawByteLen() int {
	switch {
	case c.Is(ChecksumCRC32):
		return 4
	case c.Is(ChecksumCRC32C):
		return 4
	case c.Is(ChecksumSHA1):
		return sha1.Size
	case c.Is(ChecksumSHA256):
		return sha256.Size
	}

  When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library.  The
threshold for this to be true is not precisely defined by law.

   * following constraints. This is the callers responsibility and is not enforced here.
   *
   * <ul>
   *   <li>If {@code count} is 0, {@code mean} may have any finite value (its only usage will be to
   *       get multiplied by 0 to calculate the sum), and the other parameters may have any values
   *       (they will not be used).
   *   <li>If {@code count} is 1, {@code sumOfSquaresOfDeltas} must be exactly 0.0 or {@link

			apiErr = APIError{
				Code:           "XMinioIAMNotInitialized",
				Description:    err.Error(),
				HTTPStatusCode: http.StatusServiceUnavailable,
			}
		case errors.Is(err, errPolicyInUse):
			apiErr = APIError{
				Code:           "XMinioIAMPolicyInUse",
				Description:    "The policy cannot be removed, as it is in use",
				HTTPStatusCode: http.StatusBadRequest,
			}

   *     null}
   */
  public abstract T or(Supplier<? extends T> supplier);

  /**
   * Returns the contained instance if it is present; {@code null} otherwise. If the instance is
   * known to be present, use {@link #get()} instead.
   *
   * <p><b>Comparison to {@code java.util.Optional}:</b> this method is equivalent to Java 8's