web/coverage.ts - infra/gerrit-plugins/code-coverage - Git at Google

 /** @license
  * Copyright 2020 The Chromium Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 import {PluginApi} from '@gerritcodereview/typescript-api/plugin';
 import {
   CoverageRange,
   CoverageType,
   Side,
 } from '@gerritcodereview/typescript-api/diff';
 import {
   Category,
   CheckResult,
   FetchResponse,
   ResponseCode,
   RunStatus,
 } from '@gerritcodereview/typescript-api/checks';
 import {
   ChangeInfo,
   RevisionInfo,
 } from '@gerritcodereview/typescript-api/rest-api';

 // Url suffix of the code coverage service API from which to fetch per-cl
 // coverage data.
 const COVERAGE_SERVICE_ENDPOINT_SUFFIX = '/coverage/api/coverage-data';

 // The gob coverage host which is used to process internal project.
 const GOB_COVERAGE_HOST = 'https://gob-coverage.googleplex.com';

 // The chromium coverage host which is used to process external project.
 const CHROMIUM_COVERAGE_HOST = 'https://findit-for-me.appspot.com';

 // Dict of gerrit review host and corresponding code coverage service host
 // from which to fetch per-cl coverage data.
 const GERRIT_TO_COVERAGE_HOST: {[host: string]: string} = {
   'chromium-review.git.corp.google.com': CHROMIUM_COVERAGE_HOST,
   'chromium-review.googlesource.com': CHROMIUM_COVERAGE_HOST,
   'libassistant-internal-review.git.corp.google.com': GOB_COVERAGE_HOST,
   'libassistant-internal-review.googlesource.com': GOB_COVERAGE_HOST,
 };

 // Used to identify host prefixes that should be stripped. This is needed
 // so that the plugin can work in different environments, such as 'canary-'.
 const HOST_PREFIXES = ['canary-', 'polymer1-', 'polymer2-'];

 // Bar for low coverage warning,
 const OVERALL_LOW_COVERAGE_WARNING_BAR = 70;

 const LOW_COVERAGE_REASON_PREFIXES = [
   'TRIVIAL_CHANGE', 'TESTS_ARE_DISABLED', 'TESTS_IN_SEPARATE_CL',
   'HARD_TO_TEST', 'COVERAGE_UNDERREPORTED', 'LARGE_SCALE_REFACTOR',
   'EXPERIMENTAL_CODE', 'OTHER'
 ]

 declare interface CoverageConfig {
   project: string; // Used to validate/invalidate the cache.
   // Used to indicate an async fetch of per-project configuration
   configPromise: Promise<{enabled: boolean}> | null;
 }

 declare interface CoverageChangeInfo {
   host: string;
   project: string;
   changeNum: number;
   patchNum: number | undefined;
 }
 /**
  * Description of Code coverage for a file.
  *
  * @param absolute Coverage percentage of all lines.
  * @param incremental Coverage percentages of added lines.
  * @param absolute_unit_tests Coverage percentage of all lines of unittests.
  * @param incremental_unit_tests  Coverage percentages of added unitetest lines.
  */
 export declare interface PercentageData {
   absolute?: number;
   incremental?: number;
   absolute_unit_tests?: number;
   incremental_unit_tests?: number;
 }

 declare interface CoverageData {
   changeInfo: CoverageChangeInfo;
   rangesPromise: Promise<{[path: string]: CoverageRange[]} | null>;
   percentagesPromise: Promise<{[path: string]: PercentageData} | null>;
 }

 declare interface LinesCoverage {
   line: number;
   count: number;
 }

 declare interface PctCoverage {
   covered: number;
   total: number;
 }

 declare interface CoverageFilesResponse {
   path: string;
   lines?: LinesCoverage[];
   absolute_coverage?: PctCoverage;
   incremental_coverage?: PctCoverage;
   absolute_unit_tests_coverage?: PctCoverage;
   incremental_unit_tests_coverage?: PctCoverage;
 }

 /**
  * JSON data of coverage.
  *
  * @param data Coverage, keyed by file
  */
 export declare interface CoverageResponse {
   data: {files: CoverageFilesResponse[]};
 }

 /**
  * Provides APIs to fetch and cache coverage data.
  */
 export class CoverageClient {
   plugin: PluginApi;

   coverageConfig: CoverageConfig | null;

   coverageData: CoverageData | null;

   constructor(plugin: PluginApi) {
     this.provideCoverageRanges = this.provideCoverageRanges.bind(this);
     this.prefetchCoverageRanges = this.prefetchCoverageRanges.bind(this);
     this.provideCoveragePercentages =
       this.provideCoveragePercentages.bind(this);

     this.plugin = plugin;

     this.coverageConfig = null;
     this.coverageData = null;
   }

   /**
    * Gets the normalized host name.
    *
    * @param host The host name of the window location.
    */
   getNormalizedHost(host: string): string {
     for (const prefix of HOST_PREFIXES) {
       if (host.startsWith(prefix)) {
         host = host.substring(prefix.length);
         break;
       }
     }

     return host;
   }

   /**
    * Parses project name from the path name.
    *
    * The path name is expected to be in one of the following forms:
    * '/c/chromium/src/+/1369646'
    * '/c/chromium/src/+/1369646/3'
    * '/c/chromium/src/+/1369646/3/base/base/test.cc'
    *
    * @param pathName The path name of the window location.
    * @return Returns current project such as chromium/src if the url
    *     is valid, otherwise, returns null.
    */
   parseProjectFromPathName(pathName: string): string {
     if (!pathName.startsWith('/c/')) {
       throw new Error(`${pathName} is expected to start with "/c/"`);
     }

     const indexEnd = pathName.indexOf('/+');
     if (indexEnd === -1) {
       throw new Error(`${pathName} is expected to contain "/+"`);
     }

     return pathName.substring(3, indexEnd);
   }

   /**
    * Fetches code coverage data from coverage service for a patchset.
    * The value of 'incremental_coverage' is null if there are no added lines.
    */
   async fetchCoverageJsonData(
     changeInfo: CoverageChangeInfo,
     kind: string
   ): Promise<CoverageResponse> {
     if (kind !== 'lines' && kind !== 'percentages') {
       throw new Error('Kind is expected to be either "lines" or "percentages"');
     }
     if (changeInfo.patchNum === undefined) {
       throw new Error('Patch number is undefined, cannot get coverage data');
     }
     const params = new URLSearchParams({
       // Only googlesource hosts are supported.
       host: changeInfo.host.replace('git.corp.google', 'googlesource'),
       project: changeInfo.project,
       change: changeInfo.changeNum.toString(),
       patchset: changeInfo.patchNum.toString(),
       type: kind,
       format: 'json',
       concise: '1',
     });

     let coverageHost = GERRIT_TO_COVERAGE_HOST[changeInfo.host];
     // If the host is not found, use CHROMIUM_COVERAGE_HOST by default.
     if (!coverageHost) {
       coverageHost = CHROMIUM_COVERAGE_HOST;
     }
     const endpoint = coverageHost + COVERAGE_SERVICE_ENDPOINT_SUFFIX;
     const url = `${endpoint}?${params.toString()}`;
     const response = await fetch(url);
     const responseJson = await response.json();
     if (
       response.status === 400 &&
       responseJson.is_project_supported === false
     ) {
       throw new Error(
         `"${changeInfo.project}" project is not supported for code coverage`
       );
     }

     if (response.status === 500 && responseJson.is_service_enabled === false) {
       throw new Error('Code coverage service is temporarily disabled');
     }

     if (!response.ok) {
       throw new Error(
         `Request code coverage data returned http ${response.status}`
       );
     }

     return responseJson;
   }

   /**
    * Converts the JSON response to coverage ranges needed by coverage layer.
    *
    * @param responseJson The JSON response returned from coverage
    *     service.
    * @return Returns an object whose properties are file paths and
    *     corresponding values are a list of coverage ranges if the JSON
    *     response has valid format, otherwise, returns null.
    */
   convertResponseJsonToCoverageRanges(responseJson: CoverageResponse): {
     [path: string]: CoverageRange[];
   } {
     if (!responseJson.data) {
       throw new Error(
         'Invalid coverage lines response format. Expecting "data" property'
       );
     }

     const responseData = responseJson.data;
     if (!responseData.files) {
       throw new Error(
         'Invalid coverage lines response format. Expecting "files" property'
       );
     }

     const responseFiles = responseData.files;
     const coverageRanges: {[path: string]: CoverageRange[]} = {};

     for (let i = 0; i < responseFiles.length; i++) {
       const responseFile = responseFiles[i];
       if (!responseFile.path || !responseFile.lines) {
         throw new Error(
           'Invalid coverage lines response format. Expecting ' +
             '"path" and "lines" properties'
         );
       }

       coverageRanges[responseFile.path] = [];
       const responseLines = responseFile.lines;
       responseLines.sort((a, b) => (a.line > b.line ? 1 : -1));
       let startLine = -1;
       let endLine = -1;
       let isCovered = null;
       for (let j = 0; j < responseLines.length; j++) {
         const responseLine = responseLines[j];
         if (!responseLine.line || responseLine.count === null) {
           throw new Error(
             'Invalid coverage lines response format. ' +
               'Expecting "line" and "count" properties'
           );
         }

         if (
           startLine !== -1 &&
           responseLine.line === endLine + 1 &&
           isCovered === responseLine.count > 0
         ) {
           endLine += 1;
           continue;
         }

         if (startLine !== -1) {
           coverageRanges[responseFile.path].push({
             side: Side.RIGHT,
             type: isCovered ? CoverageType.COVERED : CoverageType.NOT_COVERED,
             code_range: {
               start_line: startLine,
               end_line: endLine,
             },
           });
         }

         startLine = responseLine.line;
         endLine = startLine;
         isCovered = responseLine.count > 0;
       }

       if (startLine !== -1) {
         coverageRanges[responseFile.path].push({
           side: Side.RIGHT,
           type: isCovered ? CoverageType.COVERED : CoverageType.NOT_COVERED,
           code_range: {
             start_line: startLine,
             end_line: endLine,
           },
         });
       }
     }

     return coverageRanges;
   }

   /**
    * Fetches code coverage ranges from coverage service for a patchset.
    *
    * @param changeInfo Has host, project, changeNum and patchNum.
    * @return Resolves to a map of files to coverage ranges if the
    *     coverage ata is successfully retrieved and parsed, otherwise,
    *     resolves to null.
    */
   async fetchCoverageRanges(
     changeInfo: CoverageChangeInfo
   ): Promise<{[path: string]: CoverageRange[]}> {
     const responseJson = await this.fetchCoverageJsonData(changeInfo, 'lines');
     return this.convertResponseJsonToCoverageRanges(responseJson);
   }

   /**
    * Converts the JSON response to coverage percentages.
    *
    * @param responseJson The JSON response returned from coverage
    *     service.
    * @return Returns an object whose properties are file paths and
    *     corresponding values are objects representing absolute and
    *     incremental coverage percentages if the JSON response has valid
    *     format, otherwise, returns null.
    */
   convertResponseJsonToCoveragePercentages(responseJson: CoverageResponse): {
     [path: string]: PercentageData;
   } {
     if (!responseJson.data) {
       throw new Error(
         'Invalid coverage percentages response format. ' +
           'Expecting "data" property'
       );
     }

     const responseData = responseJson.data;
     if (!responseData.files) {
       throw new Error(
         'Invalid coverage percentages response format. ' +
           'Expecting "files" property'
       );
     }

     const coveragePercentages: {[path: string]: PercentageData} = {};
     for (const responseFile of responseData.files) {
       // TODO(crbug/1424854): Also check for absolute coverage
       if (!responseFile.path) {
         throw new Error(
           'Invalid coverage percentages response format. ' +
             'Expecting "path" property'
         );
       }

       const fileCov: PercentageData = {};

       if (responseFile.absolute_coverage) {
         fileCov.absolute = Math.round(
           (responseFile.absolute_coverage.covered * 100) /
             responseFile.absolute_coverage.total
         );
       }
       if (responseFile.incremental_coverage) {
         fileCov.incremental = Math.round(
           (responseFile.incremental_coverage.covered * 100) /
             responseFile.incremental_coverage.total
         );
       }
       if (responseFile.absolute_unit_tests_coverage) {
         fileCov.absolute_unit_tests = Math.round(
           (responseFile.absolute_unit_tests_coverage.covered * 100) /
             responseFile.absolute_unit_tests_coverage.total
         );
       }
       if (responseFile.incremental_unit_tests_coverage) {
         fileCov.incremental_unit_tests = Math.round(
           (responseFile.incremental_unit_tests_coverage.covered * 100) /
             responseFile.incremental_unit_tests_coverage.total
         );
       }

       coveragePercentages[responseFile.path] = fileCov;
     }

     return coveragePercentages;
   }

   /**
    * Fetches code coverage percentages from coverage service for a patchset.
    *
    * @param changeInfo Has host, project, changeNum and patchNum.
    * @return Resolves to a map of files to coverage percentages if
    *     coverage data is successfully retrieved and parsed, otherwise,
    *     resolves to null.
    */
   async fetchCoveragePercentages(
     changeInfo: CoverageChangeInfo
   ): Promise<{[path: string]: PercentageData}> {
     const responseJson = await this.fetchCoverageJsonData(
       changeInfo,
       'percentages'
     );
     return this.convertResponseJsonToCoveragePercentages(responseJson);
   }

   /**
    * Fetches code coverage ranges from coverage service for a patchset.
    *
    * @param changeInfo Has host, project, changeNum and patchNum.
    */
   updateCoverageDataIfNecessary(changeInfo: CoverageChangeInfo) {
     if (
       changeInfo.patchNum === undefined ||
       isNaN(changeInfo.changeNum) ||
       isNaN(changeInfo.patchNum) ||
       changeInfo.changeNum <= 0 ||
       changeInfo.patchNum <= 0
     ) {
       return;
     }

     if (
       !this.coverageData ||
       JSON.stringify(changeInfo) !==
         JSON.stringify(this.coverageData.changeInfo)
     ) {
       this.coverageData = {
         changeInfo,
         rangesPromise: this.fetchCoverageRanges(changeInfo),
         percentagesPromise: this.fetchCoveragePercentages(changeInfo),
       };
       this.coverageData.rangesPromise.catch(error => {
         console.warn(error);
       });
       this.coverageData.percentagesPromise.catch(error => {
         console.warn(error);
       });
     }
   }

   /**
    * Provides code coverage ranges for a file of a patchset.
    *
    * @param changeNum The change number of the patchset.
    * @param path The relative path to the file.
    * @param basePatchNum The patchset number of the base patchset.
    * @param patchNum The patchset number of the patchset.
    * @return Returns a list of coverage ranges. On error, it logs the
    *     error and returns null/undefined.
    */
   async provideCoverageRanges(
     changeNum: number,
     path: string,
     basePatchNum: number | undefined,
     patchNum: number | undefined
   ): Promise<CoverageRange[] | undefined> {
     const changeInfo: CoverageChangeInfo = {
       host: this.getNormalizedHost(window.location.host),
       project: this.parseProjectFromPathName(window.location.pathname),
       changeNum,
       patchNum,
     };
     this.updateCoverageDataIfNecessary(changeInfo);
     try {
       if (this.coverageData) {
         const coverageRanges = await this.coverageData.rangesPromise;
         if (coverageRanges) {
           return coverageRanges[path] || [];
         }
         return [];
       } else {
         return undefined;
       }
     } catch (error: unknown) {
       console.info(error);
       return undefined;
     }
   }

   /**
    * Prefetch coverage ranges.
    *
    * This method is supposed to be triggered by the 'showchange' event.
    *
    * @param change Info of the current change.
    * @param revision Info of the current revision.
    */
   prefetchCoverageRanges(change: ChangeInfo, revision: RevisionInfo) {
     let patchNum = NaN;
     if (typeof revision._number === 'number') {
       patchNum = revision._number;
     }
     const changeInfo: CoverageChangeInfo = {
       host: this.getNormalizedHost(window.location.host),
       project: change.project,
       changeNum: change._number,
       patchNum,
     };
     this.updateCoverageDataIfNecessary(changeInfo);
   }

   /**
    * Provides code coverage percentage for a file of a patchset.
    *
    * @param changeNum The change number of the patchset.
    * @param path The relative path to the file.
    * @param patchNum The patchset number of the patchset.
    * @param type Type of percentage: "absolute" or "incremental".
    * @return Returns an object representing the absolute and
    *     incremental coverages. On error, it logs the error and returns
    *     null/undefined.
    */
   async provideCoveragePercentages(
     changeNum: string,
     path: string,
     patchNum: string
   ): Promise<PercentageData | null> {
     const changeInfo: CoverageChangeInfo = {
       host: this.getNormalizedHost(window.location.host),
       project: this.parseProjectFromPathName(window.location.pathname),
       changeNum: Number(changeNum),
       patchNum: Number(patchNum),
     };
     this.updateCoverageDataIfNecessary(changeInfo);
     try {
       if (this.coverageData) {
         const coveragePercentages = await this.coverageData.percentagesPromise;
         if (coveragePercentages) {
           return coveragePercentages[path];
         } else {
           return null;
         }
       } else {
         return null;
       }
     } catch (error: unknown) {
       console.info(error);
       return null;
     }
   }

   /**
    * Extracts low coverage reason from commit message.
    */
   getLowCoverageReason(commitMessage?: string): string|undefined {
     if(!commitMessage){
       return undefined;
     }
     const re = /Low-Coverage-Reason:(.*)/g;
     const matches = [...commitMessage.matchAll(re)];
     if (matches.length === 0 || matches[0].length === 0) {
       return undefined;
     }
     const m = matches[0];
     const reason = m[m.length - 1].toString().trim();
     if (!reason) {
       return undefined;
     }
     return reason;
   }

   /**
    * Surfaces a warning if there are files with low coverage in the patchset.
    *
    * @param changeNum The change number of the patchset.
    * @param patchNum The patchset number of the patchset.
    * @return Returns an object representing the warnings.
    *  On error, it logs the error and returns null/undefined.
    */
   async mayBeShowLowCoverageAlert(
     changeNum: number,
     patchNum: number,
     commitMessage?: string
   ): Promise<FetchResponse> {
     const changeInfo: CoverageChangeInfo = {
       host: this.getNormalizedHost(window.location.host),
       project: this.parseProjectFromPathName(window.location.pathname),
       changeNum,
       patchNum,
     };
     this.updateCoverageDataIfNecessary(changeInfo);
     try {
       if (!this.coverageData) {
         return {
           // This should never happen
           responseCode: ResponseCode.OK,
           runs: [],
         };
       }
       const coveragePercentages =
         (await this.coverageData.percentagesPromise) || {};
       const reason = this.getLowCoverageReason(commitMessage);
       const low_coverage_alerts: CheckResult[] = [];
       for (const file of Object.keys(coveragePercentages)) {
         const incremental = coveragePercentages[file].incremental;
         if (incremental !== undefined && incremental < OVERALL_LOW_COVERAGE_WARNING_BAR) {
           const msg = `Incremental coverage(All tests) for ${file} `.concat(
             `is ${incremental} which is below the bar. `)
           const alert = {
             category: Category.WARNING,
             summary: `Incremental coverage(All Tests) < ${OVERALL_LOW_COVERAGE_WARNING_BAR}%`,
             message: msg.concat(
               'Please add tests for uncovered lines or add',
               ' Low-Coverage-Reason:<reason> in change description'
             ),
           }
           // Change alert from WARNING to INFO if a reason is provided
           if(reason){
             alert.category = Category.INFO
             alert.message = msg.concat('Check skipped because Low-Coverage-Reason provided')
           }
           low_coverage_alerts.push(alert);
         }
       }
       const low_coverage_reason_not_formatted_alerts: CheckResult[] = [];
       console.log(reason)
       if(reason){
         console.log("in reason if block")
         var isFormatted = false;
         if (LOW_COVERAGE_REASON_PREFIXES.some(v => reason.startsWith(v))) {
           isFormatted = true;
         }
         console.log(isFormatted);
         if(!isFormatted)
         {
           const msg  = `Reason specified for low coverage for this CL is - ${reason} - `.concat(
             `which is missing the category string. `).concat(
             `Reason string should begin with one of the following `).concat(
             `categories - ${LOW_COVERAGE_REASON_PREFIXES.join(', ')}. `).concat(
             `For e.g. "Low-Coverage-Reason: TRIVIAL_CHANGE This change only `).concat(
             `adds log statements". See https://bit.ly/46jhjS9 for more info. `).concat(
             `If you think none of the reason `).concat(
               `categories are sufficent, please open a bug with Infra>Test>CodeCoverage`
             )
           const alert = {
             category: Category.WARNING,
             summary: 'Low-Coverage-Reason footer is not properly formatted',
             message: msg
           }
           low_coverage_reason_not_formatted_alerts.push(alert)
         }

       }
       const responseRuns = []
       if (low_coverage_alerts.length > 0) {
         responseRuns.push( {
           checkName: 'Code Coverage Check',
           status: RunStatus.COMPLETED,
           results: low_coverage_alerts,
         })
       }
       if (low_coverage_reason_not_formatted_alerts.length > 0) {
         responseRuns.push({
           checkName: 'Low-Coverage-Reason Format Check',
           status: RunStatus.COMPLETED,
           results: low_coverage_reason_not_formatted_alerts,
         })
       }
       return {
         responseCode: ResponseCode.OK,
         runs: responseRuns,
       };
     } catch (error: unknown) {
       console.info(error);
       return {
         // TODO: Make sure that a repo not being supported is not treated as an
         // error. And then report realy errors as WARNING.
         responseCode: ResponseCode.OK,
         runs: [],
       };
     }
   }

   /**
    * Returns whether to show percentage columns for the current change.
    *
    * @return Resolves to true if to show the percentage
    *     columns, otherwise, false.
    */
   async showPercentageColumns(): Promise<boolean> {
     // This method is expected to be called when percentage columns are
     // attached, which means that the current page is at change view and that
     // the current project can be parsed from the current URL.
     const project = this.parseProjectFromPathName(window.location.pathname);
     if (!this.coverageConfig || project !== this.coverageConfig.project) {
       this.coverageConfig = {
         project,
         configPromise: this.plugin
           .restApi()
           .get(
             `/projects/${encodeURIComponent(project)}/` +
               `${encodeURIComponent(this.plugin.getPluginName())}~config`
           ),
       };
     }
     try {
       const config = await this.coverageConfig.configPromise;
       return config !== null && config.enabled;
     } catch (error: unknown) {
       console.info(error);
       return false;
     }
   }
 }
	/** @license
	* Copyright 2020 The Chromium Authors. All rights reserved.
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	import {PluginApi} from '@gerritcodereview/typescript-api/plugin';
	import {
	CoverageRange,
	CoverageType,
	Side,
	} from '@gerritcodereview/typescript-api/diff';
	import {
	Category,
	CheckResult,
	FetchResponse,
	ResponseCode,
	RunStatus,
	} from '@gerritcodereview/typescript-api/checks';
	import {
	ChangeInfo,
	RevisionInfo,
	} from '@gerritcodereview/typescript-api/rest-api';

	// Url suffix of the code coverage service API from which to fetch per-cl
	// coverage data.
	const COVERAGE_SERVICE_ENDPOINT_SUFFIX = '/coverage/api/coverage-data';

	// The gob coverage host which is used to process internal project.
	const GOB_COVERAGE_HOST = 'https://gob-coverage.googleplex.com';

	// The chromium coverage host which is used to process external project.
	const CHROMIUM_COVERAGE_HOST = 'https://findit-for-me.appspot.com';

	// Dict of gerrit review host and corresponding code coverage service host
	// from which to fetch per-cl coverage data.
	const GERRIT_TO_COVERAGE_HOST: {[host: string]: string} = {
	'chromium-review.git.corp.google.com': CHROMIUM_COVERAGE_HOST,
	'chromium-review.googlesource.com': CHROMIUM_COVERAGE_HOST,
	'libassistant-internal-review.git.corp.google.com': GOB_COVERAGE_HOST,
	'libassistant-internal-review.googlesource.com': GOB_COVERAGE_HOST,
	};

	// Used to identify host prefixes that should be stripped. This is needed
	// so that the plugin can work in different environments, such as 'canary-'.
	const HOST_PREFIXES = ['canary-', 'polymer1-', 'polymer2-'];

	// Bar for low coverage warning,
	const OVERALL_LOW_COVERAGE_WARNING_BAR = 70;

	const LOW_COVERAGE_REASON_PREFIXES = [
	'TRIVIAL_CHANGE', 'TESTS_ARE_DISABLED', 'TESTS_IN_SEPARATE_CL',
	'HARD_TO_TEST', 'COVERAGE_UNDERREPORTED', 'LARGE_SCALE_REFACTOR',
	'EXPERIMENTAL_CODE', 'OTHER'
	]

	declare interface CoverageConfig {
	project: string; // Used to validate/invalidate the cache.
	// Used to indicate an async fetch of per-project configuration
	configPromise: Promise<{enabled: boolean}> \| null;
	}

	declare interface CoverageChangeInfo {
	host: string;
	project: string;
	changeNum: number;
	patchNum: number \| undefined;
	}
	/**
	* Description of Code coverage for a file.
	*
	* @param absolute Coverage percentage of all lines.
	* @param incremental Coverage percentages of added lines.
	* @param absolute_unit_tests Coverage percentage of all lines of unittests.
	* @param incremental_unit_tests Coverage percentages of added unitetest lines.
	*/
	export declare interface PercentageData {
	absolute?: number;
	incremental?: number;
	absolute_unit_tests?: number;
	incremental_unit_tests?: number;
	}

	declare interface CoverageData {
	changeInfo: CoverageChangeInfo;
	rangesPromise: Promise<{[path: string]: CoverageRange[]} \| null>;
	percentagesPromise: Promise<{[path: string]: PercentageData} \| null>;
	}

	declare interface LinesCoverage {
	line: number;
	count: number;
	}

	declare interface PctCoverage {
	covered: number;
	total: number;
	}

	declare interface CoverageFilesResponse {
	path: string;
	lines?: LinesCoverage[];
	absolute_coverage?: PctCoverage;
	incremental_coverage?: PctCoverage;
	absolute_unit_tests_coverage?: PctCoverage;
	incremental_unit_tests_coverage?: PctCoverage;
	}

	/**
	* JSON data of coverage.
	*
	* @param data Coverage, keyed by file
	*/
	export declare interface CoverageResponse {
	data: {files: CoverageFilesResponse[]};
	}

	/**
	* Provides APIs to fetch and cache coverage data.
	*/
	export class CoverageClient {
	plugin: PluginApi;

	coverageConfig: CoverageConfig \| null;

	coverageData: CoverageData \| null;

	constructor(plugin: PluginApi) {
	this.provideCoverageRanges = this.provideCoverageRanges.bind(this);
	this.prefetchCoverageRanges = this.prefetchCoverageRanges.bind(this);
	this.provideCoveragePercentages =
	this.provideCoveragePercentages.bind(this);

	this.plugin = plugin;

	this.coverageConfig = null;
	this.coverageData = null;
	}

	/**
	* Gets the normalized host name.
	*
	* @param host The host name of the window location.
	*/
	getNormalizedHost(host: string): string {
	for (const prefix of HOST_PREFIXES) {
	if (host.startsWith(prefix)) {
	host = host.substring(prefix.length);
	break;
	}
	}

	return host;
	}

	/**
	* Parses project name from the path name.
	*
	* The path name is expected to be in one of the following forms:
	* '/c/chromium/src/+/1369646'
	* '/c/chromium/src/+/1369646/3'
	* '/c/chromium/src/+/1369646/3/base/base/test.cc'
	*
	* @param pathName The path name of the window location.
	* @return Returns current project such as chromium/src if the url
	* is valid, otherwise, returns null.
	*/
	parseProjectFromPathName(pathName: string): string {
	if (!pathName.startsWith('/c/')) {
	throw new Error(`${pathName} is expected to start with "/c/"`);
	}

	const indexEnd = pathName.indexOf('/+');
	if (indexEnd === -1) {
	throw new Error(`${pathName} is expected to contain "/+"`);
	}

	return pathName.substring(3, indexEnd);
	}

	/**
	* Fetches code coverage data from coverage service for a patchset.
	* The value of 'incremental_coverage' is null if there are no added lines.
	*/
	async fetchCoverageJsonData(
	changeInfo: CoverageChangeInfo,
	kind: string
	): Promise<CoverageResponse> {
	if (kind !== 'lines' && kind !== 'percentages') {
	throw new Error('Kind is expected to be either "lines" or "percentages"');
	}
	if (changeInfo.patchNum === undefined) {
	throw new Error('Patch number is undefined, cannot get coverage data');
	}
	const params = new URLSearchParams({
	// Only googlesource hosts are supported.
	host: changeInfo.host.replace('git.corp.google', 'googlesource'),
	project: changeInfo.project,
	change: changeInfo.changeNum.toString(),
	patchset: changeInfo.patchNum.toString(),
	type: kind,
	format: 'json',
	concise: '1',
	});

	let coverageHost = GERRIT_TO_COVERAGE_HOST[changeInfo.host];
	// If the host is not found, use CHROMIUM_COVERAGE_HOST by default.
	if (!coverageHost) {
	coverageHost = CHROMIUM_COVERAGE_HOST;
	}
	const endpoint = coverageHost + COVERAGE_SERVICE_ENDPOINT_SUFFIX;
	const url = `${endpoint}?${params.toString()}`;
	const response = await fetch(url);
	const responseJson = await response.json();
	if (
	response.status === 400 &&
	responseJson.is_project_supported === false
	) {
	throw new Error(
	`"${changeInfo.project}" project is not supported for code coverage`
	);
	}

	if (response.status === 500 && responseJson.is_service_enabled === false) {
	throw new Error('Code coverage service is temporarily disabled');
	}

	if (!response.ok) {
	throw new Error(
	`Request code coverage data returned http ${response.status}`
	);
	}

	return responseJson;
	}

	/**
	* Converts the JSON response to coverage ranges needed by coverage layer.
	*
	* @param responseJson The JSON response returned from coverage
	* service.
	* @return Returns an object whose properties are file paths and
	* corresponding values are a list of coverage ranges if the JSON
	* response has valid format, otherwise, returns null.
	*/
	convertResponseJsonToCoverageRanges(responseJson: CoverageResponse): {
	[path: string]: CoverageRange[];
	} {
	if (!responseJson.data) {
	throw new Error(
	'Invalid coverage lines response format. Expecting "data" property'
	);
	}

	const responseData = responseJson.data;
	if (!responseData.files) {
	throw new Error(
	'Invalid coverage lines response format. Expecting "files" property'
	);
	}

	const responseFiles = responseData.files;
	const coverageRanges: {[path: string]: CoverageRange[]} = {};

	for (let i = 0; i < responseFiles.length; i++) {
	const responseFile = responseFiles[i];
	if (!responseFile.path \|\| !responseFile.lines) {
	throw new Error(
	'Invalid coverage lines response format. Expecting ' +
	'"path" and "lines" properties'
	);
	}

	coverageRanges[responseFile.path] = [];
	const responseLines = responseFile.lines;
	responseLines.sort((a, b) => (a.line > b.line ? 1 : -1));
	let startLine = -1;
	let endLine = -1;
	let isCovered = null;
	for (let j = 0; j < responseLines.length; j++) {
	const responseLine = responseLines[j];
	if (!responseLine.line \|\| responseLine.count === null) {
	throw new Error(
	'Invalid coverage lines response format. ' +
	'Expecting "line" and "count" properties'
	);
	}

	if (
	startLine !== -1 &&
	responseLine.line === endLine + 1 &&
	isCovered === responseLine.count > 0
	) {
	endLine += 1;
	continue;
	}

	if (startLine !== -1) {
	coverageRanges[responseFile.path].push({
	side: Side.RIGHT,
	type: isCovered ? CoverageType.COVERED : CoverageType.NOT_COVERED,
	code_range: {
	start_line: startLine,
	end_line: endLine,
	},
	});
	}

	startLine = responseLine.line;
	endLine = startLine;
	isCovered = responseLine.count > 0;
	}

	if (startLine !== -1) {
	coverageRanges[responseFile.path].push({
	side: Side.RIGHT,
	type: isCovered ? CoverageType.COVERED : CoverageType.NOT_COVERED,
	code_range: {
	start_line: startLine,
	end_line: endLine,
	},
	});
	}
	}

	return coverageRanges;
	}

	/**
	* Fetches code coverage ranges from coverage service for a patchset.
	*
	* @param changeInfo Has host, project, changeNum and patchNum.
	* @return Resolves to a map of files to coverage ranges if the
	* coverage ata is successfully retrieved and parsed, otherwise,
	* resolves to null.
	*/
	async fetchCoverageRanges(
	changeInfo: CoverageChangeInfo
	): Promise<{[path: string]: CoverageRange[]}> {
	const responseJson = await this.fetchCoverageJsonData(changeInfo, 'lines');
	return this.convertResponseJsonToCoverageRanges(responseJson);
	}

	/**
	* Converts the JSON response to coverage percentages.
	*
	* @param responseJson The JSON response returned from coverage
	* service.
	* @return Returns an object whose properties are file paths and
	* corresponding values are objects representing absolute and
	* incremental coverage percentages if the JSON response has valid
	* format, otherwise, returns null.
	*/
	convertResponseJsonToCoveragePercentages(responseJson: CoverageResponse): {
	[path: string]: PercentageData;
	} {
	if (!responseJson.data) {
	throw new Error(
	'Invalid coverage percentages response format. ' +
	'Expecting "data" property'
	);
	}

	const responseData = responseJson.data;
	if (!responseData.files) {
	throw new Error(
	'Invalid coverage percentages response format. ' +
	'Expecting "files" property'
	);
	}

	const coveragePercentages: {[path: string]: PercentageData} = {};
	for (const responseFile of responseData.files) {
	// TODO(crbug/1424854): Also check for absolute coverage
	if (!responseFile.path) {
	throw new Error(
	'Invalid coverage percentages response format. ' +
	'Expecting "path" property'
	);
	}

	const fileCov: PercentageData = {};

	if (responseFile.absolute_coverage) {
	fileCov.absolute = Math.round(
	(responseFile.absolute_coverage.covered * 100) /
	responseFile.absolute_coverage.total
	);
	}
	if (responseFile.incremental_coverage) {
	fileCov.incremental = Math.round(
	(responseFile.incremental_coverage.covered * 100) /
	responseFile.incremental_coverage.total
	);
	}
	if (responseFile.absolute_unit_tests_coverage) {
	fileCov.absolute_unit_tests = Math.round(
	(responseFile.absolute_unit_tests_coverage.covered * 100) /
	responseFile.absolute_unit_tests_coverage.total
	);
	}
	if (responseFile.incremental_unit_tests_coverage) {
	fileCov.incremental_unit_tests = Math.round(
	(responseFile.incremental_unit_tests_coverage.covered * 100) /
	responseFile.incremental_unit_tests_coverage.total
	);
	}

	coveragePercentages[responseFile.path] = fileCov;
	}

	return coveragePercentages;
	}

	/**
	* Fetches code coverage percentages from coverage service for a patchset.
	*
	* @param changeInfo Has host, project, changeNum and patchNum.
	* @return Resolves to a map of files to coverage percentages if
	* coverage data is successfully retrieved and parsed, otherwise,
	* resolves to null.
	*/
	async fetchCoveragePercentages(
	changeInfo: CoverageChangeInfo
	): Promise<{[path: string]: PercentageData}> {
	const responseJson = await this.fetchCoverageJsonData(
	changeInfo,
	'percentages'
	);
	return this.convertResponseJsonToCoveragePercentages(responseJson);
	}

	/**
	* Fetches code coverage ranges from coverage service for a patchset.
	*
	* @param changeInfo Has host, project, changeNum and patchNum.
	*/
	updateCoverageDataIfNecessary(changeInfo: CoverageChangeInfo) {
	if (
	changeInfo.patchNum === undefined \|\|
	isNaN(changeInfo.changeNum) \|\|
	isNaN(changeInfo.patchNum) \|\|
	changeInfo.changeNum <= 0 \|\|
	changeInfo.patchNum <= 0
	) {
	return;
	}

	if (
	!this.coverageData \|\|
	JSON.stringify(changeInfo) !==
	JSON.stringify(this.coverageData.changeInfo)
	) {
	this.coverageData = {
	changeInfo,
	rangesPromise: this.fetchCoverageRanges(changeInfo),
	percentagesPromise: this.fetchCoveragePercentages(changeInfo),
	};
	this.coverageData.rangesPromise.catch(error => {
	console.warn(error);
	});
	this.coverageData.percentagesPromise.catch(error => {
	console.warn(error);
	});
	}
	}

	/**
	* Provides code coverage ranges for a file of a patchset.
	*
	* @param changeNum The change number of the patchset.
	* @param path The relative path to the file.
	* @param basePatchNum The patchset number of the base patchset.
	* @param patchNum The patchset number of the patchset.
	* @return Returns a list of coverage ranges. On error, it logs the
	* error and returns null/undefined.
	*/
	async provideCoverageRanges(
	changeNum: number,
	path: string,
	basePatchNum: number \| undefined,
	patchNum: number \| undefined
	): Promise<CoverageRange[] \| undefined> {
	const changeInfo: CoverageChangeInfo = {
	host: this.getNormalizedHost(window.location.host),
	project: this.parseProjectFromPathName(window.location.pathname),
	changeNum,
	patchNum,
	};
	this.updateCoverageDataIfNecessary(changeInfo);
	try {
	if (this.coverageData) {
	const coverageRanges = await this.coverageData.rangesPromise;
	if (coverageRanges) {
	return coverageRanges[path] \|\| [];
	}
	return [];
	} else {
	return undefined;
	}
	} catch (error: unknown) {
	console.info(error);
	return undefined;
	}
	}

	/**
	* Prefetch coverage ranges.
	*
	* This method is supposed to be triggered by the 'showchange' event.
	*
	* @param change Info of the current change.
	* @param revision Info of the current revision.
	*/
	prefetchCoverageRanges(change: ChangeInfo, revision: RevisionInfo) {
	let patchNum = NaN;
	if (typeof revision._number === 'number') {
	patchNum = revision._number;
	}
	const changeInfo: CoverageChangeInfo = {
	host: this.getNormalizedHost(window.location.host),
	project: change.project,
	changeNum: change._number,
	patchNum,
	};
	this.updateCoverageDataIfNecessary(changeInfo);
	}

	/**
	* Provides code coverage percentage for a file of a patchset.
	*
	* @param changeNum The change number of the patchset.
	* @param path The relative path to the file.
	* @param patchNum The patchset number of the patchset.
	* @param type Type of percentage: "absolute" or "incremental".
	* @return Returns an object representing the absolute and
	* incremental coverages. On error, it logs the error and returns
	* null/undefined.
	*/
	async provideCoveragePercentages(
	changeNum: string,
	path: string,
	patchNum: string
	): Promise<PercentageData \| null> {
	const changeInfo: CoverageChangeInfo = {
	host: this.getNormalizedHost(window.location.host),
	project: this.parseProjectFromPathName(window.location.pathname),
	changeNum: Number(changeNum),
	patchNum: Number(patchNum),
	};
	this.updateCoverageDataIfNecessary(changeInfo);
	try {
	if (this.coverageData) {
	const coveragePercentages = await this.coverageData.percentagesPromise;
	if (coveragePercentages) {
	return coveragePercentages[path];
	} else {
	return null;
	}
	} else {
	return null;
	}
	} catch (error: unknown) {
	console.info(error);
	return null;
	}
	}

	/**
	* Extracts low coverage reason from commit message.
	*/
	getLowCoverageReason(commitMessage?: string): string\|undefined {
	if(!commitMessage){
	return undefined;
	}
	const re = /Low-Coverage-Reason:(.*)/g;
	const matches = [...commitMessage.matchAll(re)];
	if (matches.length === 0 \|\| matches[0].length === 0) {
	return undefined;
	}
	const m = matches[0];
	const reason = m[m.length - 1].toString().trim();
	if (!reason) {
	return undefined;
	}
	return reason;
	}

	/**
	* Surfaces a warning if there are files with low coverage in the patchset.
	*
	* @param changeNum The change number of the patchset.
	* @param patchNum The patchset number of the patchset.
	* @return Returns an object representing the warnings.
	* On error, it logs the error and returns null/undefined.
	*/
	async mayBeShowLowCoverageAlert(
	changeNum: number,
	patchNum: number,
	commitMessage?: string
	): Promise<FetchResponse> {
	const changeInfo: CoverageChangeInfo = {
	host: this.getNormalizedHost(window.location.host),
	project: this.parseProjectFromPathName(window.location.pathname),
	changeNum,
	patchNum,
	};
	this.updateCoverageDataIfNecessary(changeInfo);
	try {
	if (!this.coverageData) {
	return {
	// This should never happen
	responseCode: ResponseCode.OK,
	runs: [],
	};
	}
	const coveragePercentages =
	(await this.coverageData.percentagesPromise) \|\| {};
	const reason = this.getLowCoverageReason(commitMessage);
	const low_coverage_alerts: CheckResult[] = [];
	for (const file of Object.keys(coveragePercentages)) {
	const incremental = coveragePercentages[file].incremental;
	if (incremental !== undefined && incremental < OVERALL_LOW_COVERAGE_WARNING_BAR) {
	const msg = `Incremental coverage(All tests) for ${file} `.concat(
	`is ${incremental} which is below the bar. `)
	const alert = {
	category: Category.WARNING,
	summary: `Incremental coverage(All Tests) < ${OVERALL_LOW_COVERAGE_WARNING_BAR}%`,
	message: msg.concat(
	'Please add tests for uncovered lines or add',
	' Low-Coverage-Reason:<reason> in change description'
	),
	}
	// Change alert from WARNING to INFO if a reason is provided
	if(reason){
	alert.category = Category.INFO
	alert.message = msg.concat('Check skipped because Low-Coverage-Reason provided')
	}
	low_coverage_alerts.push(alert);
	}
	}
	const low_coverage_reason_not_formatted_alerts: CheckResult[] = [];
	console.log(reason)
	if(reason){
	console.log("in reason if block")
	var isFormatted = false;
	if (LOW_COVERAGE_REASON_PREFIXES.some(v => reason.startsWith(v))) {
	isFormatted = true;
	}
	console.log(isFormatted);
	if(!isFormatted)
	{
	const msg = `Reason specified for low coverage for this CL is - ${reason} - `.concat(
	`which is missing the category string. `).concat(
	`Reason string should begin with one of the following `).concat(
	`categories - ${LOW_COVERAGE_REASON_PREFIXES.join(', ')}. `).concat(
	`For e.g. "Low-Coverage-Reason: TRIVIAL_CHANGE This change only `).concat(
	`adds log statements". See https://bit.ly/46jhjS9 for more info. `).concat(
	`If you think none of the reason `).concat(
	`categories are sufficent, please open a bug with Infra>Test>CodeCoverage`
	)
	const alert = {
	category: Category.WARNING,
	summary: 'Low-Coverage-Reason footer is not properly formatted',
	message: msg
	}
	low_coverage_reason_not_formatted_alerts.push(alert)
	}

	}
	const responseRuns = []
	if (low_coverage_alerts.length > 0) {
	responseRuns.push( {
	checkName: 'Code Coverage Check',
	status: RunStatus.COMPLETED,
	results: low_coverage_alerts,
	})
	}
	if (low_coverage_reason_not_formatted_alerts.length > 0) {
	responseRuns.push({
	checkName: 'Low-Coverage-Reason Format Check',
	status: RunStatus.COMPLETED,
	results: low_coverage_reason_not_formatted_alerts,
	})
	}
	return {
	responseCode: ResponseCode.OK,
	runs: responseRuns,
	};
	} catch (error: unknown) {
	console.info(error);
	return {
	// TODO: Make sure that a repo not being supported is not treated as an
	// error. And then report realy errors as WARNING.
	responseCode: ResponseCode.OK,
	runs: [],
	};
	}
	}

	/**
	* Returns whether to show percentage columns for the current change.
	*
	* @return Resolves to true if to show the percentage
	* columns, otherwise, false.
	*/
	async showPercentageColumns(): Promise<boolean> {
	// This method is expected to be called when percentage columns are
	// attached, which means that the current page is at change view and that
	// the current project can be parsed from the current URL.
	const project = this.parseProjectFromPathName(window.location.pathname);
	if (!this.coverageConfig \|\| project !== this.coverageConfig.project) {
	this.coverageConfig = {
	project,
	configPromise: this.plugin
	.restApi()
	.get(
	`/projects/${encodeURIComponent(project)}/` +
	`${encodeURIComponent(this.plugin.getPluginName())}~config`
	),
	};
	}
	try {
	const config = await this.coverageConfig.configPromise;
	return config !== null && config.enabled;
	} catch (error: unknown) {
	console.info(error);
	return false;
	}
	}
	}