commons-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mart...@apache.org
Subject cvs commit: jakarta-commons/io/src/test/org/apache/commons/io/output DeferredFileOutputStreamTest.java
Date Sun, 01 Feb 2004 07:37:36 GMT
martinc     2004/01/31 23:37:36

  Modified:    io       project.xml
  Added:       io/src/java/org/apache/commons/io/output
                        DeferredFileOutputStream.java
                        ThresholdingOutputStream.java
               io/src/test/org/apache/commons/io/output
                        DeferredFileOutputStreamTest.java
  Log:
  Add ThresholdingOutputStream and DeferredFileOutputStream, along with tests
  for the latter. (There are no tests for the former, since it is an abstract
  class.) These classes originated in Commons FileUpload (and will continue
  to exist there as well, until IO gets to an official release).
  
  Revision  Changes    Path
  1.21      +10 -0     jakarta-commons/io/project.xml
  
  Index: project.xml
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/io/project.xml,v
  retrieving revision 1.20
  retrieving revision 1.21
  diff -u -r1.20 -r1.21
  --- project.xml	30 Jan 2004 04:14:24 -0000	1.20
  +++ project.xml	1 Feb 2004 07:37:36 -0000	1.21
  @@ -104,6 +104,16 @@
               </roles>
           </developer>
   
  +        <developer>
  +            <name>Martin Cooper</name>
  +            <id>martinc</id>
  +            <email>martinc@apache.org</email>
  +            <organization/>
  +            <roles>
  +                <role>Java Developer</role>
  +            </roles>
  +        </developer>
  +
       </developers>
   
       <contributors>
  
  
  
  1.1                  jakarta-commons/io/src/java/org/apache/commons/io/output/DeferredFileOutputStream.java
  
  Index: DeferredFileOutputStream.java
  ===================================================================
  /*
   * $Header: /home/cvs/jakarta-commons/io/src/java/org/apache/commons/io/output/DeferredFileOutputStream.java,v
1.1 2004/02/01 07:37:36 martinc Exp $
   * $Revision: 1.1 $
   * $Date: 2004/02/01 07:37:36 $
   *
   * ====================================================================
   *
   * The Apache Software License, Version 1.1
   *
   * Copyright (c) 2001-2003 The Apache Software Foundation.  All rights
   * reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   *
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in
   *    the documentation and/or other materials provided with the
   *    distribution.
   *
   * 3. The end-user documentation included with the redistribution, if
   *    any, must include the following acknowledgement:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowledgement may appear in the software itself,
   *    if and wherever such third-party acknowledgements normally appear.
   *
   * 4. The names "The Jakarta Project", "Commons", and "Apache Software
   *    Foundation" must not be used to endorse or promote products derived
   *    from this software without prior written permission. For written
   *    permission, please contact apache@apache.org.
   *
   * 5. Products derived from this software may not be called "Apache"
   *    nor may "Apache" appear in their names without prior written
   *    permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
   * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
   * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   * ====================================================================
   *
   * This software consists of voluntary contributions made by many
   * individuals on behalf of the Apache Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   *
   */
  
  
  package org.apache.commons.io.output;
  
  import java.io.ByteArrayOutputStream;
  import java.io.File;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.OutputStream;
  
  /**
   * <p>An output stream which will retain data in memory until a specified
   * threshold is reached, and only then commit it to disk. If the stream is
   * closed before the threshold is reached, the data will not be written to
   * disk at all.</p>
   *
   * @author <a href="mailto:martinc@apache.org">Martin Cooper</a>
   *
   * @version $Id: DeferredFileOutputStream.java,v 1.1 2004/02/01 07:37:36 martinc Exp $
   */
  public class DeferredFileOutputStream
      extends ThresholdingOutputStream
  {
  
      // ----------------------------------------------------------- Data members
  
  
      /**
       * The output stream to which data will be written prior to the theshold
       * being reached.
       */
      private ByteArrayOutputStream memoryOutputStream;
  
  
      /**
       * The output stream to which data will be written after the theshold is
       * reached.
       */
      private FileOutputStream diskOutputStream;
  
  
      /**
       * The output stream to which data will be written at any given time. This
       * will always be one of <code>memoryOutputStream</code> or
       * <code>diskOutputStream</code>.
       */
      private OutputStream currentOutputStream;
  
  
      /**
       * The file to which output will be directed if the threshold is exceeded.
       */
      private File outputFile;
  
  
      // ----------------------------------------------------------- Constructors
  
  
      /**
       * Constructs an instance of this class which will trigger an event at the
       * specified threshold, and save data to a file beyond that point.
       *
       * @param threshold  The number of bytes at which to trigger an event.
       * @param outputFile The file to which data is saved beyond the threshold.
       */
      public DeferredFileOutputStream(int threshold, File outputFile)
      {
          super(threshold);
          this.outputFile = outputFile;
  
          memoryOutputStream = new ByteArrayOutputStream(threshold);
          currentOutputStream = memoryOutputStream;
      }
  
  
      // --------------------------------------- ThresholdingOutputStream methods
  
  
      /**
       * Returns the current output stream. This may be memory based or disk
       * based, depending on the current state with respect to the threshold.
       *
       * @return The underlying output stream.
       *
       * @exception IOException if an error occurs.
       */
      protected OutputStream getStream() throws IOException
      {
          return currentOutputStream;
      }
  
  
      /**
       * Switches the underlying output stream from a memory based stream to one
       * that is backed by disk. This is the point at which we realise that too
       * much data is being written to keep in memory, so we elect to switch to
       * disk-based storage.
       *
       * @exception IOException if an error occurs.
       */
      protected void thresholdReached() throws IOException
      {
          byte[] data = memoryOutputStream.toByteArray();
          FileOutputStream fos = new FileOutputStream(outputFile);
          fos.write(data);
          diskOutputStream = fos;
          currentOutputStream = fos;
          memoryOutputStream = null;
      }
  
  
      // --------------------------------------------------------- Public methods
  
  
      /**
       * Determines whether or not the data for this output stream has been
       * retained in memory.
       *
       * @return <code>true</code> if the data is available in memory;
       *         <code>false</code> otherwise.
       */
      public boolean isInMemory()
      {
          return (!isThresholdExceeded());
      }
  
  
      /**
       * Returns the data for this output stream as an array of bytes, assuming
       * that the data has been retained in memory. If the data was written to
       * disk, this method returns <code>null</code>.
       *
       * @return The data for this output stream, or <code>null</code> if no such
       *         data is available.
       */
      public byte[] getData()
      {
          if (memoryOutputStream != null)
          {
              return memoryOutputStream.toByteArray();
          }
          return null;
      }
  
  
      /**
       * Returns the data for this output stream as a <code>File</code>, assuming
       * that the data was written to disk. If the data was retained in memory,
       * this method returns <code>null</code>.
       *
       * @return The file for this output stream, or <code>null</code> if no such
       *         file exists.
       */
      public File getFile()
      {
          return outputFile;
      }
  }
  
  
  
  1.1                  jakarta-commons/io/src/java/org/apache/commons/io/output/ThresholdingOutputStream.java
  
  Index: ThresholdingOutputStream.java
  ===================================================================
  /*
   * $Header: /home/cvs/jakarta-commons/io/src/java/org/apache/commons/io/output/ThresholdingOutputStream.java,v
1.1 2004/02/01 07:37:36 martinc Exp $
   * $Revision: 1.1 $
   * $Date: 2004/02/01 07:37:36 $
   *
   * ====================================================================
   *
   * The Apache Software License, Version 1.1
   *
   * Copyright (c) 2001-2003 The Apache Software Foundation.  All rights
   * reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   *
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in
   *    the documentation and/or other materials provided with the
   *    distribution.
   *
   * 3. The end-user documentation included with the redistribution, if
   *    any, must include the following acknowledgement:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowledgement may appear in the software itself,
   *    if and wherever such third-party acknowledgements normally appear.
   *
   * 4. The names "The Jakarta Project", "Commons", and "Apache Software
   *    Foundation" must not be used to endorse or promote products derived
   *    from this software without prior written permission. For written
   *    permission, please contact apache@apache.org.
   *
   * 5. Products derived from this software may not be called "Apache"
   *    nor may "Apache" appear in their names without prior written
   *    permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
   * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
   * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   * ====================================================================
   *
   * This software consists of voluntary contributions made by many
   * individuals on behalf of the Apache Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   *
   */
  
  
  package org.apache.commons.io.output;
  
  import java.io.IOException;
  import java.io.OutputStream;
  
  
  /**
   * An output stream which triggers an event when a specified number of bytes of
   * data have been written to it. The event can be used, for example, to throw
   * an exception if a maximum has been reached, or to switch the underlying
   * stream type when the threshold is exceeded.
   * <p>
   * This class overrides all <code>OutputStream</code> methods. However, these
   * overrides ultimately call the corresponding methods in the underlying output
   * stream implementation.
   * <p>
   * NOTE: This implementation may trigger the event <em>before</em> the threshold
   * is actually reached, since it triggers when a pending write operation would
   * cause the threshold to be exceeded.
   *
   * @author <a href="mailto:martinc@apache.org">Martin Cooper</a>
   *
   * @version $Id: ThresholdingOutputStream.java,v 1.1 2004/02/01 07:37:36 martinc Exp $
   */
  public abstract class ThresholdingOutputStream
      extends OutputStream
  {
  
      // ----------------------------------------------------------- Data members
  
  
      /**
       * The threshold at which the event will be triggered.
       */
      private int threshold;
  
  
      /**
       * The number of bytes written to the output stream.
       */
      private long written;
  
  
      /**
       * Whether or not the configured threshold has been exceeded.
       */
      private boolean thresholdExceeded;
  
  
      // ----------------------------------------------------------- Constructors
  
  
      /**
       * Constructs an instance of this class which will trigger an event at the
       * specified threshold.
       *
       * @param threshold The number of bytes at which to trigger an event.
       */
      public ThresholdingOutputStream(int threshold)
      {
          this.threshold = threshold;
      }
  
  
      // --------------------------------------------------- OutputStream methods
  
  
      /**
       * Writes the specified byte to this output stream.
       *
       * @param b The byte to be written.
       *
       * @exception IOException if an error occurs.
       */
      public void write(int b) throws IOException
      {
          checkThreshold(1);
          getStream().write(b);
          written++;
      }
  
  
      /**
       * Writes <code>b.length</code> bytes from the specified byte array to this
       * output stream.
       *
       * @param b The array of bytes to be written.
       *
       * @exception IOException if an error occurs.
       */
      public void write(byte b[]) throws IOException
      {
          checkThreshold(b.length);
          getStream().write(b);
          written += b.length;
      }
  
  
      /**
       * Writes <code>len</code> bytes from the specified byte array starting
at
       * offset <code>off</code> to this output stream.
       *
       * @param b   The byte array from which the data will be written.
       * @param off The start offset in the byte array.
       * @param len The number of bytes to write.
       *
       * @exception IOException if an error occurs.
       */
      public void write(byte b[], int off, int len) throws IOException
      {
          checkThreshold(len);
          getStream().write(b, off, len);
          written += len;
      }
  
  
      /**
       * Flushes this output stream and forces any buffered output bytes to be
       * written out.
       *
       * @exception IOException if an error occurs.
       */
      public void flush() throws IOException
      {
          getStream().flush();
      }
  
  
      /**
       * Closes this output stream and releases any system resources associated
       * with this stream.
       *
       * @exception IOException if an error occurs.
       */
      public void close() throws IOException
      {
          try
          {
              flush();
          }
          catch (IOException ignored)
          {
              // ignore
          }
          getStream().close();
      }
  
  
      // --------------------------------------------------------- Public methods
  
  
      /**
       * Returns the threshold, in bytes, at which an event will be triggered.
       *
       * @return The threshold point, in bytes.
       */
      public int getThreshold()
      {
          return threshold;
      }
  
  
      /**
       * Returns the number of bytes that have been written to this output stream.
       *
       * @return The number of bytes written.
       */
      public long getByteCount()
      {
          return written;
      }
  
  
      /**
       * Determines whether or not the configured threshold has been exceeded for
       * this output stream.
       *
       * @return <code>true</code> if the threshold has been reached;
       *         <code>false</code> otherwise.
       */
      public boolean isThresholdExceeded()
      {
          return (written > threshold);
      }
  
  
      // ------------------------------------------------------ Protected methods
  
  
      /**
       * Checks to see if writing the specified number of bytes would cause the
       * configured threshold to be exceeded. If so, triggers an event to allow
       * a concrete implementation to take action on this.
       *
       * @param count The number of bytes about to be written to the underlying
       *              output stream.
       *
       * @exception IOException if an error occurs.
       */
      protected void checkThreshold(int count) throws IOException
      {
          if (!thresholdExceeded && (written + count > threshold))
          {
              thresholdReached();
              thresholdExceeded = true;
          }
      }
  
  
      // ------------------------------------------------------- Abstract methods
  
  
      /**
       * Returns the underlying output stream, to which the corresponding
       * <code>OutputStream</code> methods in this class will ultimately delegate.
       *
       * @return The underlying output stream.
       *
       * @exception IOException if an error occurs.
       */
      protected abstract OutputStream getStream() throws IOException;
  
  
      /**
       * Indicates that the configured threshold has been reached, and that a
       * subclass should take whatever action necessary on this event. This may
       * include changing the underlying output stream.
       *
       * @exception IOException if an error occurs.
       */
      protected abstract void thresholdReached() throws IOException;
  }
  
  
  
  1.1                  jakarta-commons/io/src/test/org/apache/commons/io/output/DeferredFileOutputStreamTest.java
  
  Index: DeferredFileOutputStreamTest.java
  ===================================================================
  /*
   * $Header: /home/cvs/jakarta-commons/io/src/test/org/apache/commons/io/output/DeferredFileOutputStreamTest.java,v
1.1 2004/02/01 07:37:36 martinc Exp $
   * $Revision: 1.1 $
   * $Date: 2004/02/01 07:37:36 $
   *
   * ====================================================================
   *
   * The Apache Software License, Version 1.1
   *
   * Copyright (c) 2001-2003 The Apache Software Foundation.  All rights
   * reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   *
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in
   *    the documentation and/or other materials provided with the
   *    distribution.
   *
   * 3. The end-user documentation included with the redistribution, if
   *    any, must include the following acknowledgement:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowledgement may appear in the software itself,
   *    if and wherever such third-party acknowledgements normally appear.
   *
   * 4. The names "The Jakarta Project", "Commons", and "Apache Software
   *    Foundation" must not be used to endorse or promote products derived
   *    from this software without prior written permission. For written
   *    permission, please contact apache@apache.org.
   *
   * 5. Products derived from this software may not be called "Apache"
   *    nor may "Apache" appear in their names without prior written
   *    permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
   * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
   * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   * ====================================================================
   *
   * This software consists of voluntary contributions made by many
   * individuals on behalf of the Apache Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   *
   */
  
  
  package org.apache.commons.io.output;
  
  import junit.framework.TestCase;
  //import org.apache.commons.fileupload.DeferredFileOutputStream;
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.IOException;
  import java.util.Arrays;
  
  /**
   * Unit tests for the <code>DeferredFileOutputStream</code> class.
   *
   * @author <a href="mailto:martinc@apache.org">Martin Cooper</a>
   *
   * @version $Id: DeferredFileOutputStreamTest.java,v 1.1 2004/02/01 07:37:36 martinc Exp
$
   */
  public class DeferredFileOutputStreamTest extends TestCase
   {
  
      /**
       * The test data as a string (which is the simplest form).
       */
      private String testString = "0123456789";
  
      /**
       * The test data as a byte array, derived from the string.
       */
      private byte[] testBytes = testString.getBytes();
  
      /**
       * Standard JUnit test case constructor.
       *
       * @param name The name of the test case.
       */
      public DeferredFileOutputStreamTest(String name)
      {
          super(name);
      }
  
      /**
       * Tests the case where the amount of data falls below the threshold, and
       * is therefore confined to memory.
       */
      public void testBelowThreshold()
      {
          DeferredFileOutputStream dfos =
                  new DeferredFileOutputStream(testBytes.length + 42, null);
          try
          {
              dfos.write(testBytes, 0, testBytes.length);
              dfos.close();
          }
          catch (IOException e) {
              fail("Unexpected IOException");
          }
          assertTrue(dfos.isInMemory());
  
          byte[] resultBytes = dfos.getData();
          assertTrue(resultBytes.length == testBytes.length);
          assertTrue(Arrays.equals(resultBytes, testBytes));
      }
  
      /**
       * Tests the case where the amount of data is exactly the same as the
       * threshold. The behavior should be the same as that for the amount of
       * data being below (i.e. not exceeding) the threshold.
       */
      public void testAtThreshold() {
          DeferredFileOutputStream dfos =
                  new DeferredFileOutputStream(testBytes.length, null);
          try
          {
              dfos.write(testBytes, 0, testBytes.length);
              dfos.close();
          }
          catch (IOException e) {
              fail("Unexpected IOException");
          }
          assertTrue(dfos.isInMemory());
  
          byte[] resultBytes = dfos.getData();
          assertTrue(resultBytes.length == testBytes.length);
          assertTrue(Arrays.equals(resultBytes, testBytes));
      }
  
      /**
       * Tests the case where the amount of data exceeds the threshold, and is
       * therefore written to disk. The actual data written to disk is verified,
       * as is the file itself.
       */
      public void testAboveThreshold() {
          File testFile = new File("testAboveThreshold.dat");
  
          // Ensure that the test starts from a clean base.
          testFile.delete();
  
          DeferredFileOutputStream dfos =
                  new DeferredFileOutputStream(testBytes.length - 5, testFile);
          try
          {
              dfos.write(testBytes, 0, testBytes.length);
              dfos.close();
          }
          catch (IOException e) {
              fail("Unexpected IOException");
          }
          assertFalse(dfos.isInMemory());
          assertNull(dfos.getData());
  
          verifyResultFile(testFile);
  
          // Ensure that the test starts from a clean base.
          testFile.delete();
      }
  
      /**
       * Tests the case where there are multiple writes beyond the threshold, to
       * ensure that the <code>thresholdReached()</code> method is only called
       * once, as the threshold is crossed for the first time.
       */
      public void testThresholdReached() {
          File testFile = new File("testThresholdReached.dat");
  
          // Ensure that the test starts from a clean base.
          testFile.delete();
  
          DeferredFileOutputStream dfos =
                  new DeferredFileOutputStream(testBytes.length / 2, testFile);
          int chunkSize = testBytes.length / 3;
  
          try
          {
              dfos.write(testBytes, 0, chunkSize);
              dfos.write(testBytes, chunkSize, chunkSize);
              dfos.write(testBytes, chunkSize * 2,
                      testBytes.length - chunkSize * 2);
              dfos.close();
          }
          catch (IOException e) {
              fail("Unexpected IOException");
          }
          assertFalse(dfos.isInMemory());
          assertNull(dfos.getData());
  
          verifyResultFile(testFile);
  
          // Ensure that the test starts from a clean base.
          testFile.delete();
      }
  
      /**
       * Verifies that the specified file contains the same data as the original
       * test data.
       *
       * @param testFile The file containing the test output.
       */
      private void verifyResultFile(File testFile) {
          try
          {
              FileInputStream fis = new FileInputStream(testFile);
              assertTrue(fis.available() == testBytes.length);
  
              byte[] resultBytes = new byte[testBytes.length];
              assertTrue(fis.read(resultBytes) == testBytes.length);
  
              assertTrue(Arrays.equals(resultBytes, testBytes));
              assertTrue(fis.read(resultBytes) == -1);
  
              try
              {
                  fis.close();
              }
              catch (IOException e) {
                  // Ignore an exception on close
              }
          }
          catch (FileNotFoundException e) {
              fail("Unexpected FileNotFoundException");
          }
          catch (IOException e) {
              fail("Unexpected IOException");
          }
      }
  }
  
  
  

---------------------------------------------------------------------
To unsubscribe, e-mail: commons-dev-unsubscribe@jakarta.apache.org
For additional commands, e-mail: commons-dev-help@jakarta.apache.org


Mime
View raw message