         oneOfValid = _.isString(schema) or _.isObject(schema)
         assert oneOfValid, "invalid schema definition is supplied"
         assert _.isFunction(continuation), "got invalid callback"
-        results = tv4.validateMultiple(subject, schema)
-        assert results; failure = results.valid is false
+        assert results = tv4.validateMultiple(subject, schema)
+        failure = (not results.valid?) or results.valid is no
         return continuation.bind(this) failure, results
 
     # Create new validation context for the values designated by

        noChain = "the #{context} has no valid chain method"
        assert _.isFunction(context.prototype.run), noRun
        assert _.isFunction(context.prototype.chain), noChain
        @$vcontext = context; return this

    # Given the storage with possible validation contexts appended
    # run all the validator contexts in parallel and wait for the

    # continuation routine and pass the validation results to it.
    # Continuation will recieve error indicator and results params.
    validateValues: (storage, continuation) ->
        notContinuation = "a #{continuation} is not function"
        transformer = (o) -> (c) -> o.run (e) -> c null, e
        assert _.isFunction(continuation), notContinuation
        assert _.isObject(storage), "invalid storage given"
        assert vcontexts = storage.__vcontexts__ or Object()
        transformed =  _.map _.values(vcontexts), transformer
        transformed = _.object _.keys(vcontexts), transformed
        return async.parallel transformed, (error, results) =>
            failure = _.any _.values(results), _.isObject
            assert.ifError error, "internal valdation error"
            return continuation.bind(this) failure, results
