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

@Test
public void forType_build() {
	// given:
	Mockito.when(this.applicationContext.getBean(FeignContext.class))
			.thenThrow(new ClosedFileSystemException()); // throw an unusual exception
															// in the
															// FeignClientFactoryBean
	final FeignClientBuilder.Builder builder = this.feignClientBuilder
			.forType(TestClient.class, "TestClient");

	// expect: 'the build will fail right after calling build() with the mocked
	// unusual exception'
	this.thrown.expect(Matchers.isA(ClosedFileSystemException.class));
	builder.build();
}
 

/**
 * 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
public void testCheckOpen() throws IOException {
  state.checkOpen(); // does not throw
  state.close();
  try {
    state.checkOpen();
    fail();
  } catch (ClosedFileSystemException expected) {
  }
}
 

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

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

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

@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 checkClosed() {
  if(closed) throw new ClosedFileSystemException();
}
 

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

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

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