}

  private static void disallowPrimitiveType(Type[] types, String usedAs) {
    for (Type type : types) {
      if (type instanceof Class) {
        Class<?> cls = (Class<?>) type;
        checkArgument(!cls.isPrimitive(), "Primitive type '%s' used as %s", cls, usedAs);
      }
    }
  }

  /** Returns the {@code Class} object of arrays with {@code componentType}. */

from .utils import needs_pydanticv1, needs_pydanticv2


class Person:
    def __init__(self, name: str):
        self.name = name


class Pet:
    def __init__(self, owner: Person, name: str):
        self.owner = owner
        self.name = name


@dataclass
class Item:
    name: str
    count: int


class DictablePerson(Person):
    def __iter__(self):

    testers.add(ListListIteratorTester.class);
    testers.add(ListRemoveAllTester.class);
    testers.add(ListRemoveAtIndexTester.class);
    testers.add(ListRemoveTester.class);
    testers.add(ListReplaceAllTester.class);
    testers.add(ListRetainAllTester.class);
    testers.add(ListSetTester.class);
    testers.add(ListSubListTester.class);
    testers.add(ListToArrayTester.class);
    return testers;
  }

    assertThrows(IllegalArgumentException.class, () -> MediaType.parse(""));
  }

  public void testParse_badInput() {
    assertThrows(IllegalArgumentException.class, () -> MediaType.parse("/"));
    assertThrows(IllegalArgumentException.class, () -> MediaType.parse("text"));
    assertThrows(IllegalArgumentException.class, () -> MediaType.parse("text/"));
    assertThrows(IllegalArgumentException.class, () -> MediaType.parse("te<t/plain"));

 * @author Chris Povirk
 * @since 2.0
 */
@GwtCompatible(emulated = true)
@ElementTypesAreNonnullByDefault
public final class Sets {
  private Sets() {}

  /**
   * {@link AbstractSet} substitute without the potentially-quadratic {@code removeAll}
   * implementation.
   */
  abstract static class ImprovedAbstractSet<E extends @Nullable Object> extends AbstractSet<E> {
    @Override
    public boolean removeAll(Collection<?> c) {

        final EsUrlFilterService urlFilterService = ComponentUtil.getComponent(EsUrlFilterService.class);
        final EsUrlQueueService urlQueueService = ComponentUtil.getComponent(EsUrlQueueService.class);
        final EsDataService dataService = ComponentUtil.getComponent(EsDataService.class);

        try {
            // clear url filter
            urlFilterService.delete(sid);

import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;
import jakarta.annotation.Resource;

public class StandardCrawlerContainer implements CrawlerContainer {

    private final Logger logger = LoggerFactory.getLogger(StandardCrawlerContainer.class);

    private final Map<String, ComponentHolder<?>> singletonMap = new ConcurrentHashMap<>();

 *
 * @author Louis Wasserman
 */
@GwtCompatible
@Ignore // Affects only Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class MapPutIfAbsentTester<K, V> extends AbstractMapTester<K, V> {

  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutIfAbsent_supportedAbsent() {
    assertNull(

    LinkedHashMap<String, String>().apply {
      val packageName = OkHttpClient::class.java.`package`?.name

      if (packageName != null) {
        this[packageName] = "OkHttp"
      }

      this[OkHttpClient::class.java.name] = "okhttp.OkHttpClient"
      this[Http2::class.java.name] = "okhttp.Http2"
      this[TaskRunner::class.java.name] = "okhttp.TaskRunner"

  public void testNotInterfaceType() {
    assertThrows(
        IllegalArgumentException.class,
        () ->
            new ForwardingWrapperTester()
                .testForwarding(String.class, Functions.<String>identity()));
  }

  public void testNulls() {
    new NullPointerTester()
        .setDefault(Class.class, Runnable.class)
        .testAllPublicInstanceMethods(new ForwardingWrapperTester());
  }