How to use better-assert - 10 common examples

function dumpReferenceDescription(addressSpace, referenceDescription) {
  assert(addressSpace.constructor.name === "AddressSpace");
    // assert(addressSpace instanceof AddressSpace);
  assert(referenceDescription.referenceTypeId); // must be known;

  console.log("referenceDescription".red);
  console.log("    referenceTypeId : ", referenceTypeToString(addressSpace, referenceDescription.referenceTypeId));
  console.log("    isForward       : ", referenceDescription.isForward ? "true" : "false");
  console.log("    nodeId          : ", nodeIdInfo(addressSpace, referenceDescription.nodeId));
  console.log("    browseName      : ", referenceDescription.browseName.toString());
  console.log("    nodeClass       : ", referenceDescription.nodeClass.toString());
  console.log("    typeDefinition  : ", nodeIdInfo(addressSpace, referenceDescription.typeDefinition));
}
function dumpReferenceDescriptions(addressSpace, referenceDescriptions) {

function hasChildWithBrowseName(parent,childBrowseName) {
    assert(parent instanceof BaseNode);
    // extract children
    const children = parent.findReferencesAsObject("HasChild", true);

    return children.filter(child => child.browseName.name.toString()  === childBrowseName).length > 0;
}

function _install_TwoStateVariable_machinery(node,options) {
    assert(node.dataTypeObj.browseName.toString() === "LocalizedText");
    assert(node.minimumSamplingInterval === 0);
    assert(node.typeDefinitionObj.browseName.toString() === "TwoStateVariableType");
    assert(node.dataTypeObj.browseName.toString() === "LocalizedText");
    assert(node.hasOwnProperty("valueRank") && (node.valueRank === -1 || node.valueRank === 0));
    assert(node.hasOwnProperty("id"));
    options = options || {};
    // promote node into a UATwoStateVariable
    Object.setPrototypeOf(node, UATwoStateVariable.prototype);
    node.initialize(options);
}

function _install_condition_variable_type(node) {
    // from spec 1.03 : 5.3 condition variables
    // However,  a change in their value is considered important and supposed to trigger
    // an Event Notification. These information elements are called ConditionVariables.
    node.sourceTimestamp.accessLevel = makeAccessLevel("CurrentRead");
    node.accessLevel = makeAccessLevel("CurrentRead");

    // from spec 1.03 : 5.3 condition variables
    // a condition VariableType has a sourceTimeStamp exposed property
    // SourceTimestamp indicates the time of the last change of the Value of this ConditionVariable.
    // It shall be the same time that would be returned from the Read Service inside the DataValue
    // structure for the ConditionVariable Value Attribute.

    assert(node.typeDefinitionObj.browseName.toString() === "ConditionVariableType");
    assert(node.sourceTimestamp.browseName.toString() == "SourceTimestamp");
    node.on("value_changed", _update_sourceTimestamp);
}

it("Counter test, not nested Obj", () => {
    let action = { type: "sub", status: "success", count: 1 };
    let newCounter = reducers(counter, action);
    assert(newCounter.count === 0, "Problem in status test of success");
    action = { type: "sub", status: "error", count: 1 };
    newCounter = reducers(counter, action);
    assert(newCounter.count === 0.5, "Problem in status test of error");
  });
});

it('reports undefined when given no points', function(){
        var tdigest = new TDigest();
        var p = [0, 0.5, 1.0];
        assert.deepEqual(tdigest.percentile(0.5), undefined);
        assert.deepEqual(tdigest.percentile(p), [undefined,undefined,undefined]);
    });
    it('from a single point', function(){

it('preserves a discrete distribution', function(){
        var digest = new Digest(); 
        var i, ntimes = 1000, nvals=100;
        for (i = 0 ; i < ntimes ; i++) {
            for (j = 0 ; j < nvals ; j++) {
                digest.push(j);
            }
        }
        var result = digest.toArray();
        for (i = 0 ; i < nvals ; i++) {
            assert.deepEqual(result[i], {mean:i, n:ntimes});
        }
    }); 
    it('compresses a continuous distribution', function(){

it('consumes nonnumeric points', function(){
        var tdigest = new TDigest(false); 
        tdigest.push("foo");
        tdigest.push("bar");
        tdigest.push("baz");
        tdigest.push("foo");
        tdigest.push("freen");
        tdigest.push("bork");
        tdigest.push("bork");
        tdigest.push("bork");
        tdigest.push("books");
        var points = tdigest.toArray();
        assert.deepEqual(points, [
            {mean:"bar", n:1},
            {mean:"baz", n:1},
            {mean:"books", n:1},
            {mean:"bork", n:3}, 
            {mean:"foo", n:2},
            {mean:"freen", n:1},
        ]);
    });
    it('consumes same-valued points into a single point', function(){

getFolderElementByName(browseName) {
    assert(typeof browseName === "string");
    const elements = this.getFolderElements();
    const select = elements.filter(c => c.browseName.toString() === browseName);
    return select.length === 1 ? select[0] : null;
  }

function dumpReferenceDescriptions(addressSpace, referenceDescriptions) {
  assert(addressSpace);
  assert(addressSpace.constructor.name === "AddressSpace");
  assert(_.isArray(referenceDescriptions));
  referenceDescriptions.forEach((r) => {
    dumpReferenceDescription(addressSpace, r);
  });
}
export { dumpReferenceDescription };