Standard Portable Library: test/TestVarInterp.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/Log.h>
00019 #include <spl/interp/VarInterp.h>
00020 
00021 #ifdef DEBUG
00022 
00023 using namespace spl;
00024 
00025 static void _TestVarInterpStackFrame()
00026 {
00027         StackFrame frm(JsMethodPtr(new JsMethod()), 0);
00028 
00029         DEBUG_CLEAR_MEM_CHECK_POINTS();
00030         frm.CheckMem();
00031         UNIT_ASSERT_MEM_NOTED("StackFrame 1");
00032 
00033         *frm.FindProperty("prop") = "sot";
00034 
00035         DEBUG_CLEAR_MEM_CHECK_POINTS();
00036         frm.CheckMem();
00037         UNIT_ASSERT_MEM_NOTED("StackFrame 2");
00038 
00039         VariantPtr v1 = frm.FindProperty("prop");
00040         StringPtr s = v1->ToString();   
00041         UNIT_ASSERT("sot", *s == "sot");
00042 
00043         DEBUG_CLEAR_MEM_CHECK_POINTS();
00044         frm.CheckMem();
00045         s.CheckMem();
00046         v1.CheckMem();
00047         UNIT_ASSERT_MEM_NOTED("StackFrame 3");
00048 
00049         *v1 = "bye";
00050         s = v1->ToString();     
00051         UNIT_ASSERT("bye", *s == "bye");
00052 
00053         VariantPtr v2 = frm.FindProperty("prop");
00054         *v2 = "hi";
00055         s = v2->ToString();     
00056         UNIT_ASSERT("hi", *s == "hi");
00057 
00058         s = v1->ToString();     
00059         UNIT_ASSERT("hi", *s == "hi");
00060         
00061         DEBUG_CLEAR_MEM_CHECK_POINTS();
00062         frm.CheckMem();
00063         s.CheckMem();
00064         v1.CheckMem();
00065         v2.CheckMem();
00066         UNIT_ASSERT_MEM_NOTED("StackFrame 0");
00067         Log::SWriteOkFail( "StackFrame" );
00068 }
00069 
00070 static void _TestVarInterpNull()
00071 {
00072         VarInterp *vi = new VarInterp();
00073 
00074         DEBUG_CLEAR_MEM_CHECK_POINTS();
00075         DEBUG_NOTE_MEM( vi );
00076         vi->CheckMem();
00077         DEBUG_DUMP_MEM_LEAKS();
00078         UNIT_ASSERT_MEM_NOTED("VarInterp 1.0");
00079 
00080         delete vi;
00081         DEBUG_CLEAR_MEM_CHECK_POINTS();
00082         UNIT_ASSERT_MEM_NOTED("VarInterp 1.1");
00083         Log::SWriteOkFail( "VarInterp null" );
00084 }
00085 
00086 static void _TestVarInterpNoOp()
00087 {
00088         Program p;
00089         p.AppendCode(JSOP_NOP, JSOPARG_NONE, 0);
00090         VariantPtr method(new Variant(RefCountPtr<IJsObject>(new JsMethod(p))));
00091         Vector<VariantPtr> args;
00092         VarInterp vi(method, args);
00093         
00094         bool ret = vi.Execute(false);
00095         UNIT_ASSERT("eof", !ret);
00096 
00097         UNIT_ASSERT("stack not empty", vi.StackCount() == 0);
00098         UNIT_ASSERT("undefined", vi.ReturnValue()->ToString()->Equals("undefined"));
00099 
00100         Log::SWriteOkFail( "VarInterp NOP" );
00101 }
00102 
00103 static void _TestVarInterpPush()
00104 {
00105         Program p;
00106         p.AppendCode(JSOP_PUSH, JSOPARG_IMM, 1);
00107         p.AppendCode(JSOP_LINE, JSOPARG_IMM, 1);
00108         
00109         int pos = p.AddToTable(1);
00110         p.AppendCode(JSOP_PUSH, JSOPARG_TAB, pos);
00111         p.AppendCode(JSOP_LINE, JSOPARG_IMM, 2);
00112 
00113         pos = p.AddToTable("hi");
00114         p.AppendCode(JSOP_PUSH, JSOPARG_TAB, pos);
00115         p.AppendCode(JSOP_LINE, JSOPARG_IMM, 3);
00116 
00117         pos = p.AddToTable(1.2);
00118         p.AppendCode(JSOP_PUSH, JSOPARG_TAB, pos);
00119         p.AppendCode(JSOP_LINE, JSOPARG_IMM, 4);
00120 
00121         VariantPtr method(new Variant(VarInterp::CreateDefaultContext(p)));
00122         Vector<VariantPtr> args;
00123         method.ValidateMem();
00124         
00125         VarInterp vi(method, args);
00126 
00127         bool ret = vi.Execute(false);
00128         
00129         UNIT_ASSERT("continue LINE", ret);
00130 
00131         DEBUG_CLEAR_MEM_CHECK_POINTS();
00132         vi.CheckMem();
00133         p.CheckMem();
00134         method.CheckMem();
00135         args.CheckMem();
00136         DEBUG_DUMP_MEM_LEAKS();
00137         UNIT_ASSERT_MEM_NOTED("VarInterp PUSH 1");
00138         
00139         UNIT_ASSERT("stack 2", vi.StackCount() == 2);
00140         UNIT_ASSERT("line 1", vi.StackPeek()->ToInt32() == 1);
00141         vi.PopStack();
00142         UNIT_ASSERT("IM value", vi.StackPeek()->ToInt32() == 1);
00143 
00144         ret = vi.Execute(true);
00145         
00146         UNIT_ASSERT("continue LINE", ret);
00147 
00148         DEBUG_CLEAR_MEM_CHECK_POINTS();
00149         vi.CheckMem();
00150         p.CheckMem();
00151         method.CheckMem();
00152         args.CheckMem();
00153         DEBUG_DUMP_MEM_LEAKS();
00154         UNIT_ASSERT_MEM_NOTED("VarInterp PUSH 2");
00155         
00156         UNIT_ASSERT("stack 2", vi.StackCount() == 3);
00157         UNIT_ASSERT("line 2", vi.StackPeek()->ToInt32() == 2);
00158         vi.PopStack();
00159         UNIT_ASSERT("INT TAB value", vi.StackPeek()->ToInt32() == 1);
00160 
00161         ret = vi.Execute(true);
00162         
00163         UNIT_ASSERT("continue LINE", ret);
00164 
00165         DEBUG_CLEAR_MEM_CHECK_POINTS();
00166         vi.CheckMem();
00167         p.CheckMem();
00168         method.CheckMem();
00169         args.CheckMem();
00170         DEBUG_DUMP_MEM_LEAKS();
00171         UNIT_ASSERT_MEM_NOTED("VarInterp PUSH 3");
00172         
00173         UNIT_ASSERT("stack 2", vi.StackCount() == 4);
00174         UNIT_ASSERT("line 3", vi.StackPeek()->ToInt32() == 3);
00175         vi.PopStack();
00176         UNIT_ASSERT("STRING TAB value", vi.StackPeek()->ToString()->Equals("hi"));
00177 
00178         vi.ValidateMem();
00179         ret = vi.Execute(true);
00180         
00181         UNIT_ASSERT("continue LINE", ret);
00182 
00183         DEBUG_CLEAR_MEM_CHECK_POINTS();
00184         vi.CheckMem();
00185         p.CheckMem();
00186         method.CheckMem();
00187         args.CheckMem();
00188         DEBUG_DUMP_MEM_LEAKS();
00189         UNIT_ASSERT_MEM_NOTED("VarInterp PUSH 4");
00190         
00191         UNIT_ASSERT("stack 2", vi.StackCount() == 5);
00192         UNIT_ASSERT("line 4", vi.StackPeek()->ToInt32() == 4);
00193         vi.PopStack();
00194         UNIT_ASSERT("FLOAT TAB value", vi.StackPeek()->ToString()->Equals("1.2"));
00195 
00196         Log::SWriteOkFail( "VarInterp PUSH" );
00197 }
00198 
00199 static void _TestVarInterpAdd()
00200 {
00201         Program p;
00202         p.AppendCode(JSOP_PUSH, JSOPARG_IMM, 1);
00203         p.AppendCode(JSOP_PUSH, JSOPARG_IMM, 1);
00204         p.AppendCode(JSOP_ADD, JSOPARG_NONE, 0);
00205         p.AppendCode(JSOP_LINE, JSOPARG_IMM, 1);
00206 
00207         int pos = p.AddToTable(1.2);
00208         p.AppendCode(JSOP_PUSH, JSOPARG_TAB, pos);
00209         p.AppendCode(JSOP_ADD, JSOPARG_NONE, 0);
00210         p.AppendCode(JSOP_LINE, JSOPARG_IMM, 2);
00211 
00212         VariantPtr method(new Variant(VarInterp::CreateDefaultContext(p)));
00213         Vector<VariantPtr> args;
00214         
00215         VarInterp vi(method, args);
00216 
00217         bool ret = vi.Execute(false);
00218         
00219         UNIT_ASSERT("continue LINE", ret);
00220 
00221         UNIT_ASSERT("stack 2", vi.StackCount() == 2);
00222         UNIT_ASSERT("line 1", vi.StackPeek()->ToInt32() == 1);
00223         vi.PopStack();
00224         UNIT_ASSERT("2+2", vi.StackPeek()->ToInt32() == 2);
00225 
00226         ret = vi.Execute(true);
00227         
00228         UNIT_ASSERT("continue LINE", ret);
00229 
00230         UNIT_ASSERT("stack 2", vi.StackCount() == 2);
00231         UNIT_ASSERT("line 2", vi.StackPeek()->ToInt32() == 2);
00232         vi.PopStack();
00233         UNIT_ASSERT("2+1.2", vi.StackPeek()->ToString()->Equals("3.2"));
00234 
00235         Log::SWriteOkFail( "VarInterp ADD" );
00236 }
00237 
00238 static void _TestVarInterpThis()
00239 {
00240         Program p;
00241         p.AppendCode(JSOP_THIS, JSOPARG_NONE, 0);
00242         p.AppendCode(JSOP_LINE, JSOPARG_IMM, 1);
00243 
00244         VariantPtr method(new Variant(VarInterp::CreateDefaultContext(p)));
00245         Vector<VariantPtr> args;
00246         
00247         VarInterp vi(method, args);
00248 
00249         bool ret = vi.Execute(false);
00250         
00251         UNIT_ASSERT("continue LINE", ret);
00252 
00253         UNIT_ASSERT("stack 2", vi.StackCount() == 2);
00254         UNIT_ASSERT("line 1", vi.StackPeek()->ToInt32() == 1);
00255         vi.PopStack();
00256         UNIT_ASSERT("this", vi.StackPeek()->IsObject());
00257 
00258         Log::SWriteOkFail( "VarInterp THIS" );
00259 }
00260 
00261 static void _TestVarInterpFindProp()
00262 {
00263         Program p;
00264         int pos = p.AddToTable("prop1");
00265         p.AppendCode(JSOP_PUSH, JSOPARG_TAB, pos);
00266         p.AppendCode(JSOP_FINDPROP, JSOPARG_NONE, 0);
00267         p.AppendCode(JSOP_LINE, JSOPARG_IMM, 1);
00268 
00269         VariantPtr method(new Variant(VarInterp::CreateDefaultContext(p)));
00270         Vector<VariantPtr> args;
00271         
00272         VarInterp vi(method, args);
00273 
00274         bool ret = vi.Execute(false);
00275         
00276         UNIT_ASSERT("continue LINE", ret);
00277 
00278         UNIT_ASSERT("stack 2", vi.StackCount() == 2);
00279         UNIT_ASSERT("line 1", vi.StackPeek()->ToInt32() == 1);
00280         vi.PopStack();
00281         
00282         VariantPtr v = vi.StackPeek();
00283         StringPtr s = v->ToString();
00284         UNIT_ASSERT("this", StrCmp(v->TypeNameInner(), "undefined", 20) == 0);
00285 
00286         Log::SWriteOkFail( "VarInterp FINDPROP" );
00287 }
00288 
00289 static void _TestVarInterpAssign()
00290 {
00291         Program p;
00292         int posProp1 = p.AddToTable("prop1");
00293         p.AppendCode(JSOP_PUSH, JSOPARG_TAB, posProp1);
00294         p.AppendCode(JSOP_FINDPROP, JSOPARG_NONE, 0);
00295         int posHi = p.AddToTable("hi");
00296         p.AppendCode(JSOP_PUSH, JSOPARG_TAB, posHi);
00297         p.AppendCode(JSOP_ASSIGN, JSOPARG_NONE, 0);
00298         p.AppendCode(JSOP_PUSH, JSOPARG_TAB, posProp1);
00299         p.AppendCode(JSOP_FINDPROP, JSOPARG_NONE, 0);
00300         p.AppendCode(JSOP_LINE, JSOPARG_IMM, 1);
00301 
00302         VariantPtr method(new Variant(VarInterp::CreateDefaultContext(p)));
00303         Vector<VariantPtr> args;
00304         
00305         VarInterp vi(method, args);
00306 
00307         bool ret = vi.Execute(false);
00308         vi.ValidateMem();
00309         UNIT_ASSERT("continue LINE", ret);
00310 
00311         UNIT_ASSERT("stack 2", vi.StackCount() == 2);
00312         UNIT_ASSERT("line 1", vi.StackPeek()->ToInt32() == 1);
00313         vi.PopStack();
00314         
00315         VariantPtr v = vi.StackPeek();
00316         StringPtr s = v->ToString();
00317         UNIT_ASSERT("this", 0 == StrCmp(v->TypeNameInner(), "String", 20));
00318         UNIT_ASSERT("this", *s == "hi");
00319 
00320         Log::SWriteOkFail( "VarInterp ASSIGN" );
00321 }
00322 
00323 static void _TestVarInterpDeref()
00324 {
00325         Program p;
00326         int posProp1 = p.AddToTable("prop1");
00327         p.AppendCode(JSOP_PUSH, JSOPARG_TAB, posProp1);
00328         p.AppendCode(JSOP_FINDPROP, JSOPARG_NONE, 0);
00329         
00330         int pos = p.AddToTable("Object");
00331         p.AppendCode(JSOP_PUSH, JSOPARG_TAB, pos);
00332         p.AppendCode(JSOP_NEW, JSOPARG_NONE, 0);
00333         p.AppendCode(JSOP_ASSIGN, JSOPARG_NONE, 0);
00334         
00335         p.AppendCode(JSOP_PUSH, JSOPARG_TAB, posProp1);
00336         p.AppendCode(JSOP_FINDPROP, JSOPARG_NONE, 0);
00337         
00338         int posInnerProp = p.AddToTable("innerprop");
00339         p.AppendCode(JSOP_PUSH, JSOPARG_TAB, posInnerProp);
00340         p.AppendCode(JSOP_DEREF, JSOPARG_NONE, 0);
00341         int posHi = p.AddToTable("hi");
00342         p.AppendCode(JSOP_PUSH, JSOPARG_TAB, posHi);
00343 
00344         p.AppendCode(JSOP_ASSIGN, JSOPARG_NONE, 0);
00345         p.AppendCode(JSOP_PUSH, JSOPARG_TAB, posProp1);
00346         p.AppendCode(JSOP_FINDPROP, JSOPARG_NONE, 0);
00347         p.AppendCode(JSOP_PUSH, JSOPARG_TAB, posInnerProp);
00348         p.AppendCode(JSOP_DEREF, JSOPARG_NONE, 0);
00349 
00350         p.AppendCode(JSOP_LINE, JSOPARG_IMM, 1);
00351 
00352         VariantPtr method(new Variant(VarInterp::CreateDefaultContext(p)));
00353         Vector<VariantPtr> args;        
00354 
00355         VarInterp vi(method, args);
00356         bool ret = vi.Execute(false);
00357         vi.ValidateMem();
00358         UNIT_ASSERT("continue LINE", ret);
00359 
00360         UNIT_ASSERT("stack 2", vi.StackCount() == 2);
00361         UNIT_ASSERT("line 1", vi.StackPeek()->ToInt32() == 1);
00362         vi.PopStack();
00363         
00364         VariantPtr v = vi.StackPeek();
00365         StringPtr s = v->ToString();
00366         UNIT_ASSERT("this", 0 == StrCmp(v->TypeNameInner(), "String", 20));
00367         UNIT_ASSERT("this", *s == "hi");
00368 
00369         Log::SWriteOkFail( "VarInterp DEREF" );
00370 }
00371 
00372 static void _TestVarInterpEnterLeave()
00373 {
00374         Program p;
00375         int posProp1 = p.AddToTable("prop1");
00376         p.AppendCode(JSOP_FINDPROP, JSOPARG_TAB, posProp1);
00377         p.AppendCode(JSOP_ASSIGN, JSOPARG_TAB, p.AddToTable("hi"));
00378         p.AppendCode(JSOP_FINDPROP, JSOPARG_TAB, posProp1);
00379 
00380         p.AppendCode(JSOP_ENTER);
00381         int posProp2 = p.AddToTable("prop2");
00382         p.AppendCode(JSOP_DEFPROP, JSOPARG_TAB, posProp2);
00383         p.AppendCode(JSOP_ASSIGN, JSOPARG_TAB, p.AddToTable("hiher"));
00384         p.AppendCode(JSOP_FINDPROP, JSOPARG_TAB, posProp2);
00385         p.AppendCode(JSOP_LINE, JSOPARG_IMM, 1);
00386         
00387         p.AppendCode(JSOP_LEAVE);
00388         p.AppendCode(JSOP_LINE, JSOPARG_IMM, 2);
00389 
00390         VariantPtr method(new Variant(VarInterp::CreateDefaultContext(p)));
00391         Vector<VariantPtr> args;
00392         
00393         VarInterp vi(method, args);
00394         bool ret = vi.Execute(false);
00395         vi.ValidateMem();
00396         UNIT_ASSERT("continue LINE", ret);
00397 
00398         UNIT_ASSERT("2 frames", vi.FrameCount() == 1);
00399         UNIT_ASSERT("stack 2", vi.StackCount() == 3);
00400         UNIT_ASSERT("line 1", vi.StackPeek()->ToInt32() == 1);
00401         vi.PopStack();
00402         
00403         VariantPtr v = vi.StackPeek();
00404         StringPtr s = v->ToString();
00405         UNIT_ASSERT("this", 0 == StrCmp(v->TypeNameInner(), "String", 20));
00406         UNIT_ASSERT("this", *s == "hiher");
00407         vi.PopStack();
00408 
00409         ret = vi.Execute(true);
00410         vi.ValidateMem();
00411         UNIT_ASSERT("continue LINE", ret);
00412 
00413         UNIT_ASSERT("1 frames", vi.FrameCount() == 1);
00414         UNIT_ASSERT("stack 2", vi.StackCount() == 2);
00415         int line = vi.StackPeek()->ToInt32();
00416         UNIT_ASSERT("line 2", line == 2);
00417         vi.PopStack();
00418         
00419         v = vi.StackPeek();
00420         s = v->ToString();
00421         UNIT_ASSERT("this", 0 == StrCmp(v->TypeNameInner(), "String", 20));
00422         UNIT_ASSERT("this", *s == "hi");
00423 
00424         Log::SWriteOkFail( "VarInterp ENTER/LEAVE" );
00425 }
00426 
00427 static void _TestVarInterpToString()
00428 {
00429         Program p;      
00430 
00431         p.AppendCode(JSOP_ENTER);       
00432         p.AppendCode(JSOP_THIS);
00433         p.AppendCode(JSOP_DEREF, JSOPARG_TAB, p.AddToTable("toString"));
00434         p.AppendCode(JSOP_PUSH, JSOPARG_IMM, 1);        
00435         p.AppendCode(JSOP_CALL);
00436         p.AppendCode(JSOP_LINE, JSOPARG_IMM, 1);
00437 
00438         VariantPtr method(new Variant(VarInterp::CreateDefaultContext(p)));
00439         UNIT_ASSERT("toString property set", method->ToObject()->GetProperty("toString")->IsObject());
00440         
00441         Vector<VariantPtr> args;
00442         VarInterp vi(method, args);
00443         bool ret = vi.Execute(false);
00444         vi.ValidateMem();
00445         UNIT_ASSERT("continue LINE", ret);
00446 
00447         UNIT_ASSERT("1 frames", vi.FrameCount() == 1);
00448         UNIT_ASSERT("stack 2", vi.StackCount() == 2);
00449         UNIT_ASSERT("line 1", vi.StackPeek()->ToInt32() == 1);
00450         vi.PopStack();
00451         
00452         VariantPtr v = vi.StackPeek();
00453         StringPtr s = v->ToString();
00454         UNIT_ASSERT("type", 0 == StrCmp(v->TypeNameInner(), "String", 20));
00455         UNIT_ASSERT("1", *s == "1");
00456 
00457         Log::SWriteOkFail( "VarInterp toString(value)" );
00458 }
00459 
00460 static void _TestVarInterpCallRet()
00461 {
00462         Program progMain;
00463         progMain.AppendCode(JSOP_ENTER);
00464         progMain.AppendCode(JSOP_THIS);
00465         progMain.AppendCode(JSOP_DEREF, JSOPARG_TAB, progMain.AddToTable("addOne")); 
00466         progMain.AppendCode(JSOP_PUSH, JSOPARG_IMM, 1);
00467         progMain.AppendCode(JSOP_CALL);
00468         progMain.AppendCode(JSOP_LINE, JSOPARG_IMM, 1);
00469         
00470         progMain.AppendCode(JSOP_ENTER);
00471         progMain.AppendCode(JSOP_THIS);
00472         progMain.AppendCode(JSOP_DEREF, JSOPARG_TAB, progMain.AddToTable("addTwo")); 
00473         progMain.AppendCode(JSOP_PUSH, JSOPARG_IMM, 2);
00474         progMain.AppendCode(JSOP_PUSH, JSOPARG_IMM, 3);
00475         progMain.AppendCode(JSOP_CALL);
00476 
00477         Program progSub;
00478         progSub.AppendCode(JSOP_PUSH, JSOPARG_STK, 0);
00479         progSub.AppendCode(JSOP_ADD, JSOPARG_IMM, 1);
00480         progSub.NoteArgument();
00481         progSub.AppendCode(JSOP_RET);
00482         
00483         Program progSub2;
00484         progSub2.AppendCode(JSOP_PUSH, JSOPARG_STK, 0);
00485         progSub2.NoteArgument();
00486         progSub2.AppendCode(JSOP_PUSH, JSOPARG_STK, 1);
00487         progSub2.NoteArgument();
00488         progSub2.AppendCode(JSOP_ADD);
00489         progSub2.AppendCode(JSOP_RET);  
00490 
00491         IJsObjectPtr methMain = VarInterp::CreateDefaultContext(progMain);
00492         
00493         JsMethodPtr methSub(new JsMethod(progSub));
00494         methMain->SetProperty("addOne", VariantPtr(new Variant((JsObjectPtr)methSub)));
00495         JsMethodPtr methSub2(new JsMethod(progSub2));
00496         methMain->SetProperty("addTwo", VariantPtr(new Variant((JsObjectPtr)methSub2)));
00497         VariantPtr method(new Variant(methMain));
00498         
00499         Vector<VariantPtr> args;
00500         VarInterp vi(method, args);
00501         bool ret = vi.Execute(false);
00502         vi.ValidateMem();
00503         
00504         vi.PopStack();
00505         VariantPtr v = vi.ReturnValue();
00506         StringPtr s = v->ToString();
00507         UNIT_ASSERT("type", 0 == StrCmp(v->TypeNameInner(), "int64", 20));
00508         UNIT_ASSERT("2", *s == "2");
00509         
00510         ret = vi.Execute(true);
00511         v = vi.ReturnValue();
00512         s = v->ToString();
00513         UNIT_ASSERT("type", 0 == StrCmp(v->TypeNameInner(), "int64", 20));
00514         UNIT_ASSERT("5", *s == "5");    
00515         
00516         Log::SWriteOkFail( "VarInterp CALL" );
00517 }
00518 
00519 void _TestVarInterp()
00520 {
00521         _TestVarInterpStackFrame();
00522         DEBUG_CLEAR_MEM_CHECK_POINTS();
00523         DEBUG_DUMP_MEM_LEAKS();
00524 
00525         _TestVarInterpNull();
00526         DEBUG_CLEAR_MEM_CHECK_POINTS();
00527         DEBUG_DUMP_MEM_LEAKS();
00528 
00529         _TestVarInterpNoOp();
00530         DEBUG_CLEAR_MEM_CHECK_POINTS();
00531         DEBUG_DUMP_MEM_LEAKS();
00532         
00533         _TestVarInterpPush();
00534         DEBUG_CLEAR_MEM_CHECK_POINTS();
00535         DEBUG_DUMP_MEM_LEAKS();
00536 
00537         _TestVarInterpAdd();
00538         DEBUG_CLEAR_MEM_CHECK_POINTS();
00539         DEBUG_DUMP_MEM_LEAKS();
00540 
00541         _TestVarInterpThis();
00542         DEBUG_CLEAR_MEM_CHECK_POINTS();
00543         DEBUG_DUMP_MEM_LEAKS();
00544 
00545         _TestVarInterpFindProp();
00546         DEBUG_CLEAR_MEM_CHECK_POINTS();
00547         DEBUG_DUMP_MEM_LEAKS();
00548 
00549         _TestVarInterpAssign();
00550         DEBUG_CLEAR_MEM_CHECK_POINTS();
00551         DEBUG_DUMP_MEM_LEAKS();
00552 
00553         _TestVarInterpDeref();
00554         DEBUG_CLEAR_MEM_CHECK_POINTS();
00555         DEBUG_DUMP_MEM_LEAKS();
00556         
00557         _TestVarInterpEnterLeave();
00558         DEBUG_CLEAR_MEM_CHECK_POINTS();
00559         DEBUG_DUMP_MEM_LEAKS();
00560 
00561         _TestVarInterpToString();
00562         DEBUG_CLEAR_MEM_CHECK_POINTS();
00563         DEBUG_DUMP_MEM_LEAKS();
00564         
00565         _TestVarInterpCallRet();
00566         DEBUG_CLEAR_MEM_CHECK_POINTS();
00567         DEBUG_DUMP_MEM_LEAKS();
00568 }
00569 
00570 #endif