PVS-స్టూడియో ఇప్పుడు చాక్లెట్‌లో ఉంది: Azure DevOps కింద చాక్లెట్‌ని తనిఖీ చేస్తోంది

మేము PVS-స్టూడియోను మరింత సౌకర్యవంతంగా ఉపయోగించడాన్ని కొనసాగిస్తున్నాము. మా ఎనలైజర్ ఇప్పుడు Windows కోసం ప్యాకేజీ మేనేజర్ అయిన Chocolateyలో అందుబాటులో ఉంది. ఇది PVS-స్టూడియో, ప్రత్యేకించి, క్లౌడ్ సేవలలో విస్తరణను సులభతరం చేస్తుందని మేము నమ్ముతున్నాము. ఎక్కువ దూరం వెళ్లకుండా ఉండాలంటే, అదే చాక్లెట్ సోర్స్ కోడ్‌ని చెక్ చేద్దాం. Azure DevOps CI సిస్టమ్‌గా పని చేస్తుంది.

క్లౌడ్ సిస్టమ్‌లతో ఇంటిగ్రేషన్ అనే అంశంపై మా ఇతర కథనాల జాబితా ఇక్కడ ఉంది:

• PVS-స్టూడియో మేఘాలకు వెళుతుంది: Azure DevOps
• PVS-స్టూడియో మేఘాలకు వెళుతుంది: ట్రావిస్ CI
• PVS-స్టూడియో మేఘాలకు వెళుతుంది: CircleCI
• PVS-స్టూడియో మేఘాలకు వెళుతుంది: GitLab CI/CD

Azure DevOpsతో ఏకీకరణ గురించి మొదటి కథనానికి శ్రద్ధ వహించమని నేను మీకు సలహా ఇస్తున్నాను, ఎందుకంటే ఈ సందర్భంలో కొన్ని పాయింట్లు నకిలీ చేయబడకుండా తొలగించబడ్డాయి.

కాబట్టి, ఈ వ్యాసం యొక్క నాయకులు:

పివిఎస్-స్టూడియో C, C++, C# మరియు Javaలో వ్రాసిన ప్రోగ్రామ్‌లలో లోపాలు మరియు సంభావ్య దుర్బలత్వాలను గుర్తించడానికి రూపొందించబడిన స్టాటిక్ కోడ్ విశ్లేషణ సాధనం. 64-బిట్ విండోస్, లైనక్స్ మరియు మాకోస్ సిస్టమ్‌లలో రన్ అవుతుంది మరియు 32-బిట్, 64-బిట్ మరియు ఎంబెడెడ్ ARM ప్లాట్‌ఫారమ్‌ల కోసం రూపొందించిన కోడ్‌ను విశ్లేషించవచ్చు. మీ ప్రాజెక్ట్‌లను తనిఖీ చేయడానికి స్టాటిక్ కోడ్ విశ్లేషణను ప్రయత్నించడం ఇదే మొదటిసారి అయితే, మీరు మీ గురించి తెలుసుకోవాలని మేము సిఫార్సు చేస్తున్నాము వ్యాసం అత్యంత ఆసక్తికరమైన PVS-స్టూడియో హెచ్చరికలను త్వరగా వీక్షించడం మరియు ఈ సాధనం యొక్క సామర్థ్యాలను ఎలా అంచనా వేయాలి అనే దాని గురించి.

అజూర్ డెవొప్స్ — మొత్తం అభివృద్ధి ప్రక్రియను సంయుక్తంగా కవర్ చేసే క్లౌడ్ సేవల సమితి. ఈ ప్లాట్‌ఫారమ్‌లో అజూర్ పైప్‌లైన్‌లు, అజూర్ బోర్డ్‌లు, అజూర్ ఆర్టిఫాక్ట్‌లు, అజూర్ రెపోస్, అజూర్ టెస్ట్ ప్లాన్‌లు వంటి సాధనాలు ఉన్నాయి, ఇవి సాఫ్ట్‌వేర్ సృష్టించే ప్రక్రియను వేగవంతం చేయడానికి మరియు దాని నాణ్యతను మెరుగుపరచడానికి మిమ్మల్ని అనుమతిస్తాయి.

chocolatey Windows కోసం ఓపెన్ సోర్స్ ప్యాకేజీ మేనేజర్. విండోస్ ఆపరేటింగ్ సిస్టమ్‌లలో ఇన్‌స్టాలేషన్ నుండి అప్‌డేట్ మరియు అన్‌ఇన్‌స్టాలేషన్ వరకు మొత్తం సాఫ్ట్‌వేర్ జీవితచక్రాన్ని ఆటోమేట్ చేయడం ప్రాజెక్ట్ యొక్క లక్ష్యం.

చాక్లెట్ ఉపయోగించడం గురించి

ప్యాకేజీ మేనేజర్‌ని ఎలా ఇన్‌స్టాల్ చేయాలో మీరు ఇక్కడ చూడవచ్చు లింక్. ఎనలైజర్‌ను ఇన్‌స్టాల్ చేయడానికి పూర్తి డాక్యుమెంటేషన్ అందుబాటులో ఉంది లింక్ చాక్లెట్ ప్యాకేజీ మేనేజర్ విభాగాన్ని ఉపయోగించి ఇన్‌స్టాలేషన్ చూడండి. నేను అక్కడ నుండి కొన్ని పాయింట్లను క్లుప్తంగా పునరావృతం చేస్తాను.

ఎనలైజర్ యొక్క తాజా వెర్షన్‌ను ఇన్‌స్టాల్ చేయమని ఆదేశం:

choco install pvs-studio

PVS-స్టూడియో ప్యాకేజీ యొక్క నిర్దిష్ట సంస్కరణను ఇన్‌స్టాల్ చేయమని ఆదేశం:

choco install pvs-studio --version=7.05.35617.2075

డిఫాల్ట్‌గా, ఎనలైజర్ యొక్క కోర్, కోర్ కాంపోనెంట్ మాత్రమే ఇన్‌స్టాల్ చేయబడింది. అన్ని ఇతర ఫ్లాగ్‌లు (స్టాండలోన్, జావాకోర్, IDEA, MSVS2010, MSVS2012, MSVS2013, MSVS2015, MSVS2017, MSVS2019) --package-parameters ఉపయోగించి పాస్ చేయవచ్చు.

విజువల్ స్టూడియో 2019 కోసం ప్లగిన్‌తో ఎనలైజర్‌ని ఇన్‌స్టాల్ చేసే ఆదేశం యొక్క ఉదాహరణ:

choco install pvs-studio --package-parameters="'/MSVS2019'"

ఇప్పుడు Azure DevOps క్రింద ఎనలైజర్ యొక్క అనుకూలమైన ఉపయోగం యొక్క ఉదాహరణను చూద్దాం.

సర్దుబాటు

ఖాతాను నమోదు చేయడం, బిల్డ్ పైప్‌లైన్‌ని సృష్టించడం మరియు GitHub రిపోజిటరీలో ఉన్న ప్రాజెక్ట్‌తో మీ ఖాతాను సమకాలీకరించడం వంటి సమస్యల గురించి ప్రత్యేక విభాగం ఉందని నేను మీకు గుర్తు చేస్తున్నాను. వ్యాసం. మా సెటప్ వెంటనే కాన్ఫిగరేషన్ ఫైల్‌ను వ్రాయడం ద్వారా ప్రారంభమవుతుంది.

ముందుగా, లాంచ్ ట్రిగ్గర్‌ని సెటప్ చేద్దాం, ఇది మార్పుల కోసం మాత్రమే లాంచ్ అవుతుందని సూచిస్తుంది మాస్టర్ శాఖ:

trigger:
- master

తరువాత మనం వర్చువల్ మిషన్‌ను ఎంచుకోవాలి. ప్రస్తుతానికి ఇది Windows Server 2019 మరియు Visual Studio 2019తో మైక్రోసాఫ్ట్-హోస్ట్ చేసిన ఏజెంట్ అవుతుంది:

pool:
  vmImage: 'windows-latest'

కాన్ఫిగరేషన్ ఫైల్ యొక్క బాడీకి వెళ్దాం (బ్లాక్ దశలను) మీరు వర్చువల్ మెషీన్‌లో ఏకపక్ష సాఫ్ట్‌వేర్‌ను ఇన్‌స్టాల్ చేయలేనప్పటికీ, నేను డాకర్ కంటైనర్‌ను జోడించలేదు. మేము Azure DevOps కోసం పొడిగింపుగా చాక్లెట్‌ని జోడించవచ్చు. దీన్ని చేయడానికి, వెళ్దాం లింక్. క్లిక్ చేయండి ఉచితంగా పొందండి. తర్వాత, మీరు ఇప్పటికే అధికారం కలిగి ఉంటే, మీ ఖాతాను ఎంచుకోండి మరియు లేకపోతే, అధికారం తర్వాత అదే పని చేయండి.

ఇక్కడ మీరు పొడిగింపును ఎక్కడ జోడించాలో ఎంచుకోవాలి మరియు బటన్‌ను క్లిక్ చేయండి ఇన్స్టాల్.

విజయవంతమైన ఇన్‌స్టాలేషన్ తర్వాత, క్లిక్ చేయండి సంస్థకు వెళ్లండి:

మీరు ఇప్పుడు విండోలో చాక్లెట్ టాస్క్ కోసం టెంప్లేట్‌ను చూడవచ్చు పనులు కాన్ఫిగరేషన్ ఫైల్‌ను సవరించేటప్పుడు azure-pipelines.yml:

చాక్లెట్‌పై క్లిక్ చేసి, ఫీల్డ్‌ల జాబితాను చూడండి:

ఇక్కడ మనం ఎంచుకోవాలి ఇన్స్టాల్ జట్లతో మైదానంలో. IN నస్పెక్ ఫైల్ పేరు అవసరమైన ప్యాకేజీ పేరును సూచించండి - pvs-studio. మీరు సంస్కరణను పేర్కొనకపోతే, తాజాది వ్యవస్థాపించబడుతుంది, ఇది మాకు పూర్తిగా సరిపోతుంది. బటన్ నొక్కండి జోడించడానికి మరియు మేము కాన్ఫిగరేషన్ ఫైల్‌లో రూపొందించిన పనిని చూస్తాము.

steps:
- task: ChocolateyCommand@0
  inputs:
    command: 'install'
    installPackageId: 'pvs-studio'

తరువాత, మన ఫైల్ యొక్క ప్రధాన భాగానికి వెళ్దాం:

- task: CmdLine@2
  inputs:
    script: 

ఇప్పుడు మనం ఎనలైజర్ లైసెన్స్‌తో ఫైల్‌ను సృష్టించాలి. ఇక్కడ PVSNAME и PVSKEY - మేము సెట్టింగులలో పేర్కొన్న విలువలను వేరియబుల్స్ పేర్లు. వారు PVS-స్టూడియో లాగిన్ మరియు లైసెన్స్ కీని నిల్వ చేస్తారు. వాటి విలువలను సెట్ చేయడానికి, మెనుని తెరవండి వేరియబుల్స్->కొత్త వేరియబుల్. వేరియబుల్స్ క్రియేట్ చేద్దాం PVSNAME లాగిన్ కోసం మరియు PVSKEY ఎనలైజర్ కీ కోసం. పెట్టెను తనిఖీ చేయడం మర్చిపోవద్దు ఈ విలువను రహస్యంగా ఉంచండి కోసం PVSKEY. కమాండ్ కోడ్:

сall "C:Program Files (x86)PVS-StudioPVS-Studio_Cmd.exe" credentials 
–u $(PVSNAME) –n $(PVSKEY)

రిపోజిటరీలో ఉన్న బ్యాట్ ఫైల్‌ని ఉపయోగించి ప్రాజెక్ట్‌ను రూపొందిద్దాం:

сall build.bat

ఎనలైజర్ ఫలితాలతో కూడిన ఫైల్‌లు నిల్వ చేయబడే ఫోల్డర్‌ను క్రియేట్ చేద్దాం:

сall mkdir PVSTestResults

ప్రాజెక్ట్ను విశ్లేషించడం ప్రారంభిద్దాం:

сall "C:Program Files (x86)PVS-StudioPVS-Studio_Cmd.exe" 
–t .srcchocolatey.sln –o .PVSTestResultsChoco.plog 

PlogСonverter యుటిలిటీని ఉపయోగించి మేము మా నివేదికను html ఆకృతికి మారుస్తాము:

сall "C:Program Files (x86)PVS-StudioPlogConverter.exe" 
–t html –o PVSTestResults .PVSTestResultsChoco.plog

ఇప్పుడు మీరు ఒక పనిని సృష్టించాలి, తద్వారా మీరు నివేదికను అప్‌లోడ్ చేయవచ్చు.

- task: PublishBuildArtifacts@1
  inputs:
    pathToPublish: PVSTestResults
    artifactName: PVSTestResults
    condition: always()

పూర్తి కాన్ఫిగరేషన్ ఫైల్ ఇలా కనిపిస్తుంది:

trigger:
- master

pool:
  vmImage: 'windows-latest'

steps:
- task: ChocolateyCommand@0
  inputs:
    command: 'install'
    installPackageId: 'pvs-studio'

- task: CmdLine@2
  inputs:
    script: |
      call "C:Program Files (x86)PVS-StudioPVS-Studio_Cmd.exe" 
      credentials –u $(PVSNAME) –n $(PVSKEY)
      call build.bat
      call mkdir PVSTestResults
      call "C:Program Files (x86)PVS-StudioPVS-Studio_Cmd.exe" 
      –t .srcchocolatey.sln –o .PVSTestResultsChoco.plog
      call "C:Program Files (x86)PVS-StudioPlogConverter.exe" 
      –t html –o .PVSTestResults .PVSTestResultsChoco.plog

- task: PublishBuildArtifacts@1
  inputs:
    pathToPublish: PVSTestResults
    artifactName: PVSTestResults
    condition: always()

క్లిక్ చేద్దాం సేవ్->సేవ్->రన్ పనిని అమలు చేయడానికి. టాస్క్‌ల ట్యాబ్‌కి వెళ్లి నివేదికను డౌన్‌లోడ్ చేద్దాం.

చాక్లెట్ ప్రాజెక్ట్ C# కోడ్ యొక్క 37615 లైన్లను మాత్రమే కలిగి ఉంది. కనుగొనబడిన కొన్ని లోపాలను చూద్దాం.

పరీక్ష ఫలితాలు

హెచ్చరిక N1

ఎనలైజర్ హెచ్చరిక: V3005 'ప్రొవైడర్' వేరియబుల్ దానికే కేటాయించబడుతుంది. CrytpoHashProviderSpecs.cs 38

public abstract class CrytpoHashProviderSpecsBase : TinySpec
{
  ....
  protected CryptoHashProvider Provider;
  ....
  public override void Context()
  {
    Provider = Provider = new CryptoHashProvider(FileSystem.Object);
  }
}

ఎనలైజర్ తనకు వేరియబుల్ యొక్క అసైన్‌మెంట్‌ను గుర్తించింది, ఇది అర్ధవంతం కాదు. చాలా మటుకు, ఈ వేరియబుల్స్‌లో ఒకదాని స్థానంలో మరొకటి ఉండాలి. బాగా, లేదా ఇది అక్షర దోషం, మరియు అదనపు కేటాయింపును తీసివేయవచ్చు.

హెచ్చరిక N2

ఎనలైజర్ హెచ్చరిక: V3093 [CWE-480] '&' ఆపరేటర్ రెండు ఆపరాండ్‌లను మూల్యాంకనం చేస్తుంది. బదులుగా షార్ట్-సర్క్యూట్ '&&' ఆపరేటర్‌ని ఉపయోగించాలి. Platform.cs 64

public static PlatformType get_platform()
{
  switch (Environment.OSVersion.Platform)
  {
    case PlatformID.MacOSX:
    {
      ....
    }
    case PlatformID.Unix:
    if(file_system.directory_exists("/Applications")
      & file_system.directory_exists("/System")
      & file_system.directory_exists("/Users")
      & file_system.directory_exists("/Volumes"))
      {
        return PlatformType.Mac;
      }
        else
          return PlatformType.Linux;
    default:
      return PlatformType.Windows;
  }
}

ఆపరేటర్ తేడా & ఆపరేటర్ నుండి && వ్యక్తీకరణ యొక్క ఎడమ వైపు ఉంటే తప్పుడు, అప్పుడు కుడి వైపు ఇప్పటికీ లెక్కించబడుతుంది, ఈ సందర్భంలో అనవసరమైన పద్ధతి కాల్‌లను సూచిస్తుంది system.directory_exist ఉంది.

పరిగణించబడిన భాగం లో, ఇది ఒక చిన్న లోపం. అవును, & ఆపరేటర్‌ని && ఆపరేటర్‌తో భర్తీ చేయడం ద్వారా ఈ పరిస్థితిని ఆప్టిమైజ్ చేయవచ్చు, కానీ ఆచరణాత్మక కోణం నుండి, ఇది దేనినీ ప్రభావితం చేయదు. అయితే, ఇతర సందర్భాల్లో, వ్యక్తీకరణ యొక్క కుడి వైపు తప్పు/చెల్లని విలువలతో పరిగణించబడినప్పుడు & మరియు && మధ్య గందరగోళం తీవ్రమైన సమస్యలను కలిగిస్తుంది. ఉదాహరణకు, మా దోష సేకరణలో, V3093 డయాగ్నస్టిక్ ఉపయోగించి గుర్తించబడింది, ఈ సందర్భం ఉంది:

if ((k < nct) & (s[k] != 0.0))

ఇండెక్స్ అయినా k తప్పు, ఇది అర్రే ఎలిమెంట్‌ను యాక్సెస్ చేయడానికి ఉపయోగించబడుతుంది. ఫలితంగా, ఒక మినహాయింపు విసిరివేయబడుతుంది IndexOutOfRangeException.

హెచ్చరికలు N3, N4

ఎనలైజర్ హెచ్చరిక: V3022 [CWE-571] వ్యక్తీకరణ 'షార్ట్‌ప్రాంప్ట్' ఎల్లప్పుడూ నిజం. InteractivePrompt.cs 101
ఎనలైజర్ హెచ్చరిక: V3022 [CWE-571] వ్యక్తీకరణ 'షార్ట్‌ప్రాంప్ట్' ఎల్లప్పుడూ నిజం. InteractivePrompt.cs 105

public static string 
prompt_for_confirmation(.... bool shortPrompt = false, ....)
{
  ....
  if (shortPrompt)
  {
    var choicePrompt = choice.is_equal_to(defaultChoice) //1
    ?
    shortPrompt //2
    ?
    "[[{0}]{1}]".format_with(choice.Substring(0, 1).ToUpperInvariant(), //3
    choice.Substring(1,choice.Length - 1))
    :
    "[{0}]".format_with(choice.ToUpperInvariant()) //0
    : 
    shortPrompt //4
    ? 
    "[{0}]{1}".format_with(choice.Substring(0,1).ToUpperInvariant(), //5
    choice.Substring(1,choice.Length - 1)) 
    :
    choice; //0
    ....
  }
  ....
}

ఈ సందర్భంలో, టెర్నరీ ఆపరేటర్ యొక్క ఆపరేషన్ వెనుక ఒక విచిత్రమైన లాజిక్ ఉంది. నిశితంగా పరిశీలిద్దాం: నేను నంబర్ 1తో గుర్తించిన షరతు నెరవేరినట్లయితే, మేము ఎల్లప్పుడూ కండిషన్ 2కి వెళ్తాము. నిజమైన, అంటే పంక్తి 3 అమలు చేయబడుతుంది. షరతు 1 తప్పు అని తేలితే, మేము 4వ సంఖ్యతో గుర్తించబడిన పంక్తికి వెళ్తాము, దీనిలో కూడా ఎల్లప్పుడూ ఉంటుంది నిజమైన, అంటే లైన్ 5 అమలు చేయబడుతుంది. అందువల్ల, వ్యాఖ్య 0తో గుర్తించబడిన షరతులు ఎప్పటికీ నెరవేరవు, ఇది ప్రోగ్రామర్ ఊహించిన ఆపరేషన్ యొక్క లాజిక్ సరిగ్గా ఉండకపోవచ్చు.

హెచ్చరిక N5

ఎనలైజర్ హెచ్చరిక: V3123 [CWE-783] బహుశా '?:' ఆపరేటర్ ఊహించిన దాని కంటే భిన్నమైన రీతిలో పని చేస్తుంది. దాని పరిస్థితిలో ఇతర ఆపరేటర్‌ల ప్రాధాన్యత కంటే దీని ప్రాధాన్యత తక్కువగా ఉంది. Options.cs 1019

private static string GetArgumentName (...., string description)
{
  string[] nameStart;
  if (maxIndex == 1)
  {
    nameStart = new string[]{"{0:", "{"};
  }
  else
  {
    nameStart = new string[]{"{" + index + ":"};
  }
  for (int i = 0; i < nameStart.Length; ++i) 
  {
    int start, j = 0;
    do 
    {
      start = description.IndexOf (nameStart [i], j);
    } 
    while (start >= 0 && j != 0 ? description [j++ - 1] == '{' : false);
    ....
    return maxIndex == 1 ? "VALUE" : "VALUE" + (index + 1);
  }
}

రోగనిర్ధారణ లైన్ కోసం పని చేసింది:

while (start >= 0 && j != 0 ? description [j++ - 1] == '{' : false)

వేరియబుల్ నుండి j పైన ఉన్న కొన్ని పంక్తులు సున్నాకి ప్రారంభించబడ్డాయి, టెర్నరీ ఆపరేటర్ విలువను అందిస్తుంది తప్పుడు. ఈ పరిస్థితి కారణంగా, లూప్ యొక్క శరీరం ఒక్కసారి మాత్రమే అమలు చేయబడుతుంది. ప్రోగ్రామర్ ఉద్దేశించిన విధంగా ఈ కోడ్ ముక్క అస్సలు పని చేయదని నాకు అనిపిస్తోంది.

హెచ్చరిక N6

ఎనలైజర్ హెచ్చరిక: V3022 [CWE-571] వ్యక్తీకరణ 'installedPackageVersions.Count != 1' ఎల్లప్పుడూ నిజం. NugetService.cs 1405

private void remove_nuget_cache_for_package(....)
{
  if (!config.AllVersions && installedPackageVersions.Count > 1)
  {
    const string allVersionsChoice = "All versions";
    if (installedPackageVersions.Count != 1)
    {
      choices.Add(allVersionsChoice);
    }
    ....
  }
  ....
}

ఇక్కడ ఒక విచిత్రమైన స్థితి ఉంది: installPackageVersions.Count != 1ఇది ఎల్లప్పుడూ ఉంటుంది నిజమైన. తరచుగా ఇటువంటి హెచ్చరిక కోడ్‌లో తార్కిక లోపాన్ని సూచిస్తుంది మరియు ఇతర సందర్భాల్లో ఇది అనవసరమైన తనిఖీని సూచిస్తుంది.

హెచ్చరిక N7

ఎనలైజర్ హెచ్చరిక: V3001 '||' యొక్క ఎడమ మరియు కుడి వైపున ఒకే విధమైన ఉప వ్యక్తీకరణలు 'commandArguments.contains("-apikey")' ఉన్నాయి. ఆపరేటర్. ArgumentsUtility.cs 42

public static bool arguments_contain_sensitive_information(string
 commandArguments)
{
  return commandArguments.contains("-install-arguments-sensitive")
  || commandArguments.contains("-package-parameters-sensitive")
  || commandArguments.contains("apikey ")
  || commandArguments.contains("config ")
  || commandArguments.contains("push ")
  || commandArguments.contains("-p ")
  || commandArguments.contains("-p=")
  || commandArguments.contains("-password")
  || commandArguments.contains("-cp ")
  || commandArguments.contains("-cp=")
  || commandArguments.contains("-certpassword")
  || commandArguments.contains("-k ")
  || commandArguments.contains("-k=")
  || commandArguments.contains("-key ")
  || commandArguments.contains("-key=")
  || commandArguments.contains("-apikey")
  || commandArguments.contains("-api-key")
  || commandArguments.contains("-apikey")
  || commandArguments.contains("-api-key");
}

కోడ్ యొక్క ఈ విభాగాన్ని వ్రాసిన ప్రోగ్రామర్ చివరి రెండు పంక్తులను కాపీ చేసి అతికించారు మరియు వాటిని సవరించడం మర్చిపోయారు. దీని కారణంగా, చాక్లెట్ వినియోగదారులు పారామీటర్‌ను వర్తింపజేయలేకపోయారు apikey మరికొన్ని మార్గాలు. పై పారామీటర్‌ల మాదిరిగానే, నేను ఈ క్రింది ఎంపికలను అందించగలను:

commandArguments.contains("-apikey=");
commandArguments.contains("-api-key=");

పెద్ద మొత్తంలో సోర్స్ కోడ్‌తో ఏదైనా ప్రాజెక్ట్‌లో కాపీ-పేస్ట్ లోపాలు త్వరగా లేదా తర్వాత కనిపించే అవకాశం ఎక్కువగా ఉంటుంది మరియు వాటిని ఎదుర్కోవడానికి ఉత్తమ సాధనాల్లో ఒకటి స్టాటిక్ అనాలిసిస్.

PS మరియు ఎప్పటిలాగే, ఈ లోపం బహుళ-లైన్ కండిషన్ చివరిలో కనిపిస్తుంది :). ప్రచురణ చూడండి"చివరి పంక్తి ప్రభావం".

హెచ్చరిక N8

ఎనలైజర్ హెచ్చరిక: V3095 [CWE-476] 'ఇన్‌స్టాల్డ్ ప్యాకేజ్' ఆబ్జెక్ట్ శూన్యానికి వ్యతిరేకంగా ధృవీకరించబడటానికి ముందు ఉపయోగించబడింది. చెక్ లైన్లు: 910, 917. NugetService.cs 910

public virtual ConcurrentDictionary<string, PackageResult> get_outdated(....)
{
  ....
  var pinnedPackageResult = outdatedPackages.GetOrAdd(
    packageName, 
    new PackageResult(installedPackage, 
                      _fileSystem.combine_paths(
                        ApplicationParameters.PackagesLocation, 
                        installedPackage.Id)));
  ....
  if (   installedPackage != null
      && !string.IsNullOrWhiteSpace(installedPackage.Version.SpecialVersion) 
      && !config.UpgradeCommand.ExcludePrerelease)
  {
    ....
  }
  ....
}

క్లాసిక్ తప్పు: మొదట వస్తువు ఇన్‌స్టాల్ చేయబడిన ప్యాకేజీ ఉపయోగించబడుతుంది మరియు తర్వాత తనిఖీ చేయబడుతుంది శూన్య. ఈ డయాగ్నస్టిక్ ప్రోగ్రామ్‌లోని రెండు సమస్యలలో ఒకదాని గురించి చెబుతుంది: ఒకటి ఇన్‌స్టాల్ చేయబడిన ప్యాకేజీ ఎప్పుడూ సమానం కాదు శూన్య, ఇది సందేహాస్పదంగా ఉంది, ఆపై చెక్ అనవసరం, లేదా మేము కోడ్‌లో తీవ్రమైన ఎర్రర్‌ను పొందే అవకాశం ఉంది - శూన్య సూచనను యాక్సెస్ చేసే ప్రయత్నం.

తీర్మానం

కాబట్టి మేము మరొక చిన్న అడుగు తీసుకున్నాము - ఇప్పుడు PVS-స్టూడియోను ఉపయోగించడం మరింత సులభం మరియు మరింత సౌకర్యవంతంగా మారింది. PVS-Studioని ఉపయోగిస్తున్నప్పుడు కూడా తక్కువగా ఉండే కోడ్‌లో తక్కువ సంఖ్యలో లోపాలు ఉన్న Chocolatey ఒక మంచి ప్యాకేజీ మేనేజర్ అని కూడా నేను చెప్పాలనుకుంటున్నాను.

మేము మిమ్మల్ని ఆహ్వానిస్తున్నాము скачать మరియు PVS-స్టూడియోని ప్రయత్నించండి. స్టాటిక్ ఎనలైజర్‌ని క్రమం తప్పకుండా ఉపయోగించడం వల్ల మీ బృందం అభివృద్ధి చేసే కోడ్ నాణ్యత మరియు విశ్వసనీయతను మెరుగుపరుస్తుంది మరియు అనేకం నిరోధించడంలో సహాయపడుతుంది సున్నా రోజు దుర్బలత్వాలు.

PS

ప్రచురణకు ముందు, మేము కథనాన్ని చాక్లెట్ డెవలపర్‌లకు పంపాము మరియు వారు దానిని బాగా స్వీకరించారు. మేము క్లిష్టమైనది ఏదీ కనుగొనలేదు, కానీ వారు, ఉదాహరణకు, "api-key" కీకి సంబంధించి మేము కనుగొన్న బగ్‌ను ఇష్టపడ్డారు.

మీరు ఈ కథనాన్ని ఇంగ్లీష్ మాట్లాడే ప్రేక్షకులతో భాగస్వామ్యం చేయాలనుకుంటే, దయచేసి అనువాద లింక్‌ని ఉపయోగించండి: వ్లాడిస్లావ్ స్టోలియారోవ్. PVS-స్టూడియో ఇప్పుడు చాక్లెట్‌లో ఉంది: Azure DevOps కింద చాక్లెట్‌ని తనిఖీ చేస్తోంది.

మూలం: www.habr.com