sdk3
/
livecodingspace-app


			
							12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274
							<!DOCTYPE html>

<html>

  <head>

    <title>Virtual World Framework</title>

    <script type="text/javascript" src="qunit.js"></script>

    <script type="text/javascript" src="../lib/async.js"></script>

    <script type="text/javascript" src="../lib/crypto.js"></script>
    <script type="text/javascript" src="../lib/md5.js"></script>

    <script type="text/javascript" src="../lib/alea.js"></script>
    <script type="text/javascript" src="../lib/mash.js"></script>

    <script type="text/javascript" src="../lib/vwf.js"></script>

    <script type="text/javascript" src="../lib/require.js"></script>

    <script type="text/javascript">


      require( {


        baseUrl: "../lib",

        paths: {

          jquery: "jquery-1.10.2.min",

        },


      }, [


        "domReady",

        "utility.js",

        "vwf/configuration",


        "jquery",

        "vwf/kernel/model",

        "vwf/model/javascript",

        "vwf/model/object",

        "vwf/model/stage/log",

        "vwf/kernel/view",

        "vwf/view/document",

        "vwf/kernel/utility",

        "vwf/utility",

        "logger",


      ], function( ready, testUtility, configuration ) {


        // Test node replication.


        ready( function() {


          vwf.initialize(


            // Models


            [

              "vwf/model/javascript", 

              /* scriptModel */         // scriptModel will go here

              /* sceneModel */          // sceneModel will go here

              "vwf/model/object",

            ],


            // Views


            [

              "vwf/view/document"

            ]


          );


          // Insert the test-specific `scriptModel` and `sceneModel` drivers.

          // 

          // These drivers implement a specific set of properties for testing propagation and change

          // flags for properties delegated to other properties and properties handled by drivers

          // above the default model/object property store.

          // 

          //   - ps is a value property handled by model/test/scene

          //   - po is a value property handled by model/object

          //   - qs delegates as a string value to qs handled by model/test/scene

          //   - qo delegates as a string value to qo handled by model/object

          //   - rs/ro delegate to ss/so which delegate to ts/to in model/test/script

          //   - us/uo delegate to vs/vo which delegate back to us/uo in model/test/script

          // 

          //         ▾    ▾    ▾    ▾    ▾    ▾    ▾    ▾    ▾    ▾    ▾    ▾    ▾    ▾    

          // script: ▾    qs   rs ▸ ss ▸ ▾    us ▸ vs   ▾    qo   ro ▸ so ▸ ▾    uo ▸ vo   

          //         ▾    ▾    ◦    ◦    ▾    ◦  ◺ ◦    ▾    ▾    ◦    ◦    ▾    ◦  ◺ ◦    

          //  scene: ps   qs   ◦    ◦    ts   us   ◦    ▾    ▾    ◦    ◦    ▾    ▾    ◦    

          //         ◦    ◦    ◦    ◦    ◦    ◦    ◦    ▾    ▾    ◦    ◦    ▾    ▾    ◦    

          // object: ◦    ◦    ◦    ◦    ◦    ◦    ◦    po   qo   ◦    ◦    to   uo   ◦    

          // 

          // Key: ▾ ▸ : propagation path; ◦ : should not reach


          vwf.models.splice( 1, 0,

            scriptModel().create( vwf.models.kernel, [], {}, [] ),

            sceneModel().create( vwf.models.kernel, [], {}, [] )

          );


          // Patch the model and view drivers to log property-related calls.


          vwf.models.forEach( function( model ) {

            patchHandlers( model, "model", [ "creatingProperty", "initializingProperty", "settingProperty", "gettingProperty" ] );

          } );


          vwf.views.forEach( function( view ) {

            patchHandlers( view, "view", [ "createdProperty", "initializedProperty", "satProperty", "gotProperty" ] );

          } );


          // URI component to be used as a prototype. The state of a URI component can be expressed

          // as a patch to the URI's descriptor.


          var prototype = {


            // The descriptor, and a data URI referencing it.


            uri: testUtility.dataURIFromDescriptor( {

              properties: {

                p: { // numbers externally, strings internally

                  set: "this.p = value.toString()", // number to string

                  get: "return parseInt( this.p )", // string to number

                },

              }

            } ),


            // ID of the constructed component.


            id: undefined, // fill in once created


            // Function to apply a change.


            change: function( state ) {

              vwf.execute( this.id, "this.p = " + state );

            },


            // Function to calculate the expected getNode() state after a given change.


            state: function( state ) {

              if ( state ) { // modified state

                return {

                  patches: this.uri, // patches the component

                  properties: {

                    p: state.toString(), // property "p" changed

                  },

                };

              } else { // default state

                return this.uri; // component (no changes)

              }

            },


          };


          asyncTest( "URI component", function() {


            vwf.createNode( prototype.uri, function( id ) {

              prototype.id = id;


              deepEqual( vwf.getNode( id ), prototype.state(), "unmodified prototype is prototype URI" );


              prototype.change( 1 );

              deepEqual( vwf.getNode( id ), prototype.state( 1 ), "modified prototype is patched with changes" );


              prototype.change( 2 );

              deepEqual( vwf.getNode( id ), prototype.state( 2 ), "prototype modified again" );


              vwf.setNode( id, prototype.state( 1 ), function( id ) {


                deepEqual( vwf.getNode( id ), prototype.state( 1 ), "modified prototype restored" );


                // vwf.setNode( id, prototype.state() );  TODO: support property deletes

                // deepEqual( vwf.getNode( id ), prototype.state(), "unmodified prototype restored" );


                var state1 = prototype.state( 1 );


                vwf.deleteNode( id );


                vwf.createNode( state1, function( id ) {

                  prototype.id = id;


                  deepEqual( vwf.getNode( id ), state1, "modified prototype regenerated" );


                  vwf.deleteNode( id );


                  start();


                } );


              } );


            } );


          } );


          // Descriptor component deriving from the prototype. The state of a descriptor component

          // must be fully specified since there is no underlying URI to patch.


          var node = {


            // The descriptor.


            descriptor: {

              extends: prototype.uri,

            },


            // ID of the constructed component.


            id: undefined, // fill in once created


            // Function to apply a change.


            change: function( state ) {

              vwf.execute( this.id, "this.p = " + state );

            },


            // Function to calculate the expected getNode() state after a given change.


            state: function( state ) {

              if ( state ) { // modified state

                return {

                  id: this.id,

                  extends: prototype.uri,

                  sequence: 0,

                  random: randomState( undefined, this.id ),

                  properties: {

                    p: state.toString(), // property "p" from prototype set in node

                  },

                };

              } else { // default state

                return {

                  id: this.id,

                  extends: prototype.uri,

                  sequence: 0,

                  random: randomState( undefined, this.id ),

                };

              }

            },


          };


          asyncTest( "Descriptor component deriving from URI component", function() {


            vwf.createNode( node.descriptor, function( id ) {

              node.id = id;


              deepEqual( vwf.getNode( id ), node.state(), "unmodified node" );


              node.change( 1 );

              deepEqual( vwf.getNode( id ), node.state( 1 ), "modified node shows changes" );


              node.change( 2 );

              deepEqual( vwf.getNode( id ), node.state( 2 ), "node modified again" );


              vwf.setNode( id, node.state( 1 ), function( id ) {


                deepEqual( vwf.getNode( id ), node.state( 1 ), "modified node restored" );


                // vwf.setNode( id, node.state() );  TODO: support property deletes

                // deepEqual( vwf.getNode( id ), node.state(), "unmodified node restored" );


                var state1 = node.state( 1 );


                vwf.deleteNode( vwf.prototype( id ) );

                vwf.deleteNode( id );


                vwf.createNode( state1, function( id ) {

                  node.id = id;


                  deepEqual( vwf.getNode( id ), state1, "modified node regenerated" );


                  vwf.deleteNode( vwf.prototype( id ) );

                  vwf.deleteNode( id );


                  start();


                } );


              } );


            } );


          } );


          // URI component with a child.


          var prototypeWithChild = {


            // The descriptor, and a data URI referencing it.


            uri: testUtility.dataURIFromDescriptor( {

              properties: {

                p: {

                  set: "this.p = value.toString()",

                  get: "return parseInt( this.p )",

                },

              },

              children: {

                c: {

                  properties: {

                    p: null,

                  },

                },

              },

            } ),


            // ID of the constructed component.


            id: undefined, // fill in once created


            // Function to apply a change.


            change: function( state ) {

              vwf.execute( this.id, "this.c.p = " + state );

            },


            // Function to calculate the expected getNode() state after a given change.


            state: function( state ) {

              if ( state ) {

                return { // modified state

                  patches: this.uri,

                  children: {

                    c: {

                      patches: vwf.execute( this.id, "this.c.id" ),

                      properties: {

                        p: state,

                      },

                    },

                  },

                };

              } else { // default state

                return this.uri;

              }

            },


          };


          asyncTest( "URI component with child", function() {


            vwf.createNode( prototypeWithChild.uri, function( id ) {

              prototypeWithChild.id = id;


              deepEqual( vwf.getNode( id ), prototypeWithChild.state(), "unmodified prototype is prototype URI" );


              prototypeWithChild.change( 1 );

              deepEqual( vwf.getNode( id ), prototypeWithChild.state( 1 ), "modified prototype is patched with changes" );


              prototypeWithChild.change( 2 );

              deepEqual( vwf.getNode( id ), prototypeWithChild.state( 2 ), "prototype modified again" );


              vwf.setNode( id, prototypeWithChild.state( 1 ), function( id ) {


                deepEqual( vwf.getNode( id ), prototypeWithChild.state( 1 ), "modified prototype restored" );


                // vwf.setNode( id, prototypeWithChild.state() );  TODO: support property deletes

                // deepEqual( vwf.getNode( id ), prototypeWithChild.state(), "unmodified prototype restored" );


                var state1 = prototypeWithChild.state( 1 );


                vwf.deleteNode( vwf.execute( id, "this.c.id" ) );

                vwf.deleteNode( id );


                vwf.createNode( state1, function( id ) {

                  prototypeWithChild.id = id;


                  deepEqual( vwf.getNode( id ), state1, "modified prototype regenerated" );


                  vwf.deleteNode( vwf.execute( id, "this.c.id" ) );

                  vwf.deleteNode( id );


                  start();


                } );


              } );


            } );


          } );


          // URI component that creates a child in its initializer.


          var prototypeWithInitializerChild = {


            // The descriptor, and a data URI referencing it.


            uri: testUtility.dataURIFromDescriptor( {

              scripts: [

                "this.initialize = function() { " +

                  "this.children.create( 'c', { " +

                    "properties: { " +

                      "p: null, " +

                    "}, " +

                  "} ); " +

                "}"

              ]

            } ),


            // ID of the constructed component.


            id: undefined, // fill in once created


            // Function to apply a change.


            change: function( state ) {

              vwf.execute( this.id, "this.c.p = " + state );

            },


            // Function to calculate the expected getNode() state after a given change.


            state: function( state ) {

              if ( state ) {

                return { // modified state

                  patches: this.uri,

                  children: {

                    c: {

                      patches: vwf.execute( this.id, "this.c.id" ),

                      properties: {

                        p: state,

                      },

                    },

                  },

                };

              } else { // default state

                return this.uri;

              }


            },


          };


          asyncTest( "URI component with initializer child", function() {


            vwf.createNode( prototypeWithInitializerChild.uri, function( id ) {

              prototypeWithInitializerChild.id = id;


              deepEqual( vwf.getNode( id ), prototypeWithInitializerChild.state(), "unmodified prototype is prototype URI" );


              prototypeWithInitializerChild.change( 1 );

              deepEqual( vwf.getNode( id ), prototypeWithInitializerChild.state( 1 ), "modified prototype is patched with changes" );


              prototypeWithInitializerChild.change( 2 );

              deepEqual( vwf.getNode( id ), prototypeWithInitializerChild.state( 2 ), "prototype modified again" );


              vwf.setNode( id, prototypeWithInitializerChild.state( 1 ), function( id ) {


                deepEqual( vwf.getNode( id ), prototypeWithInitializerChild.state( 1 ), "modified prototype restored" );


                // vwf.setNode( id, prototypeWithInitializerChild.state() );  TODO: support property deletes

                // deepEqual( vwf.getNode( id ), prototypeWithInitializerChild.state(), "unmodified prototype restored" );


                var state1 = prototypeWithInitializerChild.state( 1 );


                vwf.deleteNode( vwf.execute( id, "this.c.id" ) );

                vwf.deleteNode( id );


                vwf.createNode( state1, function( id ) {

                  prototypeWithInitializerChild.id = id;


                  deepEqual( vwf.getNode( id ), state1, "modified prototype regenerated" );


                  vwf.deleteNode( vwf.execute( id, "this.c.id" ) );

                  vwf.deleteNode( id );


                  start();


                } );


              } );


            } );


          } );


          // Descriptor component deriving from a URI component that creates a child in its

          // initializer.


          var nodeWithPrototypeInitializerChild = {


            // The descriptor, and a data URI referencing it.


            descriptor: {

              extends: prototypeWithInitializerChild.uri,

            },


            // ID of the constructed component.


            id: undefined, // fill in once created


            // Function to apply a change.


            change: function( state ) {

              vwf.execute( this.id, "this.c.p = " + state );

            },


            // Function to calculate the expected getNode() state after a given change.


            state: function( state ) {


              var childID = vwf.execute( this.id, "this.c.id" );


              var nodeRandomState = randomState( undefined, this.id );

              var childRandomState = randomState( nodeRandomState, childID );


              return {

                id: this.id,

                extends: prototypeWithInitializerChild.uri,

                sequence: 1, // one child

                random: nodeRandomState,

                children: {

                  c: { // child always fully specified since createNode() outside of initialize()

                    id: childID,

                    sequence: 0,

                    random: childRandomState,

                    properties: {

                      p: state ? state : null,

                    },

                  },

                },

              };


            },


          };


          asyncTest( "Descriptor component deriving from URI component with initializer child", function() {


            vwf.createNode( nodeWithPrototypeInitializerChild.descriptor, function( id ) {

              nodeWithPrototypeInitializerChild.id = id;


              deepEqual( vwf.getNode( id ), nodeWithPrototypeInitializerChild.state(), "unmodified node" );


              nodeWithPrototypeInitializerChild.change( 1 );

              deepEqual( vwf.getNode( id ), nodeWithPrototypeInitializerChild.state( 1 ), "modified node" );


              nodeWithPrototypeInitializerChild.change( 2 );

              deepEqual( vwf.getNode( id ), nodeWithPrototypeInitializerChild.state( 2 ), "node modified again" );


              vwf.setNode( id, nodeWithPrototypeInitializerChild.state( 1 ), function( id ) {


                deepEqual( vwf.getNode( id ), nodeWithPrototypeInitializerChild.state( 1 ), "modified node restored" );


                vwf.setNode( id, nodeWithPrototypeInitializerChild.state(), function( id ) {


                  deepEqual( vwf.getNode( id ), nodeWithPrototypeInitializerChild.state(), "unmodified node restored" );


                  var state1 = nodeWithPrototypeInitializerChild.state( 1 );


                  vwf.deleteNode( vwf.execute( vwf.prototype( id ), "this.c.id" ) );

                  vwf.deleteNode( vwf.prototype( id ) );


                  vwf.deleteNode( vwf.execute( id, "this.c.id" ) );

                  vwf.deleteNode( id );


                  vwf.createNode( state1, function( id ) {

                    nodeWithPrototypeInitializerChild.id = id;


                    deepEqual( vwf.getNode( id ), state1, "modified node regenerated" );


                    vwf.deleteNode( vwf.execute( vwf.prototype( id ), "this.c.id" ) );

                    vwf.deleteNode( vwf.prototype( id ) );


                    vwf.deleteNode( vwf.execute( id, "this.c.id" ) );

                    vwf.deleteNode( id );


                    start();


                  } );


                } );


              } );


            } );


          } );


          // Change flags for properties handled by model/object and by a driver above model/object.


          asyncTest( "Property changes", function() {


            vwf.createNode( testUtility.dataURIFromDescriptor( {


              children: {


                alpha: {

                  properties: {

                    po: 0,

                    ps: 0,

                  }

                },


                beta: {

                  properties: {

                    po: 0,

                    ps: 0,

                  }

                },


              }


            } ), function( id ) {


              // Change the properties.


              vwf.execute( id, "this.alpha.po = 1" ); // handled by model/object; should mark alpha changed

              vwf.execute( id, "this.beta.ps = 1" );  // handled by model/test/scene; should mark beta changed


              // Verify the children and property changes are present in the replication state.


              deepEqual( vwf.getNode( id ), {

                patches: id,

                children: {

                  alpha: {

                    patches: vwf.execute( id, "this.alpha.id" ),

                    properties: {

                      po: 1,

                    }

                  },

                  beta: {

                    patches: vwf.execute( id, "this.beta.id" ),

                    properties: {

                      ps: 1,

                    }

                  },

              } }, "property changes handled by model/object and by model/test/scene detected" );


              // Clean up and continue.


              vwf.deleteNode( id );


              start();


            } );


          } );


          // Delegated properties and internal state.


          asyncTest( "Delegated properties and internal state", function() {


            vwf.createNode( testUtility.dataURIFromDescriptor( {


              properties: {


                po: { undefined: true }, ps: { undefined: true },

                qo: { undefined: true }, qs: { undefined: true },

                ro: { undefined: true }, rs: { undefined: true },

                so: { undefined: true }, ss: { undefined: true },

                to: { undefined: true }, ts: { undefined: true },

                uo: { undefined: true }, us: { undefined: true },

                vo: { undefined: true }, vs: { undefined: true },


                // Alternate configuration; would like to do this instead of creating as undefined

                // and setting, but `createProperty` needs to upgrade to work with `setProperty`

                // reentry tracking.


                // po: 1, ps: 1,

                // qo: 1, qs: 1,

                // ro: 1, rs: 1,

                // so: { undefined: true }, ss: { undefined: true },

                // to: { undefined: true }, ts: { undefined: true },

                // uo: 1, us: 1,

                // vo: { undefined: true }, vs: { undefined: true },


              }


            } ), function( id ) {


              // Another alternate configuration; would need the same `createProperty` upgrade.


              // [

              //   "vo", "vs",

              //   "uo", "us",

              //   "to", "ts",

              //   "so", "ss",

              //   "ro", "rs",

              //   "qo", "qs",

              //   "po", "ps",

              // ].forEach( function( propertyName ) {

              //   vwf.createProperty( id, propertyName, ( propertyName.match( /^[pqru]/ ) ? 1 : undefined ) );

              // } );


              // Set the initial values.


              vwf.setProperty( id, "po", 1 ); vwf.setProperty( id, "ps", 1 );

              vwf.setProperty( id, "qo", 1 ); vwf.setProperty( id, "qs", 1 );

              vwf.setProperty( id, "ro", 1 ); vwf.setProperty( id, "rs", 1 );

              vwf.setProperty( id, "uo", 1 ); vwf.setProperty( id, "us", 1 );


              // Get individually, using accessors.


              deepEqual( [

                "po", "ps",

                "qo", "qs",

                "ro", "rs",

                "so", "ss",

                "to", "ts",

                "uo", "us",

                "vo", "vs",

              ].reduce( function( properties, propertyName ) {

                properties[propertyName] = vwf.getProperty( id, propertyName );

                return properties;

              }, {} ), {

                po: 1, ps: 1,

                qo: 1, qs: 1,

                ro: 1, rs: 1,

                so: 0, ss: 0,

                to: "0", ts: "0",

                uo: 1, us: 1,

                vo: NaN, vs: NaN, // degenerate, but irrelevant for `v*`

              }, "properties individually, using accessors" );


              // Get in aggregate, using accessors.


              deepEqual( vwf.getProperties( id ), {

                po: 1, ps: 1,

                qo: 1, qs: 1,

                ro: 1, rs: 1,

                so: 0, ss: 0,

                to: "0", ts: "0",

                uo: 1, us: 1,

                vo: NaN, vs: NaN, // degenerate, but irrelevant for `v*`

              }, "properties in aggregrate, using accessors" );


              // Get individually, values only.


              vwf.models.kernel.disable();


              deepEqual( [

                "po", "ps",

                "qo", "qs",

                "ro", "rs",

                "so", "ss",

                "to", "ts",

                "uo", "us",

                "vo", "vs",

              ].reduce( function( properties, propertyName ) {

                properties[propertyName] = vwf.getProperty( id, propertyName );

                return properties;

              }, {} ), {

                po: 1, ps: 1,

                qo: "1", qs: "1",

                ro: undefined, rs: undefined,

                so: undefined, ss: undefined,

                to: "0", ts: "0",

                uo: "0", us: "0",

                vo: undefined, vs: undefined,

              }, "properties individually, values only" );


              vwf.models.kernel.enable();


              // Get in aggregate, values only.


              vwf.models.kernel.disable();


              deepEqual( vwf.getProperties( id ), {

                po: 1, ps: 1,

                qo: "1", qs: "1",

                ro: undefined, rs: undefined,

                so: undefined, ss: undefined,

                to: "0", ts: "0",

                uo: "0", us: "0",

                vo: undefined, vs: undefined,

              }, "properties in aggregrate, values only" );


              vwf.models.kernel.enable();


              // Get state.


              deepEqual( vwf.getNode( id ), { patches: id, properties: {

                po: 1, ps: 1,

                qo: "1", qs: "1",

                // ro, rs: omitted

                // so, ss: omitted

                to: "0", ts: "0",

                uo: "0", us: "0",

                // vo, vs: omitted

              } }, "node state" );


              // Clean up and continue.


              vwf.deleteNode( id );


              start();


            } );


          } );


          // Delegated properties and driver calls.


          asyncTest( "Delegated properties and driver calls", function() {


            vwf.createNode( testUtility.dataURIFromDescriptor( {


              properties: {

                po: { undefined: true }, ps: { undefined: true },

                qo: { undefined: true }, qs: { undefined: true },

                ro: { undefined: true }, rs: { undefined: true },

                so: { undefined: true }, ss: { undefined: true },

                to: { undefined: true }, ts: { undefined: true },

                uo: { undefined: true }, us: { undefined: true },

                vo: { undefined: true }, vs: { undefined: true },

              }


            } ), function( id ) {


              // SETTING


              // Setting a non-delegating property handled by vwf/model/object.


              driverCalls = []; vwf.setProperty( id, "po", 1 );


              deepEqual( driverCalls, [

                { driver: "vwf/model/javascript",  node: id, action: "settingProperty", member: "po", value: 1 }, // pass

                { driver: "vwf/model/test/script", node: id, action: "settingProperty", member: "po", value: 1 }, // pass

                { driver: "vwf/model/test/scene",  node: id, action: "settingProperty", member: "po", value: 1 }, // pass

                { driver: "vwf/model/object",      node: id, action: "settingProperty", member: "po", value: 1 }, // assign

                { driver: "vwf/view/document",     node: id, action: "satProperty",     member: "po", value: 1 }, // result

              ], "setProperty on non-delegating property terminating in vwf/model/object" );


              // Setting a non-delegating property handled before vwf/model/object.


              driverCalls = []; vwf.setProperty( id, "ps", 1 );


              deepEqual( driverCalls, [

                { driver: "vwf/model/javascript",  node: id, action: "settingProperty", member: "ps", value: 1 }, // pass

                { driver: "vwf/model/test/script", node: id, action: "settingProperty", member: "ps", value: 1 }, // pass

                { driver: "vwf/model/test/scene",  node: id, action: "settingProperty", member: "ps", value: 1 }, // assign

                // { driver: "vwf/model/object",   node: id, action: "settingProperty", member: "ps", value: 1 }, // omit

                { driver: "vwf/view/document",     node: id, action: "satProperty",     member: "ps", value: 1 }, // result

              ], "setProperty on non-delegating property terminating before vwf/model/object" );


              // Setting a self-delegating property.


              driverCalls = []; vwf.setProperty( id, "qs", 1 );


              deepEqual( driverCalls, [

                /* outer */  { driver: "vwf/model/javascript",     node: id, action: "settingProperty", member: "qs", value: 1 },   // pass

                /* outer */  { driver: "vwf/model/test/script",    node: id, action: "settingProperty", member: "qs", value: 1 },   // delegate to `qs` as "1"

                /* inner */  // { driver: "vwf/model/javascript",  node: id, action: "settingProperty", member: "qs", value: "1" }, // skip for reentrant call

                /* inner */  // { driver: "vwf/model/test/script", node: id, action: "settingProperty", member: "qs", value: "1" }, // skip for reentrant call

                /* inner */  { driver: "vwf/model/test/scene",     node: id, action: "settingProperty", member: "qs", value: "1" }, // assign

                /* inner */  // { driver: "vwf/model/object",      node: id, action: "settingProperty", member: "qs", value: "1" }, // omit since assigned

                /* inner */  { driver: "vwf/view/document",        node: id, action: "satProperty",     member: "qs", value: "1" }, // result

                /* outer */  // { driver: "vwf/model/test/scene",  node: id, action: "settingProperty", member: "qs", value: 1 },   // omit since delegated

                /* outer */  // { driver: "vwf/model/object",      node: id, action: "settingProperty", member: "qs", value: 1 },   // omit since delegated

                /* outer */  // { driver: "vwf/view/document",     node: id, action: "satProperty",     member: "qs", value: 1 },   // no result from delegated call

              ], "setProperty on property delegating to self" );


              // Setting a property delegating to a property delegating to a non-delegating property.


              driverCalls = []; vwf.setProperty( id, "rs", 1 );


              deepEqual( driverCalls, [

                /* rs */  { driver: "vwf/model/javascript",     node: id, action: "settingProperty", member: "rs", value: 1 },   // pass

                /* rs */  { driver: "vwf/model/test/script",    node: id, action: "settingProperty", member: "rs", value: 1 },   // delegate to `ss` as 0

                /* ss */  { driver: "vwf/model/javascript",     node: id, action: "settingProperty", member: "ss", value: 0 },   // pass

                /* ss */  { driver: "vwf/model/test/script",    node: id, action: "settingProperty", member: "ss", value: 0 },   // delegate to `ts` as "0"

                /* ts */  { driver: "vwf/model/javascript",     node: id, action: "settingProperty", member: "ts", value: "0" }, // pass

                /* ts */  { driver: "vwf/model/test/script",    node: id, action: "settingProperty", member: "ts", value: "0" }, // pass

                /* ts */  { driver: "vwf/model/test/scene",     node: id, action: "settingProperty", member: "ts", value: "0" }, // assign

                /* ts */  // { driver: "vwf/model/object",      node: id, action: "settingProperty", member: "ts", value: "0" }, // omit since `ts` assigned

                /* ts */  { driver: "vwf/view/document",        node: id, action: "satProperty",     member: "ts", value: "0" }, // `ts` result

                /* ss */  // { driver: "vwf/model/test/scene",  node: id, action: "settingProperty", member: "ss", value: 0 },   // omit since `ss` delegated

                /* ss */  // { driver: "vwf/model/object",      node: id, action: "settingProperty", member: "ss", value: 0 },   // omit since `ss` delegated

                /* ss */  // { driver: "vwf/view/document",     node: id, action: "satProperty",     member: "ss", value: 0 },   // no result since `ss` delegated

                /* rs */  // { driver: "vwf/model/test/scene",  node: id, action: "settingProperty", member: "rs", value: 1 },   // omit since `rs` delegated

                /* rs */  // { driver: "vwf/model/object",      node: id, action: "settingProperty", member: "rs", value: 1 },   // omit since `rs` delegated

                /* rs */  //{ driver: "vwf/view/document",      node: id, action: "satProperty",     member: "rs", value: 1 },   // no result since `rs` delegated

              ], "setProperty on property delegating to a property delegating to a non-delegating property" );


              // Setting a property delegating to a property delegating to the initial property.


              driverCalls = []; vwf.setProperty( id, "us", 1 );


              deepEqual( driverCalls, [

                /* us */  { driver: "vwf/model/javascript",     node: id, action: "settingProperty", member: "us", value: 1 },   // pass

                /* us */  { driver: "vwf/model/test/script",    node: id, action: "settingProperty", member: "us", value: 1 },   // delegate to `vs` as 0

                /* vs */  { driver: "vwf/model/javascript",     node: id, action: "settingProperty", member: "vs", value: 0 },   // pass

                /* vs */  { driver: "vwf/model/test/script",    node: id, action: "settingProperty", member: "vs", value: 0 },   // delegate back to `us` as "0"

                /* us */  // { driver: "vwf/model/javascript",  node: id, action: "settingProperty", member: "us", value: "0" }, // skip for reentrant call

                /* us */  // { driver: "vwf/model/test/script", node: id, action: "settingProperty", member: "us", value: "0" }, // skip for reentrant call

                /* us */  { driver: "vwf/model/test/scene",     node: id, action: "settingProperty", member: "us", value: "0" }, // assign

                /* us */  // { driver: "vwf/model/object",      node: id, action: "settingProperty", member: "us", value: "0" }, // omit since `us` assigned

                /* us */  { driver: "vwf/view/document",        node: id, action: "satProperty",     member: "us", value: "0" }, // result

                /* vs */  // { driver: "vwf/model/test/scene",  node: id, action: "settingProperty", member: "vs", value: 0 },   // omit since `vs` delegated

                /* vs */  // { driver: "vwf/model/object",      node: id, action: "settingProperty", member: "vs", value: 0 },   // omit since `vs` delegated

                /* vs */  // { driver: "vwf/view/document",     node: id, action: "satProperty",     member: "vs", value: 0 },   // no result since `vs` delegated 

                /* us */  // { driver: "vwf/model/test/scene",  node: id, action: "settingProperty", member: "us", value: 1 },   // omit since `us` delegated

                /* us */  // { driver: "vwf/model/object",      node: id, action: "settingProperty", member: "us", value: 1 },   // omit since `us` delegated

                /* us */  // { driver: "vwf/view/document",     node: id, action: "satProperty",     member: "us", value: 1 },   // `us` result

              ], "setProperty on property delegating to a property delegating to initial property" );


              driverCalls = undefined;


              // GETTING


              // Getting a non-delegating property handled by vwf/model/object.


              driverCalls = []; vwf.getProperty( id, "po" );


              deepEqual( driverCalls, [

                { driver: "vwf/model/javascript",  node: id, action: "gettingProperty", member: "po", value: undefined }, // pass

                { driver: "vwf/model/test/script", node: id, action: "gettingProperty", member: "po", value: undefined }, // pass

                { driver: "vwf/model/test/scene",  node: id, action: "gettingProperty", member: "po", value: undefined }, // pass

                { driver: "vwf/model/object",      node: id, action: "gettingProperty", member: "po", value: undefined }, // retrieve

                { driver: "vwf/view/document",     node: id, action: "gotProperty",     member: "po", value: 1 }, // result

              ], "getProperty on non-delegating property terminating in vwf/model/object" );


              // Getting a non-delegating property handled before vwf/model/object.


              driverCalls = []; vwf.getProperty( id, "ps" );


              deepEqual( driverCalls, [

                { driver: "vwf/model/javascript",  node: id, action: "gettingProperty", member: "ps", value: undefined }, // pass

                { driver: "vwf/model/test/script", node: id, action: "gettingProperty", member: "ps", value: undefined }, // pass

                { driver: "vwf/model/test/scene",  node: id, action: "gettingProperty", member: "ps", value: undefined }, // retrieve

                // { driver: "vwf/model/object",   node: id, action: "gettingProperty", member: "ps", value: 1 }, // omit

                { driver: "vwf/view/document",     node: id, action: "gotProperty",     member: "ps", value: 1 }, // result

              ], "getProperty on non-delegating property terminating before vwf/model/object" );


              // Getting a self-delegating property.


              driverCalls = []; vwf.getProperty( id, "qs" );


              deepEqual( driverCalls, [

                /* outer */  { driver: "vwf/model/javascript",     node: id, action: "gettingProperty", member: "qs", value: undefined }, // pass

                /* outer */  { driver: "vwf/model/test/script",    node: id, action: "gettingProperty", member: "qs", value: undefined }, // delegate to `qs` as "1"

                /* inner */  // { driver: "vwf/model/javascript",  node: id, action: "gettingProperty", member: "qs", value: undefined }, // skip for reentrant call

                /* inner */  // { driver: "vwf/model/test/script", node: id, action: "gettingProperty", member: "qs", value: undefined }, // skip for reentrant call

                /* inner */  { driver: "vwf/model/test/scene",     node: id, action: "gettingProperty", member: "qs", value: undefined }, // retrieve

                /* inner */  // { driver: "vwf/model/object",      node: id, action: "gettingProperty", member: "qs", value: "1" }, // omit since assigned

                /* inner */  // { driver: "vwf/view/document",     node: id, action: "gotProperty",     member: "qs", value: "1" }, // no result from reentrant call

                /* outer */  // { driver: "vwf/model/test/scene",  node: id, action: "gettingProperty", member: "qs", value: 1 },   // omit since delegated

                /* outer */  // { driver: "vwf/model/object",      node: id, action: "gettingProperty", member: "qs", value: 1 },   // omit since delegated

                /* outer */  { driver: "vwf/view/document",        node: id, action: "gotProperty",     member: "qs", value: 1 },   // result

              ], "getProperty on property delegating to self" );


              // Getting a property delegating to a property delegating to a non-delegating property.


              driverCalls = []; vwf.getProperty( id, "rs" );


              deepEqual( driverCalls, [

                /* rs */  { driver: "vwf/model/javascript",     node: id, action: "gettingProperty", member: "rs", value: undefined }, // pass

                /* rs */  { driver: "vwf/model/test/script",    node: id, action: "gettingProperty", member: "rs", value: undefined }, // delegate to `ss` as 0

                /* ss */  { driver: "vwf/model/javascript",     node: id, action: "gettingProperty", member: "ss", value: undefined }, // pass

                /* ss */  { driver: "vwf/model/test/script",    node: id, action: "gettingProperty", member: "ss", value: undefined }, // delegate to `ts` as "0"

                /* ts */  { driver: "vwf/model/javascript",     node: id, action: "gettingProperty", member: "ts", value: undefined }, // pass

                /* ts */  { driver: "vwf/model/test/script",    node: id, action: "gettingProperty", member: "ts", value: undefined }, // pass

                /* ts */  { driver: "vwf/model/test/scene",     node: id, action: "gettingProperty", member: "ts", value: undefined }, // retrieve

                /* ts */  // { driver: "vwf/model/object",      node: id, action: "gettingProperty", member: "ts", value: "0" }, // omit since `ts` assigned

                /* ts */  { driver: "vwf/view/document",        node: id, action: "gotProperty",     member: "ts", value: "0" }, // `ts` result

                /* ss */  // { driver: "vwf/model/test/scene",  node: id, action: "gettingProperty", member: "ss", value: 0 },   // omit since `ss` delegated

                /* ss */  // { driver: "vwf/model/object",      node: id, action: "gettingProperty", member: "ss", value: 0 },   // omit since `ss` delegated

                /* ss */  { driver: "vwf/view/document",        node: id, action: "gotProperty",     member: "ss", value: 0 },   // `ss` result

                /* rs */  // { driver: "vwf/model/test/scene",  node: id, action: "gettingProperty", member: "rs", value: 1 },   // omit since `rs` delegated

                /* rs */  // { driver: "vwf/model/object",      node: id, action: "gettingProperty", member: "rs", value: 1 },   // omit since `rs` delegated

                /* rs */  { driver: "vwf/view/document",        node: id, action: "gotProperty",     member: "rs", value: 1 },   // `rs` result

              ], "getProperty on property delegating to a property delegating to a non-delegating property" );


              // Setting a property delegating to a property delegating to the initial property.


              driverCalls = []; vwf.getProperty( id, "us" );


              deepEqual( driverCalls, [

                /* us */  { driver: "vwf/model/javascript",     node: id, action: "gettingProperty", member: "us", value: undefined },   // pass

                /* us */  { driver: "vwf/model/test/script",    node: id, action: "gettingProperty", member: "us", value: undefined },   // delegate to `vs` as 0

                /* vs */  { driver: "vwf/model/javascript",     node: id, action: "gettingProperty", member: "vs", value: undefined },   // pass

                /* vs */  { driver: "vwf/model/test/script",    node: id, action: "gettingProperty", member: "vs", value: undefined },   // delegate back to `us` as "0"

                /* us */  // { driver: "vwf/model/javascript",  node: id, action: "gettingProperty", member: "us", value: undefined }, // skip for reentrant call

                /* us */  // { driver: "vwf/model/test/script", node: id, action: "gettingProperty", member: "us", value: undefined }, // skip for reentrant call

                /* us */  { driver: "vwf/model/test/scene",     node: id, action: "gettingProperty", member: "us", value: undefined }, // retrieve

                /* us */  // { driver: "vwf/model/object",      node: id, action: "gettingProperty", member: "us", value: "0" }, // omit since `us` assigned

                /* us */  // { driver: "vwf/view/document",     node: id, action: "gotProperty",     member: "us", value: "0" }, // no result from reentrant call

                /* vs */  // { driver: "vwf/model/test/scene",  node: id, action: "gettingProperty", member: "vs", value: 0 },   // omit since `vs` delegated

                /* vs */  // { driver: "vwf/model/object",      node: id, action: "gettingProperty", member: "vs", value: 0 },   // omit since `vs` delegated

                /* vs */  { driver: "vwf/view/document",        node: id, action: "gotProperty",     member: "vs", value: 0 },   // `vs` result

                /* us */  // { driver: "vwf/model/test/scene",  node: id, action: "gettingProperty", member: "us", value: 1 },   // omit since `us` delegated

                /* us */  // { driver: "vwf/model/object",      node: id, action: "gettingProperty", member: "us", value: 1 },   // omit since `us` delegated

                /* us */  { driver: "vwf/view/document",        node: id, action: "gotProperty",     member: "us", value: 1 },   // `us` result

              ], "getProperty on property delegating to a property delegating to initial property" );


              driverCalls = undefined;


              // SETTING DURING REPLICATION


              vwf.models.kernel.disable();


              // Setting a self-delegating property during replication


              driverCalls = []; vwf.setProperty( id, "qs", "1" );


              deepEqual( driverCalls, [

                /* outer */  { driver: "vwf/model/javascript",     node: id, action: "settingProperty", member: "qs", value: "1" }, // pass

                /* outer */  { driver: "vwf/model/test/script",    node: id, action: "settingProperty", member: "qs", value: "1" }, // ignore since delegated during replication

                /* outer */  { driver: "vwf/model/test/scene",     node: id, action: "settingProperty", member: "qs", value: "1" }, // assign

                /* outer */  // { driver: "vwf/model/object",      node: id, action: "settingProperty", member: "qs", value: "1" }, // omit since assigned

                /* outer */  { driver: "vwf/view/document",        node: id, action: "satProperty",     member: "qs", value: "1" }, // internal result

              ], "setProperty on property delegating to self during replication" );


              // Setting a property delegating to a property delegating to the initial property during replication


              driverCalls = []; vwf.setProperty( id, "us", "0" );


              deepEqual( driverCalls, [

                /* us */  { driver: "vwf/model/javascript",     node: id, action: "settingProperty", member: "us", value: "0" }, // pass

                /* us */  { driver: "vwf/model/test/script",    node: id, action: "settingProperty", member: "us", value: "0" }, // ignore since delegated during replication

                /* us */  { driver: "vwf/model/test/scene",     node: id, action: "settingProperty", member: "us", value: "0" }, // assign

                /* us */  // { driver: "vwf/model/object",      node: id, action: "settingProperty", member: "us", value: "0" }, // omit since assigned

                /* us */  { driver: "vwf/view/document",        node: id, action: "satProperty",     member: "us", value: "0" }, // internal result

              ], "setProperty on property delegating to a property delegating to initial property during replication" );


              driverCalls = undefined;


              // GETTING DURING REPLICATION


              // Getting a self-delegating property during replication


              driverCalls = []; vwf.getProperty( id, "qs" );


              deepEqual( driverCalls, [

                /* outer */  { driver: "vwf/model/javascript",     node: id, action: "gettingProperty", member: "qs", value: undefined }, // pass

                /* outer */  { driver: "vwf/model/test/script",    node: id, action: "gettingProperty", member: "qs", value: undefined }, // ignore since delegated during replication

                /* outer */  { driver: "vwf/model/test/scene",     node: id, action: "gettingProperty", member: "qs", value: undefined }, // retrieve

                /* outer */  // { driver: "vwf/model/object",      node: id, action: "gettingProperty", member: "qs", value: "1" }, // omit since retrieved

                /* outer */  { driver: "vwf/view/document",        node: id, action: "gotProperty",     member: "qs", value: "1" }, // internal result

              ], "getProperty on property delegating to self during replication" );


              // Getting a property delegating to a property delegating to a non-delegating property during replication


              driverCalls = []; vwf.getProperty( id, "rs" );


              deepEqual( driverCalls, [

                /* rs */  { driver: "vwf/model/javascript",  node: id, action: "gettingProperty", member: "rs", value: undefined }, // pass

                /* rs */  { driver: "vwf/model/test/script", node: id, action: "gettingProperty", member: "rs", value: undefined }, // ignore since delegated during replication

                /* rs */  { driver: "vwf/model/test/scene",  node: id, action: "gettingProperty", member: "rs", value: undefined }, // pass

                /* rs */  { driver: "vwf/model/object",      node: id, action: "gettingProperty", member: "rs", value: undefined }, // pass

                /* rs */  { driver: "vwf/view/document",     node: id, action: "gotProperty",     member: "rs", value: undefined }, // internal result

              ], "getProperty on property delegating to a property delegating to a non-delegating property during replication" );


              // Getting a property delegating to a property delegating to the initial property during replication


              driverCalls = []; vwf.getProperty( id, "us" );


              deepEqual( driverCalls, [

                /* us */  { driver: "vwf/model/javascript",  node: id, action: "gettingProperty", member: "us", value: undefined }, // pass

                /* us */  { driver: "vwf/model/test/script", node: id, action: "gettingProperty", member: "us", value: undefined }, // ignore since delegated during replication

                /* us */  { driver: "vwf/model/test/scene",  node: id, action: "gettingProperty", member: "us", value: undefined }, // retrieve

                /* us */  // { driver: "vwf/model/object",   node: id, action: "gettingProperty", member: "us", value: "-1" },      // omit since retrieved

                /* us */  { driver: "vwf/view/document",     node: id, action: "gotProperty",     member: "us", value: "0" },       // internal result

              ], "getProperty on property delegating to a property delegating to initial property during replication" );


              driverCalls = undefined;


              vwf.models.kernel.enable();


              // Clean up and continue.


              vwf.deleteNode( id );


              start();


            } );


          } );


          // == Helper functions ===================================================================


          // A driver representing a script engine. No values are stored here, but some properties

          // delegate to other properties.


          function scriptModel() {


            return require( "vwf/model" ).load( { id: "vwf/model/test/script" }, {


              creatingProperty: function( nodeID, propertyName, propertyValue ) {


                if ( propertyValue !== undefined ) {

                  return this.settingProperty( nodeID, propertyName, propertyValue );

                }


              },


              initializingProperty: function( nodeID, propertyName, propertyValue ) {


                if ( propertyValue !== undefined ) {

                  return this.settingProperty( nodeID, propertyName, propertyValue );

                }


              },


              settingProperty: function( nodeID, propertyName, propertyValue ) {


                switch ( propertyName ) {


                  case "qo": this.kernel.setProperty( nodeID, "qo", propertyValue.toString() ); return propertyValue;

                  case "qs": this.kernel.setProperty( nodeID, "qs", propertyValue.toString() ); return propertyValue;


                  case "ro": this.kernel.setProperty( nodeID, "so", propertyValue - 1 ); return propertyValue;

                  case "rs": this.kernel.setProperty( nodeID, "ss", propertyValue - 1 ); return propertyValue;


                  case "so": this.kernel.setProperty( nodeID, "to", propertyValue.toString() ); return propertyValue;

                  case "ss": this.kernel.setProperty( nodeID, "ts", propertyValue.toString() ); return propertyValue;


                  case "uo": this.kernel.setProperty( nodeID, "vo", propertyValue - 1 ); return propertyValue;

                  case "us": this.kernel.setProperty( nodeID, "vs", propertyValue - 1 ); return propertyValue;


                  case "vo": this.kernel.setProperty( nodeID, "uo", propertyValue.toString() ); return propertyValue;

                  case "vs": this.kernel.setProperty( nodeID, "us", propertyValue.toString() ); return propertyValue;


                }


              },


              gettingProperty: function( nodeID, propertyName, propertyValue ) {


                switch ( propertyName ) {


                  case "qo": return parseInt( this.kernel.getProperty( nodeID, "qo" ) );

                  case "qs": return parseInt( this.kernel.getProperty( nodeID, "qs" ) );


                  case "ro": return this.kernel.getProperty( nodeID, "so" ) + 1;

                  case "rs": return this.kernel.getProperty( nodeID, "ss" ) + 1;


                  case "so": return parseInt( this.kernel.getProperty( nodeID, "to" ) );

                  case "ss": return parseInt( this.kernel.getProperty( nodeID, "ts" ) );


                  case "uo": return this.kernel.getProperty( nodeID, "vo" ) + 1;

                  case "us": return this.kernel.getProperty( nodeID, "vs" ) + 1;


                  case "vo": return parseInt( this.kernel.getProperty( nodeID, "uo" ) );

                  case "vs": return parseInt( this.kernel.getProperty( nodeID, "us" ) );


                }


              },


            } );


          }


          // A driver representing a scene manager or other engine that stores some properties.

          // Properties handled here won't reach the model/object driver.


          function sceneModel() {


            return require( "vwf/model" ).load( { id: "vwf/model/test/scene" }, {


              creatingProperty: function( nodeID, propertyName, propertyValue ) {

                  return this.initializingProperty( nodeID, propertyName, propertyValue );

              },


              initializingProperty: function( nodeID, propertyName, propertyValue ) {

                  return this.settingProperty( nodeID, propertyName, propertyValue );

              },


              settingProperty: function( nodeID, propertyName, propertyValue ) {


                switch ( propertyName ) {


                  case "ps": case "qs": case "ts": case "us":

                    return this.state[ nodeID + '-' + propertyName ] = propertyValue;


                }


              },


              gettingProperty: function( nodeID, propertyName, propertyValue ) {


                switch ( propertyName ) {


                  case "ps": case "qs": case "ts": case "us":

                    return this.state[ nodeID + '-' + propertyName ];


                }


              },


            } );


          }


          // Patch a driver to log calls to the specified handlers.


          // The log is recorded in `driverCalls` if an array is provided there. To use, set

          // `driverCalls = []`, invoke some actions, then test. Set `driverCalls = undefined` to

          // disable the log.


          function patchHandlers( driver, type, handlerNames ) {


            var wrappedHandlers = {};


            // Find the end of the pipeline.


            while ( driver[type] ) {

              driver = driver[type];

            }


            // Wrap each handler.


            handlerNames.forEach( function( handlerName ) {


              // Save the original.


              wrappedHandlers[handlerName] = driver[handlerName];


              // And wrap it.


              driver[handlerName] = function( nodeID, propertyName, propertyValue, propertyGet, propertySet ) {


                // Append to the log.


                driverCalls && driverCalls.push( {

                  driver: driver.module.id,

                  node: nodeID,

                  action: handlerName,

                  member: propertyName,

                  value: propertyValue

                } );


                // Call the original.


                return wrappedHandlers[handlerName] &&

                  wrappedHandlers[handlerName].call( this, nodeID, propertyName, propertyValue, propertyGet, propertySet );


              }


            } );


          }


          // Calls are logged when an array is provided here. `driversCalls` is `undefined` and

          // logging is disabled by default.


          var driverCalls;


          // Generate the random state object given a parent's state and a node ID. If the node

          // doesn't have a parent, use the global random seed. This mimics the prng initialization

          // in model/object#creatingNode.


          function randomState( parentState, childID ) {


            return new Alea(

              parentState ? JSON.stringify( parentState ) : configuration.active["random-seed"],

              childID

            ).state;


          }


        } );


      } );


    </script>

    <link rel="stylesheet" type="text/css" href="qunit.css" />

  </head>

  <body>

    <h1 id="qunit-header">Virtual World Framework</h1>
    <h2 id="qunit-banner"></h2>
    <div id="qunit-testrunner-toolbar"></div>
    <h2 id="qunit-userAgent"></h2>
    <ol id="qunit-tests"></ol>

    <div id="qunit-fixture">test markup, will be hidden</div>

  </body>

</html>