esysUtils/test/EsysExceptionTestCase.cpp

#include <iostream>

#include "EsysExceptionTestCase.h"
#include "esysUtils/EsysException.h"

using namespace std;
using namespace CppUnitTest;
using namespace esysUtils;

class DerivedEx : public EsysException {
     public:

    /// Default Constructor for Exception
    DerivedEx() : EsysException() {}

    /// Constructor for Exception
    DerivedEx(const char *cstr) : EsysException(cstr) {}

    /// Constructor for Exception
    DerivedEx(const string &str) : EsysException(str) {}

    /// Return the exception name
    virtual string exceptionName() const {
        return "DerivedException";
    }
};

void EsysExceptionTestCase::testCase0() {

    //
    // dummy test case
    //
    // just test the UnitTesting framework is OK
    //

    assert(true);

}

void EsysExceptionTestCase::testCase1() {

    EsysException defEx;

    //
    // default exception text should have contents of exceptionName near start
    //
    string defString = defEx.toString();
    assert(defString.find(defEx.exceptionName()) != string::npos);
    assert(defString.find(defEx.exceptionName()) < 4);

    //
    // default exception text shouldn't be much longer than contents of exception name
    //
    assert(defString.size() > defEx.exceptionName().size());
    assert((defString.size() - defEx.exceptionName().size()) < 10);

    string ex1Text("My first funny exception message.");
    EsysException ex1(ex1Text);

    //
    // exception text should have contents of exceptionName near start
    //
    string ex1String = ex1.toString();
    assert(ex1String.find(ex1.exceptionName()) != string::npos);
    assert(defString.find(ex1.exceptionName()) < 4);

    //
    // exception text should contain entered exception message
    //
    assert(ex1String.find(ex1Text) != string::npos);

    //
    // copy constructed exception should match original
    //
    EsysException copyEx(ex1);
    string copyString = copyEx.toString();
    assert(ex1String == copyString);

    //
    // copy assigned exception should match original
    //
    EsysException assEx;
    assEx = ex1;
    string assString = assEx.toString();
    assert(ex1String == assString);

    //
    // check throw/catch mechanism
    //
    string ex2Text("My second funny exception message.");
    try {

        EsysException ex2(ex2Text);
        throw(ex2);

    }

    catch(EsysException& e) {

        //
        // exception text should have contents of exceptionName near start
        //
        string eString = e.toString();
        assert(eString.find(e.exceptionName()) != string::npos);
        assert(defString.find(e.exceptionName()) < 4);

        //
        // exception text should contain entered exception message
        //
        assert(eString.find(ex2Text) != string::npos);

    }

}

//
// test derived EsysException
//
void EsysExceptionTestCase::testCase2() {

    DerivedEx defEx;
    //
    // default exception text should have contents of exceptionName near start
    //
    string defString = defEx.toString();
    assert(defString.find(defEx.exceptionName()) != string::npos);
    assert(defString.find(defEx.exceptionName()) < 4);

    //
    // default exception text shouldn't be much longer than contents of exception name
    //
    assert(defString.size() > defEx.exceptionName().size());
    assert((defString.size() - defEx.exceptionName().size()) < 10);

    string ex1Text("asdjhieurncidhfjsnfkjefkjndfjkhsdrdfjksdhfweh");
    DerivedEx ex1(ex1Text);
    //
    // exception text should have contents of exceptionName near start
    //
    string ex1String = ex1.toString();
    assert(ex1String.find(ex1.exceptionName()) != string::npos);
    assert(defString.find(ex1.exceptionName()) < 4);

    //
    // exception text should contain entered exception message
    //
    assert(ex1String.find(ex1Text) != string::npos);

    //
    // copy constructed exception should match original
    //
    DerivedEx copyEx(ex1);
    string copyString = copyEx.toString();
    assert(ex1String == copyString);

    //
    // copy assigned exception should match original
    //
    DerivedEx assEx;
    assEx = ex1;
    string assString = assEx.toString();
    assert(ex1String == assString);

    //
    // check throw/catch mechanism
    //
    string ex2Text("pjkkjhdfbnkjerbkjsduflfkjahalkgjlklhjhj");
    try {

        DerivedEx ex2(ex2Text);
        throw(ex2);

    }

    catch(DerivedEx& e) {

        //
        // exception text should have contents of exceptionName near start
        //
        string eString = e.toString();
        assert(eString.find(e.exceptionName()) != string::npos);
        assert(defString.find(e.exceptionName()) < 4);

        //
        // exception text should contain entered exception message
        //
        assert(eString.find(ex2Text) != string::npos);
    }

    //
    // check throw/catch mechanism
    //
    string ex3Text("irfjvniouf;iarhglAKSDIghlAKSDghladg");
    try {

        DerivedEx ex3(ex3Text);
        throw(ex3);

    }
    catch(EsysException& e) {

        //
        // exception text should have contents of exceptionName near start
        //
        DerivedEx ex4;
        std::string eString = e.toString();
        assert(eString.find(ex4.exceptionName()) != string::npos);
        assert(defString.find(ex4.exceptionName()) < 4);

        //
        // exception text should contain entered exception message
        //
        assert(eString.find(ex3Text) != string::npos);

    }

    //
    // test to see if exception name gets lost on rethrow
    //
        try {
      try {
        DerivedEx ex4("D ex4 text.");
        throw ex4;
      }
      catch (EsysException& e) {
        cout << endl << e.toString() << endl;
        throw;
      }
        }
        catch (EsysException& e) {
      cout << e.toString() << endl;
    }

    cout << "Test EsysException may be caught as a std::exception" << endl;
        try {
      DerivedEx ex4("Exception caught as std::exception");
      throw ex4;
        }
    catch (exception& e) {
      cout << e.what() << endl;
    }
    catch (...) {
           //
           // if the exception is caught here there is a problem
       assert(false);
    }
}

TestSuite* EsysExceptionTestCase::suite ()
{
  //
  // create the suite of tests to perform.
  TestSuite *testSuite = new TestSuite ("EsysExceptionTestCase");

  testSuite->addTest (new TestCaller<EsysExceptionTestCase>("testCase0",&EsysExceptionTestCase::testCase0));
  testSuite->addTest (new TestCaller<EsysExceptionTestCase>("testCase1",&EsysExceptionTestCase::testCase1));
  testSuite->addTest (new TestCaller<EsysExceptionTestCase>("testCase2",&EsysExceptionTestCase::testCase2));
  return testSuite;
}
1	#include <iostream>
2
3	#include "EsysExceptionTestCase.h"
4	#include "esysUtils/EsysException.h"
5
6	using namespace std;
7	using namespace CppUnitTest;
8	using namespace esysUtils;
9
10	class DerivedEx : public EsysException {
11	public:
12
13	/// Default Constructor for Exception
14	DerivedEx() : EsysException() {}
15
16	/// Constructor for Exception
17	DerivedEx(const char *cstr) : EsysException(cstr) {}
18
19	/// Constructor for Exception
20	DerivedEx(const string &str) : EsysException(str) {}
21
22	/// Return the exception name
23	virtual string exceptionName() const {
24	return "DerivedException";
25	}
26	};
27
28	void EsysExceptionTestCase::testCase0() {
29
30	//
31	// dummy test case
32	//
33	// just test the UnitTesting framework is OK
34	//
35
36	assert(true);
37
38	}
39
40	void EsysExceptionTestCase::testCase1() {
41
42	EsysException defEx;
43
44	//
45	// default exception text should have contents of exceptionName near start
46	//
47	string defString = defEx.toString();
48	assert(defString.find(defEx.exceptionName()) != string::npos);
49	assert(defString.find(defEx.exceptionName()) < 4);
50
51	//
52	// default exception text shouldn't be much longer than contents of exception name
53	//
54	assert(defString.size() > defEx.exceptionName().size());
55	assert((defString.size() - defEx.exceptionName().size()) < 10);
56
57	string ex1Text("My first funny exception message.");
58	EsysException ex1(ex1Text);
59
60	//
61	// exception text should have contents of exceptionName near start
62	//
63	string ex1String = ex1.toString();
64	assert(ex1String.find(ex1.exceptionName()) != string::npos);
65	assert(defString.find(ex1.exceptionName()) < 4);
66
67	//
68	// exception text should contain entered exception message
69	//
70	assert(ex1String.find(ex1Text) != string::npos);
71
72	//
73	// copy constructed exception should match original
74	//
75	EsysException copyEx(ex1);
76	string copyString = copyEx.toString();
77	assert(ex1String == copyString);
78
79	//
80	// copy assigned exception should match original
81	//
82	EsysException assEx;
83	assEx = ex1;
84	string assString = assEx.toString();
85	assert(ex1String == assString);
86
87	//
88	// check throw/catch mechanism
89	//
90	string ex2Text("My second funny exception message.");
91	try {
92
93	EsysException ex2(ex2Text);
94	throw(ex2);
95
96	}
97
98	catch(EsysException& e) {
99
100	//
101	// exception text should have contents of exceptionName near start
102	//
103	string eString = e.toString();
104	assert(eString.find(e.exceptionName()) != string::npos);
105	assert(defString.find(e.exceptionName()) < 4);
106
107	//
108	// exception text should contain entered exception message
109	//
110	assert(eString.find(ex2Text) != string::npos);
111
112	}
113
114	}
115
116	//
117	// test derived EsysException
118	//
119	void EsysExceptionTestCase::testCase2() {
120
121	DerivedEx defEx;
122	//
123	// default exception text should have contents of exceptionName near start
124	//
125	string defString = defEx.toString();
126	assert(defString.find(defEx.exceptionName()) != string::npos);
127	assert(defString.find(defEx.exceptionName()) < 4);
128
129	//
130	// default exception text shouldn't be much longer than contents of exception name
131	//
132	assert(defString.size() > defEx.exceptionName().size());
133	assert((defString.size() - defEx.exceptionName().size()) < 10);
134
135	string ex1Text("asdjhieurncidhfjsnfkjefkjndfjkhsdrdfjksdhfweh");
136	DerivedEx ex1(ex1Text);
137	//
138	// exception text should have contents of exceptionName near start
139	//
140	string ex1String = ex1.toString();
141	assert(ex1String.find(ex1.exceptionName()) != string::npos);
142	assert(defString.find(ex1.exceptionName()) < 4);
143
144	//
145	// exception text should contain entered exception message
146	//
147	assert(ex1String.find(ex1Text) != string::npos);
148
149	//
150	// copy constructed exception should match original
151	//
152	DerivedEx copyEx(ex1);
153	string copyString = copyEx.toString();
154	assert(ex1String == copyString);
155
156	//
157	// copy assigned exception should match original
158	//
159	DerivedEx assEx;
160	assEx = ex1;
161	string assString = assEx.toString();
162	assert(ex1String == assString);
163
164	//
165	// check throw/catch mechanism
166	//
167	string ex2Text("pjkkjhdfbnkjerbkjsduflfkjahalkgjlklhjhj");
168	try {
169
170	DerivedEx ex2(ex2Text);
171	throw(ex2);
172
173	}
174
175	catch(DerivedEx& e) {
176
177	//
178	// exception text should have contents of exceptionName near start
179	//
180	string eString = e.toString();
181	assert(eString.find(e.exceptionName()) != string::npos);
182	assert(defString.find(e.exceptionName()) < 4);
183
184	//
185	// exception text should contain entered exception message
186	//
187	assert(eString.find(ex2Text) != string::npos);
188	}
189
190	//
191	// check throw/catch mechanism
192	//
193	string ex3Text("irfjvniouf;iarhglAKSDIghlAKSDghladg");
194	try {
195
196	DerivedEx ex3(ex3Text);
197	throw(ex3);
198
199	}
200	catch(EsysException& e) {
201
202	//
203	// exception text should have contents of exceptionName near start
204	//
205	DerivedEx ex4;
206	std::string eString = e.toString();
207	assert(eString.find(ex4.exceptionName()) != string::npos);
208	assert(defString.find(ex4.exceptionName()) < 4);
209
210	//
211	// exception text should contain entered exception message
212	//
213	assert(eString.find(ex3Text) != string::npos);
214
215	}
216
217	//
218	// test to see if exception name gets lost on rethrow
219	//
220	try {
221	try {
222	DerivedEx ex4("D ex4 text.");
223	throw ex4;
224	}
225	catch (EsysException& e) {
226	cout << endl << e.toString() << endl;
227	throw;
228	}
229	}
230	catch (EsysException& e) {
231	cout << e.toString() << endl;
232	}
233
234	cout << "Test EsysException may be caught as a std::exception" << endl;
235	try {
236	DerivedEx ex4("Exception caught as std::exception");
237	throw ex4;
238	}
239	catch (exception& e) {
240	cout << e.what() << endl;
241	}
242	catch (...) {
243	//
244	// if the exception is caught here there is a problem
245	assert(false);
246	}
247	}
248
249	TestSuite* EsysExceptionTestCase::suite ()
250	{
251	//
252	// create the suite of tests to perform.
253	TestSuite *testSuite = new TestSuite ("EsysExceptionTestCase");
254
255	testSuite->addTest (new TestCaller<EsysExceptionTestCase>("testCase0",&EsysExceptionTestCase::testCase0));
256	testSuite->addTest (new TestCaller<EsysExceptionTestCase>("testCase1",&EsysExceptionTestCase::testCase1));
257	testSuite->addTest (new TestCaller<EsysExceptionTestCase>("testCase2",&EsysExceptionTestCase::testCase2));
258	return testSuite;
259	}
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision