# Cookie Parameter Models { #cookie-parameter-models }

If you have a group of **cookies** that are related, you can create a **Pydantic model** to declare them. 🍪

This would allow you to **re-use the model** in **multiple places** and also to declare validations and metadata for all the parameters at once. 😎

/// note

This is supported since FastAPI version `0.115.0`. 🤓

///

/// tip

  private final CountDownLatch listenerLatch = new CountDownLatch(1);

  private volatile boolean throwException = false;

  private final ListenableFutureTask<Integer> task =
      ListenableFutureTask.create(
          () -> {
            runLatch.countDown();
            taskLatch.await();
            if (throwException) {
              throw new IllegalStateException("Fail");
            }
            return 25;

@GwtCompatible
final class CartesianList<E> extends AbstractList<List<E>> implements RandomAccess {

  private final transient ImmutableList<List<E>> axes;
  private final transient int[] axesSizeProduct;

  static <E> List<List<E>> create(List<? extends List<? extends E>> lists) {
    ImmutableList.Builder<List<E>> axesBuilder = new ImmutableList.Builder<>(lists.size());
    for (List<? extends E> list : lists) {
      List<E> copy = ImmutableList.copyOf(list);

 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.internal.smb2.create;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jcifs.CIFSContext;
import jcifs.Configuration;
import jcifs.internal.smb2.RequestWithFileId;

 *
 * @param <K> the key type
 * @param <V> the value type
 */
public class ParamMap<K, V> implements Map<K, V> {

    private final Map<K, V> parent;

    /**
     * Creates a new parameter map.
     *
     * @param parent the parent map
     */
    public ParamMap(final Map<K, V> parent) {
        this.parent = parent;
    }

    /**
     * Gets the parent map.
     *

    assertThrows(IOException.class, reader::ready);

    assertThrows(IOException.class, () -> reader.mark(10));

    assertThrows(IOException.class, reader::reset);
  }

  /**
   * Creates a CharSequenceReader wrapping the given CharSequence and tests that the reader produces
   * the same sequence when read using each type of read method it provides.
   */

    String workstation;
    boolean isEstablished = false;
    byte[] serverChallenge = null;
    byte[] signingKey = null;
    String netbiosName = null;
    int state = 1;
    LogStream log;

    /**
     * Creates a new NTLM context for SMB1 authentication.
     * @param auth the NTLM authentication credentials
     * @param doSigning whether to enable message signing
     */

/**
 * Test cases for the default {@code ModelResolver} implementation.
 *
 * @since 3.5.0
 */
final class DefaultModelResolverTest extends AbstractRepositoryTestCase {

    /**
     * Creates a new {@code DefaultModelResolverTest} instance.
     */
    DefaultModelResolverTest() {
        super();
    }

    @Test

			trimLen:  1,
			expected: []int{1, 2},
		},
		{
			name:     "Empty slice",
			input:    []int{},
			trimLen:  2,
			expected: []int{},
		},
		{
			name:     "Negative trim length (should be treated as zero)",
			input:    []int{1, 2, 3},
			trimLen:  -1,
			expected: []int{1, 2, 3},
		},
	}

	for _, testcase := range tests {
		t.Run(testcase.name, func(t *testing.T) {

  private AbstractFuture<@Nullable Integer> delegate;

  abstract AbstractFuture<@Nullable Integer> newDelegate();

  @Override
  protected void setUp() {
    future = TestedFuture.create();
    delegate = newDelegate();
  }

  public void testPending() {
    assertPending(future);
  }

  public void testSuccessful() throws Exception {
    assertThat(future.set(1)).isTrue();