commons-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From m..@apache.org
Subject cvs commit: jakarta-commons/collections/src/test/org/apache/commons/collections TestBoundedFifoBuffer.java TestBoundedFifoBuffer2.java TestUnboundedFifoBuffer.java TestAll.java
Date Wed, 03 Jul 2002 01:57:08 GMT
mas         2002/07/02 18:57:08

  Modified:    collections/src/test/org/apache/commons/collections
                        TestAll.java
  Added:       collections/src/java/org/apache/commons/collections
                        BoundedFifoBuffer.java BufferUtils.java
                        UnboundedFifoBuffer.java
               collections/src/test/org/apache/commons/collections
                        TestBoundedFifoBuffer.java
                        TestBoundedFifoBuffer2.java
                        TestUnboundedFifoBuffer.java
  Log:
  Add Buffer implementations, utilities, and tests.
  
  BoundedFifoBuffer is renamed from Avalon's FixedSizeBuffer. Made it extend
  AbstractCollection, provided an iterator. Removed "final" from class and method
  declarations. Added javadoc.
  
  UnboundedFifoBuffer is renamed from Avalon's VariableSizeBuffer. Made it extend
  AbstractCollection, provided an iterator. Removed "final" from class and method
  delcarations. Added javadoc.
  
  BufferUtils provides Buffer decorators for synchronized, unmodifiable, and
  predicated Buffers.
  
  Revision  Changes    Path
  1.1                  jakarta-commons/collections/src/java/org/apache/commons/collections/BoundedFifoBuffer.java
  
  Index: BoundedFifoBuffer.java
  ===================================================================
  /*
   * Copyright (C) The Apache Software Foundation. All rights reserved.
   *
   * This software is published under the terms of the Apache Software License
   * version 1.1, a copy of which has been included with this distribution in
   * the LICENSE.txt file.
   */
  package org.apache.commons.collections;
  
  
  import java.util.AbstractCollection;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.NoSuchElementException;
  
  
  /**
   * The BoundedFifoBuffer is a <strong>very</strong> efficient implementation
of
   * Buffer that does not alter the size of the buffer at runtime.<P>
   *
   * The removal order of a <Code>BoundedFifoBuffer</Code> is based on the 
   * insertion order; elements are removed in the same order in which they
   * were added.  The iteration order is the same as the removal order.<P>
   *
   * The {@link add(Object}, {@link remove()} and {@link get()} operations
   * all perform in constant time.  All other operations perform in linear
   * time or worse.
   *
   * Note that this implementation is not synchronized.  The following can be
   * used to provide synchronized access to your <COde>BoundedFifoBuffer</Code>:
   *
   * <Pre>
   *   Buffer fifo = BufferUtils.synchronizedBuffer(new BoundedFifoBuffer());
   * </Pre>
   *
   * @author <a href="mailto:bloritsch@apache.org">Berin Loritsch</a>
   * @author Paul Jack
   * @version $Id: BoundedFifoBuffer.java,v 1.1 2002/07/03 01:57:08 mas Exp $
   */
  public class BoundedFifoBuffer extends AbstractCollection implements Buffer
  {
      private final Object[] m_elements;
      private int m_start = 0;
      private int m_end = 0;
      private boolean m_full = false;
  
  
      /**
       *  Constructs a new <Code>BoundedFifoBuffer</Code> big enough to hold
       *  the specified number of elements.
       *
       *  @param size  the maximum number of elements for this fifo
       */
      public BoundedFifoBuffer( int size )
      {
          m_elements = new Object[ size ];
      }
  
  
      /**
       *  Constructs a new <Code>BoundedFifoBuffer</Code> big enough to hold
       *  32 elements.
       */
      public BoundedFifoBuffer()
      {
          this( 32 );
      }
  
  
      /**
       *  Constructs a new <Code>BoundedFifoBuffer</Code> big enough to hold all
       *  of the elements in the specified collection.  That collection's
       *  elements will also be added to the fifo.
       *
       *  @param c  the collection whose elements to add
       */
      public BoundedFifoBuffer(Collection c) {
          this(c.size());
          addAll(c);
      }
  
  
      /**
       *  Returns this fifo's size.
       *
       *  @return this fifo's size
       */
      public int size()
      {
          int size = 0;
  
          if( m_end < m_start )
          {
              size = m_elements.length - m_start + m_end;
          }
          else if( m_end == m_start )
          {
              size = ( m_full ? m_elements.length : 0 );
          }
          else
          {
              size = m_end - m_start;
          }
  
          return size;
      }
  
  
      /**
       *  Returns true if this fifo is empty; false otherwise.
       *
       *  @return true if this fifo is empty
       */
      public boolean isEmpty()
      {
          return size() == 0;
      }
  
  
      /**
       *  Adds the given element to this fifo.
       *
       *  @param element  the element to add
       *  @return true, always
       *  @throws NullPointerException if the given element is null
       *  @throws BufferOverflowException if this fifo is full
       */
      public boolean add( Object element )
      {
          if( null == element )
          {
              throw new NullPointerException( "Attempted to add null object to buffer" );
          }
  
          if( m_full )
          {
              throw new BufferOverflowException( "The buffer cannot hold more than "
                                                 + m_elements.length + " objects." );
          }
  
          m_elements[ m_end++ ] = element;
  
          if( m_end >= m_elements.length )
          {
              m_end = 0;
          }
  
          if( m_end == m_start )
          {
              m_full = true;
          }
  
          return true;
      }
  
  
      /**
       *  Returns the least recently inserted element in this fifo.
       *
       *  @return the least recently inserted element
       *  @throws BufferUnderflowException if the fifo is empty
       */
      public Object get() {
          if( isEmpty() )
          {
              throw new BufferUnderflowException( "The buffer is already empty" );
          }
  
          return m_elements[ m_start ];
      }
  
  
      /**
       *  Removes the least recently inserted element from this fifo.
       *
       *  @return the least recently inserted element
       *  @throws BufferUnderflowException if the fifo is empty
       */
      public Object remove()
      {
          if( isEmpty() )
          {
              throw new BufferUnderflowException( "The buffer is already empty" );
          }
  
          Object element = m_elements[ m_start ];
  
          if( null != element )
          {
              m_elements[ m_start++ ] = null;
  
              if( m_start >= m_elements.length )
              {
                  m_start = 0;
              }
  
              m_full = false;
          }
  
          return element;
      }
  
  
      private int increment(int index) {
          index++; 
          if (index >= m_elements.length) index = 0;
          return index;
      }
  
  
      private int decrement(int index) {
          index--;
          if (index < 0) index = m_elements.length - 1;
          return index;
      }
  
  
      /**
       *  Returns an iterator over this fifo's elements.
       *
       *  @return an iterator over this fifo's elements
       */
      public Iterator iterator() {
          return new Iterator() {
  
              private int index = m_start;
              private int lastReturnedIndex = -1;
              private boolean isFirst = m_full;
  
              public boolean hasNext() {
                  return isFirst || (index != m_end);
                  
              }
  
              public Object next() {
                  if (!hasNext()) throw new NoSuchElementException();
                  isFirst = false;
                  lastReturnedIndex = index;
                  index = increment(index);
                  return m_elements[lastReturnedIndex];
              }
  
              public void remove() {
                  if (lastReturnedIndex == -1) throw new IllegalStateException();
  
                  // First element can be removed quickly
                  if (lastReturnedIndex == m_start) {
                      BoundedFifoBuffer.this.remove();
                      lastReturnedIndex = -1;
                      return;
                  }
  
                  // Other elements require us to shift the subsequent elements
                  int i = lastReturnedIndex + 1;
                  while (i != m_end) {
                      if (i >= m_elements.length) {
                          m_elements[i - 1] = m_elements[0];
                          i = 0;
                      } else {
                          m_elements[i - 1] = m_elements[i];
                          i++;
                      }
                  }
  
                  lastReturnedIndex = -1;
                  m_end = decrement(m_end);
                  m_elements[m_end] = null;
                  m_full = false;
                  index = decrement(index);
              }
  
          };
      }
  
  
      /**
       *  Clears this fifo.
       */
      public void clear() {
          m_full = false;
          m_start = 0;
          m_end = 0;
          Arrays.fill(m_elements, null);
      }
  
  }
  
  
  
  1.1                  jakarta-commons/collections/src/java/org/apache/commons/collections/BufferUtils.java
  
  Index: BufferUtils.java
  ===================================================================
  package org.apache.commons.collections;
  
  
  import java.util.Collection;
  import java.util.Iterator;
  
  
  /**
   *  Contains static utility methods for operating on {@link Buffer} objects.
   *
   *  @author Paul Jack
   *  @version $Id: BufferUtils.java,v 1.1 2002/07/03 01:57:08 mas Exp $
   */
  public class BufferUtils {
  
  
      /**
       *  Returns a synchronized buffer backed by the given buffer.
       *  Much like the synchronized collections returned by 
       *  {@link java.util.Collections}, you must manually synchronize on 
       *  the returned buffer's iterator to avoid non-deterministic behavior:
       *  
       *  <Pre>
       *  Buffer b = BufferUtils.synchronizedBuffer(myBuffer);
       *  synchronized (b) {
       *      Iterator i = b.iterator();
       *      while (i.hasNext()) {
       *          process (i.next());
       *      }
       *  }
       *  </Pre>
       *
       *  @param b  the buffer to synchronize
       *  @return  a synchronized buffer backed by that buffer
       */
      public static Buffer synchronizedBuffer(final Buffer b) {
          return new SynchronizedBuffer(b);
      }
  
  
      /**
       *  Returns a synchronized buffer backed by the given buffer that will
       *  block on {@link Buffer.get()} and {@link Buffer.remove()} operations.
       *  If the buffer is empty, then the {@link Buffer.get()} and 
       *  {@link Buffer.remove()} operations will block until new elements
       *  are added to the buffer, rather than immediately throwing a 
       *  <Code>BufferUnderflowException</Code>.
       *
       *  @param buf  the buffer to synchronize
       *  @return  a blocking buffer backed by that buffer
       */
      public static Buffer blockingBuffer(Buffer buf) {
          return new SynchronizedBuffer(buf) {
  
              public synchronized boolean add(Object o) {
                  boolean r = b.add(o);
                  notify();
                  return r;
              }
  
              public synchronized boolean addAll(Collection c) {
                  boolean r = b.addAll(c);
                  notifyAll();
                  return r;
              }
  
              public synchronized Object get() {
                  while (b.isEmpty()) {
                      try {
                          wait();
                      } catch (InterruptedException e) {
                          throw new BufferUnderflowException();
                      }
                  }
                  return b.get();
              }
  
              public synchronized Object remove() {
                  while (b.isEmpty()) {
                      try {
                          wait();
                      } catch (InterruptedException e) {
                          throw new BufferUnderflowException();
                      }
                  }
                  return b.remove();
              }
          };
      }
  
  
      private static class SynchronizedBuffer implements Buffer {
  
              Buffer b;
  
  
              public SynchronizedBuffer(Buffer b) {
                   this.b = b;
              }
  
              public synchronized int size() {
                  return b.size();
              }
  
              public synchronized boolean isEmpty() {
                  return b.isEmpty();
              }
  
              public synchronized boolean contains(Object o) {
                  return b.contains(o);
              }
  
              public Iterator iterator() {
                  return b.iterator();
              }
  
              public synchronized Object[] toArray() {
                  return b.toArray();
              }
  
              public synchronized Object[] toArray(Object[] o) {
                  return b.toArray(o);
              }
  
              public synchronized boolean add(Object o) {
                  return b.add(o);
              }
  
              public synchronized boolean remove(Object o) {
                  return b.remove(o);
              }
  
              public synchronized boolean containsAll(Collection c) {
                  return b.containsAll(c);
              }
  
              public synchronized boolean addAll(Collection c) {
                  return b.addAll(c);
              }
  
              public synchronized boolean removeAll(Collection c) {
                  return b.removeAll(c);
              }
  
              public synchronized boolean retainAll(Collection c) {
                  return b.retainAll(c);
              }
  
              public synchronized void clear() {
                  b.clear();
              }
  
              public synchronized boolean equals(Object o) {
                  return b.equals(o);
              }
  
              public synchronized int hashCode() {
                  return b.hashCode();
              }
  
              public synchronized String toString() {
                  return b.toString();
              }
  
              public synchronized Object get() {
                  return b.get();
              }
  
              public synchronized Object remove() {
                  return b.remove();
              }          
  
          
      }
  
  
      /**
       *  Returns an unmodifiable buffer backed by the given buffer.
       *
       *  @param b  the buffer to make unmodifiable
       *  @return  an unmodifiable buffer backed by that buffer
       */
      public static Buffer unmodifiableBuffer(Buffer b) {
          return new BufferDecorator(b) {
              public boolean addAll(Collection c) {
                  throw new UnsupportedOperationException();
              } 
  
              public boolean removeAll(Collection c) {
                  throw new UnsupportedOperationException();
              } 
  
              public boolean retainAll(Collection c) {
                  throw new UnsupportedOperationException();
              } 
  
              public boolean add(Object o) {
                  throw new UnsupportedOperationException();
              } 
  
              public boolean remove(Object o) {
                  throw new UnsupportedOperationException();
              } 
  
              public void clear() {
                  throw new UnsupportedOperationException();
              }
  
              public Object remove() {
                  throw new UnsupportedOperationException();
              }
          };
      }
  
  
      /**
       *  Returns a predicated buffer backed by the given buffer.  Elements are
       *  evaluated with the given predicate before being added to the buffer.
       *  If the predicate evaluation returns false, then an 
       *  IllegalArgumentException is raised and the element is not added to
       *  the buffer.
       *
       *  @param buf  the buffer to predicate
       *  @param p  the predicate used to evaluate new elements
       *  @return  a predicated buffer
       */
      public static Buffer predicatedBuffer(Buffer buf, final Predicate p) {
          if (buf == null) {
              throw new IllegalArgumentException("Buffer must not be null.");
          }
          if (p == null) {
              throw new IllegalArgumentException("Predicate must not be null.");
          }
          return new BufferDecorator(buf) {
  
              public boolean add(Object o) {
                  test(o);
                  return b.add(o);
              }
  
              public boolean addAll(Collection c) {
                  Iterator iterator = c.iterator();
                  while (iterator.hasNext()) {
                      test(iterator.next());
                  }
                  return b.addAll(c);
              }
  
              private void test(Object o) {
                  if (!p.evaluate(o)) {
                      throw new IllegalArgumentException("Invalid: " + o);
                  }
              }
          };
      }
  
  
      private static class BufferDecorator implements Buffer {
  
          Buffer b;
  
          BufferDecorator(Buffer b) {
              this.b = b;
          }
  
          public int size() {
              return b.size();
          }
  
          public boolean isEmpty() {
              return b.isEmpty();
          }
  
          public boolean contains(Object o) {
              return b.contains(o);
          }
  
          public Iterator iterator() {
              return b.iterator();
          }
  
          public Object[] toArray() {
              return b.toArray();
          }
  
          public Object[] toArray(Object[] o) {
              return b.toArray(o);
          }
  
          public boolean add(Object o) {
              return b.add(o);
          }
  
          public boolean remove(Object o) {
              return b.remove(o);
          }
  
          public boolean containsAll(Collection c) {
              return b.containsAll(c);
          }
  
          public boolean addAll(Collection c) {
              return b.addAll(c);
          }
  
          public boolean removeAll(Collection c) {
              return b.removeAll(c);
          }
  
          public boolean retainAll(Collection c) {
              return b.retainAll(c);
          }
  
          public void clear() {
              b.clear();
          }
  
          public boolean equals(Object o) {
              return b.equals(o);
          }
  
          public int hashCode() {
              return b.hashCode();
          }
  
          public String toString() {
              return b.toString();
          }
  
          public Object get() {
              return b.get();
          }
  
          public Object remove() {
              return b.remove();
          }
      }
  
  
  }
  
  
  
  1.1                  jakarta-commons/collections/src/java/org/apache/commons/collections/UnboundedFifoBuffer.java
  
  Index: UnboundedFifoBuffer.java
  ===================================================================
  /*
   * Copyright (C) The Apache Software Foundation. All rights reserved.
   *
   * This software is published under the terms of the Apache Software License
   * version 1.1, a copy of which has been included with this distribution in
   * the LICENSE.txt file.
   */
  package org.apache.commons.collections;
  
  
  import java.util.AbstractCollection;
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.NoSuchElementException;
  
  
  /**
   * UnboundedFifoBuffer is a <strong>very</strong> efficient buffer implementation.
   * According to performance testing, it exhibits a constant access time, but it
   * also outperforms ArrayList when used for the same purpose.
   * <P>
   * The removal order of an <Code>UnboundedFifoBuffer</Code> is based on the
insertion
   * order; elements are removed in the same order in which they were added.
   * The iteration order is the same as the removal order.<P>
   *
   * The {@link remove()} and {@link get()} operations perform in constant time.
   * The {@link add()} operation performs in amortized constant time.  All
   * other operations perform in linear time or worse.<P>
   *
   * Note that this implementation is not synchronized.  The following can be
   * used to provide synchronized access to your <COde>BoundedFifo</Code>:
   *
   * <Pre>
   *   Buffer fifo = BufferUtils.synchronizedBuffer(new BoundedFifo());
   * </Pre>
   *
   * @author  <a href="fede@apache.org">Federico Barbieri</a>
   * @author  <a href="bloritsch@apache.org">Berin Loritsch</a>
   * @author Paul Jack
   * @version CVS $Revision: 1.1 $ $Date: 2002/07/03 01:57:08 $
   * @since Avalon 4.0
   */
  public final class UnboundedFifoBuffer extends AbstractCollection implements Buffer
  {
      protected Object[] m_buffer;
      protected int m_head;
      protected int m_tail;
  
      /**
       * Initialize the UnboundedFifoBuffer with the specified number of elements.  The
       * integer must be a positive integer.
       */
      public UnboundedFifoBuffer( int size )
      {
          m_buffer = new Object[ size + 1 ];
          m_head = 0;
          m_tail = 0;
      }
  
      /**
       * Initialize the UnboundedFifoBuffer with the default number of elements.  It is
       * exactly the same as performing the following:
       *
       * <pre>
       *   new UnboundedFifoBuffer( 32 );
       * </pre>
       */
      public UnboundedFifoBuffer()
      {
          this( 32 );
      }
  
      /**
       * Tests to see if the CircularBuffer is empty.
       */
      public final boolean isEmpty()
      {
          return ( size() == 0 );
      }
  
      /**
       * Returns the number of elements stored in the buffer.
       */
      public int size()
      {
          int size = 0;
  
          if( m_tail < m_head )
          {
              size = m_buffer.length - m_head + m_tail;
          }
          else
          {
              size = m_tail - m_head;
          }
  
          return size;
      }
  
      /**
       * Add an object into the buffer
       */
      public boolean add( final Object o )
      {
          if( null == o )
          {
              throw new NullPointerException( "Attempted to add null object to buffer" );
          }
  
          if( size() + 1 >= m_buffer.length )
          {
              Object[] tmp = new Object[ ( ( m_buffer.length - 1 ) * 2 ) + 1 ];
  
              int j = 0;
              for( int i = m_head; i != m_tail; )
              {
                  tmp[ j ] = m_buffer[ i ];
                  m_buffer[ i ] = null;
  
                  j++;
                  i++;
                  if( i == m_buffer.length )
                  {
                      i = 0;
                  }
              }
  
              m_buffer = tmp;
              m_head = 0;
              m_tail = j;
          }
  
          m_buffer[ m_tail ] = o;
          m_tail++;
          if( m_tail >= m_buffer.length )
          {
              m_tail = 0;
          }
          return true;
      }
  
      /**
       * Returns the next object in the buffer.
       *
       * @return the next object in the buffer
       * @throws BufferUnderflowException if this buffer is empty
       */
      public Object get()
      {
          if( isEmpty() )
          {
              throw new BufferUnderflowException( "The buffer is already empty" );
          }
  
          return m_buffer[ m_head ];
      }
  
  
      /**
       * Removes the next object from the buffer
       *
       * @return the removed object
       * @throws BufferUnderflowException if this buffer is empty
       */
      public Object remove()
      {
          if( isEmpty() )
          {
              throw new BufferUnderflowException( "The buffer is already empty" );
          }
  
          Object element = m_buffer[ m_head ];
  
          if( null != element )
          {
              m_buffer[ m_head ] = null;
  
              m_head++;
              if( m_head >= m_buffer.length )
              {
                  m_head = 0;
              }
          }
  
          return element;
      }
  
  
      private int increment(int index) {
          index++; 
          if (index >= m_buffer.length) index = 0;
          return index;
      }
  
  
      private int decrement(int index) {
          index--;
          if (index < 0) index = m_buffer.length - 1;
          return index;
      }
  
  
      /**
       *  Returns an iterator over this fifo's elements.
       *
       *  @return an iterator over this fifo's elements
       */
      public Iterator iterator() {
          return new Iterator() {
  
              private int index = m_head;
              private int lastReturnedIndex = -1;
  
              public boolean hasNext() {
                  return index != m_tail;
                  
              }
  
              public Object next() {
                  if (!hasNext()) throw new NoSuchElementException();
                  lastReturnedIndex = index;
                  index = increment(index);
                  return m_buffer[lastReturnedIndex];
              }
  
              public void remove() {
                  if (lastReturnedIndex == -1) throw new IllegalStateException();
  
                  // First element can be removed quickly
                  if (lastReturnedIndex == m_head) {
                      UnboundedFifoBuffer.this.remove();
                      lastReturnedIndex = -1;
                      return;
                  }
  
                  // Other elements require us to shift the subsequent elements
                  int i = lastReturnedIndex + 1;
                  while (i != m_tail) {
                      if (i >= m_buffer.length) {
                          m_buffer[i - 1] = m_buffer[0];
                          i = 0;
                      } else {
                          m_buffer[i - 1] = m_buffer[i];
                          i++;
                      }
                  }
  
                  lastReturnedIndex = -1;
                  m_tail = decrement(m_tail);
                  m_buffer[m_tail] = null;
                  index = decrement(index);
              }
  
          };
      }
  
  }
  
  
  
  
  1.29      +7 -4      jakarta-commons/collections/src/test/org/apache/commons/collections/TestAll.java
  
  Index: TestAll.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/collections/src/test/org/apache/commons/collections/TestAll.java,v
  retrieving revision 1.28
  retrieving revision 1.29
  diff -u -r1.28 -r1.29
  --- TestAll.java	21 Jun 2002 06:17:45 -0000	1.28
  +++ TestAll.java	3 Jul 2002 01:57:08 -0000	1.29
  @@ -81,6 +81,8 @@
           suite.addTest(TestArrayStack.suite());
           suite.addTest(TestBeanMap.suite());
           suite.addTest(TestBinaryHeap.suite());
  +        suite.addTest(TestBoundedFifoBuffer.suite());
  +        suite.addTest(TestBoundedFifoBuffer2.suite());
           suite.addTest(TestCollectionUtils.suite());
           suite.addTest(TestComparableComparator.suite());
           suite.addTest(TestComparatorChain.suite());
  @@ -106,6 +108,7 @@
           suite.addTest(TestSingletonIterator.suite());
           suite.addTest(TestStaticBucketMap.suite());
           suite.addTest(TestTreeBag.suite());
  +        suite.addTest(TestUnboundedFifoBuffer.suite());
           suite.addTest(TestUniqueFilterIterator.suite());
           suite.addTest(org.apache.commons.collections.primitives.TestAll.suite());
           return suite;
  
  
  
  1.1                  jakarta-commons/collections/src/test/org/apache/commons/collections/TestBoundedFifoBuffer.java
  
  Index: TestBoundedFifoBuffer.java
  ===================================================================
  package org.apache.commons.collections;
  
  
  import junit.framework.Test;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Iterator;
  
  
  /**
   *  Test cases for BoundedFifoBuffer.
   */
  public class TestBoundedFifoBuffer extends TestCollection {
  
      public TestBoundedFifoBuffer(String n) {
          super(n);
      }
  
      public static Test suite() {
          return BulkTest.makeSuite(TestBoundedFifoBuffer.class);
      }
  
      /**
       *  Returns an empty BoundedFifoBuffer that won't overflow.  
       *  
       *  @return an empty BoundedFifoBuffer
       */
      public Collection makeCollection() {
          return new BoundedFifoBuffer(100);
      }
  
  
  
      /**
       *  Returns an empty ArrayList.
       *
       *  @return an empty ArrayList
       */
      public Collection makeConfirmedCollection() {
          return new ArrayList();
      }
  
  
      /**
       *  Returns a full ArrayList.
       *
       *  @return a full ArrayList
       */
      public Collection makeConfirmedFullCollection() {
          Collection c = makeConfirmedCollection();
          c.addAll(java.util.Arrays.asList(getFullElements()));
          return c;
      }
  
  
      /**
       *  Overridden because BoundedFifoBuffer doesn't support null elements.
       *
       *  @return an array of random objects without a null element
       */
      public Object[] getFullElements() {
          return getFullNonNullElements();
      }
  
  
      /**
       *  Overridden, because BoundedFifoBuffer's iterators aren't fail-fast.
       */
      public void testCollectionIteratorFailFast() {
      }
  
  
      /**
       *  Runs through the regular verifications, but also verifies that 
       *  the buffer contains the same elements in the same sequence as the
       *  list.
       */
      public void verify() {
          super.verify();
          Iterator iterator1 = collection.iterator();
          Iterator iterator2 = confirmed.iterator();
          while (iterator2.hasNext()) {
              assertTrue(iterator1.hasNext());
              Object o1 = iterator1.next();
              Object o2 = iterator2.next();
              assertEquals(o1, o2);
          }
      }
  
      /**
       * Tests that the removal operation actually removes the first element.
       */
      public void testBoundedFifoBufferRemove() {
          resetFull();
          int size = confirmed.size();
          for (int i = 0; i < size; i++) {
              Object o1 = ((BoundedFifoBuffer)collection).remove();
              Object o2 = ((ArrayList)confirmed).remove(0);
              assertEquals("Removed objects should be equal", o1, o2);
              verify();
          }
  
          try {
              ((BoundedFifoBuffer)collection).remove();
              fail("Empty buffer should raise Underflow.");
          } catch (BufferUnderflowException e) {
              // expected
          }
      }
  
  }
  
  
  
  1.1                  jakarta-commons/collections/src/test/org/apache/commons/collections/TestBoundedFifoBuffer2.java
  
  Index: TestBoundedFifoBuffer2.java
  ===================================================================
  package org.apache.commons.collections;
  
  
  import junit.framework.Test;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.Iterator;
  
  
  /**
   * Runs tests against a full BoundedFifoBuffer, since many of the algorithms
   * differ depending on whether the fifo is full or not.
   */
  public class TestBoundedFifoBuffer2 extends TestBoundedFifoBuffer {
  
      public TestBoundedFifoBuffer2(String n) {
          super(n);
      }
  
      public static Test suite() {
          return BulkTest.makeSuite(TestBoundedFifoBuffer2.class);
      }
  
      /**
       *  Returns a BoundedFifoBuffer that's filled to capacity.
       *  Any attempt to add to the returned buffer will result in a 
       *  BufferOverflowException.
       *
       *  @return a full BoundedFifoBuffer
       */
      public Collection makeFullCollection() {
          return new BoundedFifoBuffer(Arrays.asList(getFullElements()));
      }
  
  
      /**
       *  Overridden to skip the add tests.  All of them would fail with a 
       *  BufferOverflowException.
       *
       *  @return false
       */
      public boolean isAddSupported() {
          return false;
      }
  
  
      /**
       *  Overridden because the add operations raise BufferOverflowException
       *  instead of UnsupportedOperationException.
       */
      public void testUnsupportedAdd() {
      }
  
  
      /**
       *  Tests to make sure the add operations raise BufferOverflowException.
       */
      public void testBufferOverflow() {
          resetFull();
          try {
              collection.add(getOtherElements()[0]);
              fail("add should raise BufferOverflow.");
          } catch (BufferOverflowException e) {
              // expected
          }
          verify();
  
          try {
              collection.addAll(Arrays.asList(getOtherElements()));
              fail("addAll should raise BufferOverflow.");
          } catch (BufferOverflowException e) {
              // expected
          }
          verify();
      }
  
  }
  
  
  
  
  1.1                  jakarta-commons/collections/src/test/org/apache/commons/collections/TestUnboundedFifoBuffer.java
  
  Index: TestUnboundedFifoBuffer.java
  ===================================================================
  package org.apache.commons.collections;
  
  
  import junit.framework.Test;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Iterator;
  
  
  /**
   *  Test cases for UnboundedFifoBuffer.
   */
  public class TestUnboundedFifoBuffer extends TestCollection {
  
      public TestUnboundedFifoBuffer(String n) {
          super(n);
      }
  
      public static Test suite() {
          return BulkTest.makeSuite(TestUnboundedFifoBuffer.class);
      }
  
      /**
       *  Returns an empty UnboundedFifoBuffer with a small capacity.
       *
       *  @return an empty UnboundedFifoBuffer
       */
      public Collection makeCollection() {
          return new UnboundedFifoBuffer(5);
      }
  
  
      /**
       *  Returns an empty ArrayList.
       *
       *  @return an empty ArrayList
       */
      public Collection makeConfirmedCollection() {
          return new ArrayList();
      }
  
  
      /**
       *  Returns a full ArrayList.
       *
       *  @return a full ArrayList
       */
      public Collection makeConfirmedFullCollection() {
          Collection c = makeConfirmedCollection();
          c.addAll(java.util.Arrays.asList(getFullElements()));
          return c;
      }
  
  
      /**
       *  Overridden because UnboundedFifoBuffer doesn't allow null elements.
       *
       *  @return an array of random elements without the null element
       */
      public Object[] getFullElements() {
          return getFullNonNullElements();
      }
  
  
      /**
       *  Overridden because UnboundedFifoBuffer's iterators aren't fail-fast.
       */
      public void testCollectionIteratorFailFast() {
      }
  
  
      /**
       *  Verifies that the ArrayList has the same elements in the same 
       *  sequence as the UnboundedFifoBuffer.
       */
      public void verify() {
          super.verify();
          Iterator iterator1 = collection.iterator();
          Iterator iterator2 = confirmed.iterator();
          while (iterator2.hasNext()) {
              assertTrue(iterator1.hasNext());
              Object o1 = iterator1.next();
              Object o2 = iterator2.next();
              assertEquals(o1, o2);
          }
      }
  
  
      /**
       *  Tests that UnboundedFifoBuffer removes elements in the right order.
       */
      public void testUnboundedFifoBufferRemove() {
          resetFull();
          int size = confirmed.size();
          for (int i = 0; i < size; i++) {
              Object o1 = ((UnboundedFifoBuffer)collection).remove();
              Object o2 = ((ArrayList)confirmed).remove(0);
              assertEquals("Removed objects should be equal", o1, o2);
              verify();
          }
      }
  
  }
  
  
  
  

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


Mime
View raw message