extends AbstractMapBasedMultiset<E> {

  /** Creates a new, empty {@code LinkedHashMultiset} using the default initial capacity. */
  public static <E extends @Nullable Object> LinkedHashMultiset<E> create() {
    return create(ObjectCountHashMap.DEFAULT_SIZE);
  }

  /**
   * Creates a new, empty {@code LinkedHashMultiset} with the specified expected number of distinct
   * elements.
   *

    super(message);
  }

  /**
   * Creates a new instance with the given detail message and cause. Prefer to provide a
   * non-nullable {@code cause}, as many users expect to find one.
   */
  public ExecutionError(@Nullable String message, @Nullable Error cause) {
    super(message, cause);
  }

  /**
   * Creates a new instance with {@code null} as its detail message and the given cause. Prefer to

    return new Range<>(lowerBound, upperBound);
  }

  /**
   * Returns a range that contains all values strictly greater than {@code lower} and strictly less
   * than {@code upper}.
   *
   * @throws IllegalArgumentException if {@code lower} is greater than <i>or equal to</i> {@code
   *     upper}
   * @throws ClassCastException if {@code lower} and {@code upper} are not mutually comparable

    public static Map<TypeVariable<?>, Type> getTypeVariables(final Class<?> beanClass) {
        assertArgumentNotNull("beanClass", beanClass);

        return getTypeVariableMap(beanClass);
    }

    /**
     * Creates and returns a {@link ParameterizedClassDesc} that represents the type of the field.
     *
     * @param field
     *            The field. Must not be {@literal null}.
     * @param map

  /** Returns the sample elements that this generate populates its container with. */
  SampleElements<E> samples();

  /**
   * Creates a new container containing the given elements. TODO: would be nice to figure out how to
   * use E... or E[] as a parameter type, but this doesn't seem to work because Java creates an
   * array of the erased type.
   */
  T create(Object... elements);

  /**

 * Protected words are terms that should not be stemmed or modified during text analysis.
 *
 */
public class EditForm extends CreateForm {

    /**
     * Creates a new EditForm instance.
     */
    public EditForm() {
        super();
    }

    /**
     * The unique identifier of the protected words dictionary entry being edited.

    /**
     * Creates a new DictionaryException with the specified message and cause.
     *
     * @param message the detail message
     * @param cause the underlying cause of the exception
     */
    public DictionaryException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**
     * Creates a new DictionaryException with the specified message.
     *

        }
        DEFAULT_TARGET_INFORMATION = targetInfo;
    }

    /**
     * Creates a Type-2 message using default values from the current
     * environment.
     */
    public Type2Message() {
        this(getDefaultFlags(), null, null);
    }

    /**
     * Creates a Type-2 message in response to the given Type-1 message
     * using default values from the current environment.
     *

      assertTrue(t.equals(t));

      for (int j = i + 1; j < valuesInExpectedOrder.size(); j++) {
        T greater = valuesInExpectedOrder.get(j);
        assertTrue(greater + ".compareTo(" + t + ')', greater.compareTo(t) > 0);
        assertFalse(greater.equals(t));
      }
    }
  }

  /**
   * Returns a collection that simulates concurrent modification by having its size method return

import org.junit.jupiter.api.Test;

import jcifs.CIFSException;

/**
 * Test class for TransportException
 */
public class TransportExceptionTest {

    @Test
    @DisplayName("Test default constructor creates exception with null message")
    public void testDefaultConstructor() {
        // Create exception with default constructor
        TransportException exception = new TransportException();