import java.util.Collection;
import java.util.List;
import org.jspecify.annotations.NullMarked;

/**
 * Creates collections containing unhashable sample elements, to be tested.
 *
 * @author Regina O'Dell
 */
@GwtCompatible
@NullMarked
public abstract class TestUnhashableCollectionGenerator<T extends Collection<UnhashableObject>>
    implements TestCollectionGenerator<UnhashableObject> {

 *       have, of returning a new, independent iterator
 * </ul>
 *
 * <p>Because of this situation, any public method accepting an iterable should invoke the {@code
 * iterator} method only once, and should be tested using this class. Exceptions to this rule should
 * be clearly documented.
 *
 * <p>Note that although your APIs should be liberal in what they accept, your methods which

                builder.startArray("items");
                builder.value("item1");
                builder.value("item2");
                builder.endArray();
                builder.startObject("nested");
                builder.field("inner", "value");
                builder.endObject();
                builder.endObject();
                return builder;
            }
        };

        try {

import org.jspecify.annotations.NullUnmarked;

/**
 * Unit test for {@link Files}.
 *
 * <p>Some methods are tested in separate files:
 *
 * <ul>
 *   <li>{@link Files#fileTraverser()} is tested in {@link FilesFileTraverserTest}.
 *   <li>{@link Files#createTempDir()} is tested in {@link FilesCreateTempDirTest}.
 * </ul>
 *
 * @author Chris Nokleberg
 */

                        attributes.put(name, parseArray(jsonParser));
                    } else if (jsonParser.getCurrentToken() == JsonToken.START_OBJECT) {
                        // Handle nested object type
                        attributes.put(name, parseObject(jsonParser));
                    } else {
                        // Handle primitive types (string, number, boolean, etc.)

        StackTraceElement topElement = stackTrace[0];
        assertEquals(this.getClass().getName(), topElement.getClassName());
    }

    public void test_nestedExceptions() {
        // Test nested exception handling
        Exception level3 = new RuntimeException("Level 3 error");
        Exception level2 = new IllegalStateException("Level 2 error", level3);

    assertEquals(2, copy.size());
    assertSame(copy, copy.iterator().next().member);
  }

  /*
   * The behavior of toString() and iteration is tested by LinkedHashMultiset,
   * which shares a lot of code with HashMultiset and has deterministic
   * iteration order.
   */

    /*
     * We'll give ourselves a pass on testing all the possible ways of breaking the constraint,
     * because we know that newClassMap() is implemented using ConstrainedMap which is itself
     * well-tested. A purist would object to this, but what can I say, we're dirty cheaters.
     */
    map.put(Integer.class, new Integer(5));
    assertThrows(ClassCastException.class, () -> map.put(Double.class, new Long(42)));

        assertEquals(-1, ((QueryRescorerBuilder) result).windowSize().intValue());
    }

    public void test_evaluate_withComplexParams() {
        // Test with complex parameter map including nested structures
        final String testModelName = "complex_model";
        final int testWindowSize = 200;

        ComponentUtil.setFessConfig(new FessConfig.SimpleImpl() {
            @Override

 *       have, of returning a new, independent iterator
 * </ul>
 *
 * <p>Because of this situation, any public method accepting an iterable should invoke the {@code
 * iterator} method only once, and should be tested using this class. Exceptions to this rule should
 * be clearly documented.
 *
 * <p>Note that although your APIs should be liberal in what they accept, your methods which