SmbRandomAccessFile raf = newInstance("r", false, false, false);
        byte[] buf = new byte[4];
        assertEquals(0, raf.read(buf, 0, 0));
    }

    @Test
    @DisplayName("read(): returns -1 when underlying read reports EOF")
    void read_returnsMinusOne_onEOF() throws Exception {
        SmbRandomAccessFile raf = spy(newInstance("r", false, false, false));

     */
    public static DocumentBuilderFactory newInstance() {
        return newInstance(false);
    }

    /**
     * Returns a new instance of {@link DocumentBuilderFactory}.
     *
     * @param external
     *            If {@code true}, external access is allowed.
     * @return A new instance of {@link DocumentBuilderFactory}.
     */
    public static DocumentBuilderFactory newInstance(final boolean external) {

            Constructor<SmbComNtCancel> constructor = SmbComNtCancel.class.getDeclaredConstructor(Configuration.class, int.class);
            constructor.setAccessible(true);
            SmbComNtCancel cancel = constructor.newInstance(mockConfig, testMid);

            // Then
            assertNotNull(cancel);
            assertEquals(testMid, cancel.getMid());

            // Verify command is set correctly

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

    /**

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());

    }

    @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));
    }

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

    /**

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

        assertNotNull(exception1);
        assertEquals(message1, exception1.getMessage());
        assertNull(exception1.getCause());

        // Test with suppression disabled and writable stack trace
        String message2 = "Test with suppression disabled";
        CrawlerSystemException exception2 = constructor.newInstance(message2, false, true);