>
>     AsyncObjectStore .init(className, args, cb(err, v0)) should initialize an object of class className with arguments args and return the ID:   ․ AsyncObjectStore .init(className, args, cb(err, v0)) should initialize an object of class className with arguments args and return the ID
>     AsyncObjectStore .transRaw(v1, p, cb(err, v2, r, conf, eff)) should apply patch p to v1, to receive v2:   ․ AsyncObjectStore .transRaw(v1, p, cb(err, v2, r, conf, eff)) should apply patch p to v1, to receive v2
>     AsyncObjectStore .transRaw(v1, p, cb(err, v2, r, conf, eff)) should return the result r of the patch:   ․ AsyncObjectStore .transRaw(v1, p, cb(err, v2, r, conf, eff)) should return the result r of the patch
>     AsyncObjectStore .transRaw(v1, p, cb(err, v2, r, conf, eff)) should return the result version even if the source version is not in the cache:   ․ AsyncObjectStore .transRaw(v1, p, cb(err, v2, r, conf, eff)) should return the result version even if the source version is not in the cache
>     AsyncObjectStore .transRaw(v1, p, cb(err, v2, r, conf, eff)) should return the result r even if the source version is not in the cache:   ․ AsyncObjectStore .transRaw(v1, p, cb(err, v2, r, conf, eff)) should return the result r even if the source version is not in the cache
>     AsyncObjectStore .transRaw(v1, p, cb(err, v2, r, conf, eff)) should return the conflict flag (in cache):   ․ AsyncObjectStore .transRaw(v1, p, cb(err, v2, r, conf, eff)) should return the conflict flag (in cache)
>     AsyncObjectStore .transRaw(v1, p, cb(err, v2, r, conf, eff)) should return the conflict flag (out of cache):   ․ AsyncObjectStore .transRaw(v1, p, cb(err, v2, r, conf, eff)) should return the conflict flag (out of cache)
>     AsyncObjectStore .transRaw(v1, p, cb(err, v2, r, conf, eff)) should return all effect patches (in cache):   ․ AsyncObjectStore .transRaw(v1, p, cb(err, v2, r, conf, eff)) should return all effect patches (in cache)
>     AsyncObjectStore .transRaw(v1, p, cb(err, v2, r, conf, eff)) should return all effect patches (out of cache):   ․ AsyncObjectStore .transRaw(v1, p, cb(err, v2, r, conf, eff)) should return all effect patches (out of cache)
>     AsyncObjectStore .trans(v1, ps, cb(err, v2, r, conf, w)) should perform transitions and return the result version and result:   ․ AsyncObjectStore .trans(v1, ps, cb(err, v2, r, conf, w)) should perform transitions and return the result version and result
>     AsyncObjectStore .trans(v1, ps, cb(err, v2, r, conf, w)) should perform a sequence of transitions, returning the result of each:   ․ AsyncObjectStore .trans(v1, ps, cb(err, v2, r, conf, w)) should perform a sequence of transitions, returning the result of each
>     AsyncObjectStore .trans(v1, ps, cb(err, v2, r, conf, w)) should update the conflict flag appropriately:   ․ AsyncObjectStore .trans(v1, ps, cb(err, v2, r, conf, w)) should update the conflict flag appropriately
>     AsyncObjectStore .trans(v1, ps, cb(err, v2, r, conf, w)) should apply effect patches resulting from previous patches, automatically:   ․ AsyncObjectStore .trans(v1, ps, cb(err, v2, r, conf, w)) should apply effect patches resulting from previous patches, automatically
>     BinTree init should initialize a binary tree with a single element:   ․ BinTree init should initialize a binary tree with a single element
>     BinTree fetch should return the value associated with a key:   ․ BinTree fetch should return the value associated with a key
>     BinTree fetch should return undefined if the key is not in the tree:   ․ BinTree fetch should return undefined if the key is not in the tree
>     BinTree add should add a leaf to the tree, based on key comparison:   ․ BinTree add should add a leaf to the tree, based on key comparison
>     BinTree add should report a conflict and not change the state if the the key already exists:   ․ BinTree add should report a conflict and not change the state if the the key already exists
>     BinTree getMin should retrieve the the minimum key, with its associated value:   ․ BinTree getMin should retrieve the the minimum key, with its associated value
>     BinTree remove should remove the element with the given key and value:   ․ BinTree remove should remove the element with the given key and value
>     BucketObjectStore as ObjectStore .init(ctx, className, args) should call the init() method of the relevant class with args as a parameter:   ․ BucketObjectStore as ObjectStore .init(ctx, className, args) should call the init() method of the relevant class with args as a parameter
>     BucketObjectStore as ObjectStore .init(ctx, className, args) should return an ID (an object with a "$" attribute containing a string) of the newly created object:   ․ BucketObjectStore as ObjectStore .init(ctx, className, args) should return an ID (an object with a "$" attribute containing a string) of the newly created object
>     BucketObjectStore as ObjectStore .trans(ctx, v1, p) should apply patch p to version v1 (v1 is a version ID), returning pair [v2, res] where v2 is the new version ID, and res is the result:   ․ BucketObjectStore as ObjectStore .trans(ctx, v1, p) should apply patch p to version v1 (v1 is a version ID), returning pair [v2, res] where v2 is the new version ID, and res is the result
>     BucketObjectStore as ObjectStore .trans(ctx, v1, p) should replace the object if a _replaceWith field is added to the object:   ․ BucketObjectStore as ObjectStore .trans(ctx, v1, p) should replace the object if a _replaceWith field is added to the object
>     BucketObjectStore as ObjectStore .trans(ctx, v1, p) should pass exceptions thrown by patch methods as the error field of the context:   ․ BucketObjectStore as ObjectStore .trans(ctx, v1, p) should pass exceptions thrown by patch methods as the error field of the context
>     BucketObjectStore as ObjectStore .trans(ctx, v1, p) should propagate exceptions thrown by underlying invocations:   ․ BucketObjectStore as ObjectStore .trans(ctx, v1, p) should propagate exceptions thrown by underlying invocations
>     BucketObjectStore as ObjectStore context should allow underlying initializations and transitions to perform initializations and transitions:   ․ BucketObjectStore as ObjectStore context should allow underlying initializations and transitions to perform initializations and transitions
>     BucketObjectStore as ObjectStore context .conflict() should set the context's confclit flag to true:   ․ BucketObjectStore as ObjectStore context .conflict() should set the context's confclit flag to true
>     BucketObjectStore as ObjectStore context .conflict() should propagate conflicts to calling transitions:   ․ BucketObjectStore as ObjectStore context .conflict() should propagate conflicts to calling transitions
>     BucketObjectStore as ObjectStore context .effect(patch) should add a patch to the effect set held by the context:   ․ BucketObjectStore as ObjectStore context .effect(patch) should add a patch to the effect set held by the context
>     BucketObjectStore .hash(bucket, obj) should return a unique ID for each given object and bucket ID:   ․ BucketObjectStore .hash(bucket, obj) should return a unique ID for each given object and bucket ID
>     BucketObjectStore .hash(bucket, obj) should cache the object under its ID:   ․ BucketObjectStore .hash(bucket, obj) should cache the object under its ID
>     BucketObjectStore .unhash(id) should return the object corresponding to id, if in the cache:   ․ BucketObjectStore .unhash(id) should return the object corresponding to id, if in the cache
>     BucketObjectStore .unhash(id) should return the contents of an object given its ID, if in the cache:   ․ BucketObjectStore .unhash(id) should return the contents of an object given its ID, if in the cache
>     BucketObjectStore .unhash(id) should put things in motion to retrieve the value of the ID, if not in the cache:   ․ BucketObjectStore .unhash(id) should put things in motion to retrieve the value of the ID, if not in the cache
>     BucketObjectStore .trans(ctx, v1, p) should return v2=undefined if v1 is not in cache:   ․ BucketObjectStore .trans(ctx, v1, p) should return v2=undefined if v1 is not in cache
>     BucketObjectStore .trans(ctx, v1, p) should add a field named "waitFor" to the context, containing a list of cache entries.  Waiting on them assures .trans() returns value:   ․ BucketObjectStore .trans(ctx, v1, p) should add a field named "waitFor" to the context, containing a list of cache entries.  Waiting on them assures .trans() returns value
>     BucketObjectStore .trans(ctx, v1, p) should support recursive transitions:   ․ BucketObjectStore .trans(ctx, v1, p) should support recursive transitions
>     BucketObjectStore .trans(ctx, v1, p) should support recursive transitions even at the event of not having items in the cache (waitFor should be filled accordingly):   ․ BucketObjectStore .trans(ctx, v1, p) should support recursive transitions even at the event of not having items in the cache (waitFor should be filled accordingly)
>     BucketObjectStore A 1000 element tree should recall any number:   ․ BucketObjectStore A 1000 element tree should recall any number
>     BucketObjectStore A 1000 element tree should call make a reasonable number of calls to the bucket store:   ․ BucketObjectStore A 1000 element tree should call make a reasonable number of calls to the bucket store
>     counter init should create a counter with value = 0:   ․ counter init should create a counter with value = 0
>     counter add should add the given ammount to the counter value:   ․ counter add should add the given ammount to the counter value
>     counter add should subtract the given amount when unapplied:   ․ counter add should subtract the given amount when unapplied
>     counter get should return the counter value:   ․ counter get should return the counter value
>     DummyBucketStore should accumulate all added items and replay them when fetched:   ․ DummyBucketStore should accumulate all added items and replay them when fetched
>     DummyBucketStore should store each bucket individually:   ․ DummyBucketStore should store each bucket individually
>     DummyBucketStore async mode should return a unique ID when adding to a bucket, such that registering to that ID guarantees the data has been saved:   ․ DummyBucketStore async mode should return a unique ID when adding to a bucket, such that registering to that ID guarantees the data has been saved
>     DummyBucketStore async mode should not apply changes immediately:   ․ DummyBucketStore async mode should not apply changes immediately
>     DummyGraphDB as GraphDB addEdge should accept an edge and add it to the graph:   ․ DummyGraphDB as GraphDB addEdge should accept an edge and add it to the graph
>     DummyGraphDB as GraphDB addEdge should create a dual mapping, mapping also the destination to the source:   ․ DummyGraphDB as GraphDB addEdge should create a dual mapping, mapping also the destination to the source
>     DummyGraphDB as GraphDB findCommonAncestor should find the common ancestor of two nodes, and the path to each of them:   ․ DummyGraphDB as GraphDB findCommonAncestor should find the common ancestor of two nodes, and the path to each of them
>     DummyGraphDB as GraphDB findCommonAncestor should handle the case where there are also common descendants:   ․ DummyGraphDB as GraphDB findCommonAncestor should handle the case where there are also common descendants
>     DummyGraphDB as GraphDB findCommonAncestor should return the path from the common ancestor to both nodes:   ․ DummyGraphDB as GraphDB findCommonAncestor should return the path from the common ancestor to both nodes
>     DummyGraphDB .findPath(x, y, cb(err, path)) should return the labels along the edges from x to y:   ․ DummyGraphDB .findPath(x, y, cb(err, path)) should return the labels along the edges from x to y
>     DummyObjectStore as ObjectStore .init(ctx, className, args) should call the init() method of the relevant class with args as a parameter:   ․ DummyObjectStore as ObjectStore .init(ctx, className, args) should call the init() method of the relevant class with args as a parameter
>     DummyObjectStore as ObjectStore .init(ctx, className, args) should return an ID (an object with a "$" attribute containing a string) of the newly created object:   ․ DummyObjectStore as ObjectStore .init(ctx, className, args) should return an ID (an object with a "$" attribute containing a string) of the newly created object
>     DummyObjectStore as ObjectStore .trans(ctx, v1, p) should apply patch p to version v1 (v1 is a version ID), returning pair [v2, res] where v2 is the new version ID, and res is the result:   ․ DummyObjectStore as ObjectStore .trans(ctx, v1, p) should apply patch p to version v1 (v1 is a version ID), returning pair [v2, res] where v2 is the new version ID, and res is the result
>     DummyObjectStore as ObjectStore .trans(ctx, v1, p) should replace the object if a _replaceWith field is added to the object:   ․ DummyObjectStore as ObjectStore .trans(ctx, v1, p) should replace the object if a _replaceWith field is added to the object
>     DummyObjectStore as ObjectStore .trans(ctx, v1, p) should pass exceptions thrown by patch methods as the error field of the context:   ․ DummyObjectStore as ObjectStore .trans(ctx, v1, p) should pass exceptions thrown by patch methods as the error field of the context
>     DummyObjectStore as ObjectStore .trans(ctx, v1, p) should propagate exceptions thrown by underlying invocations:   ․ DummyObjectStore as ObjectStore .trans(ctx, v1, p) should propagate exceptions thrown by underlying invocations
>     DummyObjectStore as ObjectStore context should allow underlying initializations and transitions to perform initializations and transitions:   ․ DummyObjectStore as ObjectStore context should allow underlying initializations and transitions to perform initializations and transitions
>     DummyObjectStore as ObjectStore context .conflict() should set the context's confclit flag to true:   ․ DummyObjectStore as ObjectStore context .conflict() should set the context's confclit flag to true
>     DummyObjectStore as ObjectStore context .conflict() should propagate conflicts to calling transitions:   ․ DummyObjectStore as ObjectStore context .conflict() should propagate conflicts to calling transitions
>     DummyObjectStore as ObjectStore context .effect(patch) should add a patch to the effect set held by the context:   ․ DummyObjectStore as ObjectStore context .effect(patch) should add a patch to the effect set held by the context
>     MergingStateStore .trans(v1, p, cb(v2, r, c)) should apply p to v1 to receive v2:   ․ MergingStateStore .trans(v1, p, cb(v2, r, c)) should apply p to v1 to receive v2
>     MergingStateStore .merge(v1, v2[, resolve], cb(err, vm, c)) should return version vm which is a merge of both versions v1 and v2:   ․ MergingStateStore .merge(v1, v2[, resolve], cb(err, vm, c)) should return version vm which is a merge of both versions v1 and v2
>     MergingStateStore .merge(v1, v2[, resolve], cb(err, vm, c)) should record the merge so that further merges would work:   ․ MergingStateStore .merge(v1, v2[, resolve], cb(err, vm, c)) should record the merge so that further merges would work
>     MergingStateStore .merge(v1, v2[, resolve], cb(err, vm, c)) should report a conflict as an error, when one occurs:   ․ MergingStateStore .merge(v1, v2[, resolve], cb(err, vm, c)) should report a conflict as an error, when one occurs
>   - MergingStateStore .merge(v1, v2[, resolve], cb(err, vm, c)) should resolve conflicts if asked to, by prioritizing v2 over v1
>     ObjectDisp .init(ctx, className, args) should call the init() function associated with the class:   ․ ObjectDisp .init(ctx, className, args) should call the init() function associated with the class
>     ObjectDisp .init(ctx, className, args) should throw an exception if the class does not exist:   ․ ObjectDisp .init(ctx, className, args) should throw an exception if the class does not exist
>     ObjectDisp .init(ctx, className, args) should pass the given context and args to the class's init() function:   ․ ObjectDisp .init(ctx, className, args) should pass the given context and args to the class's init() function
>     ObjectDisp .init(ctx, className, args) should return the value of the "this" object in the context of the class's init() function:   ․ ObjectDisp .init(ctx, className, args) should return the value of the "this" object in the context of the class's init() function
>     ObjectDisp .init(ctx, className, args) should add a _type field to the returned object, containing the class name:   ․ ObjectDisp .init(ctx, className, args) should add a _type field to the returned object, containing the class name
>     ObjectDisp .apply(ctx, obj, patch, unapply) should call the function with name matches the _type field of the patch, in the class associated with the object.:   ․ ObjectDisp .apply(ctx, obj, patch, unapply) should call the function with name matches the _type field of the patch, in the class associated with the object.
>     ObjectDisp .apply(ctx, obj, patch, unapply) should throw an exception if the patch function is not defined:   ․ ObjectDisp .apply(ctx, obj, patch, unapply) should throw an exception if the patch function is not defined
>     ObjectDisp .apply(ctx, obj, patch, unapply) should pass the object as the "this" parameter to the patch function:   ․ ObjectDisp .apply(ctx, obj, patch, unapply) should pass the object as the "this" parameter to the patch function
>     ObjectDisp .apply(ctx, obj, patch, unapply) should pass the context, the patch and the unapply flag as parameters to the patch function:   ․ ObjectDisp .apply(ctx, obj, patch, unapply) should pass the context, the patch and the unapply flag as parameters to the patch function
>     ObjectDisp .apply(ctx, obj, patch, unapply) should return a pair [obj, res], containing the patch function's "this" object, and its return value:   ․ ObjectDisp .apply(ctx, obj, patch, unapply) should return a pair [obj, res], containing the patch function's "this" object, and its return value
>     ObjectDisp .apply(ctx, obj, patch, unapply) should use patch handlers if defined (prfixed with ":"):   ․ ObjectDisp .apply(ctx, obj, patch, unapply) should use patch handlers if defined (prfixed with ":")
>     ObjectDisp .apply(ctx, obj, patch, unapply) should prefer a method defined in a class over a generic patch function if both are defined:   ․ ObjectDisp .apply(ctx, obj, patch, unapply) should prefer a method defined in a class over a generic patch function if both are defined
>     Scheduler allows users to register a callback to a condition. Once the condition is met, the callback is called:   ․ Scheduler allows users to register a callback to a condition. Once the condition is met, the callback is called
>     Scheduler should not call a callback unless the condition has been met:   ․ Scheduler should not call a callback unless the condition has been met
>     Scheduler should allow multiple registrations on the same condition:   ․ Scheduler should allow multiple registrations on the same condition
>     Scheduler should call each callback only once even if notified multiple times:   ․ Scheduler should call each callback only once even if notified multiple times
>     Scheduler should call a callback only when all conditions are met:   ․ Scheduler should call a callback only when all conditions are met
>     SimpleCache .store(id, obj[, json]) should store an object in the cache under the given ID:   ․ SimpleCache .store(id, obj[, json]) should store an object in the cache under the given ID
>     SimpleCache .store(id, obj[, json]) should retrieve the same instance on a first fetch:   ․ SimpleCache .store(id, obj[, json]) should retrieve the same instance on a first fetch
>     SimpleCache .store(id, obj[, json]) should retrieve the same object once and again, even if it was modified on the outside:   ․ SimpleCache .store(id, obj[, json]) should retrieve the same object once and again, even if it was modified on the outside
>     SimpleCache .store(id, obj[, json]) should use the json argument, if supplied, as the JSON representation of the object to be used when the instance is no longer available:   ․ SimpleCache .store(id, obj[, json]) should use the json argument, if supplied, as the JSON representation of the object to be used when the instance is no longer available
>     SimpleCache .abolish() should remove all elements from the cache:   ․ SimpleCache .abolish() should remove all elements from the cache
>     SimpleCache .waitFor(keys, callback) should call the given callback once all keys are in the cache:   ․ SimpleCache .waitFor(keys, callback) should call the given callback once all keys are in the cache
>     SimpleCache .waitFor(keys, callback) should throw an exception if one of the keys is already in the cache:   ․ SimpleCache .waitFor(keys, callback) should throw an exception if one of the keys is already in the cache
>     SimpleCache .check(key) should return true if key exists in the cache:   ․ SimpleCache .check(key) should return true if key exists in the cache
>     SimpleVersionGraph .recordTrans(v1, p, w, v2, cb(err)) should return a callback with no error if all is OK:   ․ SimpleVersionGraph .recordTrans(v1, p, w, v2, cb(err)) should return a callback with no error if all is OK
>     SimpleVersionGraph .getMergeStrategy(v1, v2, resolve, cb(err, V1, x, V2, mergeInfo)) should return x as the common ancestor of v1 and v2:   ․ SimpleVersionGraph .getMergeStrategy(v1, v2, resolve, cb(err, V1, x, V2, mergeInfo)) should return x as the common ancestor of v1 and v2
>     SimpleVersionGraph .getMergeStrategy(v1, v2, resolve, cb(err, V1, x, V2, mergeInfo)) should return either v1 or v2 as V1, and the other as V2:   ․ SimpleVersionGraph .getMergeStrategy(v1, v2, resolve, cb(err, V1, x, V2, mergeInfo)) should return either v1 or v2 as V1, and the other as V2
>     SimpleVersionGraph .getMergeStrategy(v1, v2, resolve, cb(err, V1, x, V2, mergeInfo)) should set V1 and V2 such that the path between x and V2 is lighter than from x to V1, given that resolve=false:   ․ SimpleVersionGraph .getMergeStrategy(v1, v2, resolve, cb(err, V1, x, V2, mergeInfo)) should set V1 and V2 such that the path between x and V2 is lighter than from x to V1, given that resolve=false
>     SimpleVersionGraph .getMergeStrategy(v1, v2, resolve, cb(err, V1, x, V2, mergeInfo)) should set V1 and V2 to be v1 and v2 respectively if resolve=true:   ․ SimpleVersionGraph .getMergeStrategy(v1, v2, resolve, cb(err, V1, x, V2, mergeInfo)) should set V1 and V2 to be v1 and v2 respectively if resolve=true
>     SimpleVersionGraph .getPatches(v1, v2, cb(err, patches)) should return the patches along the path between v1 and v2 (here, v1 is an ancestor of v2):   ․ SimpleVersionGraph .getPatches(v1, v2, cb(err, patches)) should return the patches along the path between v1 and v2 (here, v1 is an ancestor of v2)
>     SimpleVersionGraph .getPatches(v1, v2, cb(err, patches)) should expand patches that result from previous merges:   ․ SimpleVersionGraph .getPatches(v1, v2, cb(err, patches)) should expand patches that result from previous merges
>     SimpleVersionGraph .recordMerge(mergeInfo, newV, patches, confPatches, cb(err)) should record a merge using the mergeInfo object obtained from getMergeStrategy(), and a merged version:   ․ SimpleVersionGraph .recordMerge(mergeInfo, newV, patches, confPatches, cb(err)) should record a merge using the mergeInfo object obtained from getMergeStrategy(), and a merged version
>     SimpleVersionGraph .recordMerge(mergeInfo, newV, patches, confPatches, cb(err)) should record the overall weight on each new edge:   ․ SimpleVersionGraph .recordMerge(mergeInfo, newV, patches, confPatches, cb(err)) should record the overall weight on each new edge
>     SimpleVersionGraph .recordMerge(mergeInfo, newV, patches, confPatches, cb(err)) should not record conflicting patches if such exist:   ․ SimpleVersionGraph .recordMerge(mergeInfo, newV, patches, confPatches, cb(err)) should not record conflicting patches if such exist
>     util seq(funcs, done) should return a function that runs asynchronous functions in funcs in order:   ․ util seq(funcs, done) should return a function that runs asynchronous functions in funcs in order
>     util seq(funcs, done) should handle errors by calling done with the error:   ․ util seq(funcs, done) should handle errors by calling done with the error
>     util seq(funcs, done) should handle exceptions thrown by functions by calling done with the exception:   ․ util seq(funcs, done) should handle exceptions thrown by functions by calling done with the exception
>     util seq(funcs, done) should call done with no error if all is successful:   ․ util seq(funcs, done) should call done with no error if all is successful
>     util seq(funcs, done) _.to(names...) should return a function that places the corresponding arguments in "this" (skipping err):   ․ util seq(funcs, done) _.to(names...) should return a function that places the corresponding arguments in "this" (skipping err)
>     util timeUid() should return a unique string:   ․ util timeUid() should return a unique string
>     util timeUid() should return a larger value when called over one millisecond later:   ․ util timeUid() should return a larger value when called over one millisecond later
>     util Encoder(allowedSpecial) .encode(str) should encode str in a way that will only include letters, digits or characters from allowedSpecial:   ․ util Encoder(allowedSpecial) .encode(str) should encode str in a way that will only include letters, digits or characters from allowedSpecial
>     util Encoder(allowedSpecial) .encode(str) should throw an exception if less than three special characters are allowed:   ․ util Encoder(allowedSpecial) .encode(str) should throw an exception if less than three special characters are allowed
>     util Encoder(allowedSpecial) .decode(enc) should decode a string encoded with .encode():   ․ util Encoder(allowedSpecial) .decode(enc) should decode a string encoded with .encode()
>     util parallel(n, callback) should return a callback function that will call "callback" after it has been called n times:   ․ util parallel(n, callback) should return a callback function that will call "callback" after it has been called n times
>     util parallel(n, callback) should call the callback immediately with an error if an error is given to the parallel callback:   ․ util parallel(n, callback) should call the callback immediately with an error if an error is given to the parallel callback
>     util Worker should call a given function iteratively, in given intervals, until stopped:   ․ util Worker should call a given function iteratively, in given intervals, until stopped
>     util Worker should assure that no more than a given number of instances of the function are running at any given time:   ․ util Worker should assure that no more than a given number of instances of the function are running at any given time
>     util repeat should repeat the given loop a given number of times, sending the iteration number to each invocation:   ․ util repeat should repeat the given loop a given number of times, sending the iteration number to each invocation
>     util depend should execute the given callback functions in the order of their dependencies:   ․ util depend should execute the given callback functions in the order of their dependencies
>     util depend should only call the callback once in the face of an exception:   ․ util depend should only call the callback once in the face of an exception
>     vercast .hash(obj) should return a SHA-256 digest of the given string:   ․ vercast .hash(obj) should return a SHA-256 digest of the given string
>     vercast .genID(bucketID, hash) should create a version ID based on a bucket ID (string) and a hash (string):   ․ vercast .genID(bucketID, hash) should create a version ID based on a bucket ID (string) and a hash (string)
>     vercast .bucketID(id) should return the bucket ID associated with the given version ID:   ․ vercast .bucketID(id) should return the bucket ID associated with the given version ID
>     vercast .objID(id) should return the object hash part of the given version ID:   ․ vercast .objID(id) should return the object hash part of the given version ID
>     vercast .childObjects(obj) should return a list of sub-object IDs nested in obj:   ․ vercast .childObjects(obj) should return a list of sub-object IDs nested in obj
>     vercast .childObjects(obj) should recursively search for children in nested objects and arrays:   ․ vercast .childObjects(obj) should recursively search for children in nested objects and arrays
>     vercast .randomByKey(key, prob) should return true in probability prob:   ․ vercast .randomByKey(key, prob) should return true in probability prob
>     vercast .randomByKey(key, prob) should behave consistently given a constant sequence of keys:   ․ vercast .randomByKey(key, prob) should behave consistently given a constant sequence of keys
>
>   129 passing (2s)
>   1 pending
>