- SequenceSet implemented on RangeSet.

 - Reduced #include dependencides on SequenceSet.h


git-svn-id: https://svn.apache.org/repos/asf/incubator/qpid/trunk@650906 13f79535-47bb-0310-9956-ffa450edef68

13 files changed, 134 insertions, 228 deletions

diff --git a/qpid/cpp/src/qpid/DataDir.cpp b/qpid/cpp/src/qpid/DataDir.cpp
index abf9b061e4..5fa26082b3 100644
--- a/qpid/cpp/src/qpid/DataDir.cpp
+++ b/qpid/cpp/src/qpid/DataDir.cpp
@@ -54,10 +54,8 @@ DataDir::DataDir (std::string path) :
             throw Exception ("Data directory is locked by another process");
         if (errno == EACCES)
             throw Exception ("Insufficient privileges for data directory");
-
-        std::ostringstream oss;
-        oss << "Error locking data directory: errno=" << errno;
-        throw Exception (oss.str ());
+        throw Exception(
+            QPID_MSG("Error locking " << lockFile << ": " << strError(errno)));
     }
 
     QPID_LOG (info, "Locked data directory: " << dirPath);
diff --git a/qpid/cpp/src/qpid/RangeSet.h b/qpid/cpp/src/qpid/RangeSet.h
index 2861337427..b0757a0249 100644
--- a/qpid/cpp/src/qpid/RangeSet.h
+++ b/qpid/cpp/src/qpid/RangeSet.h
@@ -30,17 +30,27 @@
 
 namespace qpid {
 
-/** A range of values, used in RangeSet */
+/** A range of values, used in RangeSet.
+ * Range(begin, end) includes begin but excludes end.
+ * Range::makeClosed(first,last) includes both first and last.
+ */
 template <class T>
 class Range {
   public:
+    static Range makeClosed(const T& first, T last) { return Range(first, ++last); }
+    
     Range() : begin_(), end_() {}
     explicit Range(const T& t) : begin_(t), end_(t) { ++end_; }
     Range(const T& b, const T& e) : begin_(b), end_(e) { assert(b <= e); }
 
     T begin() const { return begin_; }
+    /** End of _open_ range, i.e. !contains(end()) */
     T end() const { return end_; }
 
+    T first() const { assert(!empty()); return begin_; }
+    /** Last in closed range, i.e. contains(end()) */
+    T last() const { assert(!empty()); T ret=end_; return --ret; }
+
     void begin(const T& t) { begin_ = t; }
     void end(const T& t) { end_ = t; }
 
@@ -48,6 +58,7 @@ class Range {
 
     bool contains(const T& x) const { return begin_ <= x && x < end_; }
     bool contains(const Range& r) const { return begin_ <= r.begin_ && r.end_ <= end_; }
+    bool strictContains(const Range& r) const { return begin_ < r.begin_ && r.end_ < end_; }
 
     bool operator==(const Range& x) { return begin_ == x.begin_ && end_== x.end_; }
 
@@ -66,6 +77,8 @@ class Range {
     }
 
     operator bool() const { return !empty(); }
+
+    template <class S> void serialize(S& s) { s(begin_)(end_); }
         
   private:
     T begin_, end_;
@@ -83,7 +96,10 @@ class RangeSet
                        boost::additive2<RangeSet<T>, Range<T>,
                                         boost::additive2<RangeSet<T>, T> > >
 {
+  public:
     typedef qpid::Range<T> Range;
+
+  private:
     typedef InlineVector<Range, 3> Ranges; // TODO aconway 2008-04-21: what's the optimial inlined value?
 
   public:
@@ -116,8 +132,8 @@ class RangeSet
     typedef iterator const_iterator;
     
     RangeSet() {}
-    explicit RangeSet(const Range& r) { ranges.push_back(r); }
-    RangeSet(const T& a, const T& b) { ranges.push_back(Range(a,b)); }
+    explicit RangeSet(const Range& r) { *this += r; }
+    RangeSet(const T& a, const T& b) { *this += Range(a,b); }
     
     bool contiguous() const { return ranges.size() <= 1; }
 
@@ -129,12 +145,15 @@ class RangeSet
 
     bool operator==(const RangeSet<T>&) const;
 
+    void addRange (const Range&);
+    void addSet (const RangeSet&);
+
+    RangeSet& operator+=(const T& t) { return *this += Range(t); }
+    RangeSet& operator+=(const Range& r) { addRange(r); return *this; }
+    RangeSet& operator+=(const RangeSet& s) { addSet(s); return *this; }
+
     void removeRange (const Range&);
     void removeSet (const RangeSet&);
-    
-    RangeSet& operator+=(const T& t) { return *this += Range(t); }
-    RangeSet& operator+=(const Range&);
-    RangeSet& operator+=(const RangeSet&) { return *this; };
 
     RangeSet& operator-=(const T& t)  { return *this -= Range(t); }
     RangeSet& operator-=(const Range& r) { removeRange(r); return *this; }
@@ -143,16 +162,28 @@ class RangeSet
     T front() const { return ranges.front().begin(); }
     T back() const { return ranges.back().end(); }
 
+    // Iterate over elements in the set.
     iterator begin() const;
     iterator end() const;
-    
-    bool empty() const { return ranges.empty(); }
 
+    // Iterate over ranges in the set.
+    typedef typename Ranges::const_iterator RangeIterator;
+    RangeIterator rangesBegin() const { return ranges.begin(); }
+    RangeIterator rangesEnd() const { return ranges.end(); }
+    size_t rangesSize() const { return ranges.size(); }
+
+    bool empty() const { return ranges.empty(); }
+    void clear() { ranges.clear(); }
+    
     /** Return the largest contiguous range containing x.
      * Returns the empty range [x,x) if x is not in the set.
      */
     Range rangeContaining(const T&) const;
 
+    template <class S> void serialize(S& s) { s.split(*this); s(ranges.begin(), ranges.end()); }
+    template <class S> void encode(S& s) const { s(uint16_t(ranges.size()*sizeof(Range))); }
+    template <class S> void decode(S& s) { uint16_t sz; s(sz); ranges.resize(sz/sizeof(Range)); }
+    
  private:
     Ranges ranges;
 
@@ -188,10 +219,13 @@ bool RangeSet<T>::contains(const Range& r) const {
     return i != ranges.end() && i->contains(r);
 }
 
-template <class T> RangeSet<T>& RangeSet<T>::operator+=(const Range& r) {
+template <class T> void RangeSet<T>::addRange(const Range& r) {
+    if (r.empty()) return;
     typename Ranges::iterator i =
         std::lower_bound(ranges.begin(), ranges.end(), r.begin());
-    if (i != ranges.end() && i->touching(r)) {
+    if (i == ranges.end() || !i->touching(r)) 
+        ranges.insert(i, r);
+    else {
         i->merge(r);
         typename Ranges::iterator j = i;
         if (++j != ranges.end() && i->touching(*j)) {
@@ -199,19 +233,23 @@ template <class T> RangeSet<T>& RangeSet<T>::operator+=(const Range& r) {
             ranges.erase(j);
         }
     }
-    else
-        ranges.insert(i, r);
-    return *this;
+}
+
+
+template <class T> void RangeSet<T>::addSet(const RangeSet<T>& s) {
+    std::for_each(s.ranges.begin(), s.ranges.end(), 
+                  boost::bind((RangeSet<T>& (RangeSet<T>::*)(const Range&))&RangeSet<T>::operator+=, this, _1));
 }
 
 template <class T> void RangeSet<T>::removeRange(const Range& r) {
+    if (r.empty()) return;
     typename Ranges::iterator i,j;
     i = std::lower_bound(ranges.begin(), ranges.end(), r.begin());
     if (i == ranges.end() || i->begin() >= r.end())
         return;                 // Outside of set
     if (*i == r)                // Erase i
         ranges.erase(i);
-    else if (i->contains(r)) {  // Split i
+    else if (i->strictContains(r)) {  // Split i
         Range i1(i->begin(), r.begin());
         Range i2(r.end(), i->end());
         *i = i2;
@@ -273,6 +311,7 @@ template <class T> Range<T> RangeSet<T>::rangeContaining(const T& t) const {
     return (i != ranges.end() && i->contains(t)) ? *i : Range(t,t);
 }
 
+
 } // namespace qpid
 
 
diff --git a/qpid/cpp/src/qpid/amqp_0_10/built_in_types.h b/qpid/cpp/src/qpid/amqp_0_10/built_in_types.h
index 157696361d..7665d91736 100644
--- a/qpid/cpp/src/qpid/amqp_0_10/built_in_types.h
+++ b/qpid/cpp/src/qpid/amqp_0_10/built_in_types.h
@@ -22,8 +22,6 @@
  */
 
 #include "qpid/Serializer.h"
-#include "qpid/framing/SequenceNumber.h"
-#include "qpid/framing/SequenceSet.h"
 #include "qpid/framing/Uuid.h"
 #include "qpid/sys/Time.h"
 #include "Decimal.h"
@@ -38,6 +36,12 @@
 /**@file Mapping from built-in AMQP types to C++ types */
 
 namespace qpid {
+
+namespace framing {
+class SequenceNumber;
+class SequenceSet;
+}
+
 namespace amqp_0_10 {
 
 /** Wrapper that behaves like type T but is a distinct type for
@@ -143,6 +147,7 @@ class Map;
 class Struct32;
 class List;
 class UnknownType;
+
 template <class T> struct  ArrayDomain;
 typedef ArrayDomain<UnknownType> Array;
 
diff --git a/qpid/cpp/src/qpid/broker/SessionAdapter.cpp b/qpid/cpp/src/qpid/broker/SessionAdapter.cpp
index 3ad29e6271..c92b9bb945 100644
--- a/qpid/cpp/src/qpid/broker/SessionAdapter.cpp
+++ b/qpid/cpp/src/qpid/broker/SessionAdapter.cpp
@@ -25,6 +25,7 @@
 #include "qpid/framing/constants.h"
 #include "qpid/log/Statement.h"
 #include "qpid/amqp_0_10/exceptions.h"
+#include "qpid/framing/SequenceSet.h"
 #include <boost/format.hpp>
 #include <boost/cast.hpp>
 #include <boost/bind.hpp>
diff --git a/qpid/cpp/src/qpid/broker/SessionAdapter.h b/qpid/cpp/src/qpid/broker/SessionAdapter.h
index a80e2b0776..b5bf44ceba 100644
--- a/qpid/cpp/src/qpid/broker/SessionAdapter.h
+++ b/qpid/cpp/src/qpid/broker/SessionAdapter.h
@@ -26,7 +26,6 @@
 #include "qpid/Exception.h"
 #include "qpid/framing/AMQP_ServerOperations.h"
 #include "qpid/framing/reply_exceptions.h"
-#include "qpid/framing/SequenceSet.h"
 #include "qpid/framing/StructHelper.h"
 
 #include <vector>
diff --git a/qpid/cpp/src/qpid/broker/SessionHandler.h b/qpid/cpp/src/qpid/broker/SessionHandler.h
index 4010ce15d2..c299c465cf 100644
--- a/qpid/cpp/src/qpid/broker/SessionHandler.h
+++ b/qpid/cpp/src/qpid/broker/SessionHandler.h
@@ -30,7 +30,7 @@
 #include "qpid/framing/Array.h"
 #include "qpid/framing/ChannelHandler.h"
 #include "qpid/framing/SequenceNumber.h"
-#include "qpid/framing/SequenceSet.h"
+
 
 #include <boost/noncopyable.hpp>
 
diff --git a/qpid/cpp/src/qpid/client/Results.cpp b/qpid/cpp/src/qpid/client/Results.cpp
index 1fb3a6fec9..c605af2878 100644
--- a/qpid/cpp/src/qpid/client/Results.cpp
+++ b/qpid/cpp/src/qpid/client/Results.cpp
@@ -21,6 +21,7 @@
 
 #include "Results.h"
 #include "FutureResult.h"
+#include "qpid/framing/SequenceSet.h"
 
 using namespace qpid::framing;
 using namespace boost;
diff --git a/qpid/cpp/src/qpid/client/Results.h b/qpid/cpp/src/qpid/client/Results.h
index e17021b327..c325dcf1c5 100644
--- a/qpid/cpp/src/qpid/client/Results.h
+++ b/qpid/cpp/src/qpid/client/Results.h
@@ -20,7 +20,6 @@
  */
 
 #include "qpid/framing/SequenceNumber.h"
-#include "qpid/framing/SequenceSet.h"
 #include <map>
 #include <boost/shared_ptr.hpp>
 
diff --git a/qpid/cpp/src/qpid/framing/SequenceSet.cpp b/qpid/cpp/src/qpid/framing/SequenceSet.cpp
index 4903d92a91..2683b0025d 100644
--- a/qpid/cpp/src/qpid/framing/SequenceSet.cpp
+++ b/qpid/cpp/src/qpid/framing/SequenceSet.cpp
@@ -20,11 +20,16 @@
  */
 
 #include "SequenceSet.h"
+#include "Buffer.h"
+#include "qpid/framing/reply_exceptions.h"
 
 using namespace qpid::framing;
 using std::max;
 using std::min;
 
+namespace qpid {
+namespace framing {
+
 namespace {
 //each range contains 2 numbers, 4 bytes each
 uint16_t RANGE_SIZE = 2 * 4; 
@@ -32,9 +37,10 @@ uint16_t RANGE_SIZE = 2 * 4;
 
 void SequenceSet::encode(Buffer& buffer) const
 {
-    buffer.putShort(ranges.size() * RANGE_SIZE);
-    for (Ranges::const_iterator i = ranges.begin(); i != ranges.end(); i++) {
-        i->encode(buffer);
+    buffer.putShort(rangesSize() * RANGE_SIZE);
+    for (RangeIterator i = rangesBegin(); i != rangesEnd(); i++) {
+        buffer.putLong(i->first().getValue());
+        buffer.putLong(i->last().getValue());
     }
 }
 
@@ -42,189 +48,53 @@ void SequenceSet::decode(Buffer& buffer)
 {
     uint16_t size = buffer.getShort();
     uint16_t count = size / RANGE_SIZE;//number of ranges
-    if (size % RANGE_SIZE) throw FrameErrorException(QPID_MSG("Invalid size for sequence set: " << size)); 
+    if (size % RANGE_SIZE)
+        throw FrameErrorException(QPID_MSG("Invalid size for sequence set: " << size)); 
 
     for (uint16_t i = 0; i < count; i++) {
         add(SequenceNumber(buffer.getLong()), SequenceNumber(buffer.getLong()));
     }
 }
 
-uint32_t SequenceSet::size() const
-{
-    return 2 /*size field*/ + (ranges.size() * RANGE_SIZE);
+uint32_t SequenceSet::size() const {
+    return 2 /*size field*/ + (rangesSize() * RANGE_SIZE);
 }
 
-bool SequenceSet::contains(const SequenceNumber& point) const
-{
-    for (Ranges::const_iterator i = ranges.begin(); i != ranges.end(); i++) {
-        if (i->contains(point)) return true;
-    }
-    return false;
+bool SequenceSet::contains(const SequenceNumber& s) const {
+    return RangeSet<SequenceNumber>::contains(s);
 }
 
-void SequenceSet::add(const SequenceNumber& s)
-{
-    add(s, s);
-}
+void SequenceSet::add(const SequenceNumber& s) { *this += s; }
 
-void SequenceSet::add(const SequenceNumber& start, const SequenceNumber& end)
-{
-    if (start > end) {
-        add(end, start);
-    } else {
-        Range r(start, end);
-        Ranges::iterator merged = ranges.end();
-        Ranges::iterator i = ranges.begin();
-        while (i != ranges.end() && merged == ranges.end() && i->start < start) {
-            if (i->merge(r)) merged = i;            
-            i++;
-        }
-        if (merged == ranges.end()) {
-            i = merged = ranges.insert(i, r);
-            i++;
-        }
-        while (i != ranges.end() && merged->merge(*i)) {
-            i = ranges.erase(i);
-        }
-    }
+void SequenceSet::add(const SequenceNumber& start, const SequenceNumber& finish) {
+    *this += Range::makeClosed(std::min(start,finish), std::max(start, finish));
 }
 
-void SequenceSet::add(const SequenceSet& set)
-{
-    for (Ranges::const_iterator i = set.ranges.begin(); i != set.ranges.end(); i++) {
-        add(i->start, i->end);
-    }
-}
+void SequenceSet::add(const SequenceSet& set) { *this += set; }
 
-void SequenceSet::remove(const SequenceSet& set)
-{
-    for (Ranges::const_iterator i = set.ranges.begin(); i != set.ranges.end(); i++) {
-        remove(i->start, i->end);
-    }    
-}
+void SequenceSet::remove(const SequenceSet& set) { *this -= set; }
 
-void SequenceSet::remove(const SequenceNumber& start, const SequenceNumber& end)
-{
-    if (start > end) {
-        remove(end, start);
-    } else {
-        Ranges::iterator i = ranges.begin(); 
-        while (i != ranges.end() && i->start < start) {
-            if (start <= i->end) {
-                if (end > i->end) {
-                    //i.e. start is within the range pointed to by i, but end is not
-                    i->end = (uint32_t)start - 1;
-                } else {
-                    //whole of range to be deleted is contained within that pointed to be i
-                    if (end == i->end) {
-                        //just shrink range pointed to by i
-                        i->end = (uint32_t)start - 1;
-                    } else {
-                        //need to split the range pointed to by i
-                        Range r(i->start, (uint32_t)start - 1);
-                        i->start = end + 1;
-                        ranges.insert(i, r);
-                    }
-                    return;//no need to go any further
-                }
-            }
-            i++;
-        }
-        Ranges::iterator j = i;
-        while (j != ranges.end() && j->end < end) {            
-            j++;
-        }
-        if (j->start <= end){
-            j->start = end + 1;
-        }
-        ranges.erase(i, j);        
-    }
+void SequenceSet::remove(const SequenceNumber& start, const SequenceNumber& finish) {
+    *this -= Range::makeClosed(std::min(start,finish), std::max(start, finish));
 }
 
-void SequenceSet::remove(const SequenceNumber& s)
-{
-    for (Ranges::iterator i = ranges.begin(); i != ranges.end() && s >= i->start; i++) {
-        if (i->contains(s)) {
-            if (i->start == i->end) {
-                //range is just a single number, so we can delete the whole range
-                i = ranges.erase(i);
-            } else if (i->start == s) {
-                //move the start forward to exclude s
-                ++(i->start);
-            } else if (i->end == s) {
-                //move the end backward to exclude s
-                --(i->end);
-            } else {
-                //need to split range pointed to by i
-                Range r(i->start, (uint32_t)s - 1);
-                i->start = s + 1;
-                i = ranges.insert(i, r);
-            }
-            break;
-        }
-    }    
-}
+void SequenceSet::remove(const SequenceNumber& s) { *this -= s; }
 
-bool SequenceSet::empty() const
-{
-    return ranges.empty();
-}
 
-void SequenceSet::clear()
-{
-    return ranges.clear();
-}
-
-bool SequenceSet::Range::contains(SequenceNumber i) const 
-{ 
-    return i >= start && i <= end; 
-}
-
-bool SequenceSet::Range::intersects(const Range& r) const 
-{ 
-    return r.contains(start) || r.contains(end) || contains(r.start) || contains(r.end); 
-}
-
-bool SequenceSet::Range::merge(const Range& r) 
-{ 
-    if (intersects(r) || mergeable(r.end) || r.mergeable(end)) {
-        start = min(start, r.start); 
-        end = max(end, r.end); 
-        return true;
-    } else {
-        return false;
-    }
-}
-
-bool SequenceSet::Range::mergeable(const SequenceNumber& s) const
-{ 
-    if (contains(s) || start - s == 1 || s - end == 1) {
-        return true;
-    } else {
-        return false;
+struct RangePrinter {
+    std::ostream& out;
+    RangePrinter(std::ostream& o) : out(o) {}
+    void operator()(SequenceNumber i, SequenceNumber j) {
+        out << "[" << i.getValue() << "," << j.getValue() << "] ";
     }
-}
+};
 
-void SequenceSet::Range::encode(Buffer& buffer) const
-{
-    buffer.putLong(start);
-    buffer.putLong(end);
+std::ostream& operator<<(std::ostream& o, const SequenceSet& s) {
+    RangePrinter print(o);
+    o << "{ ";
+    s.for_each(print);
+    return o << "}";
 }
 
-SequenceSet::Range::Range(SequenceNumber s, SequenceNumber e) : start(s), end(e) {}
+}} // namespace qpid::framing
 
-namespace qpid{
-namespace framing{
-
-std::ostream& operator<<(std::ostream& out, const SequenceSet& set) {
-    out << "{";
-    for (SequenceSet::Ranges::const_iterator i = set.ranges.begin(); i != set.ranges.end(); i++) {
-        if (i != set.ranges.begin()) out << ", "; 
-        out << i->start.getValue() << "-" << i->end.getValue();
-    }
-    out << "}";
-    return out;
-}
-
-}
-}
diff --git a/qpid/cpp/src/qpid/framing/SequenceSet.h b/qpid/cpp/src/qpid/framing/SequenceSet.h
index 8b3d6b3f28..f934bb40bb 100644
--- a/qpid/cpp/src/qpid/framing/SequenceSet.h
+++ b/qpid/cpp/src/qpid/framing/SequenceSet.h
@@ -21,38 +21,18 @@
 #ifndef _framing_SequenceSet_h
 #define _framing_SequenceSet_h
 
-#include "amqp_types.h"
-#include "Buffer.h"
 #include "SequenceNumber.h"
-#include "qpid/framing/reply_exceptions.h"
-#include <ostream>
-#include <list>
+#include "qpid/RangeSet.h"
 
 namespace qpid {
 namespace framing {
+class Buffer;
 
-class SequenceSet {
-    struct Range {
-        SequenceNumber start;
-        SequenceNumber end;
-        
-        Range(SequenceNumber s=0, SequenceNumber e=0);
-        bool contains(SequenceNumber i) const;
-        bool intersects(const Range& r) const;
-        bool merge(const Range& r);
-        bool mergeable(const SequenceNumber& r) const;
-        void encode(Buffer& buffer) const;
-
-        template <class S> void serialize(S& s) { s(start)(end); }
-    };
-
-    typedef std::list<Range> Ranges;
-    Ranges ranges;
-
+class SequenceSet : public RangeSet<SequenceNumber> {
   public:
     SequenceSet() {}
     explicit SequenceSet(const SequenceNumber& s) { add(s); }
-
+    
     void encode(Buffer& buffer) const;
     void decode(Buffer& buffer);
     uint32_t size() const;   
@@ -65,26 +45,16 @@ class SequenceSet {
     void remove(const SequenceNumber& start, const SequenceNumber& end);
     void remove(const SequenceSet& set);
 
-    void clear();
-    bool empty() const;
-
-    template <class T>
-    T for_each(T& t) const
-    {
-        for (Ranges::const_iterator i = ranges.begin(); i != ranges.end(); i++) {
-            t(i->start, i->end);
+    template <class T> T for_each(T& t) const {
+        for (RangeIterator i = rangesBegin(); i != rangesEnd(); i++) {
+            t(i->first(), i->last());
         }
         return t;
     }
 
-    template <class S> void serialize(S& s) { s.split(*this); s(ranges.begin(), ranges.end()); }
-    template <class S> void encode(S& s) const { s(uint16_t(ranges.size()*sizeof(Range))); }
-    template <class S> void decode(S& s) { uint16_t sz; s(sz); ranges.resize(sz/sizeof(Range)); }
-    
   friend std::ostream& operator<<(std::ostream&, const SequenceSet&);
 };    
 
-
 }} // namespace qpid::framing
 
 
diff --git a/qpid/cpp/src/tests/Makefile.am b/qpid/cpp/src/tests/Makefile.am
index bd020e4f77..c5baf5c73b 100644
--- a/qpid/cpp/src/tests/Makefile.am
+++ b/qpid/cpp/src/tests/Makefile.am
@@ -1,4 +1,4 @@
-AM_CXXFLAGS = $(WARNING_CFLAGS) $(CPPUNIT_CXXFLAGS)   $(APR_CXXFLAGS) -DBOOST_TEST_DYN_LINK
+AM_CXXFLAG = $(WARNING_CFLAGS) $(CPPUNIT_CXXFLAGS)   $(APR_CXXFLAGS) -DBOOST_TEST_DYN_LINK
 INCLUDES =  -I$(srcdir)/.. -I$(srcdir)/../gen -I$(top_builddir)/src/gen
 
 abs_builddir=@abs_builddir@
diff --git a/qpid/cpp/src/tests/RangeSet.cpp b/qpid/cpp/src/tests/RangeSet.cpp
index e16339ab84..9c602de78d 100644
--- a/qpid/cpp/src/tests/RangeSet.cpp
+++ b/qpid/cpp/src/tests/RangeSet.cpp
@@ -63,6 +63,22 @@ QPID_AUTO_TEST_CASE(testRangeSetAddRange) {
     BOOST_CHECK(r.back() == 6);
 }
 
+QPID_AUTO_TEST_CASE(testRangeSetAddSet) {
+    TestRangeSet r;
+    TestRangeSet s = TestRangeSet(0,3)+TestRange(5,10);
+    r += s;
+    BOOST_CHECK_EQUAL(r,s);
+    r += TestRangeSet(3,5) + TestRange(7,12) + 15;
+    BOOST_CHECK_EQUAL(r, TestRangeSet(0,12) + 15);
+
+    r.clear();
+    BOOST_CHECK(r.empty());
+    r += TestRange::makeClosed(6,10);
+    BOOST_CHECK_EQUAL(r, TestRangeSet(6,11));
+    r += TestRangeSet(2,6)+8;
+    BOOST_CHECK_EQUAL(r, TestRangeSet(2,11));
+}
+
 QPID_AUTO_TEST_CASE(testRangeSetIterate) {
     TestRangeSet r;
     (((r += 1) += 10) += TestRange(4,7)) += 2;
@@ -74,12 +90,14 @@ QPID_AUTO_TEST_CASE(testRangeSetIterate) {
 }
 
 QPID_AUTO_TEST_CASE(testRangeSetRemove) {
+    // points
     BOOST_CHECK_EQUAL(TestRangeSet(0,5)-3, TestRangeSet(0,3)+TestRange(4,5));
     BOOST_CHECK_EQUAL(TestRangeSet(1,5)-5, TestRangeSet(1,5));
     BOOST_CHECK_EQUAL(TestRangeSet(1,5)-0, TestRangeSet(1,5));
 
     TestRangeSet r(TestRangeSet(0,5)+TestRange(10,15)+TestRange(20,25));
 
+    // TestRanges
     BOOST_CHECK_EQUAL(r-TestRange(0,5), TestRangeSet(10,15)+TestRange(20,25));
     BOOST_CHECK_EQUAL(r-TestRange(10,15), TestRangeSet(0,5)+TestRange(20,25));
     BOOST_CHECK_EQUAL(r-TestRange(20,25), TestRangeSet(0,5)+TestRange(10,15));
@@ -89,16 +107,22 @@ QPID_AUTO_TEST_CASE(testRangeSetRemove) {
     BOOST_CHECK_EQUAL(r-TestRange(-5, 7), TestRangeSet(10,15)+TestRange(20,25));
     BOOST_CHECK_EQUAL(r-TestRange(8,19), TestRangeSet(0,5)+TestRange(20,25));
     BOOST_CHECK_EQUAL(r-TestRange(17,30), TestRangeSet(0,5)+TestRange(10,15));
+    BOOST_CHECK_EQUAL(r-TestRange(17,30), TestRangeSet(0,5)+TestRange(10,15));
 
     BOOST_CHECK_EQUAL(r-TestRange(-5, 5), TestRangeSet(10,15)+TestRange(20,25));
     BOOST_CHECK_EQUAL(r-TestRange(10,19), TestRangeSet(0,5)+TestRange(20,25));
     BOOST_CHECK_EQUAL(r-TestRange(18,25), TestRangeSet(0,5)+TestRange(10,15));
+    BOOST_CHECK_EQUAL(r-TestRange(23,25), TestRangeSet(0,5)+TestRange(10,15)+TestRange(20,23));
 
     BOOST_CHECK_EQUAL(r-TestRange(-3, 3), TestRangeSet(3,5)+TestRange(10,15)+TestRange(20,25));
     BOOST_CHECK_EQUAL(r-TestRange(3, 7), TestRangeSet(0,2)+TestRange(10,15)+TestRange(20,25));
     BOOST_CHECK_EQUAL(r-TestRange(3, 12), TestRangeSet(0,3)+TestRange(12,15)+TestRange(20,25));
     BOOST_CHECK_EQUAL(r-TestRange(3, 22), TestRangeSet(12,15)+TestRange(22,25));
     BOOST_CHECK_EQUAL(r-TestRange(12, 22), TestRangeSet(0,5)+TestRange(10,11)+TestRange(22,25));
+
+    // Sets
+    BOOST_CHECK_EQUAL(r-(TestRangeSet(-1,6)+TestRange(11,14)+TestRange(23,25)),
+                      TestRangeSet(10,11)+TestRange(14,15)+TestRange(20,23));
 }
 
 QPID_AUTO_TEST_CASE(testRangeContaining) {
diff --git a/qpid/cpp/src/tests/SequenceSet.cpp b/qpid/cpp/src/tests/SequenceSet.cpp
index c204a8b5c5..1cc66fa55a 100644
--- a/qpid/cpp/src/tests/SequenceSet.cpp
+++ b/qpid/cpp/src/tests/SequenceSet.cpp
@@ -80,7 +80,7 @@ QPID_AUTO_TEST_CASE(testAdd) {
         BOOST_CHECK(!t.contains(i));
 
     for (uint32_t i = 2; i <= 10; i++)
-        BOOST_CHECK(t.contains(i));
+        BOOST_CHECK_MESSAGE(t.contains(i), t << " contains " << i);
 
     RangeExpectations().expect(2, 10).check(t);
 }