import org.jspecify.annotations.NullUnmarked;

/**
 * Test cases for {@link TypeToken}.
 *
 * @author Sven Mawson
 * @author Ben Yu
 */
@AndroidIncompatible // lots of failures, possibly some related to bad equals() implementations?
@NullUnmarked
public class TypeTokenTest extends TestCase {

  private abstract static class StringList implements List<String> {}

        return new JobManager() {
            @Override
            public OptionalThing<LaScheduledJob> findJobByUniqueOf(final LaJobUnique jobUnique) {
                if (expectedJobId.equals(jobUnique.value()) && laScheduledJob != null) {
                    return OptionalThing.of(laScheduledJob);
                }
                return OptionalThing.ofNullable(null, () -> {

                final String newId = ComponentUtil.getCrawlingInfoHelper().generateId(entity);
                final String oldId = (String) entity.get(fessConfig.getIndexFieldId());
                if (!newId.equals(oldId)) {
                    entity.put(fessConfig.getIndexFieldId(), newId);
                    entity.remove(fessConfig.getIndexFieldVersion());

                            .setScroll(settings.getScrollTimeout())
                            .execute()
                            .actionGet(settings.getSearchTimeout());
                    if (!scrollId.equals(response.getScrollId())) {
                        SuggestUtil.deleteScrollContext(client, scrollId);
                    }
                }
                scrollId = response.getScrollId();

                final String msg = ex.getMessage();
                final boolean timeout = ex instanceof SocketTimeoutException || msg != null && msg.equals("Read timed out");
                final boolean closed = msg != null && msg.equals("Socket closed");

                if (closed) {
                    log.trace("Remote closed connection");
                } else if (timeout) {

      int bucketLength = 0;
      do {
        entryIndex = next - 1;
        entry = entries[entryIndex];
        if (CompactHashing.getHashPrefix(entry, mask) == hashPrefix
            && Objects.equals(object, elements[entryIndex])) {
          return false;
        }
        next = CompactHashing.getNext(entry, mask);
        bucketLength++;
      } while (next != UNSET);

        // We use a "custom" equivalence to force MapMaker to make a MapMakerInternalMap.
        ConcurrentMap<K, V> newMap = new MapMaker().keyEquivalence(Equivalence.equals()).makeMap();
        checkState(newMap instanceof MapMakerInternalMap);
        newMap.putAll(map);
        return newMap;
      }
    },
    MapMakerStrongKeysWeakValues {
      @Override

            if (dir == null) {
                return false;
            }
            final File directory = dir.toFile();
            if (directory.list() != null && directory.list().length == 0 && !THUMBNAILS_DIR_NAME.equals(directory.getName())) {
                Files.delete(dir);
                if (logger.isDebugEnabled()) {
                    logger.debug("Deleted empty directory: {}", dir);
                }

    return bestResult;
  }

  private static boolean matchesType(
      @Nullable PublicSuffixType desiredType, @Nullable PublicSuffixType actualType) {
    return actualType != null && (desiredType == null || desiredType.equals(actualType));
  }

  private static boolean isExcludedMatch(int metadata) {
    return ((metadata >> EXCLUSION_SHIFT) & EXCLUSION_MASK) != 0;
  }

    if (!Objects.equals(actual, expected)) {
      // fail(), but with the JUnit-supplied message.
      assertEquals("Using seed " + seed, expected, actual);
    }
  }

  private static void assertEqualsUsingStartedWith(
      Collection<?> startedWith, @Nullable Object expected, @Nullable Object actual) {
    if (!Objects.equals(actual, expected)) {