}

  /*
   * Whenever an implementation uses `instanceof` on a parameter instance, the test has to know that
   * (so much for "black box") and try instances that both do and don't pass the check. The "don't"
   * half of that is more awkward to arrange...
   */
  private static <T> Iterable<T> iterable(Collection<T> collection) {
    // return collection::iterator;

/**
 * Utility for converting objects that represent only dates to {@link Date}, {@link Calendar}, or {@link java.sql.Date}.
 * <p>
 * For objects that represent only time, see {@link TimeConversionUtil}. For objects that represent both date and time, see {@link TimestampConversionUtil}.
 * </p>
 * <p>
 * If the source object is a {@link Date}, {@link Calendar}, or {@link java.sql.Date}, the converted object is created using the millisecond value of the source.

Depois, você poderia adicionar permissões sobre essa entidade, como "dirigir" (para o carro) ou "editar" (para o blog).

E então, poderia dar esse token JWT para um usuário (ou bot), e ele poderia usá-lo para realizar essas ações (dirigir o carro ou editar o blog) sem sequer precisar ter uma conta, apenas com o token JWT que sua API gerou para isso.

   * values present. This method is also useful in environments such as GWT where {@code
   * String.format} is not available. As an example, method implementations of the {@link
   * Preconditions} class use this formatter, for both of the reasons just discussed.
   *
   * <p><b>Warning:</b> Only the exact two-character placeholder sequence {@code "%s"} is
   * recognized.
   *

import java.io.Serializable;
import java.util.Comparator;
import java.util.List;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

@AndroidIncompatible // lots of failures, possibly some related to bad equals() implementations?
@NullUnmarked
public class TypeTokenSubtypeTest extends TestCase {

  public void testOwnerTypeSubtypes() throws Exception {

  }

  /* ---------------- Local utilities -------------- */

  /** Most of the tests in this class run against every one of these caches. */
  private Iterable<LoadingCache<Object, Object>> caches() {
    // lots of different ways to configure a LoadingCache
    CacheBuilderFactory factory = cacheFactory();
    return Iterables.transform(
        factory.buildAllPermutations(),

        setField(transport, "socket", s);

        // Act & Assert
        assertFalse(transport.isDisconnected());
        assertFalse(transport.isFailed());

        // Close socket -> both should be true
        when(s.isClosed()).thenReturn(true);
        assertTrue(transport.isDisconnected());
        assertTrue(transport.isFailed());
    }

    @Test

func (z *dataUsageEntry) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	var zb0001Mask uint8 /* 1 bits */
	_ = zb0001Mask
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {

import org.dbflute.optional.OptionalEntity;

/**
 * Manages a dictionary file for synonyms.
 * This class handles reading, parsing, and updating files that contain
 * synonym rules. The file format supports both explicit mappings (e.g., `a => b`)
 * and equivalent synonyms (e.g., `a, b, c`).
 *
 * The class provides methods for retrieving, adding, updating, and
 * deleting synonym items, as well as reloading the dictionary

        timeZone = utc
      }

    return dateFormat.format(date)
  }

  /**
   * Returns a composite adapter for a struct or data class. This may be used for both SEQUENCE and
   * SET types.
   *
   * The fields are specified as a list of member adapters. When decoding, a value for each
   * non-optional member but be included in sequence.
   *