Main Page | Namespace List | Class Hierarchy | Alphabetical List | Compound List | File List | Compound Members | File Members

TestCase.h

Go to the documentation of this file.
00001 //------------------------------------------------------------------------------
00002 // Lamp : Open source game middleware
00003 // Copyright (C) 2004  Junpei Ohtani ( Email : junpee@users.sourceforge.jp )
00004 //
00005 // This library is free software; you can redistribute it and/or
00006 // modify it under the terms of the GNU Lesser General Public
00007 // License as published by the Free Software Foundation; either
00008 // version 2.1 of the License, or (at your option) any later version.
00009 //
00010 // This library is distributed in the hope that it will be useful,
00011 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00012 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00013 // Lesser General Public License for more details.
00014 //
00015 // You should have received a copy of the GNU Lesser General Public
00016 // License along with this library; if not, write to the Free Software
00017 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00018 //------------------------------------------------------------------------------
00019 
00020 /** @file
00021  * テストケースヘッダ
00022  * @author Junpee
00023  */
00024 
00025 #ifndef TEST_CASE_H_
00026 #define TEST_CASE_H_
00027 
00028 #include <LampUnit/Test.h>
00029 
00030 /**
00031  * テスト用失敗マクロ
00032  * @param message メッセージ
00033  */
00034 #define TestFail(message) \
00035     { addFailure((message), __FILE__, __LINE__); }
00036 
00037 /**
00038  * テスト用アサートマクロ
00039  * @param condition falseならアサート発生
00040  */
00041 #define TestAssert(condition) \
00042     if(!(condition)){ TestFail((#condition)); }
00043 
00044 /**
00045  * テスト用アサートマクロ
00046  * @param condition falseならアサート発生
00047  * @param message メッセージ
00048  */
00049 #define TestAssertMessage(condition, message) \
00050     if(!(condition)){ TestFail((message)); }
00051 
00052 /**
00053  * テスト用イコールマクロ
00054  * @param expected 期待される値
00055  * @param actual 実際の値
00056  */
00057 #define TestEquals(expected, actual) \
00058     { assertEquals((expected), (actual), __FILE__, __LINE__); }
00059 
00060 /**
00061  * テスト用ノットイコールマクロ
00062  * @param notExpected 期待されない値
00063  * @param actual 実際の値
00064  */
00065 #define TestNotEquals(notExpected, actual) \
00066     { assertNotEquals((notExpected), (actual), __FILE__, __LINE__); }
00067 
00068 /**
00069  * テスト用イコールマクロ
00070  * @param expected 期待される値
00071  * @param actual 実際の値
00072  * @param epsilon 許容誤差
00073  */
00074 #define TestEpsilonEquals(expected, actual, epsilon) \
00075     { assertEquals((expected), (actual), __FILE__, __LINE__, (epsilon)); }
00076 
00077 /**
00078  * テスト用ノットイコールマクロ
00079  * @param notExpected 期待されない値
00080  * @param actual 実際の値
00081  * @param epsilon 許容誤差
00082  */
00083 #define TestNotEpsilonEquals(notExpected, actual, epsilon) \
00084     { assertNotEquals((notExpected), (actual), __FILE__, __LINE__, (epsilon)); }
00085 
00086 namespace LampUnit{
00087 
00088 //------------------------------------------------------------------------------
00089 /**
00090  * テストケースヘッダ
00091  */
00092 class TestCase : public Test{
00093 public:
00094     /**
00095      * コンストラクタ
00096      * @param name テストの名前
00097      */
00098     explicit TestCase(Lamp::String name);
00099 
00100     /**
00101      * デストラクタ
00102      */
00103     virtual ~TestCase(){}
00104 
00105     /**
00106      * テストを実行する
00107      */
00108     virtual void run(TestResult* result);
00109 
00110     /**
00111      * テストケースの個数を取得
00112      * @return テストケースの個数
00113      */
00114     virtual int getCountTestCases() const{ return 1; }
00115 
00116     /**
00117      * テストの名前を取得
00118      * @return テストの名前
00119      */
00120     virtual const Lamp::String& getName() const{ return name_; }
00121 
00122     /**
00123      * テストを文字列に変換
00124      * @return テストの文字列表記
00125      */
00126     virtual const Lamp::String& toString() const{ return name_; }
00127 
00128     /**
00129      * テストの初期化
00130      */
00131     virtual void setUp(){}
00132 
00133     /**
00134      * テストの後始末
00135      */
00136     virtual void tearDown(){}
00137 
00138     /**
00139      * テストスィートの取得
00140      *
00141      * 各テストクラスのスィートを作成する場合は、同じ定義を持つメソッドを
00142      * 各テストクラスで新たに作成してください。
00143      * @return テストスィート
00144      */
00145     static Test* suite(){ return NULL; }
00146 
00147 //------------------------------------------------------------------------------
00148 protected:
00149     /**
00150      * コンストラクタ
00151      *
00152      * TestCallerから呼ばれるときに使用する
00153      */
00154     TestCase();
00155 
00156     /**
00157      * テストを実行する
00158      */
00159     virtual void runTest() = 0;
00160 
00161     /**
00162      * 失敗の追加
00163      * @param message メッセージ
00164      * @param file ファイル名
00165      * @param line 行数
00166      */
00167     virtual void addFailure(
00168         const Lamp::String& message, const char* file, int line);
00169 
00170     //--------------------------------------------------------------------------
00171     // 値が同じかどうか
00172     //--------------------------------------------------------------------------
00173     /**
00174      * 値が同じかどうか
00175      * @param expected 期待される値
00176      * @param actual 実際の値
00177      * @param file ファイル名
00178      * @param line 行数
00179      * @return 値が同じならtrue
00180      */
00181     bool assertEquals(int expected, int actual, const char* file, int line){
00182         if(expected == actual){ return true; }
00183         addFailure(notEqualMessage(expected, actual), file, line);
00184         return false;
00185     }
00186 
00187     /**
00188      * 値が同じかどうか
00189      * @param expected 期待される値
00190      * @param actual 実際の値
00191      * @param file ファイル名
00192      * @param line 行数
00193      * @return 値が同じならtrue
00194      */
00195     bool assertEquals(u_int expected, u_int actual,
00196         const char* file, int line){
00197         if(expected == actual){ return true; }
00198         addFailure(notEqualMessage(expected, actual), file, line);
00199         return false;
00200     }
00201 
00202     /**
00203      * 値が同じかどうか
00204      * @param expected 期待される値
00205      * @param actual 実際の値
00206      * @param file ファイル名
00207      * @param line 行数
00208      * @param epsilon 許容誤差
00209      * @return 値が同じならtrue
00210      */
00211     bool assertEquals(float expected, float actual,
00212         const char* file, int line, float epsilon = 0.f){
00213         Assert(epsilon >= 0.f);
00214         if(equals(expected, actual, epsilon)){ return true; }
00215         addFailure(notEqualMessage(expected, actual, epsilon), file, line);
00216         return false;
00217     }
00218 
00219     /**
00220      * 値が同じかどうか
00221      * @param expected 期待される値
00222      * @param actual 実際の値
00223      * @param file ファイル名
00224      * @param line 行数
00225      * @param epsilon 許容誤差
00226      * @return 値が同じならtrue
00227      */
00228     bool assertEquals(double expected, double actual,
00229         const char* file, int line, double epsilon = 0.f){
00230         Assert(epsilon >= 0.f);
00231         if(equals(expected, actual, epsilon)){ return true; }
00232         addFailure(notEqualMessage(expected, actual, epsilon), file, line);
00233         return false;
00234     }
00235 
00236     /**
00237      * 文字列が同じかどうか
00238      * @param expected 期待される文字列
00239      * @param actual 実際の文字列
00240      * @param file ファイル名
00241      * @param line 行数
00242      * @return 文字列が同じならtrue
00243      */
00244     bool assertEquals(
00245         const char* expected, const char* actual, const char* file, int line){
00246         if(equals(expected, actual)){ return true; }
00247         addFailure(notEqualMessage(expected, actual), file, line);
00248         return false;
00249     }
00250 
00251     /**
00252      * 文字列が同じかどうか
00253      * @param expected 期待される文字列
00254      * @param actual 実際の文字列
00255      * @param file ファイル名
00256      * @param line 行数
00257      * @return 文字列が同じならtrue
00258      */
00259     bool assertEquals(const Lamp::String& expected, const Lamp::String& actual,
00260         const char* file, int line){
00261         return assertEquals(
00262             expected.getBytes(), actual.getBytes(), file, line);
00263     }
00264 
00265     //--------------------------------------------------------------------------
00266     // 値が同じでないかどうか
00267     //--------------------------------------------------------------------------
00268     /**
00269      * 値が同じでないかどうか
00270      * @param notExpected 期待されない値
00271      * @param actual 実際の値
00272      * @param file ファイル名
00273      * @param line 行数
00274      * @return 値が同じならtrue
00275      */
00276     bool assertNotEquals(
00277         int notExpected, int actual, const char* file, int line){
00278         if(notExpected != actual){ return true; }
00279         addFailure(equalMessage(notExpected, actual), file, line);
00280         return false;
00281     }
00282 
00283     /**
00284      * 値が同じでないかどうか
00285      * @param notExpected 期待されない値
00286      * @param actual 実際の値
00287      * @param file ファイル名
00288      * @param line 行数
00289      * @return 値が同じならtrue
00290      */
00291     bool assertNotEquals(u_int notExpected, u_int actual,
00292         const char* file, int line){
00293         if(notExpected != actual){ return true; }
00294         addFailure(equalMessage(notExpected, actual), file, line);
00295         return false;
00296     }
00297 
00298     /**
00299      * 値が同じでないかどうか
00300      * @param notExpected 期待されない値
00301      * @param actual 実際の値
00302      * @param file ファイル名
00303      * @param line 行数
00304      * @param epsilon 許容誤差
00305      * @return 値が同じならtrue
00306      */
00307     bool assertNotEquals(float notExpected, float actual,
00308         const char* file, int line, float epsilon = 0.f){
00309         Assert(epsilon >= 0.f);
00310         if(!equals(notExpected, actual, epsilon)){ return true; }
00311         addFailure(equalMessage(notExpected, actual, epsilon), file, line);
00312         return false;
00313     }
00314 
00315     /**
00316      * 値が同じでないかどうか
00317      * @param notExpected 期待されない値
00318      * @param actual 実際の値
00319      * @param file ファイル名
00320      * @param line 行数
00321      * @param epsilon 許容誤差
00322      * @return 値が同じならtrue
00323      */
00324     bool assertNotEquals(double notExpected, double actual,
00325         const char* file, int line, double epsilon = 0.f){
00326         Assert(epsilon >= 0.f);
00327         if(!equals(notExpected, actual, epsilon)){ return true; }
00328         addFailure(equalMessage(notExpected, actual, epsilon), file, line);
00329         return false;
00330     }
00331 
00332     /**
00333      * 文字列が同じでないかどうか
00334      * @param notExpected 期待されない文字列
00335      * @param actual 実際の文字列
00336      * @param file ファイル名
00337      * @param line 行数
00338      * @return 文字列が同じならtrue
00339      */
00340     bool assertNotEquals(const char* notExpected, const char* actual,
00341         const char* file, int line){
00342         if(!equals(notExpected, actual)){ return true; }
00343         addFailure(equalMessage(notExpected, actual), file, line);
00344         return false;
00345     }
00346 
00347     /**
00348      * 文字列が同じでないかどうか
00349      * @param notExpected 期待されない文字列
00350      * @param actual 実際の文字列
00351      * @param file ファイル名
00352      * @param line 行数
00353      * @return 文字列が同じならtrue
00354      */
00355     bool assertNotEquals(
00356         const Lamp::String& notExpected, const Lamp::String& actual,
00357         const char* file, int line){
00358         return assertNotEquals(
00359             notExpected.getBytes(), actual.getBytes(), file, line);
00360     }
00361 
00362     //--------------------------------------------------------------------------
00363     // 値の比較
00364     //--------------------------------------------------------------------------
00365     /**
00366      * floatの比較
00367      * @param leftValue 左の値
00368      * @param rightValue 右の値
00369      * @param epsilon 許容誤差
00370      * @return 値が同じならtrue
00371      */
00372     static inline bool equals(
00373         float leftValue, float rightValue, float epsilon = 0.f){
00374         if(leftValue == rightValue){ return true; }
00375         float difference = leftValue - rightValue;
00376         if(difference < 0.f){ difference = -difference; }
00377         return (difference <= epsilon);
00378     }
00379 
00380     /**
00381      * doubleの比較
00382      * @param leftValue 左の値
00383      * @param rightValue 右の値
00384      * @param epsilon 許容誤差
00385      * @return 値が同じならtrue
00386      */
00387     static inline bool equals(
00388         double leftValue, double rightValue, double epsilon = 0.f){
00389         if(leftValue == rightValue){ return true; }
00390         double difference = leftValue - rightValue;
00391         if(difference < 0.f){ difference = -difference; }
00392         return (difference <= epsilon);
00393     }
00394 
00395     /**
00396      * 文字列の比較
00397      * @param leftValue 左の値
00398      * @param rightValue 右の値
00399      * @return 値が同じならtrue
00400      */
00401     static bool equals(const char* leftValue, const char* rightValue);
00402 
00403     //--------------------------------------------------------------------------
00404     // 値が同じでないメッセージ
00405     //--------------------------------------------------------------------------
00406     /**
00407      * 値が同じでないメッセージ
00408      * @param expected 期待される値
00409      * @param actual 実際の値
00410      * @return 作成されたメッセージ
00411      */
00412     static Lamp::String notEqualMessage(int expected, int actual);
00413 
00414     /**
00415      * 値が同じでないメッセージ
00416      * @param expected 期待される値
00417      * @param actual 実際の値
00418      * @return 作成されたメッセージ
00419      */
00420     static Lamp::String notEqualMessage(
00421         u_int expected, u_int actual);
00422 
00423     /**
00424      * 値が同じでないメッセージ
00425      * @param expected 期待される値
00426      * @param actual 実際の値
00427      * @param epsilon 許容誤差
00428      * @return 作成されたメッセージ
00429      */
00430     static Lamp::String notEqualMessage(
00431         float expected, float actual, float epsilon);
00432 
00433     /**
00434      * 値が同じでないメッセージ
00435      * @param expected 期待される値
00436      * @param actual 実際の値
00437      * @param epsilon 許容誤差
00438      * @return 作成されたメッセージ
00439      */
00440     static Lamp::String notEqualMessage(
00441         double expected, double actual, double epsilon);
00442 
00443     /**
00444      * 文字列が同じでないメッセージ
00445      * @param expected 期待される文字列
00446      * @param actual 実際の文字列
00447      * @return 作成されたメッセージ
00448      */
00449     static Lamp::String notEqualMessage(
00450         const char* expected, const char* actual);
00451 
00452     //--------------------------------------------------------------------------
00453     // 値が同じメッセージ
00454     //--------------------------------------------------------------------------
00455     /**
00456      * 値が同じメッセージ
00457      * @param notExpected 期待されない値
00458      * @param actual 実際の値
00459      * @return 作成されたメッセージ
00460      */
00461     static Lamp::String equalMessage(int notExpected, int actual);
00462 
00463     /**
00464      * 値が同じメッセージ
00465      * @param notExpected 期待されない値
00466      * @param actual 実際の値
00467      * @return 作成されたメッセージ
00468      */
00469     static Lamp::String equalMessage(
00470         u_int notExpected, u_int actual);
00471 
00472     /**
00473      * 値が同じメッセージ
00474      * @param notExpected 期待されない値
00475      * @param actual 実際の値
00476      * @param epsilon 許容誤差
00477      * @return 作成されたメッセージ
00478      */
00479     static Lamp::String equalMessage(
00480         float notExpected, float actual, float epsilon);
00481 
00482     /**
00483      * 値が同じメッセージ
00484      * @param notExpected 期待されない値
00485      * @param actual 実際の値
00486      * @param epsilon 許容誤差
00487      * @return 作成されたメッセージ
00488      */
00489     static Lamp::String equalMessage(
00490         double notExpected, double actual, double epsilon);
00491 
00492     /**
00493      * 文字列が同じメッセージ
00494      * @param notExpected 期待されない文字列
00495      * @param actual 実際の文字列
00496      * @return 作成されたメッセージ
00497      */
00498     static Lamp::String equalMessage(
00499         const char* notExpected, const char* actual);
00500 
00501 //------------------------------------------------------------------------------
00502 private:
00503     // コピーコンストラクタの隠蔽
00504     TestCase(const TestCase& copy);
00505 
00506     // 代入コピーの隠蔽
00507     void operator =(const TestCase& copy);
00508 
00509     // 名前
00510     const Lamp::String name_;
00511     // テスト結果
00512     TestResult* result_;
00513 };
00514 
00515 //------------------------------------------------------------------------------
00516 } // End of namespace LampUnit
00517 #endif // End of TEST_CASE_H_
00518 //------------------------------------------------------------------------------

Generated on Wed Mar 16 10:29:54 2005 for LampUnit by doxygen 1.3.2