Standard Portable Library: test/TestVariant.cpp Source File

00001 /*
00002  *   This file is part of the Standard Portable Library (SPL).
00003  *
00004  *   SPL is free software: you can redistribute it and/or modify
00005  *   it under the terms of the GNU General Public License as published by
00006  *   the Free Software Foundation, either version 3 of the License, or
00007  *   (at your option) any later version.
00008  *
00009  *   SPL is distributed in the hope that it will be useful,
00010  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012  *   GNU General Public License for more details.
00013  *
00014  *   You should have received a copy of the GNU General Public License
00015  *   along with SPL.  If not, see <http://www.gnu.org/licenses/>.
00016  */
00017 #include <spl/Debug.h>
00018 #include <spl/interp/JsObject.h>
00019 #include <spl/Log.h>
00020 #include <spl/Variant.h>
00021 
00022 #ifdef DEBUG
00023 
00024 static void _TestVariant1()
00025 {
00026         Variant *vp = new Variant(1);
00027         DEBUG_CLEAR_MEM_CHECK_POINTS();
00028         DEBUG_NOTE_MEM( vp );
00029         vp->CheckMem();
00030         DEBUG_DUMP_MEM_LEAKS();
00031         UNIT_ASSERT_MEM_NOTED("Variant 1.1");
00032 
00033         delete vp;
00034         DEBUG_CLEAR_MEM_CHECK_POINTS();
00035         UNIT_ASSERT_MEM_NOTED("Variant 1.1");
00036         Log::SWriteOkFail( "Variant 1" );
00037 }
00038 
00039 static void _TestVariantBinOps()
00040 {
00041         Variant v1(4), v2(2);
00042 
00043         DEBUG_CLEAR_MEM_CHECK_POINTS();
00044         v1.CheckMem();
00045         v2.CheckMem();
00046         DEBUG_DUMP_MEM_LEAKS();
00047         UNIT_ASSERT_MEM_NOTED("Variant 2.1");
00048 
00049         Variant res = v1 + v2;
00050         UNIT_ASSERT("4 + 2", res.ToInt32() == 6);
00051 
00052         DEBUG_CLEAR_MEM_CHECK_POINTS();
00053         v1.CheckMem();
00054         v2.CheckMem();
00055         res.CheckMem();
00056         DEBUG_DUMP_MEM_LEAKS();
00057         UNIT_ASSERT_MEM_NOTED("Variant 2.2");
00058 
00059         res = v1 - v2;
00060         UNIT_ASSERT("4 - 2", res.ToInt32() == 2);
00061 
00062         res = v1 / v2;
00063         UNIT_ASSERT("4 / 2", res.ToInt32() == 2);
00064 
00065         res = v1 * v2;
00066         UNIT_ASSERT("4 * 2", res.ToInt32() == 8);
00067 
00068         res = v2 % v1;
00069         UNIT_ASSERT(*res.ToString() + " == 2 %% 4", res.ToInt32() == 2);
00070 
00071         v1 = 4.4;
00072         v2 = 2.2;
00073 
00074         res = v1 + v2;
00075         UNIT_ASSERT(*res.ToString() + " == 4.4 + 2.2", res.ToString()->Equals("6.6"));
00076 
00077         res = v1 - v2;
00078         UNIT_ASSERT(*res.ToString() + " == 4.4 - 2.2", res.ToString()->Equals("2.2"));
00079 
00080         res = v1 / v2;
00081         UNIT_ASSERT(*res.ToString() + " == 4.4 / 2.2", Math::Round(res.ToFloat64(), 2) == 2);
00082 
00083         v1 = "a";
00084         v2 = "b";
00085 
00086         res = v1 + v2;
00087         UNIT_ASSERT(*res.ToString() + " == ab", res.ToString()->Equals("ab"));
00088 
00089         res = "11";
00090         UNIT_ASSERT(*res.ParseInt()->ToString() + " == parseInt", res.ParseInt()->ToInt64() == 11);
00091         UNIT_ASSERT(*res.ParseFloat()->ToString() + " == parseFloat", res.ParseFloat()->ToFloat64() == 11.0);
00092 
00093         res = v1 / v2;
00094         UNIT_ASSERT(*res.ToString() + " == undefined", res.ToString()->Equals("undefined"));
00095 
00096         v1 = DateTime::Now();
00097         res = v1 * v2;
00098         UNIT_ASSERT(*res.ToString() + " == undefined", res.ToString()->Equals("undefined"));
00099 
00100         DEBUG_CLEAR_MEM_CHECK_POINTS();
00101         v1.CheckMem();
00102         v2.CheckMem();
00103         res.CheckMem();
00104         DEBUG_DUMP_MEM_LEAKS();
00105         UNIT_ASSERT_MEM_NOTED("Variant 2.3");
00106 
00107         Log::SWriteOkFail( "Variant math" );
00108 }
00109 
00110 static void _TestVariantLogOps()
00111 {
00112         Variant v1(4), v2(2);
00113 
00114         v1 = true;
00115         v2 = false;
00116 
00117         Variant res = v1 | v2;
00118         UNIT_ASSERT(*res.ToString() + " == true | false", res.ToBool() == true);
00119         
00120         res = v1 || v2;
00121         UNIT_ASSERT(*res.ToString() + " == true || false", res.ToBool() == true);
00122 
00123         res = v1 & v2;
00124         UNIT_ASSERT(*res.ToString() + " == true & false", res.ToBool() == false);
00125 
00126         res = v1 && v2;
00127         UNIT_ASSERT(*res.ToString() + " == true && false", res.ToBool() == false);
00128 
00129         res = v1 ^ v2;
00130         UNIT_ASSERT(*res.ToString() + " == true ^ false", res.ToBool() == true);
00131 
00132         v1 = 1;
00133         v2 = 0;
00134         
00135         res = v1 > v2;
00136         UNIT_ASSERT(*res.ToString() + " == 1 > 0", res.ToBool() == true);
00137         
00138         res = v1 < v2;
00139         UNIT_ASSERT(*res.ToString() + " == 1 < 0", res.ToBool() == false);
00140 
00141         res = v1 >= v2;
00142         UNIT_ASSERT(*res.ToString() + " == 1 >= 0", res.ToBool() == true);
00143 
00144         res = v1 <= v2;
00145         UNIT_ASSERT(*res.ToString() + " == 1 <= 0", res.ToBool() == false);
00146 
00147         res = v1 == v2;
00148         UNIT_ASSERT(*res.ToString() + " == 1 == 0", res.ToBool() == false);
00149 
00150         res = v1 != v2;
00151         UNIT_ASSERT(*res.ToString() + " == 1 != 0", res.ToBool() == true);
00152 
00153         v1 = "hi";
00154         v2 = "hi";
00155         UNIT_ASSERT(*res.ToString() + " == 1 == 0", res.ToBool() == true);
00156 
00157         v1 = DateTime::Now();
00158         v2 = v1;
00159         UNIT_ASSERT(*res.ToString() + " == Now == Now", res.ToBool() == true);
00160 
00161         v1 = 1;
00162         v2 = 2;
00163         
00164         res = v1 | v2;
00165         UNIT_ASSERT(*res.ToString() + " == 1 | 2 ", res.ToInt32() == 3);
00166 
00167         DEBUG_CLEAR_MEM_CHECK_POINTS();
00168         v1.CheckMem();
00169         v2.CheckMem();
00170         res.CheckMem();
00171         DEBUG_DUMP_MEM_LEAKS();
00172         UNIT_ASSERT_MEM_NOTED("Variant 2.1");
00173 
00174         Log::SWriteOkFail( "Variant logic" );
00175 }
00176 
00177 static void _TestVariantUnOps()
00178 {
00179         Variant v1(false);
00180 
00181         Variant res = !v1;
00182         UNIT_ASSERT(*res.ToString() + " == !false", res.ToBool() == true);
00183 
00184         v1 = 1;
00185         res = ~v1;
00186         UNIT_ASSERT(*res.ToString() + " == ~1", res.ToInt32() != 1 && res.ToInt32() < 0);
00187 
00188         DEBUG_CLEAR_MEM_CHECK_POINTS();
00189         v1.CheckMem();
00190         res.CheckMem();
00191         DEBUG_DUMP_MEM_LEAKS();
00192         UNIT_ASSERT_MEM_NOTED("Variant 3.1");
00193 
00194         Log::SWriteOkFail( "Variant unary" );
00195 }
00196 
00197 static void _TestVariantObject()
00198 {
00199         Variant v1;
00200 
00201         if (true)
00202         {
00203                 RefCountPtr<IJsObject> tmp(new JsObject());
00204                 v1 = tmp;
00205 
00206                 Variant v2 = v1;
00207                 v1.ValidateMem();
00208                 v2.ValidateMem();
00209                 UNIT_ASSERT("IsObject",  v2.IsObject());
00210         }
00211 
00212         v1.ValidateMem();       
00213         UNIT_ASSERT("IsObject",  v1.IsObject());
00214 
00215         DEBUG_CLEAR_MEM_CHECK_POINTS();
00216         v1.CheckMem();
00217         DEBUG_DUMP_MEM_LEAKS();
00218         UNIT_ASSERT_MEM_NOTED("Variant object 1");
00219 
00220         Log::SWriteOkFail( "Variant object" );
00221 }
00222 
00223 static void _TestVariantToObject()
00224 {
00225         Variant v1;
00226 
00227         if (true)
00228         {
00229                 RefCountPtr<IJsObject> tmp(new JsObject());
00230                 v1 = tmp;
00231         }
00232 
00233         Variant v2;
00234         if (true)
00235         {
00236                 RefCountPtr<IJsObject> tmp2 = v1.ToObject();
00237                 UNIT_ASSERT_MEM("jsobject ref mem", tmp2.Get(), sizeof(JsObject));
00238 
00239                 v2 = tmp2;
00240                 v2.ValidateMem();
00241         }
00242 
00243         v1.ValidateMem();
00244         v2.ValidateMem();
00245         UNIT_ASSERT("IsObject",  v1.IsObject());
00246 
00247         DEBUG_CLEAR_MEM_CHECK_POINTS();
00248         v1.CheckMem();
00249         v2.CheckMem();
00250         DEBUG_DUMP_MEM_LEAKS();
00251         UNIT_ASSERT_MEM_NOTED("Variant object 1");
00252 
00253         Log::SWriteOkFail( "Variant ToObject" );
00254 }
00255 
00256 void _TestVariant()
00257 {
00258         _TestVariant1();
00259         DEBUG_CLEAR_MEM_CHECK_POINTS();
00260         DEBUG_DUMP_MEM_LEAKS();
00261 
00262         _TestVariantBinOps();
00263         DEBUG_CLEAR_MEM_CHECK_POINTS();
00264         DEBUG_DUMP_MEM_LEAKS();
00265 
00266         _TestVariantLogOps();
00267         DEBUG_CLEAR_MEM_CHECK_POINTS();
00268         DEBUG_DUMP_MEM_LEAKS();
00269 
00270         _TestVariantUnOps();
00271         DEBUG_CLEAR_MEM_CHECK_POINTS();
00272         DEBUG_DUMP_MEM_LEAKS();
00273 
00274         _TestVariantObject();
00275         DEBUG_CLEAR_MEM_CHECK_POINTS();
00276         DEBUG_DUMP_MEM_LEAKS();
00277 
00278         _TestVariantToObject();
00279         DEBUG_CLEAR_MEM_CHECK_POINTS();
00280         DEBUG_DUMP_MEM_LEAKS();
00281 }
00282 
00283 #endif