Java 类java.nio.file.ClosedFileSystemException 实例源码

void test(boolean withOption) {
    System.err.println("Testing " + (withOption ? "with" : "without") + " option");
    try {
        String dump = "";
        RootDoc root = getRootDoc(withOption);
        for (ClassDoc cd: root.specifiedClasses()) {
            dump += dump(cd);
        }
        if (dump.contains("lib.Lib2.i")) {
            if (!withOption) {
                error("control case failed: Lib2 class file was read, unexpectedly, without using option");
            }
        } else {
            if (withOption) {
                error("test case failed: could not read Lib2 class file, using option");
            }
        }
    } catch (ClosedFileSystemException e) {
        error("Unexpected exception: " + e);
    }
    System.err.println();
}

void test(boolean withOption) {
    System.err.println("Testing " + (withOption ? "with" : "without") + " option");
    try {
        RootDoc root = getRootDoc(withOption);
        for (ClassDoc cd: root.specifiedClasses()) {
            dump("", cd);
        }
        if (!withOption) {
            error("expected option did not occur");
        }
    } catch (ClosedFileSystemException e) {
        if (withOption) {
            error("Unexpected exception: " + e);
        } else {
            System.err.println("Exception received as expected: " + e);
        }
    }
    System.err.println();
}

@Test
public void testCloseWillThrowAnExceptionForSubsequentCalls() throws IOException {
    context.checking(new Expectations() {{
        allowing(cloudHostSettings).getName();
        will(returnValue("unit-test"));

        exactly(1).of(blobStoreContext).close();
    }});

    impl.close();
    Assert.assertFalse(impl.isOpen());

    try {
        impl.getBlobStoreContext();
        Assert.fail("Expected an exception");
    } catch (ClosedFileSystemException e) {
        // OK
    }
}

@Override
public void close(String runID) throws InvalidRunIdException, InvalidExecutionIdException {
    Run run = getRun(runID);
    try {
        Bundle dataBundle = run.getDataBundle();
        DataBundles.closeBundle(dataBundle);
    } catch (IOException | ClosedFileSystemException e) {
        logger.log(Level.WARNING, "Error closing data bundle for run " + runID, e);
    }
    runMap.remove(runID);
    postEvent(RUN_CLOSED, runID);
}

/**
 * Thread-safe ClosedFileSystemException test
 * 
 * @return
 */
protected FileSystem getOrigFS() {
    FileSystem orig = origFS;
    if (orig == null || !orig.isOpen()) {
        throw new ClosedFileSystemException();
    }
    return orig;
}

@Override
public Set<String> supportedFileAttributeViews() {
    if (origFS == null) {
        throw new ClosedFileSystemException();
    }
    return origFS.supportedFileAttributeViews();
}

@Test( expected = ClosedFileSystemException.class )
@Category( Closable.class )
public void testClosedFSnewByteChannel() throws Exception {
    getClosedFS();

    FS.provider().newByteChannel( getClosedFileA(), Sets.asSet( READ ) );
}

@Test
public void testCheckOpen() throws IOException {
  state.checkOpen(); // does not throw
  state.close();
  try {
    state.checkOpen();
    fail();
  } catch (ClosedFileSystemException expected) {
  }
}

@Test
public void shouldFindDescendantExceptionMapperFromException() throws Exception {
    Optional<JsonApiExceptionMapper> mapper = exceptionMapperRegistry.findMapperFor(ClosedFileSystemException.class);
    assertThat(mapper.isPresent()).isTrue();
    assertThat(mapper.get()).isExactlyInstanceOf(IllegalStateExceptionMapper.class);
}

void run() throws Exception {
    ToolBox tb = new ToolBox();
    Path jar = createJar(tb);

    Path src = Paths.get("src");
    tb.writeJavaFiles(src, "class C { p1.C1 c1; }");

    JavaCompiler comp = ToolProvider.getSystemJavaCompiler();
    PrintWriter out = new PrintWriter(System.err, true);
    StandardJavaFileManager fm = comp.getStandardFileManager(null, null, null);
    List<String> options = Arrays.asList("-classpath", jar.toString(), "-proc:none");
    Iterable<? extends JavaFileObject> files = fm.getJavaFileObjects(src.resolve("C.java"));
    com.sun.source.util.JavacTask task =
            (com.sun.source.util.JavacTask) comp.getTask(out, fm, null, options, null, files);
    task.parse();

    Elements elems = task.getElements();

    try {
        // Use  p1, p1.C1 as a control to verify normal behavior
        PackageElement p1 = elems.getPackageElement("p1");
        TypeElement p1C1 = elems.getTypeElement("p1.C1");
        System.err.println("p1: " + p1 + ";  p1C1: " + p1C1);
        if (p1C1 == null) {
            throw new Exception("p1.C1 not found");
        }

        // Now repeat for p2, p2.C2, closing the file manager early
        PackageElement p2 = elems.getPackageElement("p2");
        System.err.println("closing file manager");
        fm.close();
        TypeElement p2C2 = elems.getTypeElement("p2.C2");
        System.err.println("p2: " + p2 + ";  p2C2: " + p2C2);
        if (p2C2 != null) {
            throw new Exception("p2.C2 found unexpectedly");
        }
    } catch (ClosedFileSystemException e) {
        throw new Exception("unexpected exception thrown", e);
    }

}

final void ensureOpen() throws IOException {
    if (!isOpen()) {
        throw new ClosedFileSystemException();
    }
}

final void ensureOpen() throws IOException {
    if (!isOpen()) {
        throw new ClosedFileSystemException();
    }
}

void checkClosed() throws ClosedFileSystemException {
    if (closed.get()) {
        throw new ClosedFileSystemException();
    }
}

@Test
public void shouldFindDescendantExceptionMapperFromException() throws Exception {
    Optional<JsonApiExceptionMapper> mapper = exceptionMapperRegistry.findMapperFor(ClosedFileSystemException.class);
    assertThat(mapper.isPresent()).isTrue();
    assertThat(mapper.get()).isExactlyInstanceOf(IllegalStateExceptionMapper.class);
}

private void checkClosed() {
  if(closed) throw new ClosedFileSystemException();
}

private void checkClosed() {
  if(closed) throw new ClosedFileSystemException();
}

private void ensureOpen() throws IOException {
    if (!isOpen) {
        throw new ClosedFileSystemException();
    }
}

private void checkClosed() {
  if(closed) throw new ClosedFileSystemException();
}

private void checkClosed() {
  if(closed) throw new ClosedFileSystemException();
}

private void ensureOpen() throws IOException {
    if (!isOpen)
        throw new ClosedFileSystemException();
}

@Test( expected = ClosedFileSystemException.class )
@Category( Closable.class )
public void testClosedFSCantRead() throws Exception {
    Files.readAllBytes( getClosedFileA() );
}

@Test( expected = ClosedFileSystemException.class )
@Category( Closable.class )
public void testClosedFSCantReadDir() throws Exception {
    Files.newDirectoryStream( getClosedDirB() );
}

@Test( expected = ClosedFileSystemException.class )
@Category( Closable.class )
public void testClosedFSGetBasicFileAttributeViewProvider() throws IOException {
    getClosedFS();
    FS.provider().getFileAttributeView( getClosedFileA(), BasicFileAttributeView.class );
}

@Test( expected = ClosedFileSystemException.class )
@Category( Closable.class )
public void testClosedFSCreateDirectoryOtherProvider() throws IOException {
    getClosedFSProvider().createDirectory( getClosedFileA() );
}

@Test( expected = ClosedFileSystemException.class )
@Category({ Closable.class, FileChannelT.class })
public void testClosedFSNewFileChannel() throws IOException {
    getClosedFSProvider().newFileChannel( getClosedFileA(), Collections.<OpenOption> emptySet() );
}

@Test( expected = ClosedFileSystemException.class )
@Category( Closable.class )
public void testClosedFSCheckAccess() throws IOException {
    getClosedFS();
    FS.provider().checkAccess( getClosedFileA() );
}

@Test( expected = ClosedFileSystemException.class )
@Category({ Closable.class, Writable.class })
public void testCopyFromClosedFS() throws IOException {
    getClosedFSProvider().copy( getClosedFileA(), dirTA() );
}

@Test( expected = ClosedFileSystemException.class )
@Category({ Closable.class, Writable.class })
public void testCopyToClosedFS() throws IOException {
    getClosedFSProvider().copy( fileTA(), getClosedFileA() );
}

@Test( expected = ClosedFileSystemException.class )
@Category({ Closable.class, Writable.class, Move.class })
public void testMoveToClosedFS() throws IOException {
    getClosedFSProvider().move( fileTA(), getClosedFileA() );
}

@Test( expected = ClosedFileSystemException.class )
@Category( Closable.class )
public void testClosedFSCreateHardLink() throws IOException {
    getClosedFSProvider().createLink( getClosedFileA(), getClosedFileA() );
}

@Test( expected = ClosedFileSystemException.class )
@Category( Closable.class )
public void testClosedFSDelete() throws IOException {
    getClosedFSProvider().delete( getClosedFileA() );
}

@Test( expected = ClosedFileSystemException.class )
@Category( Closable.class )
public void testClosedFSGetFileStore() throws IOException {
    getClosedFSProvider().getFileStore( getClosedFileA() );
}

@Test( expected = ClosedFileSystemException.class )
@Category( Closable.class )
public void testClosedFSIsHidden() throws IOException {
    getClosedFSProvider().isHidden( getClosedFileA() );
}

@Test( expected = ClosedFileSystemException.class )
@Category( Closable.class )
public void testClosedFSNewInputStream() throws IOException {
    getClosedFSProvider().newOutputStream( getClosedFileA() );
}

@Test( expected = ClosedFileSystemException.class )
@Category( Closable.class )
public void testClosedFSNewOutputStream() throws IOException {
    getClosedFSProvider().newOutputStream( getClosedFileA() );
}

@Test( expected = ClosedFileSystemException.class )
@Category( Closable.class )
public void testClosedFSReadAttributes() throws IOException {
    getClosedFSProvider().readAttributes( getClosedFileA(), BasicFileAttributes.class );
}

@Test( expected = ClosedFileSystemException.class )
@Category( Closable.class )
public void testClosedFSReadAttributesString() throws IOException {
    getClosedFSProvider().readAttributes( getClosedFileA(), "*" );
}

@Test( expected = ClosedFileSystemException.class )
@Category( Closable.class )
public void testAppendFilesInClosedFSThrows() throws IOException {
    Files.write( getClosedFileA(), CONTENT_OTHER, APPEND );
}

/**
 * Checks that the file system is open, throwing {@link ClosedFileSystemException} if it is not.
 */
public void checkOpen() {
  if (!open.get()) {
    throw new ClosedFileSystemException();
  }
}

/**
 * Returns the total capacity of the share represented by this {@link SMBFileStore} instance.
 *
 * @return  Total capacity of the share represented by this {@link SMBFileStore} instance
 * @throws IOException If total capacity cannot be determined.
 */
@Override
public long getTotalSpace() throws IOException {
    if (!this.fileSystem.isOpen()) throw new ClosedFileSystemException();
    return new SmbFile(this.name()).length();
}