Changed exception names

test/test_array.cpp

@@ -153,7 +153,7 @@ namespace
         CHECK_EQUAL(data.at(i), testData.at(i));
       }
 
-      CHECK_THROW(data.at(data.size()), etl::array_out_of_range_exception);
+      CHECK_THROW(data.at(data.size()), etl::array_out_of_range);
     }
 
     //*************************************************************************
@@ -164,7 +164,7 @@ namespace
         CHECK_EQUAL(data.at(i), testData.at(i));
       }
 
-      CHECK_THROW(data.at(data.size()), etl::array_out_of_range_exception);
+      CHECK_THROW(data.at(data.size()), etl::array_out_of_range);
     }
 
     //*************************************************************************

test/test_cyclic_value.cpp

@@ -188,7 +188,7 @@ namespace
     {
       etl::cyclic_value<int> value;
       
-      CHECK_THROW(value.set(2, 7, 4), etl::cyclic_value_illegal_range_exception);
+      CHECK_THROW(value.set(2, 7, 4), etl::cyclic_value_illegal_range);
     }
   };
 }

test/test_list.cpp

@@ -25,6 +25,7 @@ SOFTWARE.
 ******************************************************************************/
 
 #include <UnitTest++/UnitTest++.h>
+#include "ExtraCheckMacros.h"
 
 #include "../list.h"
 
@@ -84,7 +85,7 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, ConstructorSizeExcess)
     {
-      CHECK_THROW(Data data(SIZE + 1), etl::list_full_exception);
+      CHECK_THROW(Data data(SIZE + 1), etl::list_full);
     }
 
     //*************************************************************************
@@ -215,7 +216,7 @@ namespace
       const size_t INITIAL_SIZE = 4;
       Data data(INITIAL_SIZE);
 
-      CHECK_THROW(data.resize(data.max_size() + 1), etl::list_full_exception);
+      CHECK_THROW(data.resize(data.max_size() + 1), etl::list_full);
     }
 
     //*************************************************************************
@@ -284,7 +285,7 @@ namespace
 
       Data data;
 
-      CHECK_THROW(data.assign(data.max_size() + 1, VALUE), etl::list_full_exception);
+      CHECK_THROW(data.assign(data.max_size() + 1, VALUE), etl::list_full);
     }
 
     //*************************************************************************
@@ -394,21 +395,12 @@ namespace
       compare_data.push_front(5);
       compare_data.push_front(6);
 
-#ifdef CHECK_NO_THROW
       CHECK_NO_THROW(data.push_front(1));
       CHECK_NO_THROW(data.push_front(2));
       CHECK_NO_THROW(data.push_front(3));
       CHECK_NO_THROW(data.push_front(4));
       CHECK_NO_THROW(data.push_front(5));
       CHECK_NO_THROW(data.push_front(6));
-#else
-      data.push_front(1);
-      data.push_front(2);
-      data.push_front(3);
-      data.push_front(4);
-      data.push_front(5);
-      data.push_front(6);
-#endif
 
       are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
 
@@ -418,10 +410,8 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, PushFrontExcess)
     {  
-      bool gotException = false;
       Data data;
 
-#ifdef CHECK_NO_THROW
       CHECK_NO_THROW(data.push_front(1));
       CHECK_NO_THROW(data.push_front(2));
       CHECK_NO_THROW(data.push_front(3));
@@ -432,20 +422,8 @@ namespace
       CHECK_NO_THROW(data.push_front(8));
       CHECK_NO_THROW(data.push_front(9));
       CHECK_NO_THROW(data.push_front(10));
-#else
-      data.push_front(1);
-      data.push_front(2);
-      data.push_front(3);
-      data.push_front(4);
-      data.push_front(5);
-      data.push_front(6);
-      data.push_front(7);
-      data.push_front(8);
-      data.push_front(9);
-      data.push_front(10);
-#endif
 
-      CHECK_THROW(data.push_front(11) , etl::list_full_exception);
+      CHECK_THROW(data.push_front(11) , etl::list_full);
     }
 
     //*************************************************************************
@@ -455,11 +433,7 @@ namespace
 
       for (size_t i = 0; i < 2 * data.max_size(); ++i)
       {
-#ifdef CHECK_NO_THROW
         CHECK_NO_THROW(data.push_front(i));
-#else
-        data.push_back(i);
-#endif
         data.pop_front();
       }
       
@@ -473,11 +447,7 @@ namespace
 
       for (size_t i = 0; i < 2 * data.max_size(); ++i)
       {
-#ifdef CHECK_NO_THROW
         CHECK_NO_THROW(data.push_front(i));
-#else
-        data.push_back(i);
-#endif
         data.pop_back();
       }
 
@@ -491,11 +461,7 @@ namespace
 
       for (size_t i = 0; i < 2 * data.max_size(); ++i)
       {
-#ifdef CHECK_NO_THROW
         CHECK_NO_THROW(data.push_front(i));
-#else
-        data.push_back(i);
-#endif
         data.pop_front();
       }
       
@@ -509,11 +475,7 @@ namespace
 
       for (size_t i = 0; i < 2 * data.max_size(); ++i)
       {
-#ifdef CHECK_NO_THROW
         CHECK_NO_THROW(data.push_front(i));
-#else
-        data.push_back(i);
-#endif
         data.pop_back();
       }
       
@@ -533,32 +495,21 @@ namespace
       compare_data.push_back(5);
       compare_data.push_back(6);
 
-#ifdef CHECK_NO_THROW
       CHECK_NO_THROW(data.push_back(1));
       CHECK_NO_THROW(data.push_back(2));
       CHECK_NO_THROW(data.push_back(3));
       CHECK_NO_THROW(data.push_back(4));
       CHECK_NO_THROW(data.push_back(5));
       CHECK_NO_THROW(data.push_back(6));
-#else
-      data.push_back(1);
-      data.push_back(2);
-      data.push_back(3);
-      data.push_back(4);
-      data.push_back(5);
-      data.push_back(6);
-#endif
 
       are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
 
       CHECK(are_equal);
     }
-
+    
-
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, PushBackExcess)
     {
-      bool gotException = false;
       Data data;
 
       data.push_back(1);
@@ -572,7 +523,7 @@ namespace
       data.push_back(9);
       data.push_back(10);
 
-      CHECK_THROW(data.push_back(11), etl::list_full_exception);
+      CHECK_THROW(data.push_back(11), etl::list_full);
     }
 
     //*************************************************************************

test/test_observer.cpp

@@ -420,7 +420,7 @@ namespace
       observable.add_observer(observer4);
       CHECK_EQUAL(4, observable.number_of_observers());
 
-      CHECK_THROW(observable.add_observer(observer5), etl::observer_list_full_exception);
+      CHECK_THROW(observable.add_observer(observer5), etl::observer_list_full);
 
       observable.remove_observer(observer3);
       CHECK_EQUAL(3, observable.number_of_observers());

test/test_queue.cpp

@@ -134,7 +134,7 @@ namespace
         queue.push(1);
       }
 
-      CHECK_THROW(queue.push(1), etl::queue_full_exception);      
+      CHECK_THROW(queue.push(1), etl::queue_full);      
     }
 
     //*************************************************************************
@@ -190,7 +190,7 @@ namespace
     {
       etl::queue<int, 4> queue;
 
-      CHECK_THROW(queue.front(), etl::queue_empty_exception);
+      CHECK_THROW(queue.front(), etl::queue_empty);
     }
 
     //*************************************************************************
@@ -229,7 +229,7 @@ namespace
     {
       etl::queue<int, 4> queue;
 
-      CHECK_THROW(queue.back(), etl::queue_empty_exception);
+      CHECK_THROW(queue.back(), etl::queue_empty);
     }
 
     //*************************************************************************

test/test_stack.cpp

@@ -134,7 +134,7 @@ namespace
         stack.push(1);
       }
 
-      CHECK_THROW(stack.push(1), etl::stack_full_exception);
+      CHECK_THROW(stack.push(1), etl::stack_full);
     }
 
     //*************************************************************************
@@ -190,7 +190,7 @@ namespace
     {
       etl::stack<int, 4> stack;
 
-      CHECK_THROW(stack.top(), etl::stack_empty_exception);
+      CHECK_THROW(stack.top(), etl::stack_empty);
     }
 
     //*************************************************************************

test/test_vector.cpp

@@ -109,7 +109,7 @@ namespace
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, ConstructorSizeExcess)
     {
-      CHECK_THROW(Data data(SIZE + 1), etl::vector_full_exception);
+      CHECK_THROW(Data data(SIZE + 1), etl::vector_full);
     }
 
     //*************************************************************************
@@ -217,7 +217,7 @@ namespace
 
       Data data(INITIAL_SIZE);
 
-      CHECK_THROW(data.resize(NEW_SIZE), etl::vector_full_exception);
+      CHECK_THROW(data.resize(NEW_SIZE), etl::vector_full);
     }
 
     //*************************************************************************
@@ -318,7 +318,7 @@ namespace
 
       Data data;
       
-      CHECK_THROW(data.assign(EXCESS_SIZE, INITIAL_VALUE), etl::vector_full_exception);
+      CHECK_THROW(data.assign(EXCESS_SIZE, INITIAL_VALUE), etl::vector_full);
     }
 
     //*************************************************************************
@@ -376,15 +376,15 @@ namespace
 
       size_t offset = 2;
 
-      CHECK_THROW(data.insert(data.begin() + offset, INITIAL_VALUE), etl::vector_full_exception);
+      CHECK_THROW(data.insert(data.begin() + offset, INITIAL_VALUE), etl::vector_full);
 
       offset = 0;
 
-      CHECK_THROW(data.insert(data.begin() + offset, INITIAL_VALUE), etl::vector_full_exception);
+      CHECK_THROW(data.insert(data.begin() + offset, INITIAL_VALUE), etl::vector_full);
 
       offset = data.size();
 
-      CHECK_THROW(data.insert(data.begin() + offset, INITIAL_VALUE), etl::vector_full_exception);
+      CHECK_THROW(data.insert(data.begin() + offset, INITIAL_VALUE), etl::vector_full);
     }
 
     //*************************************************************************
@@ -449,15 +449,15 @@ namespace
 
       size_t offset = 2;
 
-      CHECK_THROW(data.insert(data.begin() + offset, INSERT_SIZE, INITIAL_VALUE), etl::vector_full_exception);
+      CHECK_THROW(data.insert(data.begin() + offset, INSERT_SIZE, INITIAL_VALUE), etl::vector_full);
 
       offset = 0;
      
-      CHECK_THROW(data.insert(data.begin() + offset, INSERT_SIZE, INITIAL_VALUE), etl::vector_full_exception);
+      CHECK_THROW(data.insert(data.begin() + offset, INSERT_SIZE, INITIAL_VALUE), etl::vector_full);
 
       offset = data.size();
 
-      CHECK_THROW(data.insert(data.begin() + offset, INSERT_SIZE, INITIAL_VALUE), etl::vector_full_exception);
+      CHECK_THROW(data.insert(data.begin() + offset, INSERT_SIZE, INITIAL_VALUE), etl::vector_full);
     }
 
     //*************************************************************************
@@ -518,15 +518,15 @@ namespace
 
       size_t offset = 2; 
 
-      CHECK_THROW(data.insert(data.begin() + offset, initial_data.begin(), initial_data.end()), etl::vector_full_exception);
+      CHECK_THROW(data.insert(data.begin() + offset, initial_data.begin(), initial_data.end()), etl::vector_full);
 
       offset = 0;
 
-      CHECK_THROW(data.insert(data.begin() + offset, initial_data.begin(), initial_data.end()), etl::vector_full_exception);
+      CHECK_THROW(data.insert(data.begin() + offset, initial_data.begin(), initial_data.end()), etl::vector_full);
 
       offset = data.size();
 
-      CHECK_THROW(data.insert(data.begin() + offset, initial_data.begin(), initial_data.end()), etl::vector_full_exception);
+      CHECK_THROW(data.insert(data.begin() + offset, initial_data.begin(), initial_data.end()), etl::vector_full);
     }
 
     //*************************************************************************
@@ -580,7 +580,7 @@ namespace
         data.push_back(i);
       }
 
-      CHECK_THROW(data.push_back(SIZE), etl::vector_full_exception);
+      CHECK_THROW(data.push_back(SIZE), etl::vector_full);
     }
 
     //*************************************************************************
@@ -689,7 +689,7 @@ namespace
         CHECK_EQUAL(data.at(i), testData.at(i));
       }
 
-      CHECK_THROW(data.at(data.size()), etl::vector_out_of_bounds_exception);
+      CHECK_THROW(data.at(data.size()), etl::vector_out_of_bounds);
     }
 
     //*************************************************************************

vector_base.h

@@ -58,11 +58,11 @@ namespace etl
   ///\ingroup vector
   /// Vector full exception.
   //***************************************************************************
-  class vector_full_exception : public vector_exception
+  class vector_full : public vector_exception
   {
   public:
 
-    vector_full_exception()
+    vector_full()
       : vector_exception("vector full")
     {
     }
@@ -72,11 +72,11 @@ namespace etl
   ///\ingroup vector
   /// Vector empty exception.
   //***************************************************************************
-  class vector_empty_exception : public vector_exception
+  class vector_empty : public vector_exception
   {
   public:
 
-    vector_empty_exception()
+    vector_empty()
       : vector_exception("vector empty")
     {
     }
@@ -86,11 +86,11 @@ namespace etl
   ///\ingroup vector
   /// Vector out of bounds exception.
   //***************************************************************************
-  class vector_out_of_bounds_exception : public vector_exception
+  class vector_out_of_bounds : public vector_exception
   {
   public:
 
-    vector_out_of_bounds_exception()
+    vector_out_of_bounds()
       : vector_exception("vector out of bounds")
     {
     }
@@ -100,11 +100,11 @@ namespace etl
   ///\ingroup vector
   /// Vector iterator exception.
   //***************************************************************************
-  class vector_iterator_exception : public vector_exception
+  class vector_iterator : public vector_exception
   {
   public:
 
-    vector_iterator_exception()
+    vector_iterator()
       : vector_exception("vector iterator error")
     {
     }
@@ -176,14 +176,14 @@ namespace etl
 
     //*************************************************************************
     /// Increases the size of the vector by one, but does not initialise the new element.
-    /// If ETL_USE_EXCEPTIONS is defined, throws a vector_full_exception if the vector is already full.
+    /// If ETL_USE_EXCEPTIONS is defined, throws a vector_full if the vector is already full.
     //*************************************************************************
     void push_back()
     {
 #ifdef ETL_USE_EXCEPTIONS
       if (current_size == MAX_SIZE)
       {
-        throw vector_full_exception();
+        throw vector_full();
       }
 #endif