*
     * @return 新しい {@link DocumentBuilderFactory}のインスタンス
     */
    public static DocumentBuilderFactory newInstance() {
        return newInstance(false);
    }

    public static DocumentBuilderFactory newInstance(final boolean external) {
        final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        if (!external) {
            try {

    public GradleDocumentationExtension(ObjectFactory objects) {
        releaseNotes = objects.newInstance(ReleaseNotes.class);
        userManual = objects.newInstance(UserManual.class);
        dslReference = objects.newInstance(DslReference.class);
        javadocs = objects.newInstance(Javadocs.class);
        kotlinDslReference = objects.newInstance(KotlinDslReference.class);
    }

    /**

        root.documentElement
    }

    Node emptyDoc() {
        root = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument()
    }

    void write(File destFile, boolean indent = false) {
        destFile.withOutputStream { OutputStream stream ->
            TransformerFactory factory = TransformerFactory.newInstance()
            Transformer transformer = factory.newTransformer()
            if (indent) {

            + "  </dependencyManagement>\n"
            + "</project>\n";

    @Test
    void testCycleInImports() throws Exception {
        ModelBuilder builder = new DefaultModelBuilderFactory().newInstance();
        assertNotNull(builder);

        DefaultModelBuildingRequest request = new DefaultModelBuildingRequest();
        request.setModelSource(new StringModelSource(BASE1));

    }

    @Test
    void testOneProblem() {
        ProblemCollector problemCollector = ProblemCollectorFactory.newInstance(null);
        problemCollector.add(Problem.Severity.ERROR, "MESSAGE", 3, 5, new Exception());
        ToolchainsBuildingException e = new ToolchainsBuildingException(problemCollector.getProblems());
        assertEquals(

    }

    @Test
    void testV4ModelPriority() {
        Model m = model.withBuild(Build.newInstance()
                .withPlugins(Collections.singleton(Plugin.newInstance()
                        .withExecutions(Collections.singleton(
                                PluginExecution.newInstance().withPriority(5))))));
        assertEquals("4.0.0", new MavenModelVersion().getModelVersion(m));
    }

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

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

class ProblemCollectorFactoryTest {

    @Test
    void testNewInstance() {
        ProblemCollector collector1 = ProblemCollectorFactory.newInstance(null);

        Problem problem = new DefaultProblem("MESSAGE1", null, null, -1, -1, null);
        ProblemCollector collector2 = ProblemCollectorFactory.newInstance(Collections.singletonList(problem));

        assertNotSame(collector1, collector2);
        assertEquals(0, collector1.getProblems().size());

        assertArgumentNotNull("array", array);

        final int length = array.length;
        @SuppressWarnings("unchecked")
        final T[] newArray = (T[]) Array.newInstance(array.getClass().getComponentType(), length + 1);
        System.arraycopy(array, 0, newArray, 0, length);
        newArray[length] = obj;
        return newArray;
    }

    /**

        return newW3cXmlSchemaFactory(false);
    }

    public static SchemaFactory newW3cXmlSchemaFactory(final boolean external) {
        final SchemaFactory schemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
        if (!external) {
            disableExternalResources(schemaFactory);
        }
        return schemaFactory;
    }

    /**