implements TestSetGenerator<E> {

  ReserializingTestSetGenerator(TestSetGenerator<E> delegate) {
    super(delegate);
  }

  public static <E> TestSetGenerator<E> newInstance(TestSetGenerator<E> delegate) {
    return new ReserializingTestSetGenerator<>(delegate);
  }

  @Override
  public Set<E> create(Object... elements) {
    return (Set<E>) super.create(elements);
  }

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;

class SettingsTest {

    @Test
    void testSetLocalRepository() {
        Settings s = Settings.newInstance();

        s = s.withLocalRepository("xxx");
        assertEquals("xxx", s.getLocalRepository());

        s = s.withLocalRepository("yyy");
        assertEquals("yyy", s.getLocalRepository());

                            handlerClass = ClassLoader.getSystemClassLoader().loadClass(className);
                        }
                        handler = (URLStreamHandler) handlerClass.newInstance();
                        break;
                    }
                    catch ( Exception ex ) {
                        log.debug("Failed to initialize handler " + className, ex);
                    }

    String className = prefix + queueType + "BlockingQueue";
    Constructor<?> constructor = Class.forName(className).getConstructor(int.class);
    queue = (BlockingQueue<String>) constructor.newInstance(capacity);

    strings = new String[capacity];
    for (int i = 0; i < capacity; i++) {
      strings[i] = String.valueOf(Math.random());
    }
  }

  @Benchmark
  void addsAndRemoves(int reps) {

      return (paddingChar == null) ? this : newInstance(alphabet, null);
    }

    @Override
    public BaseEncoding withPadChar(char padChar) {
      if (8 % alphabet.bitsPerChar == 0
          || (paddingChar != null && paddingChar.charValue() == padChar)) {
        return this;
      } else {
        return newInstance(alphabet, padChar);
      }
    }

    @Override

    }

    @Override
    protected <RESULT extends Group> RESULT createEntity(final Map<String, Object> source, final Class<? extends RESULT> entityType) {
        try {
            final RESULT result = entityType.newInstance();
            result.setName(DfTypeUtil.toString(source.get("name")));
            result.setAttributes(source.entrySet().stream().filter(e -> !"name".equals(e.getKey()))

        // convert to a collection first then convert that into an array
        final Collection<?> collection = parseCollection(parser, toType);
        final Object array = Array.newInstance(toType.getRawType(), collection.size());

        int i = 0;
        for (final Object element : collection) {
            Array.set(array, i++, element);
        }

        return array;
    }

     *             このコンストラクタが列挙型に関連している場合
     * @see Constructor#newInstance(Object[])
     */
    public static <T> T newInstance(final Class<T> clazz) throws InstantiationRuntimeException, IllegalAccessRuntimeException {
        assertArgumentNotNull("clazz", clazz);

        try {
            return clazz.newInstance();
        } catch (final InstantiationException e) {

  ) {
    responder(Request(network, domain, nsType, flags, callback))
  }

  companion object {
    @Implementation
    @JvmStatic
    fun getInstance(): DnsResolver = Shadow.newInstance(DnsResolver::class.java, arrayOf(), arrayOf())
  }

     * {@link SAXParserFactoryUtil#setXIncludeAware}のテストです。
     *
     * @throws Exception
     */
    public void testSetXIncludeAware() throws Exception {
        final SAXParserFactory spf = SAXParserFactoryUtil.newInstance();
        SAXParserFactoryUtil.setXIncludeAware(spf, true);
        spf.setNamespaceAware(true);
        final SAXParser parser = SAXParserFactoryUtil.newSAXParser(spf);