LCOV - app.info - js/src/jsapi-tests/testCloneScript.cpp

LCOV - code coverage report
| Current view: | directory - js/src/jsapi-tests - testCloneScript.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 63 | 59 | 93.7 %
| Date: | 2012-07-07 | Functions: | 17 | 14 | 82.4 %

           1                 : /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
           2                 :  * vim: set ts=8 sw=4 et tw=99:
           3                 :  *
           4                 :  * Test script cloning.
           5                 :  */
           6                 :
           7                 : #include "tests.h"
           8                 : #include "jsapi.h"
           9                 : #include "jsdbgapi.h"
          10                 : #include "jsxdrapi.h"
          11                 :
          12               4 : BEGIN_TEST(test_cloneScript)
          13                 : {
          14                 :     JSObject *A, *B;
          15                 :
          16               1 :     CHECK(A = createGlobal());
          17               1 :     CHECK(B = createGlobal());
          18                 :
          19                 :     const char *source =
          20                 :         "var i = 0;\n"
          21                 :         "var sum = 0;\n"
          22                 :         "while (i < 10) {\n"
          23                 :         "    sum += i;\n"
          24                 :         "    ++i;\n"
          25                 :         "}\n"
          26               1 :         "(sum);\n";
          27                 :
          28                 :     JSObject *obj;
          29                 :
          30                 :     // compile for A
          31                 :     {
          32               2 :         JSAutoEnterCompartment a;
          33               1 :         if (!a.enter(cx, A))
          34               0 :             return false;
          35                 :
          36                 :         JSFunction *fun;
          37               1 :         CHECK(fun = JS_CompileFunction(cx, A, "f", 0, NULL, source, strlen(source), __FILE__, 1));
          38               1 :         CHECK(obj = JS_GetFunctionObject(fun));
          39                 :     }
          40                 :
          41                 :     // clone into B
          42                 :     {
          43               2 :         JSAutoEnterCompartment b;
          44               1 :         if (!b.enter(cx, B))
          45               0 :             return false;
          46                 :
          47               1 :         CHECK(JS_CloneFunctionObject(cx, obj, B));
          48                 :     }
          49                 :
          50               1 :     return true;
          51                 : }
          52               1 : END_TEST(test_cloneScript)
          53                 :
          54                 : void
          55               2 : DestroyPrincipals(JSPrincipals *principals)
          56                 : {
          57               2 :     delete principals;
          58               2 : }
          59                 :
          60                 : struct Principals : public JSPrincipals
          61                 : {
          62                 :   public:
          63               2 :     Principals()
          64               2 :     {
          65               2 :         refcount = 0;
          66               2 :     }
          67                 : };
          68                 :
          69                 : class AutoDropPrincipals
          70                 : {
          71                 :     JSRuntime *rt;
          72                 :     JSPrincipals *principals;
          73                 :
          74                 :   public:
          75               2 :     AutoDropPrincipals(JSRuntime *rt, JSPrincipals *principals)
          76               2 :       : rt(rt), principals(principals)
          77                 :     {
          78               2 :         JS_HoldPrincipals(principals);
          79               2 :     }
          80                 :
          81               2 :     ~AutoDropPrincipals()
          82                 :     {
          83               2 :         JS_DropPrincipals(rt, principals);
          84               2 :     }
          85                 : };
          86                 :
          87               4 : BEGIN_TEST(test_cloneScriptWithPrincipals)
          88                 : {
          89               1 :     JS_InitDestroyPrincipalsCallback(rt, DestroyPrincipals);
          90                 :
          91               1 :     JSPrincipals *principalsA = new Principals();
          92               2 :     AutoDropPrincipals dropA(rt, principalsA);
          93               1 :     JSPrincipals *principalsB = new Principals();
          94               2 :     AutoDropPrincipals dropB(rt, principalsB);
          95                 :
          96                 :     JSObject *A, *B;
          97                 :
          98               1 :     CHECK(A = createGlobal(principalsA));
          99               1 :     CHECK(B = createGlobal(principalsB));
         100                 :
         101               1 :     const char *argnames[] = { "arg" };
         102               1 :     const char *source = "return function() { return arg; }";
         103                 :
         104                 :     JSObject *obj;
         105                 :
         106                 :     // Compile in A
         107                 :     {
         108               2 :         JSAutoEnterCompartment a;
         109               1 :         if (!a.enter(cx, A))
         110               0 :             return false;
         111                 :
         112                 :         JSFunction *fun;
         113               1 :         CHECK(fun = JS_CompileFunctionForPrincipals(cx, A, principalsA, "f",
         114                 :                                                     mozilla::ArrayLength(argnames), argnames,
         115                 :                                                     source, strlen(source), __FILE__, 1));
         116                 :
         117                 :         JSScript *script;
         118               1 :         CHECK(script = JS_GetFunctionScript(cx, fun));
         119                 :
         120               1 :         CHECK(JS_GetScriptPrincipals(cx, script) == principalsA);
         121               1 :         CHECK(obj = JS_GetFunctionObject(fun));
         122                 :     }
         123                 :
         124                 :     // Clone into B
         125                 :     {
         126               2 :         JSAutoEnterCompartment b;
         127               1 :         if (!b.enter(cx, B))
         128               0 :             return false;
         129                 :
         130                 :         JSObject *cloned;
         131               1 :         CHECK(cloned = JS_CloneFunctionObject(cx, obj, B));
         132                 :
         133                 :         JSFunction *fun;
         134               1 :         CHECK(fun = JS_ValueToFunction(cx, JS::ObjectValue(*cloned)));
         135                 :
         136                 :         JSScript *script;
         137               1 :         CHECK(script = JS_GetFunctionScript(cx, fun));
         138                 :
         139               1 :         CHECK(JS_GetScriptPrincipals(cx, script) == principalsB);
         140                 :
         141                 :         JS::Value v;
         142               1 :         JS::Value args[] = { JS::Int32Value(1) };
         143               1 :         CHECK(JS_CallFunctionValue(cx, B, JS::ObjectValue(*cloned), 1, args, &v));
         144               1 :         CHECK(v.isObject());
         145                 :
         146               1 :         JSObject *funobj = &v.toObject();
         147               1 :         CHECK(JS_ObjectIsFunction(cx, funobj));
         148               1 :         CHECK(fun = JS_ValueToFunction(cx, v));
         149               1 :         CHECK(script = JS_GetFunctionScript(cx, fun));
         150               1 :         CHECK(JS_GetScriptPrincipals(cx, script) == principalsB);
         151                 :     }
         152                 :
         153               1 :     return true;
         154                 : }
         155               3 : END_TEST(test_cloneScriptWithPrincipals)

Generated by: LCOV version 1.7