return delegate.floor(checkValid(e));
  }

  @Override
  public SortedSet<E> headSet(E toElement) {
    return headSet(toElement, false);
  }

  @Override
  public NavigableSet<E> headSet(E toElement, boolean inclusive) {
    return new SafeTreeSet<>(delegate.headSet(checkValid(toElement), inclusive));
  }

  @Override
  public @Nullable E higher(E e) {

    return new Strings();
  }

  @Override
  public List<String> create(Object... elements) {
    String[] array = new String[elements.length];
    int i = 0;
    for (Object e : elements) {
      array[i++] = (String) e;
    }
    return create(array);
  }

  /**
   * Creates a new collection containing the given elements; implement this method instead of {@link
   * #create(Object...)}.
   */

    return new Strings();
  }

  @Override
  public Multiset<String> create(Object... elements) {
    String[] array = new String[elements.length];
    int i = 0;
    for (Object e : elements) {
      array[i++] = (String) e;
    }
    return create(array);
  }

  protected abstract Multiset<String> create(String[] elements);

  @Override
  public String[] createArray(int length) {
    return new String[length];

    return new Strings();
  }

  @Override
  public Collection<String> create(Object... elements) {
    String[] array = new String[elements.length];
    int i = 0;
    for (Object e : elements) {
      array[i++] = (String) e;
    }
    return create(array);
  }

  protected abstract Collection<String> create(String[] elements);

  @Override
  public String[] createArray(int length) {
    return new String[length];

 * limitations under the License.
 */

package com.google.common.collect.testing;

import com.google.common.annotations.GwtCompatible;

/**
 * A type which will never be used as the element type of any collection in our tests, and so can be
 * used to test how a Collection behaves when given input of the wrong type.
 */
@GwtCompatible
public enum WrongType {
  VALUE

   *       UnsupportedOperationException when those mutators are called.
   * </ol>
   *
   * @param collection the presumed-immutable collection
   * @param sampleElement an element of the same type as that contained by {@code collection}.
   *     {@code collection} may or may not have {@code sampleElement} as a member.
   */
  public static <E extends @Nullable Object> void assertCollectionIsUnmodifiable(

    return new Colliders();
  }

  @Override
  public Object[] createArray(int length) {
    return new Object[length];
  }

  /** Returns the original element list, unchanged. */
  @Override
  public List<Object> order(List<Object> insertionOrder) {
    return insertionOrder;
  }

import org.gradle.api.provider.Property
import org.gradle.api.tasks.Internal
import org.gradle.internal.util.PropertiesUtils
import org.gradle.work.DisableCachingByDefault
import org.w3c.dom.Element
import java.util.Properties
import javax.xml.XMLConstants
import javax.xml.parsers.DocumentBuilderFactory

@DisableCachingByDefault(because = "Not worth tracking")

        assertNotNull(authorizations, "The authorizations list should not be null.");
        assertEquals(1, authorizations.size(), "The authorizations list should contain one element.");
        assertEquals(mockAuthData, authorizations.get(0), "The authorization element should be the mocked object.");
    }

    /**
     * Test constructor with a malformed ASN.1 token.
     */
    @Test
    void testConstructor_MalformedToken() {

  public void testPutAllNullForbidden() {
    assertThrows(NullPointerException.class, () -> multimap().putAll(null, singletonList(v3())));
  }

  @SuppressWarnings("EmptyList") // ImmutableList doesn't support nullable element types
  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutAllEmptyCollectionOnAbsentKey() {
    assertFalse(multimap().putAll(k3(), Collections.emptyList()));
    expectUnchanged();
  }