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>