[prev in list] [next in list] [prev in thread] [next in thread]
List: activemq-commits
Subject: svn commit: r808918 - in /activemq/activemq-cpp/trunk/activemq-cpp/src:
From: tabish () apache ! org
Date: 2009-08-28 15:32:37
Message-ID: 20090828153238.132C823888FC () eris ! apache ! org
[Download RAW message or body]
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 + * "close" or "shutdown" 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();
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic