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

LCOV - code coverage report
| Current view: | directory - js/src/jsapi-tests - testFuncCallback.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 8 | 8 | 100.0 %
| Date: | 2012-04-07 | Functions: | 9 | 7 | 77.8 %

           1                 : #include "tests.h"
           2                 : #include "jsfun.h"
           3                 : #include "jscntxt.h"
           4                 :
           5                 : #include "jsobjinlines.h"
           6                 :
           7                 : #ifdef MOZ_TRACE_JSCALLS
           8                 :
           9                 : static int depth = 0;
          10                 : static int enters = 0;
          11                 : static int leaves = 0;
          12                 : static int interpreted = 0;
          13                 :
          14                 : static void
          15                 : funcTransition(const JSFunction *,
          16                 :                const JSScript *,
          17                 :                const JSContext *cx,
          18                 :                int entering)
          19                 : {
          20                 :     if (entering > 0) {
          21                 :         ++depth;
          22                 :         ++enters;
          23                 :         ++interpreted;
          24                 :     } else {
          25                 :         --depth;
          26                 :         ++leaves;
          27                 :     }
          28                 : }
          29                 :
          30                 : static JSBool called2 = false;
          31                 :
          32                 : static void
          33                 : funcTransition2(const JSFunction *, const JSScript*, const JSContext*, int)
          34                 : {
          35                 :     called2 = true;
          36                 : }
          37                 :
          38                 : static int overlays = 0;
          39                 : static JSFunctionCallback innerCallback = NULL;
          40                 : static void
          41                 : funcTransitionOverlay(const JSFunction *fun,
          42                 :                       const JSScript *script,
          43                 :                       const JSContext *cx,
          44                 :                       int entering)
          45                 : {
          46                 :     (*innerCallback)(fun, script, cx, entering);
          47                 :     overlays++;
          48                 : }
          49                 : #endif
          50                 :
          51               4 : BEGIN_TEST(testFuncCallback_bug507012)
          52                 : {
          53                 : #ifdef MOZ_TRACE_JSCALLS
          54                 :     // Call funcTransition() whenever a Javascript method is invoked
          55                 :     JS_SetFunctionCallback(cx, funcTransition);
          56                 :
          57                 :     EXEC("x = 0; function f (n) { if (n > 1) { f(n - 1); } }");
          58                 :     interpreted = enters = leaves = depth = 0;
          59                 :
          60                 :     // Check whether JS_Execute() tracking works
          61                 :     EXEC("42");
          62                 :     CHECK_EQUAL(enters, 1);
          63                 :     CHECK_EQUAL(leaves, 1);
          64                 :     CHECK_EQUAL(depth, 0);
          65                 :     interpreted = enters = leaves = depth = 0;
          66                 :
          67                 :     // Check whether the basic function tracking works
          68                 :     EXEC("f(1)");
          69                 :     CHECK_EQUAL(enters, 1+1);
          70                 :     CHECK_EQUAL(leaves, 1+1);
          71                 :     CHECK_EQUAL(depth, 0);
          72                 :
          73                 :     // Can we switch to a different callback?
          74                 :     enters = 777;
          75                 :     JS_SetFunctionCallback(cx, funcTransition2);
          76                 :     EXEC("f(1)");
          77                 :     CHECK(called2);
          78                 :     CHECK_EQUAL(enters, 777);
          79                 :
          80                 :     // Check whether we can turn off function tracing
          81                 :     JS_SetFunctionCallback(cx, NULL);
          82                 :     EXEC("f(1)");
          83                 :     CHECK_EQUAL(enters, 777);
          84                 :     interpreted = enters = leaves = depth = 0;
          85                 :
          86                 :     // Check nested invocations
          87                 :     JS_SetFunctionCallback(cx, funcTransition);
          88                 :     enters = leaves = depth = 0;
          89                 :     EXEC("f(3)");
          90                 :     CHECK_EQUAL(enters, 1+3);
          91                 :     CHECK_EQUAL(leaves, 1+3);
          92                 :     CHECK_EQUAL(depth, 0);
          93                 :     interpreted = enters = leaves = depth = 0;
          94                 :
          95                 :     // Check calls invoked while running on trace -- or now, perhaps on
          96                 :     // IonMonkey's equivalent, if it ever starts to exist?
          97                 :     EXEC("function g () { ++x; }");
          98                 :     interpreted = enters = leaves = depth = 0;
          99                 :     EXEC("for (i = 0; i < 5000; ++i) { g(); }");
         100                 :     CHECK_EQUAL(enters, 1+5000);
         101                 :     CHECK_EQUAL(leaves, 1+5000);
         102                 :     CHECK_EQUAL(depth, 0);
         103                 :
         104                 :     // Test nesting callbacks via JS_GetFunctionCallback()
         105                 :     JS_SetFunctionCallback(cx, funcTransition);
         106                 :     innerCallback = JS_GetFunctionCallback(cx);
         107                 :     JS_SetFunctionCallback(cx, funcTransitionOverlay);
         108                 :
         109                 :     EXEC("x = 0; function f (n) { if (n > 1) { f(n - 1); } }");
         110                 :     interpreted = enters = leaves = depth = overlays = 0;
         111                 :
         112                 :     EXEC("42.5");
         113                 :     CHECK_EQUAL(enters, 1);
         114                 :     CHECK_EQUAL(leaves, 1);
         115                 :     CHECK_EQUAL(depth, 0);
         116                 :     CHECK_EQUAL(overlays, enters + leaves);
         117                 :     interpreted = enters = leaves = depth = overlays = 0;
         118                 : #endif
         119                 :
         120                 :     // Uncomment this to validate whether you're hitting all runmodes (interp,
         121                 :     // mjit, ...?) Unfortunately, that still doesn't cover all
         122                 :     // transitions between the various runmodes, but it's a start.
         123                 :     //JS_DumpAllProfiles(cx);
         124                 :
         125               1 :     return true;
         126                 : }
         127                 :
         128                 : // Make sure that the method jit is enabled.
         129                 : // We'll probably want to test in all modes.
         130                 : virtual
         131               1 : JSContext *createContext()
         132                 : {
         133               1 :     JSContext *cx = JSAPITest::createContext();
         134               1 :     if (cx)
         135               1 :         JS_SetOptions(cx, JS_GetOptions(cx) | JSOPTION_METHODJIT | JSOPTION_PCCOUNT);
         136               1 :     return cx;
         137                 : }
         138                 :
         139               2 : END_TEST(testFuncCallback_bug507012)

Generated by: LCOV version 1.7