The Tor Browser / file revision

 /*

  * Copyright 2006 The Android Open Source Project

  *

  * Use of this source code is governed by a BSD-style license that can be

  * found in the LICENSE file.

  */

 #include "SkAnimatorScript.h"

 #include "SkAnimateBase.h"

 #include "SkAnimateMaker.h"

 #include "SkDisplayTypes.h"

 #include "SkExtras.h"

 #include "SkMemberInfo.h"

 #include "SkParse.h"

 static const SkDisplayEnumMap gEnumMaps[] = {

     { SkType_AddMode, "indirect|immediate" },

     { SkType_Align, "left|center|right" },

     { SkType_ApplyMode, "create|immediate|once" },

     { SkType_ApplyTransition, "normal|reverse" },

     { SkType_BitmapEncoding, "jpeg|png" },

     { SkType_BitmapFormat, "none|A1|A8|Index8|RGB16|RGB32" },

     { SkType_Boolean, "false|true" },

     { SkType_Cap, "butt|round|square" },

     { SkType_EventCode, "none|leftSoftKey|rightSoftKey|home|back|send|end|key0|key1|key2|key3|key4|key5|key6|key7|key8|key9|star|hash|up|down|left|right|OK|volUp|volDown|camera" },

     { SkType_EventKind, "none|keyChar|keyPress|keyPressUp|mouseDown|mouseDrag|mouseMove|mouseUp|onEnd|onLoad|user" },

     { SkType_EventMode, "deferred|immediate" },

     { SkType_FillType, "winding|evenOdd" },

     { SkType_FilterType, "none|bilinear" },

     { SkType_FontStyle, "normal|bold|italic|boldItalic" },

     { SkType_FromPathMode, "normal|angle|position" },

     { SkType_Join, "miter|round|blunt" },

     { SkType_MaskFilterBlurStyle, "normal|solid|outer|inner" },

     { SkType_PathDirection, "cw|ccw" },

     { SkType_Style, "fill|stroke|strokeAndFill" },

     { SkType_TextBoxAlign, "start|center|end" },

     { SkType_TextBoxMode, "oneLine|lineBreak" },

     { SkType_TileMode, "clamp|repeat|mirror" },

     { SkType_Xfermode, "clear|src|dst|srcOver|dstOver|srcIn|dstIn|srcOut|dstOut|"

         "srcATop|dstATop|xor|darken|lighten" },

 };

 static int gEnumMapCount = SK_ARRAY_COUNT(gEnumMaps);

 SkAnimatorScript::SkAnimatorScript(SkAnimateMaker& maker, SkDisplayable* working, SkDisplayTypes type)

     : SkScriptEngine(SkScriptEngine::ToOpType(type)), fMaker(maker), fParent(NULL), fWorking(working)

 {

     memberCallBack(EvalMember, (void*) this);

     memberFunctionCallBack(EvalMemberFunction, (void*) this);

     boxCallBack(Box, (void*) this);

     unboxCallBack(Unbox, (void*) &maker);

     propertyCallBack(EvalID, (void*) this); // must be first (entries are prepended, will be last), since it never fails

     propertyCallBack(Infinity, (void*) this);

     propertyCallBack(NaN, (void*) this);

     functionCallBack(Eval, (void*) this);

     functionCallBack(IsFinite, (void*) this);

     functionCallBack(IsNaN, (void*) this);

     if (type == SkType_ARGB) {

         functionCallBack(EvalRGB, (void*) this);

         propertyCallBack(EvalNamedColor, (void*) &maker.fIDs);

     }

     if (SkDisplayType::IsEnum(&maker, type)) {

         // !!! for SpiderMonkey, iterate through the enum values, and map them to globals

         const SkDisplayEnumMap& map = GetEnumValues(type);

         propertyCallBack(EvalEnum, (void*) map.fValues);

     }

     for (SkExtras** extraPtr = maker.fExtras.begin(); extraPtr < maker.fExtras.end(); extraPtr++) {

         SkExtras* extra = *extraPtr;

         if (extra->fExtraCallBack)

             propertyCallBack(extra->fExtraCallBack, extra->fExtraStorage);

     }

 }

 SkAnimatorScript::~SkAnimatorScript() {

     for (SkDisplayable** dispPtr = fTrackDisplayable.begin(); dispPtr < fTrackDisplayable.end(); dispPtr++)

         delete *dispPtr;

 }

 bool SkAnimatorScript::evaluate(const char* original, SkScriptValue* result, SkDisplayTypes type) {

         const char* script = original;

         bool success = evaluateScript(&script, result);

         if (success == false || result->fType != type) {

             fMaker.setScriptError(*this);

             return false;

         }

         return true;

 }

 bool SkAnimatorScript::Box(void* user, SkScriptValue* scriptValue) {

     SkAnimatorScript* engine = (SkAnimatorScript*) user;

     SkDisplayTypes type = scriptValue->fType;

     SkDisplayable* displayable;

     switch (type) {

         case SkType_Array: {

             SkDisplayArray* boxedValue = new SkDisplayArray(*scriptValue->fOperand.fArray);

             displayable = boxedValue;

             } break;

         case SkType_Boolean: {

             SkDisplayBoolean* boxedValue = new SkDisplayBoolean;

             displayable = boxedValue;

             boxedValue->value = !! scriptValue->fOperand.fS32;

             } break;

         case SkType_Int: {

             SkDisplayInt* boxedValue = new SkDisplayInt;

             displayable = boxedValue;

             boxedValue->value = scriptValue->fOperand.fS32;

             } break;

         case SkType_Float: {

             SkDisplayFloat* boxedValue = new SkDisplayFloat;

             displayable = boxedValue;

             boxedValue->value = scriptValue->fOperand.fScalar;

             } break;

         case SkType_String: {

             SkDisplayString* boxedValue = new SkDisplayString(*scriptValue->fOperand.fString);

             displayable = boxedValue;

             } break;

         case SkType_Displayable:

             scriptValue->fOperand.fObject = scriptValue->fOperand.fDisplayable;

             scriptValue->fType = SkType_Displayable;

             return true;

         default:

             SkASSERT(0);

             return false;

     }

     engine->track(displayable);

     scriptValue->fOperand.fObject = displayable;

     scriptValue->fType = SkType_Displayable;

     return true;

 }

 bool SkAnimatorScript::Eval(const char* function, size_t len, SkTDArray<SkScriptValue>& params,

         void* eng, SkScriptValue* value) {

     if (SK_LITERAL_STR_EQUAL("eval", function, len) == false)

         return false;

     if (params.count() != 1)

         return false;

     SkAnimatorScript* host = (SkAnimatorScript*) eng;

     SkAnimatorScript engine(host->fMaker, host->fWorking, SkScriptEngine::ToDisplayType(host->fReturnType));

     SkScriptValue* scriptValue = params.begin();

     bool success = true;

     if (scriptValue->fType == SkType_String) {

         const char* script = scriptValue->fOperand.fString->c_str();

         success = engine.evaluateScript(&script, value);

     } else

         *value = *scriptValue;

     return success;

 }

 bool SkAnimatorScript::EvalEnum(const char* token, size_t len, void* callBack, SkScriptValue* value) {

     const char* tokens = (const char*) callBack;

     value->fType = SkType_Int;

     if (MapEnums(tokens, token, len, (int*)&value->fOperand.fS32))

         return true;

     return false;

 }

 bool SkAnimatorScript::EvalID(const char* token, size_t len, void* user, SkScriptValue* value) {

     SkAnimatorScript* engine = (SkAnimatorScript*) user;

     SkTDict<SkDisplayable*>* ids = &engine->fMaker.fIDs;

     SkDisplayable* displayable;

     bool success = ids->find(token, len, &displayable);

     if (success == false) {

         displayable = engine->fWorking;

         if (SK_LITERAL_STR_EQUAL("parent", token, len)) {

             SkDisplayable* parent = displayable->getParent();

             if (parent == NULL)

                 parent = engine->fParent;

             if (parent) {

                 value->fOperand.fDisplayable = parent;

                 value->fType = SkType_Displayable;

                 return true;

             }

         }

         if (displayable && EvalMember(token, len, displayable, engine, value))

             return true;

         value->fOperand.fString = NULL;

         value->fType = SkType_String;

     } else {

         SkDisplayable* working = engine->fWorking;

         value->fOperand.fDisplayable = displayable;

         value->fType = SkType_Displayable;

         if (displayable->canContainDependents() && working && working->isAnimate()) {

             SkAnimateBase* animator = (SkAnimateBase*) working;

             if (animator->isDynamic()) {

                 SkDisplayDepend* depend = (SkDisplayDepend* ) displayable;

                 depend->addDependent(working);

             }

         }

     }

     return true;

 }

 bool SkAnimatorScript::EvalNamedColor(const char* token, size_t len, void* callback, SkScriptValue* value) {

         value->fType = SkType_Int;

     if (SkParse::FindNamedColor(token, len, (SkColor*) &value->fOperand.fS32) != NULL)

         return true;

     return false;

 }

 bool SkAnimatorScript::EvalRGB(const char* function, size_t len, SkTDArray<SkScriptValue>& params,

         void* eng, SkScriptValue* value) {

     if (SK_LITERAL_STR_EQUAL("rgb", function, len) == false)

         return false;

     if (params.count() != 3)

         return false;

     SkScriptEngine* engine = (SkScriptEngine*) eng;

     unsigned result = 0xFF000000;

     int shift = 16;

     for (SkScriptValue* valuePtr = params.begin(); valuePtr < params.end(); valuePtr++) {

         engine->convertTo(SkType_Int, valuePtr);

         result |= SkClampMax(valuePtr->fOperand.fS32, 255) << shift;

         shift -= 8;

     }

     value->fOperand.fS32 = result;

     value->fType = SkType_Int;

     return true;

 }

 bool SkAnimatorScript::EvalMemberCommon(SkScriptEngine* engine, const SkMemberInfo* info,

         SkDisplayable* displayable, SkScriptValue* value) {

     SkDisplayTypes original;

     SkDisplayTypes type = original = (SkDisplayTypes) info->getType();

     if (info->fType == SkType_Array)

         type = SkType_Array;

     switch (type) {

         case SkType_ARGB:

             type = SkType_Int;

         case SkType_Boolean:

         case SkType_Int:

         case SkType_MSec:

         case SkType_Float:

             SkASSERT(info->getCount() == 1);

             if (info->fType != SkType_MemberProperty && info->fType != SkType_MemberFunction)

                 value->fOperand.fS32 = *(int32_t*) info->memberData(displayable);   // OK for SkScalar too

             if (type == SkType_MSec) {

                 value->fOperand.fScalar = SkScalarDiv((SkScalar) value->fOperand.fS32, 1000); // dividing two ints is the same as dividing two scalars

                 type = SkType_Float;

             }

             break;

         case SkType_String: {

             SkString* displayableString;

             if (info->fType != SkType_MemberProperty && info->fType != SkType_MemberFunction) {

                 info->getString(displayable, &displayableString);

                 value->fOperand.fString = new SkString(*displayableString);

             }

             } break;

         case SkType_Array: {

             SkASSERT(info->fType != SkType_MemberProperty); // !!! incomplete

             SkTDOperandArray* displayableArray = (SkTDOperandArray*) info->memberData(displayable);

             if (displayable->getType() == SkType_Array) {

                 SkDisplayArray* typedArray = (SkDisplayArray*) displayable;

                 original = typedArray->values.getType();

             }

             SkASSERT(original != SkType_Unknown);

             SkTypedArray* array = value->fOperand.fArray = new SkTypedArray(original);

             engine->track(array);

             int count = displayableArray->count();

             if (count > 0) {

                 array->setCount(count);

                 memcpy(array->begin(), displayableArray->begin(), count * sizeof(SkOperand));

             }

             } break;

         default:

             SkASSERT(0); // unimplemented

     }

     value->fType = type;

     return true;

 }

 bool SkAnimatorScript::EvalMember(const char* member, size_t len, void* object, void* eng,

         SkScriptValue* value) {

     SkScriptEngine* engine = (SkScriptEngine*) eng;

     SkDisplayable* displayable = (SkDisplayable*) object;

     SkString name(member, len);

     SkDisplayable* named = displayable->contains(name);

     if (named) {

         value->fOperand.fDisplayable = named;

         value->fType = SkType_Displayable;

         return true;

     }

     const SkMemberInfo* info = displayable->getMember(name.c_str());

     if (info == NULL)

         return false;

     if (info->fType == SkType_MemberProperty) {

         if (displayable->getProperty(info->propertyIndex(), value) == false) {

             SkASSERT(0);

             return false;

         }

     }

     return EvalMemberCommon(engine, info, displayable, value);

 }

 bool SkAnimatorScript::EvalMemberFunction(const char* member, size_t len, void* object,

         SkTDArray<SkScriptValue>& params, void* eng, SkScriptValue* value) {

     SkScriptEngine* engine = (SkScriptEngine*) eng;

     SkDisplayable* displayable = (SkDisplayable*) object;

     SkString name(member, len);

     const SkMemberInfo* info = displayable->getMember(name.c_str());

     SkASSERT(info != NULL); /* !!! error handling unimplemented */

     if (info->fType != SkType_MemberFunction) {

         SkASSERT(0);

         return false;

     }

     displayable->executeFunction(displayable, info->functionIndex(), params, info->getType(),

         value);

     return EvalMemberCommon(engine, info, displayable, value);

 }

 bool SkAnimatorScript::EvaluateDisplayable(SkAnimateMaker& maker, SkDisplayable* displayable, const char* script, SkDisplayable** result) {

     SkAnimatorScript engine(maker, displayable, SkType_Displayable);

     SkScriptValue value;

     bool success = engine.evaluate(script, &value, SkType_Displayable);

     if (success)

         *result = value.fOperand.fDisplayable;

     return success;

 }

 bool SkAnimatorScript::EvaluateInt(SkAnimateMaker& maker, SkDisplayable* displayable, const char* script, int32_t* result) {

     SkAnimatorScript engine(maker, displayable, SkType_Int);

     SkScriptValue value;

     bool success = engine.evaluate(script, &value, SkType_Int);

     if (success)

         *result = value.fOperand.fS32;

     return success;

 }

 bool SkAnimatorScript::EvaluateFloat(SkAnimateMaker& maker, SkDisplayable* displayable, const char* script, SkScalar* result) {

     SkAnimatorScript engine(maker, displayable, SkType_Float);

     SkScriptValue value;

     bool success = engine.evaluate(script, &value, SkType_Float);

     if (success)

         *result = value.fOperand.fScalar;

     return success;

 }

 bool SkAnimatorScript::EvaluateString(SkAnimateMaker& maker, SkDisplayable* displayable, const char* script, SkString* result) {

     SkAnimatorScript engine(maker, displayable, SkType_String);

     SkScriptValue value;

     bool success = engine.evaluate(script, &value, SkType_String);

     if (success)

         result->set(*(value.fOperand.fString));

   return success;

 }

 bool SkAnimatorScript::EvaluateString(SkAnimateMaker& maker, SkDisplayable* displayable, SkDisplayable* parent, const char* script, SkString* result) {

     SkAnimatorScript engine(maker, displayable, SkType_String);

     engine.fParent = parent;

     SkScriptValue value;

     bool success = engine.evaluate(script, &value, SkType_String);

     if (success)

         result->set(*(value.fOperand.fString));

   return success;

 }

 const SkDisplayEnumMap& SkAnimatorScript::GetEnumValues(SkDisplayTypes type) {

     int index = SkTSearch<SkDisplayTypes>(&gEnumMaps[0].fType, gEnumMapCount, type,

         sizeof(SkDisplayEnumMap));

     SkASSERT(index >= 0);

     return gEnumMaps[index];

 }

 bool SkAnimatorScript::Infinity(const char* token, size_t len, void* user, SkScriptValue* value) {

     if (SK_LITERAL_STR_EQUAL("Infinity", token, len) == false)

         return false;

     value->fType = SkType_Float;

     value->fOperand.fScalar = SK_ScalarInfinity;

     return true;

 }

 bool SkAnimatorScript::IsFinite(const char* function, size_t len, SkTDArray<SkScriptValue>& params,

         void* eng, SkScriptValue* value) {

     if (SK_LITERAL_STR_EQUAL(function, "isFinite", len) == false)

         return false;

     if (params.count() != 1)

         return false;

     SkScriptValue* scriptValue = params.begin();

     SkDisplayTypes type = scriptValue->fType;

     SkScalar scalar = scriptValue->fOperand.fScalar;

     value->fType = SkType_Int;

     value->fOperand.fS32 = type == SkType_Float ? SkScalarIsNaN(scalar) == false &&

         SkScalarAbs(scalar) != SK_ScalarInfinity    : type == SkType_Int;

     return true;

 }

 bool SkAnimatorScript::IsNaN(const char* function, size_t len, SkTDArray<SkScriptValue>& params,

         void* eng, SkScriptValue* value) {

     if (SK_LITERAL_STR_EQUAL("isNaN", function, len) == false)

         return false;

     if (params.count() != 1)

         return false;

     SkScriptValue* scriptValue = params.begin();

     value->fType = SkType_Int;

     value->fOperand.fS32 = scriptValue->fType == SkType_Float ? SkScalarIsNaN(scriptValue->fOperand.fScalar) : 0;

     return true;

 }

 bool SkAnimatorScript::MapEnums(const char* ptr, const char* match, size_t len, int* value) {

     int index = 0;

     bool more = true;

     do {

         const char* last = strchr(ptr, '|');

         if (last == NULL) {

             last = &ptr[strlen(ptr)];

             more = false;

         }

         size_t length = last - ptr;

         if (len == length && strncmp(ptr, match, length) == 0) {

             *value = index;

             return true;

         }

         index++;

         ptr = last + 1;

     } while (more);

     return false;

 }

 bool SkAnimatorScript::NaN(const char* token, size_t len, void* user, SkScriptValue* value) {

     if (SK_LITERAL_STR_EQUAL("NaN", token, len) == false)

         return false;

     value->fType = SkType_Float;

     value->fOperand.fScalar = SK_ScalarNaN;

     return true;

 }

 #if 0

 bool SkAnimatorScript::ObjectToString(void* object, void* user, SkScriptValue* value) {

     SkTDict<SkDisplayable*>* ids = (SkTDict<SkDisplayable*>*) user;

     SkDisplayable* displayable = (SkDisplayable*) object;

     const char* key;

     bool success = ids->findKey(displayable, &key);

     if (success == false)

         return false;

     value->fOperand.fString =   new SkString(key);

     value->fType = SkType_String;

     return true;

 }

 #endif

 bool SkAnimatorScript::Unbox(void* m, SkScriptValue* scriptValue) {

     SkAnimateMaker* maker = (SkAnimateMaker*) m;

     SkASSERT((unsigned) scriptValue->fType == (unsigned) SkType_Displayable);

     SkDisplayable* displayable = (SkDisplayable*) scriptValue->fOperand.fObject;

     SkDisplayTypes type = displayable->getType();

     switch (displayable->getType()) {

         case SkType_Array: {

             SkDisplayArray* boxedValue = (SkDisplayArray*) displayable;

             scriptValue->fOperand.fArray = &boxedValue->values;

             } break;

         case SkType_Boolean: {

             SkDisplayBoolean* boxedValue = (SkDisplayBoolean*) displayable;

             scriptValue->fOperand.fS32 = boxedValue->value;

             } break;

         case SkType_Int: {

             SkDisplayInt* boxedValue = (SkDisplayInt*) displayable;

             scriptValue->fOperand.fS32 = boxedValue->value;

             } break;

         case SkType_Float: {

             SkDisplayFloat* boxedValue = (SkDisplayFloat*) displayable;

             scriptValue->fOperand.fScalar = boxedValue->value;

             } break;

         case SkType_String: {

             SkDisplayString* boxedValue = (SkDisplayString*) displayable;

             scriptValue->fOperand.fString = SkNEW_ARGS(SkString, (boxedValue->value));

             } break;

         default: {

             const char* id = NULL;

             SkDEBUGCODE(bool success = ) maker->findKey(displayable, &id);

             SkASSERT(success);

             scriptValue->fOperand.fString = SkNEW_ARGS(SkString, (id));

             type = SkType_String;

         }

     }

     scriptValue->fType = type;

     return true;

 }

 #if defined SK_SUPPORT_UNITTEST

 #include "SkAnimator.h"

 static const char scriptTestSetup[]  =

 "<screenplay>\n"

     "<text id='label' text='defg'/>\n"

     "<add id='addLabel' use='label'/>\n"

     "<text id='text1' text='test'/>\n"

     "<apply scope='addLabel'>\n"

         "<set target='label' field='text' to='#script:text1.text'/>\n"

     "</apply>\n"

     "<apply>\n"

         "<paint id='labelPaint'>\n"

             "<emboss id='emboss' direction='[1,1,1]'  />\n"

         "</paint>\n"

         "<animate id='animation' field='direction' target='emboss' from='[1,1,1]' to='[-1,1,1]' dur='1'/>\n"

         "<set lval='direction[0]' target='emboss' to='-1' />\n"

     "</apply>\n"

     "<color id='testColor' color='0 ? rgb(0,0,0) : rgb(255,255,255)' />\n"

     "<color id='xColor' color='rgb(12,34,56)' />\n"

     "<array id='emptyArray' />\n"

     "<array id='intArray' values='[1, 4, 6]' />\n"

     "<int id='idx' value='2' />\n"

     "<int id='idy' value='2' />\n"

     "<string id='alpha' value='abc' />\n"

     "<rect id='testRect' left='Math.cos(0)' top='2' right='12' bottom='5' />\n"

     "<event id='evt'>\n"

         "<input name='x' />\n"

         "<apply scope='idy'>\n"

             "<set field='value' to='evt.x.int' />\n"

         "</apply>\n"

     "</event>\n"

 "</screenplay>";

 #define DEFAULT_ANSWER   , 0

 static const SkScriptNAnswer scriptTests[]  = {

     { "label.text.length == 4", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER },

 //  { "labelPaint.measureText(label.text) > 0 ? labelPaint.measureText(label.text)+10 : 40", SkType_Float, 0, SkIntToScalar(0x23)  },

     {   "Number.POSITIVE_INFINITY >= Number.MAX_VALUE ? 1 : 0", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER },

     {   "Infinity >= Number.MAX_VALUE ? 1 : 0", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER },

     {   "Number.NEGATIVE_INFINITY <= -Number.MAX_VALUE ? 1 : 0", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER },

     {   "Number.MIN_VALUE > 0 ? 1 : 0", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER },

     {   "isNaN(Number.NaN)", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER },

     {   "isNaN(NaN)", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER },

     {   "Math.sin(0)", SkType_Float, 0, SkIntToScalar(0) DEFAULT_ANSWER },

     {   "alpha+alpha", SkType_String, 0, 0, "abcabc" },

     {   "intArray[4]", SkType_Unknown DEFAULT_ANSWER DEFAULT_ANSWER DEFAULT_ANSWER },

     {   "emptyArray[4]", SkType_Unknown DEFAULT_ANSWER DEFAULT_ANSWER DEFAULT_ANSWER },

     {   "idx", SkType_Int, 2 DEFAULT_ANSWER DEFAULT_ANSWER },

     {   "intArray.length", SkType_Int, 3 DEFAULT_ANSWER DEFAULT_ANSWER },

     {   "intArray.values[0]", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER },

     {   "intArray[0]", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER },

     {   "idx.value", SkType_Int, 2 DEFAULT_ANSWER DEFAULT_ANSWER },

     {   "alpha.value", SkType_String, 0, 0, "abc" },

     {   "alpha", SkType_String, 0, 0, "abc" },

     {   "alpha.value+alpha.value", SkType_String, 0, 0, "abcabc" },

     {   "alpha+idx", SkType_String, 0, 0, "abc2" },

     {   "idx+alpha", SkType_String, 0, 0, "2abc" },

     {   "intArray[idx]", SkType_Int, 6 DEFAULT_ANSWER DEFAULT_ANSWER },

     {   "alpha.slice(1,2)", SkType_String, 0, 0, "b" },

     {   "alpha.value.slice(1,2)", SkType_String, 0, 0, "b" },

     {   "testRect.left+2", SkType_Float, 0, SkIntToScalar(3) DEFAULT_ANSWER },

     {   "0 ? Math.sin(0) : 1", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER },

     {   "0 ? intArray[0] : 1", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER },

     {   "0 ? intArray.values[0] : 1", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER },

     {   "0 ? idx : 1", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER },

     {   "0 ? idx.value : 1", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER },

     {   "0 ? alpha.slice(1,2) : 1", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER },

     {   "0 ? alpha.value.slice(1,2) : 1", SkType_Int, 1 DEFAULT_ANSWER DEFAULT_ANSWER },

     { "idy", SkType_Int, 3 DEFAULT_ANSWER DEFAULT_ANSWER }

 };

 #define SkScriptNAnswer_testCount   SK_ARRAY_COUNT(scriptTests)

 void SkAnimatorScript::UnitTest() {

 #if defined(SK_SUPPORT_UNITTEST)

     SkAnimator animator;

     SkASSERT(animator.decodeMemory(scriptTestSetup, sizeof(scriptTestSetup)-1));

     SkEvent evt;

     evt.setString("id", "evt");

     evt.setS32("x", 3);

     animator.doUserEvent(evt);

     // set up animator with memory script above, then run value tests

     for (unsigned index = 0; index < SkScriptNAnswer_testCount; index++) {

         SkAnimatorScript engine(*animator.fMaker, NULL, scriptTests[index].fType);

         SkScriptValue value;

         const char* script = scriptTests[index].fScript;

         bool success = engine.evaluateScript(&script, &value);

         if (success == false) {

             SkDebugf("script failed: %s\n", scriptTests[index].fScript);

             SkASSERT(scriptTests[index].fType == SkType_Unknown);

             continue;

         }

         SkASSERT(value.fType == scriptTests[index].fType);

         SkScalar error;

         switch (value.fType) {

             case SkType_Int:

                 SkASSERT(value.fOperand.fS32 == scriptTests[index].fIntAnswer);

                 break;

             case SkType_Float:

                 error = SkScalarAbs(value.fOperand.fScalar - scriptTests[index].fScalarAnswer);

                 SkASSERT(error < SK_Scalar1 / 10000);

                 break;

             case SkType_String:

                 SkASSERT(strcmp(value.fOperand.fString->c_str(), scriptTests[index].fStringAnswer) == 0);

                 break;

             default:

                 SkASSERT(0);

         }

     }

 #endif

 }

 #endif