PVS-Studio ഇപ്പോൾ ചോക്കലേറ്റിലാണ്: Azure DevOps-ന് കീഴിൽ നിന്ന് ചോക്കലേറ്റ് പരിശോധിക്കുന്നു

ഞങ്ങൾ PVS-Studio ഉപയോഗിക്കുന്നത് കൂടുതൽ സൗകര്യപ്രദമാക്കുന്നത് തുടരുന്നു. ഞങ്ങളുടെ അനലൈസർ ഇപ്പോൾ Windows-നുള്ള പാക്കേജ് മാനേജറായ ചോക്കലേറ്റിയിൽ ലഭ്യമാണ്. ഇത് പിവിഎസ്-സ്റ്റുഡിയോയുടെ വിന്യാസം സുഗമമാക്കുമെന്ന് ഞങ്ങൾ വിശ്വസിക്കുന്നു, പ്രത്യേകിച്ചും, ക്ലൗഡ് സേവനങ്ങളിൽ. ദൂരത്തേക്ക് പോകാതിരിക്കാൻ, അതേ ചോക്കലേറ്റിന്റെ സോഴ്സ് കോഡ് പരിശോധിക്കാം. Azure DevOps ഒരു CI സിസ്റ്റമായി പ്രവർത്തിക്കും.

ക്ലൗഡ് സിസ്റ്റങ്ങളുമായുള്ള സംയോജനം എന്ന വിഷയത്തെക്കുറിച്ചുള്ള ഞങ്ങളുടെ മറ്റ് ലേഖനങ്ങളുടെ ഒരു ലിസ്റ്റ് ഇതാ:

• PVS-Studio മേഘങ്ങളിലേക്ക് പോകുന്നു: Azure DevOps
• പിവിഎസ്-സ്റ്റുഡിയോ മേഘങ്ങളിലേക്ക് പോകുന്നു: ട്രാവിസ് സിഐ
• PVS-സ്റ്റുഡിയോ മേഘങ്ങളിലേക്ക് പോകുന്നു: CircleCI
• PVS-Studio മേഘങ്ങളിലേക്ക് പോകുന്നു: GitLab CI/CD

Azure DevOps-മായി സംയോജിപ്പിക്കുന്നതിനെക്കുറിച്ചുള്ള ആദ്യ ലേഖനം ശ്രദ്ധിക്കാൻ ഞാൻ നിങ്ങളെ ഉപദേശിക്കുന്നു, കാരണം ഈ സാഹചര്യത്തിൽ തനിപ്പകർപ്പാക്കാതിരിക്കാൻ ചില പോയിന്റുകൾ ഒഴിവാക്കിയിരിക്കുന്നു.

അതിനാൽ, ഈ ലേഖനത്തിലെ നായകന്മാർ:

പിവിഎസ്-സ്റ്റുഡിയോ C, C++, C#, Java എന്നിവയിൽ എഴുതിയ പ്രോഗ്രാമുകളിലെ പിശകുകളും സാധ്യതയുള്ള കേടുപാടുകളും തിരിച്ചറിയാൻ രൂപകൽപ്പന ചെയ്ത ഒരു സ്റ്റാറ്റിക് കോഡ് വിശകലന ഉപകരണമാണ്. 64-ബിറ്റ് വിൻഡോസ്, ലിനക്സ്, മാകോസ് സിസ്റ്റങ്ങളിൽ പ്രവർത്തിക്കുന്നു, കൂടാതെ 32-ബിറ്റ്, 64-ബിറ്റ്, ഉൾച്ചേർത്ത ARM പ്ലാറ്റ്‌ഫോമുകൾക്കായി രൂപകൽപ്പന ചെയ്‌ത കോഡ് വിശകലനം ചെയ്യാൻ കഴിയും. നിങ്ങളുടെ പ്രോജക്‌റ്റുകൾ പരിശോധിക്കാൻ സ്റ്റാറ്റിക് കോഡ് വിശകലനം ചെയ്യുന്നത് ഇതാദ്യമാണെങ്കിൽ, നിങ്ങൾ സ്വയം പരിചയപ്പെടാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു ലേഖനം ഏറ്റവും രസകരമായ പിവിഎസ്-സ്റ്റുഡിയോ മുന്നറിയിപ്പുകൾ എങ്ങനെ വേഗത്തിൽ കാണാമെന്നും ഈ ഉപകരണത്തിന്റെ കഴിവുകൾ എങ്ങനെ വിലയിരുത്താമെന്നും.

അസുർ ഡെവൊപ്‌സ് - മുഴുവൻ വികസന പ്രക്രിയയും സംയുക്തമായി ഉൾക്കൊള്ളുന്ന ഒരു കൂട്ടം ക്ലൗഡ് സേവനങ്ങൾ. സോഫ്‌റ്റ്‌വെയർ സൃഷ്‌ടിക്കുന്ന പ്രക്രിയ വേഗത്തിലാക്കാനും അതിന്റെ ഗുണനിലവാരം മെച്ചപ്പെടുത്താനും നിങ്ങളെ അനുവദിക്കുന്ന അസൂർ പൈപ്പ്‌ലൈനുകൾ, അസൂർ ബോർഡുകൾ, അസൂർ ആർട്ടിഫാക്‌റ്റുകൾ, അസൂർ റിപ്പോസ്, അസൂർ ടെസ്റ്റ് പ്ലാനുകൾ തുടങ്ങിയ ഉപകരണങ്ങൾ ഈ പ്ലാറ്റ്‌ഫോമിൽ ഉൾപ്പെടുന്നു.

ചോക്കലേറ്റ് വിൻഡോസിനായുള്ള ഒരു ഓപ്പൺ സോഴ്‌സ് പാക്കേജ് മാനേജരാണ്. വിൻഡോസ് ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിൽ ഇൻസ്റ്റാളേഷൻ മുതൽ അപ്‌ഡേറ്റ് ചെയ്യലും അൺഇൻസ്റ്റാളുചെയ്യലും വരെയുള്ള മുഴുവൻ സോഫ്റ്റ്‌വെയർ ലൈഫ് സൈക്കിളും ഓട്ടോമേറ്റ് ചെയ്യുക എന്നതാണ് പദ്ധതിയുടെ ലക്ഷ്യം.

ചോക്കലേറ്റ് ഉപയോഗിക്കുന്നതിനെക്കുറിച്ച്

പാക്കേജ് മാനേജർ എങ്ങനെ ഇൻസ്റ്റാൾ ചെയ്യാമെന്ന് ഇതിൽ കാണാം ലിങ്ക്. അനലൈസർ ഇൻസ്റ്റാൾ ചെയ്യുന്നതിനുള്ള പൂർണ്ണമായ ഡോക്യുമെന്റേഷൻ ഇവിടെ ലഭ്യമാണ് ലിങ്ക് ചോക്കലേറ്റ് പാക്കേജ് മാനേജർ വിഭാഗം ഉപയോഗിച്ചുള്ള ഇൻസ്റ്റാളേഷൻ കാണുക. അവിടെ നിന്നുള്ള ചില പോയിന്റുകൾ ഞാൻ ചുരുക്കമായി ആവർത്തിക്കുന്നു.

അനലൈസറിന്റെ ഏറ്റവും പുതിയ പതിപ്പ് ഇൻസ്റ്റാൾ ചെയ്യാനുള്ള കമാൻഡ്:

choco install pvs-studio

PVS-Studio പാക്കേജിന്റെ ഒരു പ്രത്യേക പതിപ്പ് ഇൻസ്റ്റാൾ ചെയ്യാനുള്ള കമാൻഡ്:

choco install pvs-studio --version=7.05.35617.2075

സ്ഥിരസ്ഥിതിയായി, അനലൈസറിന്റെ കോർ, കോർ ഘടകം മാത്രമേ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുള്ളൂ. മറ്റെല്ലാ ഫ്ലാഗുകളും (Standalone, JavaCore, IDEA, MSVS2010, MSVS2012, MSVS2013, MSVS2015, MSVS2017, MSVS2019) --package-parameters ഉപയോഗിച്ച് കൈമാറാനാകും.

വിഷ്വൽ സ്റ്റുഡിയോ 2019-നുള്ള പ്ലഗിൻ ഉപയോഗിച്ച് അനലൈസർ ഇൻസ്റ്റാൾ ചെയ്യുന്ന ഒരു കമാൻഡിന്റെ ഉദാഹരണം:

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

ഇപ്പോൾ Azure DevOps-ന് കീഴിൽ അനലൈസറിന്റെ സൗകര്യപ്രദമായ ഉപയോഗത്തിന്റെ ഒരു ഉദാഹരണം നോക്കാം.

കമപ്പെടുത്തല്

ഒരു അക്കൗണ്ട് രജിസ്റ്റർ ചെയ്യുക, ഒരു ബിൽഡ് പൈപ്പ്‌ലൈൻ സൃഷ്ടിക്കുക, GitHub ശേഖരത്തിൽ സ്ഥിതി ചെയ്യുന്ന ഒരു പ്രോജക്‌റ്റുമായി നിങ്ങളുടെ അക്കൗണ്ട് സമന്വയിപ്പിക്കുക തുടങ്ങിയ പ്രശ്‌നങ്ങളെക്കുറിച്ച് ഒരു പ്രത്യേക വിഭാഗം ഉണ്ടെന്ന് ഞാൻ നിങ്ങളെ ഓർമ്മിപ്പിക്കട്ടെ. ഒരു ലേഖനം. ഒരു കോൺഫിഗറേഷൻ ഫയൽ എഴുതിക്കൊണ്ട് ഞങ്ങളുടെ സജ്ജീകരണം ഉടൻ ആരംഭിക്കും.

ആദ്യം, നമുക്ക് ഒരു ലോഞ്ച് ട്രിഗർ സജ്ജീകരിക്കാം, മാറ്റങ്ങൾക്ക് വേണ്ടി മാത്രമാണ് ഞങ്ങൾ സമാരംഭിക്കുന്നത് എന്ന് സൂചിപ്പിക്കുന്നു യജമാനന് ശാഖ:

trigger:
- master

അടുത്തതായി നമ്മൾ ഒരു വെർച്വൽ മെഷീൻ തിരഞ്ഞെടുക്കേണ്ടതുണ്ട്. ഇപ്പോൾ ഇത് വിൻഡോസ് സെർവർ 2019, വിഷ്വൽ സ്റ്റുഡിയോ 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 и പി.വി.എസ്.കെ.ഇ - ക്രമീകരണങ്ങളിൽ ഞങ്ങൾ വ്യക്തമാക്കുന്ന മൂല്യങ്ങളുടെ വേരിയബിളുകളുടെ പേരുകൾ. അവർ പിവിഎസ്-സ്റ്റുഡിയോ ലോഗിൻ, ലൈസൻസ് കീ എന്നിവ സംഭരിക്കും. അവയുടെ മൂല്യങ്ങൾ സജ്ജമാക്കാൻ, മെനു തുറക്കുക വേരിയബിളുകൾ->പുതിയ വേരിയബിൾ. നമുക്ക് വേരിയബിളുകൾ ഉണ്ടാക്കാം PVSNAME ലോഗിൻ ചെയ്യുന്നതിനും പി.വി.എസ്.കെ.ഇ അനലൈസർ കീയ്ക്കായി. ബോക്സ് ചെക്ക് ചെയ്യാൻ മറക്കരുത് ഈ മൂല്യം രഹസ്യമായി സൂക്ഷിക്കുക വേണ്ടി പി.വി.എസ്.കെ.ഇ. കമാൻഡ് കോഡ്:

с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_ നിലവിലുണ്ട്.

പരിഗണിച്ച ശകലത്തിൽ, ഇതൊരു ചെറിയ പിഴവാണ്. അതെ, & ഓപ്പറേറ്ററെ && ഓപ്പറേറ്റർ ഉപയോഗിച്ച് മാറ്റി ഈ അവസ്ഥ ഒപ്റ്റിമൈസ് ചെയ്യാൻ കഴിയും, എന്നാൽ പ്രായോഗിക കാഴ്ചപ്പാടിൽ, ഇത് ഒന്നിനെയും ബാധിക്കില്ല. എന്നിരുന്നാലും, മറ്റ് സന്ദർഭങ്ങളിൽ, പദപ്രയോഗത്തിന്റെ വലതുഭാഗം തെറ്റായ/അസാധുവായ മൂല്യങ്ങൾ ഉപയോഗിച്ച് കൈകാര്യം ചെയ്യുമ്പോൾ & &&& തമ്മിലുള്ള ആശയക്കുഴപ്പം ഗുരുതരമായ പ്രശ്നങ്ങൾ ഉണ്ടാക്കാം. ഉദാഹരണത്തിന്, ഞങ്ങളുടെ പിശക് ശേഖരത്തിൽ, V3093 ഡയഗ്നോസ്റ്റിക് ഉപയോഗിച്ച് തിരിച്ചറിഞ്ഞു, ഈ കേസ് ഉണ്ട്:

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

സൂചിക ആണെങ്കിലും k തെറ്റാണ്, ഒരു അറേ എലമെന്റ് ആക്സസ് ചെയ്യാൻ ഇത് ഉപയോഗിക്കും. തൽഫലമായി, ഒരു അപവാദം എറിയപ്പെടും IndexOutOfRangeException.

മുന്നറിയിപ്പുകൾ N3, N4

അനലൈസർ മുന്നറിയിപ്പ്: V3022 [CWE-571] 'shortPrompt' എന്ന പ്രയോഗം എല്ലായ്പ്പോഴും ശരിയാണ്. InteractivePrompt.cs 101
അനലൈസർ മുന്നറിയിപ്പ്: V3022 [CWE-571] 'shortPrompt' എന്ന പ്രയോഗം എല്ലായ്പ്പോഴും ശരിയാണ്. 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");
}

കോഡിന്റെ ഈ ഭാഗം എഴുതിയ പ്രോഗ്രാമർ അവസാന രണ്ട് വരികൾ പകർത്തി ഒട്ടിച്ചു, അവ എഡിറ്റുചെയ്യാൻ മറന്നു. ഇക്കാരണത്താൽ, ചോക്കലേറ്റ് ഉപയോക്താക്കൾക്ക് പാരാമീറ്റർ പ്രയോഗിക്കാൻ കഴിഞ്ഞില്ല ആപികെ ഒന്നുരണ്ടു വഴികൾ കൂടി. മുകളിലുള്ള പാരാമീറ്ററുകൾക്ക് സമാനമായി, എനിക്ക് ഇനിപ്പറയുന്ന ഓപ്ഷനുകൾ വാഗ്ദാനം ചെയ്യാൻ കഴിയും:

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-Studio ഉപയോഗിക്കുമ്പോൾ ഇതിലും കുറവായ കോഡിൽ ചെറിയ പിശകുകളുള്ള ഒരു നല്ല പാക്കേജ് മാനേജരാണ് Chocolatey എന്നും ഞാൻ പറയാൻ ആഗ്രഹിക്കുന്നു.

ഞങ്ങൾ ക്ഷണിക്കുന്നു скачать കൂടാതെ PVS-Studio പരീക്ഷിക്കുക. ഒരു സ്റ്റാറ്റിക് അനലൈസറിന്റെ പതിവ് ഉപയോഗം നിങ്ങളുടെ ടീം വികസിപ്പിക്കുന്ന കോഡിന്റെ ഗുണനിലവാരവും വിശ്വാസ്യതയും മെച്ചപ്പെടുത്തുകയും പലതും തടയാൻ സഹായിക്കുകയും ചെയ്യും പൂജ്യം ദിവസത്തെ കേടുപാടുകൾ.

പി.എസ്

പ്രസിദ്ധീകരിക്കുന്നതിന് മുമ്പ്, ഞങ്ങൾ ലേഖനം ചോക്ലേറ്റ് ഡെവലപ്പർമാർക്ക് അയച്ചു, അവർക്ക് അത് നന്നായി ലഭിച്ചു. നിർണായകമായ ഒന്നും ഞങ്ങൾ കണ്ടെത്തിയില്ല, പക്ഷേ, ഉദാഹരണത്തിന്, "api-key" കീയുമായി ബന്ധപ്പെട്ട് ഞങ്ങൾ കണ്ടെത്തിയ ബഗ് അവർ ഇഷ്ടപ്പെട്ടു.

ഇംഗ്ലീഷ് സംസാരിക്കുന്ന പ്രേക്ഷകരുമായി ഈ ലേഖനം പങ്കിടാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, വിവർത്തന ലിങ്ക് ഉപയോഗിക്കുക: Vladislav Stolyarov. പിവിഎസ്-സ്റ്റുഡിയോ ഇപ്പോൾ ചോക്കലേറ്റിലാണ്: അസൂർ ഡെവോപ്‌സിന് കീഴിൽ ചോക്ലേറ്റി പരിശോധിക്കുന്നു.

അവലംബം: www.habr.com