How to use the notEqual function from assert

index.js

GitHub: dependents/node-precinct

184
185
186
187
188
189
190
191
192
193
});

it('returns the dependencies for the given filepath', () => {
  assert.notEqual(precinct.paperwork(path.join(__dirname, '/fixtures/es6.js')).length, 0);
  assert.notEqual(precinct.paperwork(path.join(__dirname, '/fixtures/styles.scss')).length, 0);
  assert.notEqual(precinct.paperwork(path.join(__dirname, '/fixtures/typescript.ts')).length, 0);
  assert.notEqual(precinct.paperwork(path.join(__dirname, '/fixtures/styles.css')).length, 0);
});

it('throws if the file cannot be found', () => {

39

177

0

+ 9 other calls in file

test-AlexaSmartHomeV3-DeviceManager.js

GitHub: ioBroker/ioBroker.iot

33
34
35
36
37
38
39
40
41
42

stateChange = null;

await deviceManager.handleAlexaEvent(event);

assert.notEqual(stateChange, null);
assert.equal(stateChange.context.properties.length, 1);
assert.equal(stateChange.context.properties[0].name, 'brightness');

assert.equal(stateChange.event.payload.change.properties[0].name, 'powerState');

21

65

0

test-AlexaSmartHomeV3-Controls.js

GitHub: ioBroker/ioBroker.iot

52
53
54
55
56
57
58
59
60
61
describe('Dimmer', async function () {
    it('Dimmer respects values range on setting brightness', async function () {

        const event = await helpers.getSample('BrightnessController/BrightnessController.SetBrightness.request.json')
        const d = dimmerDeviceManager.endpointById(event.directive.endpoint.endpointId)
        assert.notEqual(d, undefined)
        assert.equal(d instanceof Device, true)
        const response = await d.handle(event)
        assert.equal(response.context.properties[0].namespace, "Alexa.BrightnessController", "Properties Namespace!");
        assert.equal(response.context.properties[0].name, "brightness", "Properties Name!");

21

65

0

fernetBrowser.js

GitHub: pizzapanther/Super-Neutron-Drive

368
369
370
371
372
373
374
375
376
377
378
379
assert.equal = function equal(actual, expected, message) {
  if (actual != expected) fail(actual, expected, message, '==', assert.equal);
};


// 6. The non-equality assertion tests for whether two objects are not equal
// with != assert.notEqual(actual, expected, message_opt);


assert.notEqual = function notEqual(actual, expected, message) {
  if (actual == expected) {
    fail(actual, expected, message, '!=', assert.notEqual);

11

21

6

metrics.spec.js

GitHub: NucleoidJS/Nucleoid

7
8
9
10
11
12
13
14
15


  it("retrieves memory details", async () => {
    const res = await request(terminal).get("/metrics").send();
    equal(res.status, 200);
    notEqual(res.body.free, undefined);
    notEqual(res.body.total, undefined);
  });
});

7

448

9

+ 3 other calls in file

nucleoid.spec.js

GitHub: NucleoidJS/Nucleoid

2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
});

it("returns object itself in object creation", () => {
  nucleoid.run("class Test { constructor ( prop ) { this.prop = prop } }");
  const object = nucleoid.run("new Test ( 123 )");
  notEqual(object.id, null);
  equal(object.prop, 123);
});

it("accepts JS function", () => {

7

448

9

logs.spec.js

GitHub: NucleoidJS/Nucleoid

19
20
21
22
23
24
25
26
    equal(res2.status, 200);
    equal(logs2.length, 1);
    equal(logs2[0].s, "'Hello'");
    notEqual(logs2[0].t, undefined);
    equal(logs2[0].r, "Hello");
    notEqual(logs2[0].d, undefined);
  });
});

7

448

9

+ 3 other calls in file

user_data_manager_test.js

GitHub: Educating-Autistic-Software-Engineers/collaborationStation

73
74
75
76
77
78
79
80
81
82
  test('Markers have unique colors and are registered.', async () => {
    const positionUpdate1 = {workspaceId: 'mockId1', position: this.position};
    const positionUpdate2 = {workspaceId: 'mockId2', position: this.position};
    const marker1 = this.userDataManager.createMarker_(positionUpdate1);
    const marker2 = this.userDataManager.createMarker_(positionUpdate2);
    assert.notEqual(marker1.colour, marker2.colour);
    assert.deepEqual(this.BlocklyMarkerManager.getMarker('mockId1'), marker1);
    assert.deepEqual(this.BlocklyMarkerManager.getMarker('mockId2'), marker2);
  });
});

0

1

0

topics.js

GitHub: HomieOmie/nodebb-temp

1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
            topics.getUnreadTopics({ cid: 0, uid: uid, start: 0, stop: -1, filter: '' }, done);
        },
        function (results, done) {
            const { topics } = results;
            const tids = topics.map(topic => topic.tid);
            assert.notEqual(tids.indexOf(newTid), -1, 'The topic did not appear in the unread list.');
            done();
        },
    ], done);
});

0

0

0

+ 3 other calls in file

utils.js

GitHub: HomieOmie/nodebb-temp

103
104
105
106
107
108
109
110
111
112
    it('return unique random value every time', () => {
        delete require.cache[require.resolve('../src/utils')];
        const { generateUUID } = require('../src/utils');
        const uuid1 = generateUUID();
        const uuid2 = generateUUID();
        assert.notEqual(uuid1, uuid2, 'matches');
    });
});

describe('cleanUpTag', () => {

0

0

0

sets.js

GitHub: HomieOmie/nodebb-temp

49
50
51
52
53
54
55
56
57
58
it('should return a set with all elements', (done) => {
    db.getSetMembers('testSet2', (err, set) => {
        assert.equal(err, null);
        assert.equal(set.length, 5);
        set.forEach((value) => {
            assert.notEqual(['1', '2', '3', '4', '5'].indexOf(value), -1);
        });

        done();
    });

0

0

0

hash.js

GitHub: HomieOmie/nodebb-temp

385
386
387
388
389
390
391
392
393
394
    db.getObjectKeys('hashTestObject', function (err, keys) {
        assert.equal(err, null);
        assert.equal(arguments.length, 2);
        assert.equal(Array.isArray(keys) && keys.length === 3, true);
        keys.forEach((key) => {
            assert.notEqual(['name', 'lastname', 'age'].indexOf(key), -1);
        });
        done();
    });
});

0

0

0

.issue-guidelines.js

GitHub: naily26/sistem-penerbitan-rekom-dishub

25
26
27
28
29
30
31
32
33
34
'should always be made against -wip branches': function (pull) {
    assert.ok(/\-wip$/.test(pull.base.ref))
},

'should always be made from feature branches': function (pull) {
    assert.notEqual(pull.head.ref, 'master')
},

'should always include a unit test if changing js files': function (pull) {
    var hasJS    = false

0

0

0

spec.snapshot-worker.js

GitHub: recordwright/recordwright

48
49
50
51
52
53
54
55
56
57
        for (let i = 0; i < 50; i++) {
            window.takePictureSnapshot('hello world')
        }
    })
    await waitTillSnapshotQueueCleared(recordManager)
    assert.notEqual(recordManager.browserControl.activeSnapshotWorker.records.length, 50)

}).timeout(10000000)
it('should take screenshot in case the page is changed', async () => {
    await recordManager.start({ headless: true })

0

0

0

spec.operation-functions.js

GitHub: recordwright/recordwright

42
43
44
45
46
47
48
49
50
51
let btnGetStarted = await recordManager.browserControl.activePage.locator(locator['input'].locator)
await new Promise(resolve => setTimeout(resolve, 50))
await callInBrowserSpy(btnGetStarted)
await new Promise(resolve => setTimeout(resolve, 50))
let activeFunc = recordManager.operation.activeFunctionList.find(item => item.name == 'click1')
assert.notEqual(activeFunc, null, 'function "click1" should be visible when item is there')

//remove target element
await btnGetStarted.evaluate(item => {
    item.remove()

0

0

0

+ 2 other calls in file

test-assert.js

GitHub: vladimir-andreevich/node.js-14-windows-7

510
511
512
513
514
515
516
517
518
519
{
  const a = require('assert');
  const assert = require('assert').strict;
  /* eslint-disable no-restricted-properties */
  assert.throws(() => assert.equal(1, true), assert.AssertionError);
  assert.notEqual(0, false);
  assert.throws(() => assert.deepEqual(1, true), assert.AssertionError);
  assert.notDeepEqual(0, false);
  assert.equal(assert.strict, assert.strict.strict);
  assert.equal(assert.equal, assert.strictEqual);

0

0

0

findItemsOver20.test.js

GitHub: Unalo/bootcamp-terminal-tests

10
11
12
13
14
15
16
17
18
19
      {name : 'apples', qty : 3}
    ]
    ,20),2);
});
it('Expected results not equal to the given threshold  ' , function(){
  assert.notEqual(
    [
      {name : 'apples', qty : 10},
      {name : 'pears', qty : 3},
      {name : 'bananas', qty : 7},

0

0

0