activemq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From tab...@apache.org
Subject svn commit: r808918 - in /activemq/activemq-cpp/trunk/activemq-cpp/src: main/decaf/util/ main/decaf/util/concurrent/ test/decaf/util/
Date Fri, 28 Aug 2009 15:32:37 GMT
Author: tabish
Date: Fri Aug 28 15:32:36 2009
New Revision: 808918

URL: http://svn.apache.org/viewvc?rev=808918&view=rev
Log:
http://issues.apache.org/activemq/browse/AMQCPP-250

More work on the Collections needed for implementing the ThreadPoolExecutor.  More tests as
well.

Added:
    activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/BlockingQueue.h
  (with props)
Modified:
    activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/AbstractQueue.h
    activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/PriorityQueue.h
    activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/Queue.h
    activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/PriorityQueueTest.cpp
    activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/PriorityQueueTest.h

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/AbstractQueue.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/AbstractQueue.h?rev=808918&r1=808917&r2=808918&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/AbstractQueue.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/AbstractQueue.h Fri Aug 28
15:32:36 2009
@@ -118,7 +118,14 @@
          * @throws NoSuchElementException if the queue is empty.
          */
         virtual E remove() throw ( decaf::lang::exceptions::NoSuchElementException ) {
-            return this->poll();
+
+            E result;
+            if( this->poll( result ) == true ) {
+                return result;
+            }
+
+            throw decaf::lang::exceptions::NoSuchElementException(
+                __FILE__, __LINE__, "Unable to remove specified element from the Queue."
);
         }
 
         /**
@@ -130,10 +137,16 @@
          * @return the element in the head of the queue.
          * @throws NoSuchElementException if the queue is empty.
          */
-        virtual const E& element() const
+        virtual E element() const
             throw( decaf::lang::exceptions::NoSuchElementException ) {
 
-            return this->peek();
+            E result;
+            if( this->peek( result ) == true ) {
+                return result;
+            }
+
+            throw decaf::lang::exceptions::NoSuchElementException(
+                __FILE__, __LINE__, "Unable to remove specified element from the Queue."
);
         }
 
         /**
@@ -147,9 +160,12 @@
                 return;
             }
 
+            E result;
+            bool successful = true;
+
             do {
-                this->poll();
-            } while( !this->isEmpty() );
+                successful = this->poll( result );
+            } while( successful );
         }
 
     };

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/PriorityQueue.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/PriorityQueue.h?rev=808918&r1=808917&r2=808918&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/PriorityQueue.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/PriorityQueue.h Fri Aug 28
15:32:36 2009
@@ -261,26 +261,37 @@
             return true;
         }
 
-        virtual E poll() throw( decaf::lang::exceptions::NoSuchElementException ) {
+        virtual bool poll( E& result ) {
 
             if( Queue<E>::isEmpty() ) {
-                throw lang::exceptions::NoSuchElementException(
-                    __FILE__, __LINE__, "Queue is empty" );
+                return false;
             }
 
-            E result = elements[0];
+            result = elements[0];
             removeAt( 0 );
-            return result;
+            return true;
         }
 
-        virtual const E& peek() const throw( decaf::lang::exceptions::NoSuchElementException
) {
+        virtual bool peek( E& result ) const {
 
             if( Queue<E>::isEmpty() ) {
-                throw lang::exceptions::NoSuchElementException(
-                    __FILE__, __LINE__, "Queue is empty" );
+                return false;
+            }
+
+            result = elements[0];
+            return true;
+        }
+
+        virtual E remove() throw ( decaf::lang::exceptions::NoSuchElementException ) {
+
+            if( !Queue<E>::isEmpty() ) {
+                E result = elements[0];
+                removeAt( 0 );
+                return result;
             }
 
-            return elements[0];
+            throw decaf::lang::exceptions::NoSuchElementException(
+                __FILE__, __LINE__, "Unable to remove specified element from the Queue."
);
         }
 
         virtual bool remove( const E& value )

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/Queue.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/Queue.h?rev=808918&r1=808917&r2=808918&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/Queue.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/Queue.h Fri Aug 28 15:32:36
2009
@@ -41,10 +41,13 @@
      * methods.
      *
      * Unlike the Java Queue interface the methods of this class cannot return null
-     * to indicate that a Queue is empty since null has no meaning for elements that
-     * are class or struct types and a comparison between null and a primitive type
-     * is not a meaningful check for an empty queue.  Methods that would have returned
-     * null in Java throw the NoSuchElementException instead.
+     * to indicate that a Queue is empty since null has no meaning for elements such
+     * as classes, structs and primitive types and cannot be used in a meaningful way
+     * to check for an empty queue.  Methods that would have returned null in the
+     * Java Queue interface have been altered to return a boolean value indicating if
+     * the operation succeeded and take single argument that is a reference to the
+     * location where the returned value is to be assigned.  This implies that elements
+     * in the Queue must be <em>assignable</em> in order to utilize these methods.
      *
      * @since 1.0
      */
@@ -71,15 +74,18 @@
         virtual bool offer( const E& value ) throw( decaf::lang::exceptions::NullPointerException
) = 0;
 
         /**
-         * Gets and removes the element in the head of the queue, or returns null if
-         * there is no element in the queue.
+         * Gets and removes the element in the head of the queue.  If the operation succeeds
the
+         * value of the element at the head of the Queue is assigned to the result parameter
and
+         * the method returns true.  If the operation fails the method returns false and
the value
+         * of the result parameter is undefined.
          *
-         * @return the element in the head of the queue.
+         * @param result
+         *        Reference to an instance of the contained type to assigned the removed
value to.
          *
-         * @throws NoSuchElementException
-         *         if there is no element in the queue.
+         * @return true if the element at the head of the queue was removed and assigned
to the
+         *         result parameter.
          */
-        virtual E poll() throw ( decaf::lang::exceptions::NoSuchElementException ) = 0;
+        virtual bool poll( E& result ) = 0;
 
         /**
          * Gets and removes the element in the head of the queue. Throws a
@@ -93,15 +99,16 @@
         virtual E remove() throw ( decaf::lang::exceptions::NoSuchElementException ) = 0;
 
         /**
-         * Gets but not removes the element in the head of the queue.
+         * Gets but not removes the element in the head of the queue.  The result if successful
is
+         * assigned to the result parameter.
          *
-         * @return the element in the head of the queue.
+         * @param result
+         *        Reference to an instance of the contained type to assigned the removed
value to.
          *
-         * @throws NoSuchElementException
-         *         if there is no element in the queue.
+         * @return true if the element at the head of the queue was removed and assigned
to the
+         *         result parameter.
          */
-        virtual const E& peek() const
-            throw ( decaf::lang::exceptions::NoSuchElementException ) = 0;
+        virtual bool peek( E& result ) const = 0;
 
         /**
          * Gets but not removes the element in the head of the queue. Throws a
@@ -112,7 +119,7 @@
          * @throws NoSuchElementException
          *         if there is no element in the queue.
          */
-        virtual const E& element() const
+        virtual E element() const
             throw( decaf::lang::exceptions::NoSuchElementException ) = 0;
 
     };

Added: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/BlockingQueue.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/BlockingQueue.h?rev=808918&view=auto
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/BlockingQueue.h
(added)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/BlockingQueue.h
Fri Aug 28 15:32:36 2009
@@ -0,0 +1,365 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _DECAF_UTIL_CONCURRENT_BLOCKINGQUEUE_H_
+#define _DECAF_UTIL_CONCURRENT_BLOCKINGQUEUE_H_
+
+#include <decaf/util/Config.h>
+#include <decaf/util/Queue.h>
+
+namespace decaf {
+namespace util {
+namespace concurrent {
+
+    /**
+     * A {@link java.util.Queue} that additionally supports operations that wait for
+     * the queue to become non-empty when retrieving an element, and wait for space
+     * to become available in the queue when storing an element.
+     *
+     * <p><tt>BlockingQueue</tt> methods come in three forms, with different
ways of
+     * handling operations that cannot be satisfied immediately, but may be satisfied
+     * at some point in the future:
+     * one throws an exception, the second returns a special value (either
+     * <tt>null</tt> or <tt>false</tt>, depending on the operation),
the third
+     * blocks the current thread indefinitely until the operation can succeed,
+     * and the fourth blocks for only a given maximum time limit before giving
+     * up.  These methods are summarized in the following table:
+     *
+     * <p>
+     * <table BORDER CELLPADDING=3 CELLSPACING=1>
+     *  <tr>
+     *    <td></td>
+     *    <td ALIGN=CENTER><em>Throws exception</em></td>
+     *    <td ALIGN=CENTER><em>Boolean Flag</em></td>
+     *    <td ALIGN=CENTER><em>Blocks</em></td>
+     *    <td ALIGN=CENTER><em>Times out</em></td>
+     *  </tr>
+     *  <tr>
+     *    <td><b>Insert</b></td>
+     *    <td>{@link #add add(e)}</td>
+     *    <td>{@link #offer offer(e)}</td>
+     *    <td>{@link #put put(e)}</td>
+     *    <td>{@link #offer(Object, long, TimeUnit) offer(e, time, unit)}</td>
+     *  </tr>
+     *  <tr>
+     *    <td><b>Remove</b></td>
+     *    <td>{@link #remove remove()}</td>
+     *    <td>{@link #poll poll()}</td>
+     *    <td>{@link #take take()}</td>
+     *    <td>{@link #poll(long, TimeUnit) poll(time, unit)}</td>
+     *  </tr>
+     *  <tr>
+     *    <td><b>Examine</b></td>
+     *    <td>{@link #element element()}</td>
+     *    <td>{@link #peek peek()}</td>
+     *    <td><em>not applicable</em></td>
+     *    <td><em>not applicable</em></td>
+     *  </tr>
+     * </table>
+     *
+     * <p>A <tt>BlockingQueue</tt> may be capacity bounded. At any given
time it may
+     * have a <tt>remainingCapacity</tt> beyond which no additional elements
can
+     * be <tt>put</tt> without blocking.  A <tt>BlockingQueue</tt>
without any
+     * intrinsic capacity constraints always reports a remaining capacity of
+     * <tt>Integer::MAX_VALUE</tt>.
+     *
+     * <p> <tt>BlockingQueue</tt> implementations are designed to be used
primarily for
+     * producer-consumer queues, but additionally support {@link decaf.util.Collection}
+     * interface.  So, for example, it is possible to remove an arbitrary element from a
+     * queue using <tt>remove(x)</tt>. However, such operations are in general
<em>not</em>
+     * performed very efficiently, and are intended for only occasional use, such as
+     * when a queued message is cancelled.
+     *
+     * <p> <tt>BlockingQueue</tt> implementations are thread-safe.  All
queuing methods
+     * achieve their effects atomically using internal locks or other forms of concurrency
+     * control. However, the <em>bulk</em> Collection operations <tt>addAll</tt>,
+     * <tt>containsAll</tt>, <tt>retainAll</tt> and <tt>removeAll</tt>
are <em>not</em>
+     * necessarily performed atomically unless specified otherwise in an implementation.
+     * So it is possible, for example, for <tt>addAll(c)</tt> to fail (throwing
an exception)
+     * after adding only some of the elements in <tt>c</tt>.
+     *
+     * <p>A <tt>BlockingQueue</tt> does <em>not</em> intrinsically
support any kind of
+     * &quot;close&quot; or &quot;shutdown&quot; operation to indicate that
no more
+     * items will be added.  The needs and usage of such features tend to be
+     * implementation-dependent. For example, a common tactic is for producers to
+     * insert special <em>end-of-stream</em> or <em>poison</em> objects,
that are
+     * interpreted accordingly when taken by consumers.
+     *
+     * <p>
+     * Usage example, based on a typical producer-consumer scenario.  Note that a
+     * <tt>BlockingQueue</tt> can safely be used with multiple producers and
multiple
+     * consumers.
+     * <pre>
+     * class Producer : public Runnable {
+     * private:
+     *
+     *     BlockingQueue* queue;
+     *
+     * public:
+     *
+     *     Producer( BlockingQueue* q ) : queue( q ) {}
+     *
+     *     virtual void run() {
+     *         try {
+     *             while( true ) { queue->put( produce() ); }
+     *         } catch( InterruptedException& ex ) { ... handle ...}
+     *     }
+     *
+     *     Object produce() { ... }
+     * }
+     *
+     * class Consumer : public Runnable {
+     * private:
+     *
+     *     BlockingQueue* queue;
+     *
+     * public:
+     *
+     *     Consumer( BlockingQueue* q ) : queue( q ) {}
+     *
+     *     virtual void run() {
+     *         try {
+     *             while( true ) { consume( queue->take() ); }
+     *         } catch( InterruptedException& ex ) { ... handle ...}
+     *     }
+     *
+     *     void consume( Object& x ) { ... }
+     * }
+     *
+     * int main( int argc, char** argv ) {
+     *
+     *     BlockingQueue q = new SomeQueueImplementation();
+     *     Producer p( &q );
+     *     Consumer c1( &q );
+     *     Consumer c2( &q );
+     *     Thread t1( &p ).start();
+     *     Thread t2( &c1 ).start();
+     *     Thread t3( &c2 ).start();
+     * }
+     * </pre>
+     *
+     * <p>Memory consistency effects: As with other concurrent collections, actions
in a
+     * thread prior to placing an object into a {@code BlockingQueue} <em>happen-before</em><
+     * actions subsequent to the access or removal of that element from the
+     * {@code BlockingQueue} in another thread.
+     *
+     * @since 1.0
+     */
+    template< typename E >
+    class BlockingQueue : public Queue<E> {
+    public:
+
+        virtual ~BlockingQueue() {
+        }
+
+        /**
+         * Inserts the specified element into this queue if it is possible to do
+         * so immediately without violating capacity restrictions, returning
+         * <tt>true</tt> upon success and throwing an
+         * <tt>IllegalStateException</tt> if no space is currently available.
+         * When using a capacity-restricted queue, it is generally preferable to
+         * use {@link #offer(Object) offer}.
+         *
+         * @param e the element to add
+         * @return <tt>true</tt> (as specified by {@link Collection#add})
+         * @throws IllegalStateException if the element cannot be added at this
+         *         time due to capacity restrictions
+         * @throws ClassCastException if the class of the specified element
+         *         prevents it from being added to this queue
+         * @throws NullPointerException if the specified element is null
+         * @throws IllegalArgumentException if some property of the specified
+         *         element prevents it from being added to this queue
+         */
+        virtual bool add(E e);
+
+        /**
+         * Inserts the specified element into this queue if it is possible to do
+         * so immediately without violating capacity restrictions, returning
+         * <tt>true</tt> upon success and <tt>false</tt> if no space
is currently
+         * available.  When using a capacity-restricted queue, this method is
+         * generally preferable to {@link #add}, which can fail to insert an
+         * element only by throwing an exception.
+         *
+         * @param e the element to add
+         * @return <tt>true</tt> if the element was added to this queue, else
+         *         <tt>false</tt>
+         * @throws ClassCastException if the class of the specified element
+         *         prevents it from being added to this queue
+         * @throws NullPointerException if the specified element is null
+         * @throws IllegalArgumentException if some property of the specified
+         *         element prevents it from being added to this queue
+         */
+        virtual bool offer(E e);
+
+        /**
+         * Inserts the specified element into this queue, waiting if necessary
+         * for space to become available.
+         *
+         * @param e the element to add
+         * @throws InterruptedException if interrupted while waiting
+         * @throws ClassCastException if the class of the specified element
+         *         prevents it from being added to this queue
+         * @throws NullPointerException if the specified element is null
+         * @throws IllegalArgumentException if some property of the specified
+         *         element prevents it from being added to this queue
+         */
+        virtual void put(E e) throws InterruptedException;
+
+        /**
+         * Inserts the specified element into this queue, waiting up to the
+         * specified wait time if necessary for space to become available.
+         *
+         * @param e the element to add
+         * @param timeout how long to wait before giving up, in units of
+         *        <tt>unit</tt>
+         * @param unit a <tt>TimeUnit</tt> determining how to interpret the
+         *        <tt>timeout</tt> parameter
+         * @return <tt>true</tt> if successful, or <tt>false</tt>
if
+         *         the specified waiting time elapses before space is available
+         * @throws InterruptedException if interrupted while waiting
+         * @throws ClassCastException if the class of the specified element
+         *         prevents it from being added to this queue
+         * @throws NullPointerException if the specified element is null
+         * @throws IllegalArgumentException if some property of the specified
+         *         element prevents it from being added to this queue
+         */
+        virtual bool offer(E e, long timeout, TimeUnit unit)
+            throws InterruptedException;
+
+        /**
+         * Retrieves and removes the head of this queue, waiting if necessary
+         * until an element becomes available.
+         *
+         * @return the head of this queue
+         * @throws InterruptedException if interrupted while waiting
+         */
+        virtual E take() throws InterruptedException;
+
+        /**
+         * Retrieves and removes the head of this queue, waiting up to the
+         * specified wait time if necessary for an element to become available.
+         *
+         * @param timeout how long to wait before giving up, in units of
+         *        <tt>unit</tt>
+         * @param unit a <tt>TimeUnit</tt> determining how to interpret the
+         *        <tt>timeout</tt> parameter
+         * @return the head of this queue, or <tt>null</tt> if the
+         *         specified waiting time elapses before an element is available
+         * @throws InterruptedException if interrupted while waiting
+         */
+        virtual E poll(long timeout, TimeUnit unit)
+            throws InterruptedException;
+
+        /**
+         * Returns the number of additional elements that this queue can ideally
+         * (in the absence of memory or resource constraints) accept without
+         * blocking, or <tt>Integer.MAX_VALUE</tt> if there is no intrinsic
+         * limit.
+         *
+         * <p>Note that you <em>cannot</em> always tell if an attempt to
insert
+         * an element will succeed by inspecting <tt>remainingCapacity</tt>
+         * because it may be the case that another thread is about to
+         * insert or remove an element.
+         *
+         * @return the remaining capacity
+         */
+        virtual int remainingCapacity();
+
+        /**
+         * Removes a single instance of the specified element from this queue,
+         * if it is present.  More formally, removes an element <tt>e</tt> such
+         * that <tt>o.equals(e)</tt>, if this queue contains one or more such
+         * elements.
+         * Returns <tt>true</tt> if this queue contained the specified element
+         * (or equivalently, if this queue changed as a result of the call).
+         *
+         * @param o element to be removed from this queue, if present
+         * @return <tt>true</tt> if this queue changed as a result of the call
+         * @throws ClassCastException if the class of the specified element
+         *         is incompatible with this queue (optional)
+         * @throws NullPointerException if the specified element is null (optional)
+         */
+        virtual bool remove(Object o);
+
+        /**
+         * Returns <tt>true</tt> if this queue contains the specified element.
+         * More formally, returns <tt>true</tt> if and only if this queue contains
+         * at least one element <tt>e</tt> such that <tt>o.equals(e)</tt>.
+         *
+         * @param o object to be checked for containment in this queue
+         * @return <tt>true</tt> if this queue contains the specified element
+         * @throws ClassCastException if the class of the specified element
+         *         is incompatible with this queue (optional)
+         * @throws NullPointerException if the specified element is null (optional)
+         */
+        virtual bool contains(Object o);
+
+        /**
+         * Removes all available elements from this queue and adds them
+         * to the given collection.  This operation may be more
+         * efficient than repeatedly polling this queue.  A failure
+         * encountered while attempting to add elements to
+         * collection <tt>c</tt> may result in elements being in neither,
+         * either or both collections when the associated exception is
+         * thrown.  Attempts to drain a queue to itself result in
+         * <tt>IllegalArgumentException</tt>. Further, the behavior of
+         * this operation is undefined if the specified collection is
+         * modified while the operation is in progress.
+         *
+         * @param c the collection to transfer elements into
+         * @return the number of elements transferred
+         * @throws UnsupportedOperationException if addition of elements
+         *         is not supported by the specified collection
+         * @throws ClassCastException if the class of an element of this queue
+         *         prevents it from being added to the specified collection
+         * @throws NullPointerException if the specified collection is null
+         * @throws IllegalArgumentException if the specified collection is this
+         *         queue, or some property of an element of this queue prevents
+         *         it from being added to the specified collection
+         */
+        virtual int drainTo(Collection<? super E> c);
+
+        /**
+         * Removes at most the given number of available elements from
+         * this queue and adds them to the given collection.  A failure
+         * encountered while attempting to add elements to
+         * collection <tt>c</tt> may result in elements being in neither,
+         * either or both collections when the associated exception is
+         * thrown.  Attempts to drain a queue to itself result in
+         * <tt>IllegalArgumentException</tt>. Further, the behavior of
+         * this operation is undefined if the specified collection is
+         * modified while the operation is in progress.
+         *
+         * @param c the collection to transfer elements into
+         * @param maxElements the maximum number of elements to transfer
+         * @return the number of elements transferred
+         * @throws UnsupportedOperationException if addition of elements
+         *         is not supported by the specified collection
+         * @throws ClassCastException if the class of an element of this queue
+         *         prevents it from being added to the specified collection
+         * @throws NullPointerException if the specified collection is null
+         * @throws IllegalArgumentException if the specified collection is this
+         *         queue, or some property of an element of this queue prevents
+         *         it from being added to the specified collection
+         */
+        virtual int drainTo( Collection<E> c, int maxElements ) = 0;
+
+    };
+
+}}}
+
+#endif /* _DECAF_UTIL_CONCURRENT_BLOCKINGQUEUE_H_ */

Propchange: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/BlockingQueue.h
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/PriorityQueueTest.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/PriorityQueueTest.cpp?rev=808918&r1=808917&r2=808918&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/PriorityQueueTest.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/PriorityQueueTest.cpp Fri
Aug 28 15:32:36 2009
@@ -153,13 +153,14 @@
 
     std::string sortedArray[] = { "AA", "AAAA", "AAAAA", "AAAAAAAA" };
     for( int i = 0; i < 4; i++ ) {
-        CPPUNIT_ASSERT( sortedArray[i] == queue.poll() );
+        CPPUNIT_ASSERT( sortedArray[i] == queue.remove() );
     }
 
+    std::string result;
     CPPUNIT_ASSERT( 0 == queue.size() );
     CPPUNIT_ASSERT_THROW_MESSAGE(
         "Should Throw a NoSuchElementException",
-        queue.poll(),
+        queue.remove(),
         decaf::lang::exceptions::NoSuchElementException );
 }
 
@@ -174,25 +175,23 @@
         intQueue.offer( array[i] );
     }
 
+    int result = 0;
     for( int i = 0; i < 5; i++ ) {
-        CPPUNIT_ASSERT( sorted[i] == intQueue.poll() );
+        CPPUNIT_ASSERT( intQueue.poll( result ) );
+        CPPUNIT_ASSERT( sorted[i] == result );
     }
 
     CPPUNIT_ASSERT( 0 == intQueue.size() );
-    CPPUNIT_ASSERT_THROW_MESSAGE(
-        "Should Throw a NoSuchElementException",
-        intQueue.poll(),
-        decaf::lang::exceptions::NoSuchElementException );
+    CPPUNIT_ASSERT( intQueue.poll( result ) == false );
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 void PriorityQueueTest::testPollEmpty() {
+
+    double result;
     PriorityQueue<double> queue;
     CPPUNIT_ASSERT( 0 == queue.size() );
-    CPPUNIT_ASSERT_THROW_MESSAGE(
-        "Should Throw a NoSuchElementException",
-        queue.poll(),
-        decaf::lang::exceptions::NoSuchElementException );
+    CPPUNIT_ASSERT( queue.poll( result ) == false );
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -206,18 +205,22 @@
         integerQueue.add( array[i] );
     }
 
-    CPPUNIT_ASSERT( sorted[0] == integerQueue.peek() );
-    CPPUNIT_ASSERT( sorted[0] == integerQueue.peek() );
+    int result = 0;
+
+    CPPUNIT_ASSERT( integerQueue.peek( result ) == true );
+    CPPUNIT_ASSERT( sorted[0] == result );
+
+    CPPUNIT_ASSERT( integerQueue.peek( result ) == true );
+    CPPUNIT_ASSERT( sorted[0] == result );
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 void PriorityQueueTest::testPeekEmpty() {
+
+    float result;
     PriorityQueue<float> queue;
     CPPUNIT_ASSERT( 0 == queue.size() );
-    CPPUNIT_ASSERT_THROW_MESSAGE(
-        "Should Throw a NoSuchElementException",
-        queue.poll(),
-        decaf::lang::exceptions::NoSuchElementException );
+    CPPUNIT_ASSERT( queue.peek( result ) == false );
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -248,7 +251,31 @@
     CPPUNIT_ASSERT( 5 == integerQueue.size() );
 
     for( int i = 0; i < 5; i++ ) {
-        CPPUNIT_ASSERT( sorted[i] == integerQueue.poll() );
+        CPPUNIT_ASSERT( sorted[i] == integerQueue.remove() );
+    }
+
+    CPPUNIT_ASSERT( 0 == integerQueue.size() );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void PriorityQueueTest::testAddAll() {
+    PriorityQueue<int> integerQueue;
+
+    StlList<int> list;
+    list.add( 2 );
+    list.add( 45 );
+    list.add( 7 );
+    list.add( -12 );
+    list.add( 9 );
+
+    int sorted[] = { -12, 2, 7, 9, 45 };
+
+    integerQueue.addAll( list );
+
+    CPPUNIT_ASSERT( 5 == integerQueue.size() );
+
+    for( int i = 0; i < 5; i++ ) {
+        CPPUNIT_ASSERT( sorted[i] == integerQueue.remove() );
     }
 
     CPPUNIT_ASSERT( 0 == integerQueue.size() );
@@ -269,8 +296,10 @@
 
     int sorted[] = { -12, 2, 7, 9, 10, 17, 23, 39, 45, 1118 };
 
+    int result = 0;
     for( int i = 0; i < 10; i++ ) {
-        CPPUNIT_ASSERT( sorted[i] == integerQueue.poll() );
+        CPPUNIT_ASSERT( integerQueue.poll( result ) );
+        CPPUNIT_ASSERT( sorted[i] == result );
     }
 
     CPPUNIT_ASSERT( 0 == integerQueue.size() );
@@ -413,9 +442,11 @@
         newArray.push_back( iter->next() );
     }
 
+    int result;
     std::sort( newArray.begin(), newArray.end() );
     for( std::size_t i = 0; i < intQueue.size(); i++ ) {
-        CPPUNIT_ASSERT( newArray[i] == intQueue.poll() );
+        CPPUNIT_ASSERT( intQueue.poll( result ) );
+        CPPUNIT_ASSERT( newArray[i] == result );
     }
 
     const PriorityQueue<int> constQueue( intQueue );

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/PriorityQueueTest.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/PriorityQueueTest.h?rev=808918&r1=808917&r2=808918&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/PriorityQueueTest.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/PriorityQueueTest.h Fri Aug
28 15:32:36 2009
@@ -39,6 +39,7 @@
         CPPUNIT_TEST( testPeekEmpty );
         CPPUNIT_TEST( testClear );
         CPPUNIT_TEST( testAdd );
+        CPPUNIT_TEST( testAddAll );
         CPPUNIT_TEST( testRemove );
         CPPUNIT_TEST( testRemoveUsingComparator );
         CPPUNIT_TEST( testRemoveNotExists );
@@ -67,6 +68,7 @@
         void testPeekEmpty();
         void testClear();
         void testAdd();
+        void testAddAll();
         void testRemove();
         void testRemoveUsingComparator();
         void testRemoveNotExists();



Mime
View raw message