*
     * @param rule the rule to be removed
     * @return true if the rule was successfully removed, false otherwise
     */
    boolean removeRule(Rule rule);

    /**
     * Checks if the specified rule exists.
     *
     * @param rule the rule to check for existence
     * @return true if the rule exists, false otherwise
     */
    boolean hasRule(Rule rule);

     * Gets the name of this thumbnail generator.
     * @return The generator name.
     */
    String getName();

    /**
     * Generates a thumbnail for the given thumbnail ID and saves it to the output file.
     *
     * @param thumbnailId the unique identifier for the thumbnail
     * @param outputFile the file where the generated thumbnail will be saved
     * @return true if the thumbnail was successfully generated, false otherwise

/*
 * Copyright 2012-2025 CodeLibs Project and the Others.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,

    private Map<String, Object> fields;

    @Override
    public String getId() {
        return asDocMeta().id();
    }

    public void setId(final String id) {
        asDocMeta().id(id);
    }

    @Override
    public Long getVersionNo() {
        return asDocMeta().version();
    }

    public void setVersionNo(final Long version) {
        asDocMeta().version(version);
    }

  public void testElement_size1() {
    assertEquals("size1Queue.element() should return first element", e0(), getQueue().element());
    expectUnchanged();
  }

  @CollectionFeature.Require(KNOWN_ORDER)
  @CollectionSize.Require(SEVERAL)
  public void testElement_sizeMany() {
    assertEquals("sizeManyQueue.element() should return first element", e0(), getQueue().element());
    expectUnchanged();
  }

  @CollectionSize.Require(ZERO)
  public void testPeek_empty() {
    assertNull("emptyQueue.peek() should return null", getQueue().peek());
    expectUnchanged();
  }

  @CollectionSize.Require(ONE)
  public void testPeek_size1() {
    assertEquals("size1Queue.peek() should return first element", e0(), getQueue().peek());
    expectUnchanged();
  }

  @CollectionFeature.Require(KNOWN_ORDER)

    assertTrue(
        "add(somePresent) should return true", getSet().addAll(MinimalCollection.of(e3(), e0())));
    expectAdded(e3());
  }

  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testAddAll_withDuplicates() {
    MinimalCollection<E> elementsToAdd = MinimalCollection.of(e3(), e4(), e3(), e4());
    assertTrue("add(hasDuplicates) should return true", getSet().addAll(elementsToAdd));
    expectAdded(e3(), e4());

  @Override
  public TestContainerGenerator<T, E> getInnerGenerator() {
    return generator;
  }

  @Override
  public SampleElements<E> samples() {
    return generator.samples();
  }

  @Override
  public T create(Object... elements) {
    return generator.create(elements);
  }

  @Override
  public E[] createArray(int length) {
    return generator.createArray(length);
  }

  @Override

    return new AnEnum[length];
  }

  @Override
  public final String[] createValueArray(int length) {
    return new String[length];
  }

  /** Returns the elements sorted in natural order. */
  @Override
  public Iterable<Entry<AnEnum, String>> order(List<Entry<AnEnum, String>> insertionOrder) {
    return orderEntriesByKey(insertionOrder);
  }

        builder.put(entry.getKey(), entry.getValue());
      }
      return ImmutableBiMap.copyOf(builder);
    }
  }

  public static class ImmutableBiMapCopyOfEntriesGenerator extends TestStringBiMapGenerator {
    @Override
    protected BiMap<String, String> create(Entry<String, String>[] entries) {
      return ImmutableBiMap.copyOf(asList(entries));
    }
  }

  /**