MultiReader(Iterator<? extends CharSource> readers) throws IOException {
    this.it = readers;
    advance();
  }

  /** Closes the current reader and opens the next one, if any. */
  private void advance() throws IOException {
    close();
    if (it.hasNext()) {
      current = it.next().openStream();
    }
  }

  @Override
  public int read(char[] cbuf, int off, int len) throws IOException {
    checkNotNull(cbuf);

  }

  @Override
  protected void tearDown() throws Exception {
    classReloader.close();
    Thread.currentThread().setContextClassLoader(oldClassLoader);
    System.clearProperty("guava.concurrent.generate_cancellation_cause");
  }

  public void testCancel_notDoneNoInterrupt() throws Exception {
    Future<?> future = newFutureInstance();
    assertTrue(future.cancel(false));

  }

  @Override
  protected void tearDown() throws Exception {
    classReloader.close();
    Thread.currentThread().setContextClassLoader(oldClassLoader);
    System.clearProperty("guava.concurrent.generate_cancellation_cause");
  }

  public void testCancel_notDoneNoInterrupt() throws Exception {
    Future<?> future = newFutureInstance();
    assertTrue(future.cancel(false));

     *
     * @param model the input model
     * @return the transformed model, or the input model if no transformation is needed
     * @throws ModelTransformerException
     */
    @Nonnull
    default Model transformFileModel(@Nonnull Model model) throws ModelTransformerException {
        return model;
    }

    /**
     * Apply a transformation on the raw models.
     *

 *
 */
public class ByteConversionUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testToByte() throws Exception {
        assertEquals(new Byte("100"), ByteConversionUtil.toByte("100"));
    }

    /**
     * @throws Exception
     */
    public void testToPrimitiveByte() throws Exception {
        assertEquals(100, ByteConversionUtil.toPrimitiveByte("100"));
    }

 *
 */
public class DoubleConversionUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testToDouble() throws Exception {
        assertEquals(new Double("1000.5"), DoubleConversionUtil.toDouble("1,000.5"));
    }

    /**
     * @throws Exception
     */
    public void testToPrimitiveDouble() throws Exception {
        assertEquals(1000.5, DoubleConversionUtil.toPrimitiveDouble("1,000.5"), 0);

 *
 */
public class FloatConversionUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testToFloat() throws Exception {
        assertEquals(new Float("1000.5"), FloatConversionUtil.toFloat("1,000.5"));
    }

    /**
     * @throws Exception
     */
    public void testToPrimitiveFloat() throws Exception {
        assertEquals(1000.5, FloatConversionUtil.toPrimitiveFloat("1,000.5"), 0);

        return this.nscl.getNodeStatus(nbtAddress);
    }


    @Override
    public NetbiosAddress getNbtByName ( String host ) throws UnknownHostException {
        return this.nscl.getNbtByName(host);
    }


    @Override
    public NetbiosAddress getNbtByName ( String host, int type, String scope ) throws UnknownHostException {

            throws ArtifactResolutionException, ArtifactNotFoundException {
        for (ArtifactTransformation transform : artifactTransformations) {
            transform.transformForResolve(artifact, remoteRepositories, localRepository);
        }
    }

    public void transformForInstall(Artifact artifact, ArtifactRepository localRepository)
            throws ArtifactInstallationException {

        return artifact;
    }

    private Artifact createTestArtifact(String directory, String type) throws IOException {
        return createTestArtifact(directory, "1.0", type);
    }

    private Artifact createTestArtifact(String directory, String version, String type) throws IOException {
        File testData = getTestFile(directory);
        FileUtils.deleteDirectory(testData);
        testData.mkdirs();