<     Array init should create an array containing objects in their initial version:   ․ Array init should create an array containing objects in their initial version
<     Array apply should relay a patch to an array entry corresponding to the given index:   ․ Array apply should relay a patch to an array entry corresponding to the given index
<     Array apply should return the underlying patch's return value:   ․ Array apply should return the underlying patch's return value
<     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
<     BranchStore .fork(name, v0, cb(err)) should create a new branch of the given name, and set its head version to v0:   ․ BranchStore .fork(name, v0, cb(err)) should create a new branch of the given name, and set its head version to v0
<     BranchStore .head(branchName) should return the last known version of the given branch:   ․ BranchStore .head(branchName) should return the last known version of the given branch
<     BranchStore .push(branchName, v2, cb(err)) should assign v2 to the head of the branch, if v2 is a descendant of the current head:   ․ BranchStore .push(branchName, v2, cb(err)) should assign v2 to the head of the branch, if v2 is a descendant of the current head
<     BranchStore .push(branchName, v2, cb(err)) should merge the head version and v2 if not a direct descendant:   ․ BranchStore .push(branchName, v2, cb(err)) should merge the head version and v2 if not a direct descendant
<     BranchStore .push(branchName, v2, cb(err)) should fail if a conflict is encountered:   ․ BranchStore .push(branchName, v2, cb(err)) should fail if a conflict is encountered
<     BranchStore .push(branchName, v2, cb(err)) should handle cases where two pushes are done in parallel. If no conflicts occur, the resulting head should include all contributions:   ․ BranchStore .push(branchName, v2, cb(err)) should handle cases where two pushes are done in parallel. If no conflicts occur, the resulting head should include all contributions
<     BranchStore .pull(v1, versionOrBranch, cb(err, vm)) should merge between the two versions (if so given):   ․ BranchStore .pull(v1, versionOrBranch, cb(err, vm)) should merge between the two versions (if so given)
<     BranchStore .pull(v1, versionOrBranch, cb(err, vm)) should merge between the given version and the given branch (if so given):   ․ BranchStore .pull(v1, versionOrBranch, cb(err, vm)) should merge between the given version and the given branch (if so given)
<     BranchStore .pull(v1, versionOrBranch, cb(err, vm)) should resolve conflicts, should they occur, by preferring the second argument:   ․ BranchStore .pull(v1, versionOrBranch, cb(err, vm)) should resolve conflicts, should they occur, by preferring the second argument
<     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
<     DummyAtomicKVS as AtomicKeyValue .newKey(key, val, cb(err)) should store a new key/value pair, given that key does not already exist:   ․ DummyAtomicKVS as AtomicKeyValue .newKey(key, val, cb(err)) should store a new key/value pair, given that key does not already exist
<     DummyAtomicKVS as AtomicKeyValue .newKey(key, val, cb(err)) should emit an error when the key already exists:   ․ DummyAtomicKVS as AtomicKeyValue .newKey(key, val, cb(err)) should emit an error when the key already exists
<     DummyAtomicKVS as AtomicKeyValue .retrieve(key, cb(err, val)) should emit an error if the value does not exist:   ․ DummyAtomicKVS as AtomicKeyValue .retrieve(key, cb(err, val)) should emit an error if the value does not exist
<     DummyAtomicKVS as AtomicKeyValue .modify(key, oldVal, newVal, cb(err, valAfterMod)) should change the value under key to newVal, given that the previous value was oldVal:   ․ DummyAtomicKVS as AtomicKeyValue .modify(key, oldVal, newVal, cb(err, valAfterMod)) should change the value under key to newVal, given that the previous value was oldVal
<     DummyAtomicKVS as AtomicKeyValue .modify(key, oldVal, newVal, cb(err, valAfterMod)) should not change the value under key if the current value does not equal oldVal:   ․ DummyAtomicKVS as AtomicKeyValue .modify(key, oldVal, newVal, cb(err, valAfterMod)) should not change the value under key if the current value does not equal oldVal
<     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)) should return version vm which is a merge of both versions v1 and v2:   ․ MergingStateStore .merge(v1, v2[, resolve], cb(err, vm)) should return version vm which is a merge of both versions v1 and v2
<     MergingStateStore .merge(v1, v2[, resolve], cb(err, vm)) should record the merge so that further merges would work:   ․ MergingStateStore .merge(v1, v2[, resolve], cb(err, vm)) should record the merge so that further merges would work
<     MergingStateStore .merge(v1, v2[, resolve], cb(err, vm)) should report a conflict as an error, when one occurs:   ․ MergingStateStore .merge(v1, v2[, resolve], cb(err, vm)) should report a conflict as an error, when one occurs
<     MergingStateStore .merge(v1, v2[, resolve], cb(err, vm)) should resolve conflicts if asked to, by prioritizing v1 over v2:   ․ MergingStateStore .merge(v1, v2[, resolve], cb(err, vm)) should resolve conflicts if asked to, by prioritizing v1 over v2
<     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
---
>     Array init should create an array containing objects in their initial version
>   ․ Array init should create an array containing objects in their initial version
>     Array apply should relay a patch to an array entry corresponding to the given index
>   ․ Array apply should relay a patch to an array entry corresponding to the given index
>     Array apply should return the underlying patch's return value
>   ․ Array apply should return the underlying patch's return value
>     Array apply_range should apply a patch to a given range in the array
>   ․ Array apply_range should apply a patch to a given range in the array
>     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
>     BranchStore .fork(name, v0, cb(err)) should create a new branch of the given name, and set its head version to v0
>   ․ BranchStore .fork(name, v0, cb(err)) should create a new branch of the given name, and set its head version to v0
>     BranchStore .head(branchName) should return the last known version of the given branch
>   ․ BranchStore .head(branchName) should return the last known version of the given branch
>     BranchStore .push(branchName, v2, cb(err)) should assign v2 to the head of the branch, if v2 is a descendant of the current head
>   ․ BranchStore .push(branchName, v2, cb(err)) should assign v2 to the head of the branch, if v2 is a descendant of the current head
>     BranchStore .push(branchName, v2, cb(err)) should merge the head version and v2 if not a direct descendant
>   ․ BranchStore .push(branchName, v2, cb(err)) should merge the head version and v2 if not a direct descendant
>     BranchStore .push(branchName, v2, cb(err)) should fail if a conflict is encountered
>   ․ BranchStore .push(branchName, v2, cb(err)) should fail if a conflict is encountered
>     BranchStore .push(branchName, v2, cb(err)) should handle cases where two pushes are done in parallel. If no conflicts occur, the resulting head should include all contributions
>   ․ BranchStore .push(branchName, v2, cb(err)) should handle cases where two pushes are done in parallel. If no conflicts occur, the resulting head should include all contributions
>     BranchStore .pull(v1, versionOrBranch, cb(err, vm)) should merge between the two versions (if so given)
>   ․ BranchStore .pull(v1, versionOrBranch, cb(err, vm)) should merge between the two versions (if so given)
>     BranchStore .pull(v1, versionOrBranch, cb(err, vm)) should merge between the given version and the given branch (if so given)
>   ․ BranchStore .pull(v1, versionOrBranch, cb(err, vm)) should merge between the given version and the given branch (if so given)
>     BranchStore .pull(v1, versionOrBranch, cb(err, vm)) should resolve conflicts, should they occur, by preferring the second argument
>   ․ BranchStore .pull(v1, versionOrBranch, cb(err, vm)) should resolve conflicts, should they occur, by preferring the second argument
>     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
>     DummyAtomicKVS as AtomicKeyValue .newKey(key, val, cb(err)) should store a new key/value pair, given that key does not already exist
>   ․ DummyAtomicKVS as AtomicKeyValue .newKey(key, val, cb(err)) should store a new key/value pair, given that key does not already exist
>     DummyAtomicKVS as AtomicKeyValue .newKey(key, val, cb(err)) should emit an error when the key already exists
>   ․ DummyAtomicKVS as AtomicKeyValue .newKey(key, val, cb(err)) should emit an error when the key already exists
>     DummyAtomicKVS as AtomicKeyValue .retrieve(key, cb(err, val)) should emit an error if the value does not exist
>   ․ DummyAtomicKVS as AtomicKeyValue .retrieve(key, cb(err, val)) should emit an error if the value does not exist
>     DummyAtomicKVS as AtomicKeyValue .modify(key, oldVal, newVal, cb(err, valAfterMod)) should change the value under key to newVal, given that the previous value was oldVal
>   ․ DummyAtomicKVS as AtomicKeyValue .modify(key, oldVal, newVal, cb(err, valAfterMod)) should change the value under key to newVal, given that the previous value was oldVal
>     DummyAtomicKVS as AtomicKeyValue .modify(key, oldVal, newVal, cb(err, valAfterMod)) should not change the value under key if the current value does not equal oldVal
>   ․ DummyAtomicKVS as AtomicKeyValue .modify(key, oldVal, newVal, cb(err, valAfterMod)) should not change the value under key if the current value does not equal oldVal
>     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)) should return version vm which is a merge of both versions v1 and v2
>   ․ MergingStateStore .merge(v1, v2[, resolve], cb(err, vm)) should return version vm which is a merge of both versions v1 and v2
>     MergingStateStore .merge(v1, v2[, resolve], cb(err, vm)) should record the merge so that further merges would work
>   ․ MergingStateStore .merge(v1, v2[, resolve], cb(err, vm)) should record the merge so that further merges would work
>     MergingStateStore .merge(v1, v2[, resolve], cb(err, vm)) should report a conflict as an error, when one occurs
>   ․ MergingStateStore .merge(v1, v2[, resolve], cb(err, vm)) should report a conflict as an error, when one occurs
>     MergingStateStore .merge(v1, v2[, resolve], cb(err, vm)) should resolve conflicts if asked to, by prioritizing v1 over v2
>   ․ MergingStateStore .merge(v1, v2[, resolve], cb(err, vm)) should resolve conflicts if asked to, by prioritizing v1 over v2
>     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
150c299
<   147 passing (3s)
---
>   148 passing (3s)