TypeScript assert.isFalse方法代码示例

			const assertDoesNotThrow = async (opts?: { shouldStartApplicatinThrow: boolean }) => {
				assert.deepEqual(logger.traceOutput, "");
				applicationManager.startApplication = async (appData: Mobile.IApplicationData) => {
					if (opts && opts.shouldStartApplicatinThrow) {
						throw error;
					}

					isStartApplicationCalled = true;
				};

				await applicationManager.tryStartApplication(applicationData);
				assert.isFalse(isStartApplicationCalled, "startApplication must not be called when there's an error.");
				assert.isTrue(logger.traceOutput.indexOf("Throw!") !== -1, "Error message must be shown in trace output.");
				assert.isTrue(logger.traceOutput.indexOf("Unable to start application") !== -1, "'Unable to start application' must be shown in trace output.");
			};

    it('recognizes valid and invalid url parameter combinations according to provided rules', ()=>{
        assert.isTrue(
            validateParameters({ studyId:'someString', sampleId:'someString' }, [ 'studyId', ['sampleId', 'caseId']]).isValid
        );

        assert.isTrue(
            validateParameters({ studyId:'someString', caseId:'someString' }, [ 'studyId', ['sampleId', 'caseId']]).isValid
        );

        assert.isFalse(
            validateParameters({ studyId:'someString', sampleId:'' }, [ 'studyId', ['sampleId', 'caseId']]).isValid,
            'non zero length string required'
        )

        assert.isFalse(
            validateParameters({ studyId:'someString', sampleId:'' }, [ 'param1', ['sampleId', 'caseId']]).isValid,
            'non zero length string required'
        )

        assert.isFalse(
            validateParameters({ sampleId:'' }, [ 'studyId', ['sampleId', 'caseId']]).isValid,
            'missing parameter recognized'
        )
    });

		return (() => {
			let fs: IFileSystem = this.testInjector.resolve("fs");
			let projectDir = path.join(tempFolder, projectName);
			let appDirectoryPath = path.join(projectDir, "app");
			let platformsDirectoryPath = path.join(projectDir, "platforms");
			let tnsProjectFilePath = path.join(projectDir, "package.json");
			let tnsModulesPath = path.join(projectDir, constants.NODE_MODULES_FOLDER_NAME, constants.TNS_CORE_MODULES_NAME);
			let packageJsonContent = fs.readJson(tnsProjectFilePath).wait();
			let options = this.testInjector.resolve("options");

			assert.isTrue(fs.exists(appDirectoryPath).wait());
			assert.isTrue(fs.exists(platformsDirectoryPath).wait());
			assert.isTrue(fs.exists(tnsProjectFilePath).wait());
			assert.isTrue(fs.exists(tnsModulesPath).wait());

			assert.isFalse(fs.isEmptyDir(appDirectoryPath).wait());
			assert.isTrue(fs.isEmptyDir(platformsDirectoryPath).wait());

			let actualAppId = packageJsonContent["nativescript"].id;
			let expectedAppId = appId;
			assert.equal(actualAppId, expectedAppId);

			let tnsCoreModulesRecord = packageJsonContent["dependencies"][constants.TNS_CORE_MODULES_NAME];
			assert.isTrue(tnsCoreModulesRecord !== null);

			let sourceDir = projectSourceDirectory || options.copyFrom;

			let expectedFiles = fs.enumerateFilesInDirectorySync(sourceDir);
			let actualFiles = fs.enumerateFilesInDirectorySync(appDirectoryPath);
			assert.isTrue(actualFiles.length >= expectedFiles.length, "Files in created project must be at least as files in app dir.");
			_.each(expectedFiles, file => {
				let relativeToProjectDir = helpers.getRelativeToRootPath(sourceDir, file);
				let filePathInApp = path.join(appDirectoryPath, relativeToProjectDir);
				assert.isTrue(fs.exists(filePathInApp).wait(), `File ${filePathInApp} does not exist.`);
			});

			// assert dependencies and devDependencies are copied from template to real project
			let sourcePackageJsonContent = fs.readJson(path.join(sourceDir, "package.json")).wait();
			let missingDeps = _.difference(_.keys(sourcePackageJsonContent.dependencies), _.keys(packageJsonContent.dependencies));
			let missingDevDeps = _.difference(_.keys(sourcePackageJsonContent.devDependencies), _.keys(packageJsonContent.devDependencies));
			assert.deepEqual(missingDeps, [], `All dependencies from template must be copied to project's package.json. Missing ones are: ${missingDeps.join(", ")}.`);
			assert.deepEqual(missingDevDeps, [], `All devDependencies from template must be copied to project's package.json. Missing ones are: ${missingDevDeps.join(", ")}.`);

			// assert App_Resources are prepared correctly
			let appResourcesDir = path.join(appDirectoryPath, "App_Resources");
			let appResourcesContents = fs.readDirectory(appResourcesDir).wait();
			assert.deepEqual(appResourcesContents, ["Android", "iOS"], "Project's app/App_Resources must contain Android and iOS directories.");
		}).future<void>()();

 it("should verify IsOffline", function() {
     let reason: any = { code: "ENOENT" };
     assert.isTrue(Utils.IsOffline(reason));
     reason = { code: "ENOTFOUND" };
     assert.isTrue(Utils.IsOffline(reason));
     reason = { code: "EAI_AGAIN" };
     assert.isTrue(Utils.IsOffline(reason));
     let reason2: any = { statusCode: "ENOENT" };
     assert.isTrue(Utils.IsOffline(reason2));
     reason2 = { statusCode: "ENOTFOUND" };
     assert.isTrue(Utils.IsOffline(reason2));
     reason2 = { statusCode: "EAI_AGAIN" };
     assert.isTrue(Utils.IsOffline(reason2));
     reason = { code: "404" };
     assert.isFalse(Utils.IsOffline(reason));
 });

    it('should trigger gpio on updating schedule', function () {
        const clock = sinon.useFakeTimers(new Date(2016, 8, 20, 10, 0, 0).getTime());
        const gpioController = new MockGpioController();
        const controller = new ScheduleController(gpioController, new Schedule());

        assert.equal(gpioController.state, false);

        const schedule = new Schedule();
        schedule.includeHour(10);
        controller.updateSchedule(schedule);
        assert.equal(gpioController.state, true);

        clock.tick(61 * 60 * 1000);
        assert.isFalse(gpioController.state);
        clock.restore();
    });

    it("should verify TeamServices origin remote", function() {
        const repoName: string = "gitrepo";
        const repoPath: string = path.join(__dirname, TEST_REPOS_FOLDER, repoName, DOT_GIT_FOLDER);
        const gc: GitContext = new GitContext(repoPath, DOT_GIT_FOLDER);

        assert.equal(gc.CurrentBranch, "jeyou/approved-pr");
        assert.equal(gc.CurrentRef, "refs/heads/jeyou/approved-pr");
        assert.isFalse(gc.IsSsh);
        assert.isTrue(gc.IsTeamFoundation);
        assert.isTrue(gc.IsTeamServices);
        assert.equal(gc.RemoteUrl, "https://account.visualstudio.com/DefaultCollection/teamproject/_git/gitrepo");
        assert.equal(gc.RepositoryParentFolder, path.join(__dirname, TEST_REPOS_FOLDER, repoName));
        assert.equal(gc.RepoFolder, repoPath);
        assert.isUndefined(gc.TeamProjectName); //For Git repositories, teamproject comes from vsts/info (not remoteUrl)
        assert.equal(gc.Type, RepositoryType.GIT);
    });

			const assertIsCalled = async (methodName: string): Promise<void> => {
				const instance: any = new InvokeBeforeDecoratorsTest();
				assert.isFalse(instance.isInvokeBeforeMethodCalled);
				const expectedResult = 1;
				assert.deepEqual(await instance[methodName](expectedResult), expectedResult);
				assert.isTrue(instance.isInvokeBeforeMethodCalled);

				instance.invokedBeforeCount = 0;

				for (let iteration = 0; iteration < 10; iteration++) {
					instance.isInvokeBeforeMethodCalled = false;
					assert.deepEqual(await instance[methodName](iteration), iteration);
					assert.isTrue(instance.isInvokeBeforeMethodCalled);
					assert.deepEqual(instance.invokedBeforeCount, iteration + 1);
				}
			};

  test('calling dependencies() starts analysis', () => {
    const config = new ProjectConfig({
      root: `test-fixtures/analyzer-data`,
      entrypoint: 'entrypoint.html',
      fragments: [
        'a.html',
        'b.html',
      ],
      sources: ['a.html', 'b.html', 'entrypoint.html'],
    });

    const analyzer = new BuildAnalyzer(config);
    assert.isFalse(analyzer.started);
    analyzer.dependencies().pipe(new NoopStream());
    assert.isTrue(analyzer.started);
  });

 PRIMITIVE_MARKS.forEach((mark) => {
   const spec = {
     "data": {"url": "data/barley.json"},
     "mark": mark,
     "encoding": {
       "x": {"aggregate": "sum", "field": "yield", "type": "quantitative"},
       "y": {"field": "variety", "type": "nominal"},
       "color": {"aggregate": "count", "field": "*", "type": "quantitative"}
     },
     "config": {
       "mark": {"stacked": stacked}
     }
   };
   assert.isNull(stack(spec.mark, spec.encoding as any, spec.config));
   assert.isFalse(isStacked(spec as any));
 });

 it("should verify 'collection in the domain' case insensitivity in repositoryInfo to RepositoryInfo constructor for azure", function() {
     let repoInfo: RepositoryInfo = new RepositoryInfo("https://test.azure.com/account/teamproject/_git/repositoryName");
     assert.equal(repoInfo.Host, "test.azure.com");
     assert.equal(repoInfo.Account, "account");
     assert.isTrue(repoInfo.IsTeamServices);
     assert.isTrue(repoInfo.IsTeamFoundation);
     // To properly test 'collection in the domain' case insensitivity, ensure the collection name is a different case than the account (e.g., 'ACCOUNT' versus 'account')
     const repositoryInfo: any = {
        "serverUrl": "https://test.azure.com",
        "collection": {
           "id": "5e082e28-e8b2-4314-9200-629619e91098",
           "name": "ACCOUNT",
           "url": "https://test.azure.com/account/_apis/projectCollections/5e082e28-e8b2-4314-9200-629619e91098"
        },
        "repository": {
           "id": "cc015c05-de20-4e3f-b3bc-3662b6bc0e42",
           "name": "repositoryName",
           "url": "https://test.azure.com/account/_apis/git/repositories/cc015c05-de20-4e3f-b3bc-3662b6bc0e42",
           "project": {
              "id": "ecbf2301-0e62-4b0d-a12d-1992f2ea95a8",
              "name": "teamproject",
              "description": "Our team project",
              "url": "https://test.azure.com/account/_apis/projects/ecbf2301-0e62-4b0d-a12d-1992f2ea95a8",
              "state": 1,
              "revision": 14558
           },
           "remoteUrl": "https://test.azure.com/account/teamproject/_git/repositoryName"
        }
     };
     repoInfo = new RepositoryInfo(repositoryInfo);
     assert.equal(repoInfo.Host, "test.azure.com");
     assert.equal(repoInfo.Account, "account");
     assert.equal(repoInfo.AccountUrl, "https://test.azure.com/account");
     assert.equal(repoInfo.CollectionId, "5e082e28-e8b2-4314-9200-629619e91098");
     // CollectionName should maintain the same case as in the JSON
     assert.equal(repoInfo.CollectionName, "ACCOUNT");
     // CollectionUrl should not contain the collection name since this is an azure-backed/test.azure.com account & collection name are the same (case insensitive)
     assert.equal(repoInfo.CollectionUrl, "https://test.azure.com/account");
     assert.isTrue(repoInfo.IsTeamServices);
     assert.isTrue(repoInfo.IsTeamFoundation);
     assert.isFalse(repoInfo.IsTeamFoundationServer);
     assert.equal(repoInfo.RepositoryId, "cc015c05-de20-4e3f-b3bc-3662b6bc0e42");
     assert.equal(repoInfo.RepositoryName, "repositoryName");
     assert.equal(repoInfo.RepositoryUrl, "https://test.azure.com/account/teamproject/_git/repositoryName");
     assert.equal(repoInfo.TeamProject, "teamproject");
     assert.equal(repoInfo.TeamProjectUrl, "https://test.azure.com/account/teamproject");
 });