TypeScript assert.notEqual函数代码示例

 it('should exist', () => {
   assert.notEqual(typeof localDrive._options, 'undefined');
   assert.notEqual(typeof remoteDrive._options, 'undefined');
 });

//.........这里部分代码省略.........
                    // the max height of the div
                    for (var i = 0; i < vertIndicesInLayers[divIndex].length; i++) {
                        sword.geometryData.vertices[vertIndicesInLayers[divIndex][i] * 3 + 1] = baseSectionLength + midSectionLength;
                    }
                    break;
                } else {
                    // randomly determine a height and modify the verts
                    var minDivLength = equalMidDivLength * 0.5;
                    var maxDivLength = spaceLeft - (minDivLength * (numMidDivs - Math.abs(divIndex - (numBaseDivs))));
                    var divLength =  getRandomFloat(this.randGenerator, minDivLength, maxDivLength);

                    // Change y value for all verts at this level
                    for (var i = 0; i < vertIndicesInLayers[divIndex].length; i++) {
                        sword.geometryData.vertices[vertIndicesInLayers[divIndex][i] * 3 + 1] = divLength + (midSectionLength - spaceLeft) + baseSectionLength;
                    }

                    spaceLeft = spaceLeft - divLength;
                }
            }
        }


        if (genParams.equalTipDivs) {
            for (var divIndex = numBaseDivs + numMidDivs + 1; divIndex <= totalBladeDivs; divIndex++) {
                for(var i = 0; i < vertIndicesInLayers[divIndex].length; i++) {
                    sword.geometryData.vertices[vertIndicesInLayers[divIndex][i] * 3 + 1] = (equalTipDivLength * Math.abs(divIndex - (numBaseDivs + numMidDivs))) + baseSectionLength + midSectionLength;
                }
            }
        } else {
            // We need to loop through each layer in the base and set the height
            // Space left to work with in this div
            var spaceLeft = tipSectionLength;

            // Loop through each level in the division
            for (var divIndex = numBaseDivs + numMidDivs + 1; divIndex <= totalBladeDivs; divIndex++) {

                if (divIndex == totalBladeDivs) {
                    // This is the last layer so we set thhe verts to be at
                    // the max height of the div
                    for(var i = 0; i < vertIndicesInLayers[divIndex].length; i++) {
                        sword.geometryData.vertices[vertIndicesInLayers[divIndex][i] * 3 + 1] = bladeLength;
                    }
                } else {
                    // randomly determine a height and modify the verts
                    var minDivLength = equalTipDivLength * 0.5;
                    var maxDivLength = spaceLeft - (minDivLength * (numTipDivs - Math.abs(divIndex - (numBaseDivs + numMidDivs))));
                    var divLength =  getRandomFloat(this.randGenerator, minDivLength, maxDivLength);

                    // Change y value for all verts at this level
                    for (var i = 0; i < vertIndicesInLayers[divIndex].length; i++) {
                        sword.geometryData.vertices[vertIndicesInLayers[divIndex][i] * 3 + 1] = divLength + (tipSectionLength - spaceLeft) + (baseSectionLength + midSectionLength);
                    }

                    spaceLeft = spaceLeft - divLength;
                }
            }
        }

        if (this.verbose) {
            console.log(`Vertices after height mod:\n${sword.geometryData.toString("vertex")}`);
        }

        // Place a point at the tip of the blade
        var topFaceVertIndices: number[] = SwordGenerator.getTopVertIndices(sword.geometryData.vertices);
        sword.geometryData.vertices = SwordGenerator.createBladeTip(sword.geometryData.vertices, topFaceVertIndices);

        // Ensure that the height of the blade matches the template
        for (var i = 0; i < topFaceVertIndices.length; i++) {
            Assert.equal(sword.geometryData.vertices[topFaceVertIndices[i] * 3 + 1], template.length,
                `ERROR:: Blade does not match template expected ${template.length} was ${sword.geometryData.vertices[topFaceVertIndices[i] * 3 + 1]}`);
        }

        // Check number of vertices
        Assert.notEqual(sword.geometryData.vertices.length, 0, "ERROR:: Model does not have any vertices defined");
        Assert.equal(sword.geometryData.vertices.length % 3, 0, "ERROR:: Model has the incorrect number of vertex components");

        // Check the number of triangles
        Assert.notEqual(sword.geometryData.triangles.length, "ERROR:: Model does not have any triangles defined");
        Assert.equal(sword.geometryData.triangles.length % 3, 0, "ERROR:: Model has the incorrect number of triangle components");

        // Add colors for the sword blade
        for (var i = 0; i < (sword.geometryData.vertices.length / 3); i++) {
            sword.geometryData.addColor(0.5, 0.5, 0.5);
        }

        // Check number of colors
        Assert.notEqual(sword.geometryData.colors.length, 0, "ERROR:: Model does not have any colors defined");
        Assert.equal(sword.geometryData.colors.length % 3, 0, "ERROR:: Model has the incorrect number of color components");

        // Add normals for the sword blade
        for (var i = 0; i < (sword.geometryData.vertices.length / 3); i++) {
            sword.geometryData.addNormal(1.0, 0.0, 0.0);
        }

        // Check number of normals
        Assert.notEqual(sword.geometryData.normals.length, 0, "ERROR:: Model does not have any normals defined");
        Assert.equal(sword.geometryData.normals.length % 3, 0, "ERROR:: Model has the incorrect number of normal components");

        return sword;
    }

 it("tests unstaging of second file", function () {
     doesNotThrow(() => test_repo.unstage("test2.txt"));
     assert.notEqual(test_repo.staged[1], "test2.txt",
         "failed unstaging of second file");
 });

 test("Boolean checks", () => {
     assert.equal(true, true, "true is not true");
     assert.notEqual(true, false, "true is false");
     assert.equal(false, false, "false is not false");
     assert.notEqual(false, true, "false is true");
 });

 remoteDrive.files.get({}, (e: Error) => {
   assert.notEqual(e, null);
   done();
 });

	test('register and resolve decoration type', () => {
		var s = new CodeEditorServiceImpl();
		s.registerDecorationType('example', options);
		assert.notEqual(s.resolveDecorationOptions('example', false), undefined);
	});

	test('boolean', () => {
		assert.equal(hash(true), hash(true));
		assert.notEqual(hash(true), hash(false));
	});

  @test @timeout(60000) async "suppression"() {
    const autoRest = new AutoRest(new RealFileSystem(), ResolveUri(CreateFolderUri(__dirname), "resources/literate-example/"));
    autoRest.Message.Subscribe((_, m) => m.Channel === Channel.Fatal ? console.error(m.Text) : "");

    // reference run
    await autoRest.ResetConfiguration();
    await autoRest.AddConfiguration({ "azure-arm": true });
    let numWarningsRef: number;
    {
      const messages: Message[] = [];
      const dispose = autoRest.Message.Subscribe((_, m) => { if (m.Channel == Channel.Warning) { messages.push(m) } });

      await autoRest.Process().finish;
      numWarningsRef = messages.length;

      dispose();
    }
    assert.notEqual(numWarningsRef, 0);

    // muted run
    await autoRest.ResetConfiguration();
    await autoRest.AddConfiguration({ "azure-arm": true });
    await autoRest.AddConfiguration({ directive: { suppress: ["AvoidNestedProperties", "ModelTypeIncomplete", "DescriptionMissing", "PutRequestResponseValidation"] } });
    {
      const messages: Message[] = [];
      const dispose = autoRest.Message.Subscribe((_, m) => { if (m.Channel == Channel.Warning) { messages.push(m) } });

      await autoRest.Process().finish;
      if (messages.length > 0) {
        console.log("Should have been muted but found:");
        console.log(JSON.stringify(messages, null, 2));
      }
      assert.strictEqual(messages.length, 0);

      dispose();
    }

    // makes sure that neither all nor nothing was returned
    const pickyRun = async (directive: any) => {
      await autoRest.ResetConfiguration();
      await autoRest.AddConfiguration({ "azure-arm": true });
      await autoRest.AddConfiguration({ directive: directive });
      {
        const messages: Message[] = [];
        const dispose = autoRest.Message.Subscribe((_, m) => { if (m.Channel == Channel.Warning) { messages.push(m) } });

        await autoRest.Process().finish;
        if (messages.length === 0 || messages.length === numWarningsRef) {
          console.log(JSON.stringify(messages, null, 2));
        }
        assert.notEqual(messages.length, 0);
        assert.notEqual(messages.length, numWarningsRef);

        // console.log(directive, messages.length);

        dispose();
      }
    };

    // not all types
    await pickyRun({ suppress: ["AvoidNestedProperties"] });
    // certain paths
    await pickyRun({ suppress: ["AvoidNestedProperties", "ModelTypeIncomplete", "DescriptionMissing"], where: "$..properties" });
    await pickyRun({ suppress: ["AvoidNestedProperties"], where: "$..properties.properties" });
    // multiple directives
    await pickyRun([{ suppress: ["AvoidNestedProperties"], where: "$..properties.properties" }]);
    await pickyRun([
      { suppress: ["AvoidNestedProperties"] },
      { suppress: ["ModelTypeIncomplete"] }
    ]);
    await pickyRun([
      { suppress: ["DescriptionMissing"] },
      { suppress: ["ModelTypeIncomplete"] }
    ]);
    // document
    await pickyRun({ suppress: ["AvoidNestedProperties"], where: "$..properties.properties", from: "swagger.md" });
  }

 it('should fail to convert bytes beyound ascii.', () => {
     assert.notEqual(
         readBytesToISO8859(Buffer.from(expectedStr, 'utf8')),
         expectedStr,
     );
 });