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 //------------------------------------------------------------------------------