new functions min and max for 2 - 2+n parameters - now in C++11 vith variadics
This commit is contained in:
		@@ -29,6 +29,7 @@
 | 
			
		||||
#include <mrw/multiset.hxx>
 | 
			
		||||
#include <mrw/multimap.hxx>
 | 
			
		||||
#include <mrw/stacktrace.hxx>
 | 
			
		||||
#include <mrw/stdext.hxx>
 | 
			
		||||
#include <cppunit/TestFixture.h>
 | 
			
		||||
#include <cppunit/ui/text/TestRunner.h>
 | 
			
		||||
#include <cppunit/extensions/HelperMacros.h>
 | 
			
		||||
@@ -37,233 +38,255 @@
 | 
			
		||||
#include <fstream>
 | 
			
		||||
 | 
			
		||||
class StdExtTest: public CppUnit::TestFixture { 
 | 
			
		||||
public:
 | 
			
		||||
  void StringConv() {
 | 
			
		||||
    std::string s("Integer=");
 | 
			
		||||
    int i(-7382);
 | 
			
		||||
    CPPUNIT_ASSERT_EQUAL(std::string("Integer=-7382"), s+mrw::string(i));
 | 
			
		||||
    CPPUNIT_ASSERT_EQUAL(i, mrw::to<int>(mrw::string(i)));
 | 
			
		||||
  }
 | 
			
		||||
  void StringShift() {
 | 
			
		||||
    std::string s("Integer=");
 | 
			
		||||
    int i(4);
 | 
			
		||||
    CPPUNIT_ASSERT_EQUAL(std::string("Integer=4 test 45 xx"),
 | 
			
		||||
                         (s<<i<<" test "<<4<<(long)5<<" xx"));
 | 
			
		||||
    int i2 = 0;
 | 
			
		||||
    std::string s2, s3;
 | 
			
		||||
    CPPUNIT_ASSERT_NO_THROW(s>>s2>>s3>>i2);
 | 
			
		||||
    CPPUNIT_ASSERT_EQUAL(std::string("Integer=4"), s2);
 | 
			
		||||
    CPPUNIT_ASSERT_EQUAL(std::string("test"), s3);
 | 
			
		||||
    CPPUNIT_ASSERT_EQUAL(45, i2);
 | 
			
		||||
    CPPUNIT_ASSERT_EQUAL(std::string(" xx"), s);
 | 
			
		||||
    s2=""; s3="";
 | 
			
		||||
    s>>s2;
 | 
			
		||||
    CPPUNIT_ASSERT_EQUAL(std::string("xx"), s2);
 | 
			
		||||
  public:
 | 
			
		||||
    void StringConv() {
 | 
			
		||||
      std::string s("Integer=");
 | 
			
		||||
      int i(-7382);
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(std::string("Integer=-7382"), s+mrw::string(i));
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(i, mrw::to<int>(mrw::string(i)));
 | 
			
		||||
    }
 | 
			
		||||
    void StringShift() {
 | 
			
		||||
      std::string s("Integer=");
 | 
			
		||||
      int i(4);
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(std::string("Integer=4 test 45 xx"),
 | 
			
		||||
                           (s<<i<<" test "<<4<<(long)5<<" xx"));
 | 
			
		||||
      int i2 = 0;
 | 
			
		||||
      std::string s2, s3;
 | 
			
		||||
      CPPUNIT_ASSERT_NO_THROW(s>>s2>>s3>>i2);
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(std::string("Integer=4"), s2);
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(std::string("test"), s3);
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(45, i2);
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(std::string(" xx"), s);
 | 
			
		||||
      s2=""; s3="";
 | 
			
		||||
      s>>s2;
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(std::string("xx"), s2);
 | 
			
		||||
    CPPUNIT_ASSERT_EQUAL(std::string(), s);
 | 
			
		||||
  }
 | 
			
		||||
  void StringAdd() {
 | 
			
		||||
    std::string s;
 | 
			
		||||
    s=s+(signed short)1+(signed int)2+(signed long)3+(signed char)'A'+
 | 
			
		||||
      (unsigned short)1+(unsigned int)2+(unsigned long)3+(unsigned char)'A'+'c';
 | 
			
		||||
    CPPUNIT_ASSERT_EQUAL(std::string("1236512365c"), s);
 | 
			
		||||
    s=(signed short)-4+s;
 | 
			
		||||
    s=(signed int)5+s;
 | 
			
		||||
    s=(signed long)6+s;
 | 
			
		||||
    s=(signed char)8+s;
 | 
			
		||||
    s=(unsigned short)4+s;
 | 
			
		||||
    s=(unsigned int)5+s;
 | 
			
		||||
    s=(unsigned long)6+s;
 | 
			
		||||
    s=(unsigned char)8+s;
 | 
			
		||||
    s='a'+s;
 | 
			
		||||
    CPPUNIT_ASSERT_EQUAL(std::string("a8654865-41236512365c"), s);
 | 
			
		||||
    s+=(signed short)-4;
 | 
			
		||||
    s+=(signed int)5  ;
 | 
			
		||||
    s+=(signed long)6;
 | 
			
		||||
    s+=(signed char)8  ;
 | 
			
		||||
    s+=(unsigned short)4;
 | 
			
		||||
    s+=(unsigned int)5  ;
 | 
			
		||||
    s+=(unsigned long)6;
 | 
			
		||||
    s+=(unsigned char)8  ;
 | 
			
		||||
    s+='a';
 | 
			
		||||
    CPPUNIT_ASSERT_EQUAL(std::string("a8654865-41236512365c-45684568a"), s);
 | 
			
		||||
  }
 | 
			
		||||
  void ListShift() {
 | 
			
		||||
    std::list<int> l;
 | 
			
		||||
    l<<1<<2<<3<<4<<5<<6<<7<<8;
 | 
			
		||||
    int i1(0), i2(0), i3(0), i4(0);
 | 
			
		||||
    l>>i1>>i2>>i3>>i4;
 | 
			
		||||
    // now: i1==1 i2==2 i3==3 i4==4 l=={5, 6, 7, 8}
 | 
			
		||||
    CPPUNIT_ASSERT(i1==1 && i2==2 && i3==3 && i4==4);
 | 
			
		||||
    CPPUNIT_ASSERT_EQUAL(std::list<int>::size_type(4), l.size());
 | 
			
		||||
    for (int i=0; i<4; (l.pop_front(), ++i)) {
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(i+5, l.front());
 | 
			
		||||
    }
 | 
			
		||||
    bool exc(false);
 | 
			
		||||
    try {
 | 
			
		||||
      l>>i1;
 | 
			
		||||
    } catch (mrw::length_error&) {
 | 
			
		||||
      exc=true;
 | 
			
		||||
    void StringAdd() {
 | 
			
		||||
      std::string s;
 | 
			
		||||
      s=s+(signed short)1+(signed int)2+(signed long)3+(signed char)'A'+
 | 
			
		||||
        (unsigned short)1+(unsigned int)2+(unsigned long)3+(unsigned char)'A'
 | 
			
		||||
        +'c';
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(std::string("1236512365c"), s);
 | 
			
		||||
      s=(signed short)-4+s;
 | 
			
		||||
      s=(signed int)5+s;
 | 
			
		||||
      s=(signed long)6+s;
 | 
			
		||||
      s=(signed char)8+s;
 | 
			
		||||
      s=(unsigned short)4+s;
 | 
			
		||||
      s=(unsigned int)5+s;
 | 
			
		||||
      s=(unsigned long)6+s;
 | 
			
		||||
      s=(unsigned char)8+s;
 | 
			
		||||
      s='a'+s;
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(std::string("a8654865-41236512365c"), s);
 | 
			
		||||
      s+=(signed short)-4;
 | 
			
		||||
      s+=(signed int)5  ;
 | 
			
		||||
      s+=(signed long)6;
 | 
			
		||||
      s+=(signed char)8  ;
 | 
			
		||||
      s+=(unsigned short)4;
 | 
			
		||||
      s+=(unsigned int)5  ;
 | 
			
		||||
      s+=(unsigned long)6;
 | 
			
		||||
      s+=(unsigned char)8  ;
 | 
			
		||||
      s+='a';
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(std::string("a8654865-41236512365c-45684568a"), s);
 | 
			
		||||
    }
 | 
			
		||||
    CPPUNIT_ASSERT(exc);
 | 
			
		||||
  }
 | 
			
		||||
  void VectorShift() {
 | 
			
		||||
    std::vector<int> l;
 | 
			
		||||
    CPPUNIT_ASSERT_NO_THROW(l<<1<<2<<3<<4<<5<<6<<7<<8);
 | 
			
		||||
    CPPUNIT_ASSERT_EQUAL(std::vector<int>::size_type(8), l.size());
 | 
			
		||||
    int i1(0), i2(0), i3(0), i4(0);
 | 
			
		||||
    CPPUNIT_ASSERT_NO_THROW(l>>i1>>i2>>i3>>i4);
 | 
			
		||||
    CPPUNIT_ASSERT_EQUAL(std::vector<int>::size_type(4), l.size());
 | 
			
		||||
    // now: i1==1 i2==2 i3==3 i4==4 l=={5, 6, 7, 8}
 | 
			
		||||
    CPPUNIT_ASSERT(i1==1 && i2==2 && i3==3 && i4==4);
 | 
			
		||||
    CPPUNIT_ASSERT(l.size()==4);
 | 
			
		||||
    for (int i=0; i<4; (l.erase(l.begin()), ++i)) {
 | 
			
		||||
      CPPUNIT_ASSERT(l.front()==i+5);
 | 
			
		||||
    void ListShift() {
 | 
			
		||||
      std::list<int> l;
 | 
			
		||||
      l<<1<<2<<3<<4<<5<<6<<7<<8;
 | 
			
		||||
      int i1(0), i2(0), i3(0), i4(0);
 | 
			
		||||
      l>>i1>>i2>>i3>>i4;
 | 
			
		||||
      // now: i1==1 i2==2 i3==3 i4==4 l=={5, 6, 7, 8}
 | 
			
		||||
      CPPUNIT_ASSERT(i1==1 && i2==2 && i3==3 && i4==4);
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(std::list<int>::size_type(4), l.size());
 | 
			
		||||
      for (int i=0; i<4; (l.pop_front(), ++i)) {
 | 
			
		||||
        CPPUNIT_ASSERT_EQUAL(i+5, l.front());
 | 
			
		||||
      }
 | 
			
		||||
      bool exc(false);
 | 
			
		||||
      try {
 | 
			
		||||
        l>>i1;
 | 
			
		||||
      } catch (mrw::length_error&) {
 | 
			
		||||
        exc=true;
 | 
			
		||||
      }
 | 
			
		||||
      CPPUNIT_ASSERT(exc);
 | 
			
		||||
    }
 | 
			
		||||
    bool exc(false);
 | 
			
		||||
    try {
 | 
			
		||||
      l>>i1;
 | 
			
		||||
    } catch (mrw::length_error&) {
 | 
			
		||||
      exc=true;
 | 
			
		||||
    void VectorShift() {
 | 
			
		||||
      std::vector<int> l;
 | 
			
		||||
      CPPUNIT_ASSERT_NO_THROW(l<<1<<2<<3<<4<<5<<6<<7<<8);
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(std::vector<int>::size_type(8), l.size());
 | 
			
		||||
      int i1(0), i2(0), i3(0), i4(0);
 | 
			
		||||
      CPPUNIT_ASSERT_NO_THROW(l>>i1>>i2>>i3>>i4);
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(std::vector<int>::size_type(4), l.size());
 | 
			
		||||
      // now: i1==1 i2==2 i3==3 i4==4 l=={5, 6, 7, 8}
 | 
			
		||||
      CPPUNIT_ASSERT(i1==1 && i2==2 && i3==3 && i4==4);
 | 
			
		||||
      CPPUNIT_ASSERT(l.size()==4);
 | 
			
		||||
      for (int i=0; i<4; (l.erase(l.begin()), ++i)) {
 | 
			
		||||
        CPPUNIT_ASSERT(l.front()==i+5);
 | 
			
		||||
      }
 | 
			
		||||
      bool exc(false);
 | 
			
		||||
      try {
 | 
			
		||||
        l>>i1;
 | 
			
		||||
      } catch (mrw::length_error&) {
 | 
			
		||||
        exc=true;
 | 
			
		||||
      }
 | 
			
		||||
      CPPUNIT_ASSERT(exc);
 | 
			
		||||
    }
 | 
			
		||||
    CPPUNIT_ASSERT(exc);
 | 
			
		||||
  }
 | 
			
		||||
  void DequeShift() {
 | 
			
		||||
    std::deque<int> l;
 | 
			
		||||
    CPPUNIT_ASSERT_NO_THROW(l<<1<<2<<3<<4<<5<<6<<7<<8);
 | 
			
		||||
    int i1(0), i2(0), i3(0), i4(0);
 | 
			
		||||
    CPPUNIT_ASSERT_NO_THROW(l>>i1>>i2>>i3>>i4);
 | 
			
		||||
    // now: i1==1 i2==2 i3==3 i4==4 l=={5, 6, 7, 8}
 | 
			
		||||
    CPPUNIT_ASSERT(i1==1 && i2==2 && i3==3 && i4==4);
 | 
			
		||||
    CPPUNIT_ASSERT_EQUAL(std::deque<int>::size_type(4), l.size());
 | 
			
		||||
    for (int i=0; i<4; (l.erase(l.begin()), ++i)) {
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(i+5, l.front());
 | 
			
		||||
    void DequeShift() {
 | 
			
		||||
      std::deque<int> l;
 | 
			
		||||
      CPPUNIT_ASSERT_NO_THROW(l<<1<<2<<3<<4<<5<<6<<7<<8);
 | 
			
		||||
      int i1(0), i2(0), i3(0), i4(0);
 | 
			
		||||
      CPPUNIT_ASSERT_NO_THROW(l>>i1>>i2>>i3>>i4);
 | 
			
		||||
      // now: i1==1 i2==2 i3==3 i4==4 l=={5, 6, 7, 8}
 | 
			
		||||
      CPPUNIT_ASSERT(i1==1 && i2==2 && i3==3 && i4==4);
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(std::deque<int>::size_type(4), l.size());
 | 
			
		||||
      for (int i=0; i<4; (l.erase(l.begin()), ++i)) {
 | 
			
		||||
        CPPUNIT_ASSERT_EQUAL(i+5, l.front());
 | 
			
		||||
      }
 | 
			
		||||
      bool exc(false);
 | 
			
		||||
      try {
 | 
			
		||||
        l>>i1;
 | 
			
		||||
      } catch (mrw::length_error&) {
 | 
			
		||||
        exc=true;
 | 
			
		||||
      }
 | 
			
		||||
      CPPUNIT_ASSERT(exc);
 | 
			
		||||
    }
 | 
			
		||||
    bool exc(false);
 | 
			
		||||
    try {
 | 
			
		||||
      l>>i1;
 | 
			
		||||
    } catch (mrw::length_error&) {
 | 
			
		||||
      exc=true;
 | 
			
		||||
    void SetShift() {
 | 
			
		||||
      std::set<int> s;
 | 
			
		||||
      bool exc(false);
 | 
			
		||||
      try {
 | 
			
		||||
        s<<1<<2<<3<<4<<5<<6<<7<<8<<8;
 | 
			
		||||
      } catch (mrw::invalid_argument& e) {
 | 
			
		||||
        mrw::StackTrace::createSymtable();
 | 
			
		||||
        exc=true;
 | 
			
		||||
      }
 | 
			
		||||
      CPPUNIT_ASSERT(exc);
 | 
			
		||||
      int i1(0), i2(0), i3(0), i4(0);
 | 
			
		||||
      s>>i1>>i2>>i3>>i4;
 | 
			
		||||
      // now: i1==1 i2==2 i3==3 i4==4 s=={5, 6, 7, 8}
 | 
			
		||||
      CPPUNIT_ASSERT(i1==1 && i2==2 && i3==3 && i4==4);
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(std::set<int>::size_type(4), s.size());
 | 
			
		||||
      for (int i=0; i<4; ++i) {
 | 
			
		||||
        CPPUNIT_ASSERT(s.find(i+5)!=s.end());
 | 
			
		||||
      }
 | 
			
		||||
      s.erase(s.begin(), s.end());
 | 
			
		||||
      exc=false;
 | 
			
		||||
      try {
 | 
			
		||||
        s>>i1;
 | 
			
		||||
      } catch (mrw::length_error&) {
 | 
			
		||||
        exc=true;
 | 
			
		||||
      }
 | 
			
		||||
      CPPUNIT_ASSERT(exc);
 | 
			
		||||
    }
 | 
			
		||||
    CPPUNIT_ASSERT(exc);
 | 
			
		||||
  }
 | 
			
		||||
  void SetShift() {
 | 
			
		||||
    std::set<int> s;
 | 
			
		||||
    bool exc(false);
 | 
			
		||||
    try {
 | 
			
		||||
      s<<1<<2<<3<<4<<5<<6<<7<<8<<8;
 | 
			
		||||
    } catch (mrw::invalid_argument& e) {
 | 
			
		||||
      mrw::StackTrace::createSymtable();
 | 
			
		||||
      exc=true;
 | 
			
		||||
    void MapShift() {
 | 
			
		||||
      typedef std::map<int, std::string> Map;
 | 
			
		||||
      Map s;
 | 
			
		||||
      bool exc(false);
 | 
			
		||||
      try {
 | 
			
		||||
        s<<std::make_pair(1, std::string("one"))
 | 
			
		||||
         <<std::make_pair(2, std::string("two"))
 | 
			
		||||
         <<std::make_pair(2, std::string("two"));
 | 
			
		||||
      } catch (mrw::invalid_argument& e) {
 | 
			
		||||
        exc=true;
 | 
			
		||||
      }
 | 
			
		||||
      CPPUNIT_ASSERT(exc);
 | 
			
		||||
      std::pair<int, std::string> i1, i2;
 | 
			
		||||
      s>>i1>>i2;
 | 
			
		||||
      // now: i1==1 i2==2 i3==3 i4==4 s=={5, 6, 7, 8}
 | 
			
		||||
      CPPUNIT_ASSERT(i1==std::make_pair(1, std::string("one")) &&
 | 
			
		||||
                     i2==std::make_pair(2, std::string("two")));
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(Map::size_type(0), s.size());
 | 
			
		||||
      exc=false;
 | 
			
		||||
      try {
 | 
			
		||||
        s>>i1;
 | 
			
		||||
      } catch (mrw::length_error&) {
 | 
			
		||||
        exc=true;
 | 
			
		||||
      }
 | 
			
		||||
      CPPUNIT_ASSERT(exc);
 | 
			
		||||
    }
 | 
			
		||||
    CPPUNIT_ASSERT(exc);
 | 
			
		||||
    int i1(0), i2(0), i3(0), i4(0);
 | 
			
		||||
    s>>i1>>i2>>i3>>i4;
 | 
			
		||||
    // now: i1==1 i2==2 i3==3 i4==4 s=={5, 6, 7, 8}
 | 
			
		||||
    CPPUNIT_ASSERT(i1==1 && i2==2 && i3==3 && i4==4);
 | 
			
		||||
    CPPUNIT_ASSERT_EQUAL(std::set<int>::size_type(4), s.size());
 | 
			
		||||
    for (int i=0; i<4; ++i) {
 | 
			
		||||
      CPPUNIT_ASSERT(s.find(i+5)!=s.end());
 | 
			
		||||
    void MultisetShift() {
 | 
			
		||||
      std::multiset<int> s;
 | 
			
		||||
      s<<1<<2<<3<<4<<5<<6<<7<<8<<9;
 | 
			
		||||
      int i1(0), i2(0), i3(0), i4(0);
 | 
			
		||||
      s>>i1>>i2>>i3>>i4;
 | 
			
		||||
      // now: i1==1 i2==2 i3==3 i4==4 s=={5, 6, 7, 8}
 | 
			
		||||
      CPPUNIT_ASSERT(i1==1 && i2==2 && i3==3 && i4==4);
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(std::multiset<int>::size_type(5), s.size());
 | 
			
		||||
      for (int i=0; i<5; ++i) {
 | 
			
		||||
        CPPUNIT_ASSERT(s.find(i+5)!=s.end());
 | 
			
		||||
      }
 | 
			
		||||
      s.erase(s.begin(), s.end());
 | 
			
		||||
      bool exc(false);
 | 
			
		||||
      try {
 | 
			
		||||
        s>>i1;
 | 
			
		||||
      } catch (mrw::length_error&) {
 | 
			
		||||
        exc=true;
 | 
			
		||||
      }
 | 
			
		||||
      CPPUNIT_ASSERT(exc);
 | 
			
		||||
    }
 | 
			
		||||
    s.erase(s.begin(), s.end());
 | 
			
		||||
    exc=false;
 | 
			
		||||
    try {
 | 
			
		||||
      s>>i1;
 | 
			
		||||
    } catch (mrw::length_error&) {
 | 
			
		||||
      exc=true;
 | 
			
		||||
    }
 | 
			
		||||
    CPPUNIT_ASSERT(exc);
 | 
			
		||||
  }
 | 
			
		||||
  void MapShift() {
 | 
			
		||||
    typedef std::map<int, std::string> Map;
 | 
			
		||||
    Map s;
 | 
			
		||||
    bool exc(false);
 | 
			
		||||
    try {
 | 
			
		||||
    void MultimapShift() {
 | 
			
		||||
      typedef std::multimap<int, std::string> Map;
 | 
			
		||||
      Map s;
 | 
			
		||||
      s<<std::make_pair(1, std::string("one"))
 | 
			
		||||
       <<std::make_pair(2, std::string("two"))
 | 
			
		||||
       <<std::make_pair(2, std::string("two"));
 | 
			
		||||
    } catch (mrw::invalid_argument& e) {
 | 
			
		||||
      exc=true;
 | 
			
		||||
    }
 | 
			
		||||
    CPPUNIT_ASSERT(exc);
 | 
			
		||||
    std::pair<int, std::string> i1, i2;
 | 
			
		||||
    s>>i1>>i2;
 | 
			
		||||
    // now: i1==1 i2==2 i3==3 i4==4 s=={5, 6, 7, 8}
 | 
			
		||||
    CPPUNIT_ASSERT(i1==std::make_pair(1, std::string("one")) &&
 | 
			
		||||
                   i2==std::make_pair(2, std::string("two")));
 | 
			
		||||
    CPPUNIT_ASSERT_EQUAL(Map::size_type(0), s.size());
 | 
			
		||||
    exc=false;
 | 
			
		||||
    try {
 | 
			
		||||
      std::pair<int, std::string> i1, i2;
 | 
			
		||||
      s>>i1>>i2;
 | 
			
		||||
      // now: i1==1 i2==2 i3==3 i4==4 s=={5, 6, 7, 8}
 | 
			
		||||
      CPPUNIT_ASSERT(i1==std::make_pair(1, std::string("one")) &&
 | 
			
		||||
                     i2==std::make_pair(2, std::string("two")));
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(Map::size_type(1), s.size());
 | 
			
		||||
      s>>i1;
 | 
			
		||||
    } catch (mrw::length_error&) {
 | 
			
		||||
      exc=true;
 | 
			
		||||
      CPPUNIT_ASSERT(std::make_pair(2, std::string("two"))==i1);
 | 
			
		||||
      bool exc(false);
 | 
			
		||||
      try {
 | 
			
		||||
        s>>i1;
 | 
			
		||||
      } catch (mrw::length_error&) {
 | 
			
		||||
        exc=true;
 | 
			
		||||
      }
 | 
			
		||||
      CPPUNIT_ASSERT(exc);
 | 
			
		||||
    }
 | 
			
		||||
    CPPUNIT_ASSERT(exc);
 | 
			
		||||
  }
 | 
			
		||||
  void MultisetShift() {
 | 
			
		||||
    std::multiset<int> s;
 | 
			
		||||
    s<<1<<2<<3<<4<<5<<6<<7<<8<<9;
 | 
			
		||||
    int i1(0), i2(0), i3(0), i4(0);
 | 
			
		||||
    s>>i1>>i2>>i3>>i4;
 | 
			
		||||
    // now: i1==1 i2==2 i3==3 i4==4 s=={5, 6, 7, 8}
 | 
			
		||||
    CPPUNIT_ASSERT(i1==1 && i2==2 && i3==3 && i4==4);
 | 
			
		||||
    CPPUNIT_ASSERT_EQUAL(std::multiset<int>::size_type(5), s.size());
 | 
			
		||||
    for (int i=0; i<5; ++i) {
 | 
			
		||||
      CPPUNIT_ASSERT(s.find(i+5)!=s.end());
 | 
			
		||||
    void StringException1() {
 | 
			
		||||
      std::string s("Hello World");
 | 
			
		||||
      int hello;
 | 
			
		||||
      s>>hello; // not an int, exception expected
 | 
			
		||||
    }
 | 
			
		||||
    s.erase(s.begin(), s.end());
 | 
			
		||||
    bool exc(false);
 | 
			
		||||
    try {
 | 
			
		||||
      s>>i1;
 | 
			
		||||
    } catch (mrw::length_error&) {
 | 
			
		||||
      exc=true;
 | 
			
		||||
    void StringException2() {
 | 
			
		||||
      std::string s("Hello World");
 | 
			
		||||
      mrw::to<int>(s); // not an int, exception expected
 | 
			
		||||
    }
 | 
			
		||||
    CPPUNIT_ASSERT(exc);
 | 
			
		||||
  }
 | 
			
		||||
  void MultimapShift() {
 | 
			
		||||
    typedef std::multimap<int, std::string> Map;
 | 
			
		||||
    Map s;
 | 
			
		||||
    s<<std::make_pair(1, std::string("one"))
 | 
			
		||||
     <<std::make_pair(2, std::string("two"))
 | 
			
		||||
     <<std::make_pair(2, std::string("two"));
 | 
			
		||||
    std::pair<int, std::string> i1, i2;
 | 
			
		||||
    s>>i1>>i2;
 | 
			
		||||
    // now: i1==1 i2==2 i3==3 i4==4 s=={5, 6, 7, 8}
 | 
			
		||||
    CPPUNIT_ASSERT(i1==std::make_pair(1, std::string("one")) &&
 | 
			
		||||
                   i2==std::make_pair(2, std::string("two")));
 | 
			
		||||
    CPPUNIT_ASSERT_EQUAL(Map::size_type(1), s.size());
 | 
			
		||||
    s>>i1;
 | 
			
		||||
    CPPUNIT_ASSERT(std::make_pair(2, std::string("two"))==i1);
 | 
			
		||||
    bool exc(false);
 | 
			
		||||
    try {
 | 
			
		||||
      s>>i1;
 | 
			
		||||
    } catch (mrw::length_error&) {
 | 
			
		||||
      exc=true;
 | 
			
		||||
    void Max() {
 | 
			
		||||
      int a1(3), a2(23), a3(2), a4(432), a5(73), a6(32);
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(432, mrw::max(a1, a2, a3, a4, a5, a6));
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(432, mrw::max(a1, a2, a3, a4, a5, a6));
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(73, mrw::max(a1, a2, a3, a5, a6));
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(32, mrw::max(a1, a2, a3, a6));
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(23, mrw::max(a1, a2, a3));
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(3, mrw::max(a1, a3));
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(42, mrw::max(3, 42, 6, 1));
 | 
			
		||||
    }
 | 
			
		||||
    CPPUNIT_ASSERT(exc);
 | 
			
		||||
  }
 | 
			
		||||
  void StringException1() {
 | 
			
		||||
    std::string s("Hello World");
 | 
			
		||||
    int hello;
 | 
			
		||||
    s>>hello; // not an int, exception expected
 | 
			
		||||
  }
 | 
			
		||||
  void StringException2() {
 | 
			
		||||
    std::string s("Hello World");
 | 
			
		||||
    mrw::to<int>(s); // not an int, exception expected
 | 
			
		||||
  }
 | 
			
		||||
  CPPUNIT_TEST_SUITE(StdExtTest);
 | 
			
		||||
  CPPUNIT_TEST(StringConv);
 | 
			
		||||
  CPPUNIT_TEST(StringShift);
 | 
			
		||||
  CPPUNIT_TEST(StringAdd);
 | 
			
		||||
  CPPUNIT_TEST(ListShift);
 | 
			
		||||
  CPPUNIT_TEST(VectorShift);
 | 
			
		||||
  CPPUNIT_TEST(DequeShift);
 | 
			
		||||
  CPPUNIT_TEST(SetShift);
 | 
			
		||||
  CPPUNIT_TEST(MapShift);
 | 
			
		||||
  CPPUNIT_TEST(MultisetShift);
 | 
			
		||||
  CPPUNIT_TEST(MultimapShift);
 | 
			
		||||
  CPPUNIT_TEST_EXCEPTION(StringException1, mrw::invalid_argument);
 | 
			
		||||
  CPPUNIT_TEST_EXCEPTION(StringException2, mrw::invalid_argument);
 | 
			
		||||
  CPPUNIT_TEST_SUITE_END();
 | 
			
		||||
    void Min() {
 | 
			
		||||
      int a1(3), a2(23), a3(2), a4(432), a5(73), a6(32);
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(2, mrw::min(a1, a2, a3, a4, a5, a6));
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(3, mrw::min(a1, a2, a4, a5, a6));
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(23, mrw::min(a2, a4, a5, a6));
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(32, mrw::min(a4, a5, a6));
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(73, mrw::min(a4, a5));
 | 
			
		||||
      CPPUNIT_ASSERT_EQUAL(42, mrw::min(323, 42, 126, 91));
 | 
			
		||||
    }
 | 
			
		||||
    CPPUNIT_TEST_SUITE(StdExtTest);
 | 
			
		||||
    CPPUNIT_TEST(StringConv);
 | 
			
		||||
    CPPUNIT_TEST(StringShift);
 | 
			
		||||
    CPPUNIT_TEST(StringAdd);
 | 
			
		||||
    CPPUNIT_TEST(ListShift);
 | 
			
		||||
    CPPUNIT_TEST(VectorShift);
 | 
			
		||||
    CPPUNIT_TEST(DequeShift);
 | 
			
		||||
    CPPUNIT_TEST(SetShift);
 | 
			
		||||
    CPPUNIT_TEST(MapShift);
 | 
			
		||||
    CPPUNIT_TEST(MultisetShift);
 | 
			
		||||
    CPPUNIT_TEST(MultimapShift);
 | 
			
		||||
    CPPUNIT_TEST(Max);
 | 
			
		||||
    CPPUNIT_TEST(Min);
 | 
			
		||||
    CPPUNIT_TEST_EXCEPTION(StringException1, mrw::invalid_argument);
 | 
			
		||||
    CPPUNIT_TEST_EXCEPTION(StringException2, mrw::invalid_argument);
 | 
			
		||||
    CPPUNIT_TEST_SUITE_END();
 | 
			
		||||
};
 | 
			
		||||
CPPUNIT_TEST_SUITE_REGISTRATION(StdExtTest);
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
		Reference in New Issue
	
	Block a user