// Try to parse as Crawl-delay directive
                    value = getValue(CRAWL_DELAY_RECORD, line);
                    if (value != null) {
                        if (!currentDirectiveList.isEmpty() && !StringUtil.isEmpty(value)) {
                            try {
                                final int crawlDelay = Integer.parseInt(value);
                                for (final Directive directive : currentDirectiveList) {

            // Apply default behavior: if no specific options are provided, use default
            if (options.all().isEmpty()
                    && options.infer().isEmpty()
                    && options.model().isEmpty()
                    && options.plugins().isEmpty()
                    && options.modelVersion().isEmpty()) {
                return defaultValue;
            }

            return false;
        }
    }

    entryIterator.next();
    entryIterator.remove();
    assertFalse(underlying.containsKey("g"));

    assertTrue(underlying.isEmpty());
    assertTrue(map.isEmpty());
    assertTrue(keys.isEmpty());
    assertTrue(values.isEmpty());
    assertTrue(entries.isEmpty());
  }

  public void testTransformEquals() {
    Map<String, Integer> underlying = ImmutableMap.of("a", 0, "b", 1, "c", 2);

    return singletonMap(key, value).entrySet().iterator().next();
  }

  private static boolean isEmpty(Iterable<?> iterable) {
    return iterable instanceof Collection
        ? ((Collection<?>) iterable).isEmpty()
        : !iterable.iterator().hasNext();
  }

  public static void assertEmpty(Iterable<?> iterable) {
    if (!isEmpty(iterable)) {
      fail("Not true that " + iterable + " is empty");
    }
  }

        this.took = took;
        if (errors != null && !errors.isEmpty()) {
            this.errors.addAll(errors);
        }
    }

    /**
     * Checks if the response has any errors.
     * @return True if there are errors, false otherwise.
     */
    public boolean hasError() {
        return !errors.isEmpty();
    }

    /**
     * Returns the list of errors.

        if (versioning.getRelease() != null && !versioning.getRelease().isEmpty()) {
            merge(RELEASE, infos, versioning.getLastUpdated(), versioning.getRelease(), repository);
        }

        if (versioning.getLatest() != null && !versioning.getLatest().isEmpty()) {
            merge(LATEST, infos, versioning.getLastUpdated(), versioning.getLatest(), repository);
        }

    assertThat(set.tailSet(2, false)).containsExactly(3).inOrder();
    assertThat(set.tailSet(3, false)).isEmpty();
  }

  public void testTailSet_tooLarge() {
    assertThat(ContiguousSet.create(Range.closed(1, 3), integers()).tailSet(4)).isEmpty();
  }

  public void testSubSet() {
    ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers());

      public boolean contains(@Nullable Object element) {
        return multiset1.contains(element) || multiset2.contains(element);
      }

      @Override
      public boolean isEmpty() {
        return multiset1.isEmpty() && multiset2.isEmpty();
      }

      @Override
      public int count(@Nullable Object element) {
        return max(multiset1.count(element), multiset2.count(element));
      }

        }

        @Override
        public boolean storedInArtifactVersionDirectory() {
            return !metadata.getVersion().isEmpty();
        }

        @Override
        public boolean storedInGroupDirectory() {
            return metadata.getArtifactId().isEmpty();
        }

        @Override
        public String getGroupId() {
            return nullify(metadata.getGroupId());
        }

  }

  @Override
  protected void assertGet(K key, Collection<? extends V> values) {
    assertEqualInOrder(values, multimap().get(key));

    if (!values.isEmpty()) {
      assertEqualInOrder(values, multimap().asMap().get(key));
      assertFalse(multimap().isEmpty());
    } else {
      assertNull(multimap().asMap().get(key));
    }

    assertEquals(values.size(), multimap().get(key).size());