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

/**
 */
@Named("test")
@Singleton
public class TestRepositoryConnectorFactory implements RepositoryConnectorFactory {

    @Override
    public RepositoryConnector newInstance(RepositorySystemSession session, RemoteRepository repository)
            throws NoRepositoryConnectorException {
        return new TestRepositoryConnector(repository);
    }

    @Override

 *     fieldDesc.getFieldValue(foo); // Retrieve the value of Foo's field
 * }
 *
 * for (ConstructorDesc constructorDesc : beanDesc.getConstructorDescs()) {
 *     constructorDesc.newInstance(...); // Create an instance of Foo
 * }
 *
 * for (String methodName : beanDesc.getMethodNames()) {
 *     for (MethodDesc methodDesc : beanDesc.getMethodDescs(methodName)) {

    }

    @Override
    protected <RESULT extends Role> 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()))

    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) {

        // 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;
    }

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

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

    public void configure(Binder binder) {
        if (plugin.getKey() != null) {
            XmlNode configuration = plugin.getConfiguration();
            if (configuration == null) {
                configuration = XmlNode.newInstance("configuration");
            }
            binder.bind(XmlNode.class)
                    .annotatedWith(Names.named(plugin.getKey()))
                    .toInstance(configuration);

     * {@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);

        System.out.format("=> source %s%n", source);
        System.out.format("=> dest %s%n", dest);
        System.out.format("=> destDir %s%n", destDir);

        TransformerFactory factory = TransformerFactory.newInstance();
        Transformer transformer = factory.newTransformer(new StreamSource(stylesheet));

        System.out.format("=> transformer %s (%s)%n", transformer, transformer.getClass().getName());