PVS-ਸਟੂਡੀਓ ਹੁਣ ਚਾਕਲੇਟ ਵਿੱਚ ਹੈ: Azure DevOps ਦੇ ਹੇਠਾਂ ਤੋਂ ਚਾਕਲੇਟ ਦੀ ਜਾਂਚ ਕਰ ਰਿਹਾ ਹੈ

ਅਸੀਂ PVS-ਸਟੂਡੀਓ ਦੀ ਵਰਤੋਂ ਨੂੰ ਹੋਰ ਸੁਵਿਧਾਜਨਕ ਬਣਾਉਣਾ ਜਾਰੀ ਰੱਖਦੇ ਹਾਂ। ਸਾਡਾ ਵਿਸ਼ਲੇਸ਼ਕ ਹੁਣ Chocolatey ਵਿੱਚ ਉਪਲਬਧ ਹੈ, ਵਿੰਡੋਜ਼ ਲਈ ਇੱਕ ਪੈਕੇਜ ਮੈਨੇਜਰ। ਸਾਡਾ ਮੰਨਣਾ ਹੈ ਕਿ ਇਹ PVS-ਸਟੂਡੀਓ ਦੀ ਤੈਨਾਤੀ ਦੀ ਸਹੂਲਤ ਦੇਵੇਗਾ, ਖਾਸ ਤੌਰ 'ਤੇ, ਕਲਾਉਡ ਸੇਵਾਵਾਂ ਵਿੱਚ। ਦੂਰ ਨਾ ਜਾਣ ਲਈ, ਆਓ ਉਸੇ ਚਾਕਲੇਟ ਦੇ ਸਰੋਤ ਕੋਡ ਦੀ ਜਾਂਚ ਕਰੀਏ। Azure DevOps ਇੱਕ CI ਸਿਸਟਮ ਵਜੋਂ ਕੰਮ ਕਰੇਗਾ।

ਇੱਥੇ ਕਲਾਉਡ ਪ੍ਰਣਾਲੀਆਂ ਨਾਲ ਏਕੀਕਰਣ ਦੇ ਵਿਸ਼ੇ 'ਤੇ ਸਾਡੇ ਹੋਰ ਲੇਖਾਂ ਦੀ ਸੂਚੀ ਹੈ:

• PVS-ਸਟੂਡੀਓ ਬੱਦਲਾਂ 'ਤੇ ਜਾਂਦਾ ਹੈ: Azure DevOps
• ਪੀਵੀਐਸ-ਸਟੂਡੀਓ ਬੱਦਲਾਂ 'ਤੇ ਜਾਂਦਾ ਹੈ: ਟ੍ਰੈਵਿਸ ਸੀਆਈ
• ਪੀਵੀਐਸ-ਸਟੂਡੀਓ ਬੱਦਲਾਂ 'ਤੇ ਜਾਂਦਾ ਹੈ: ਸਰਕਲਸੀਆਈ
• PVS-ਸਟੂਡੀਓ ਬੱਦਲਾਂ 'ਤੇ ਜਾਂਦਾ ਹੈ: GitLab CI/CD

ਮੈਂ ਤੁਹਾਨੂੰ Azure DevOps ਨਾਲ ਏਕੀਕਰਣ ਬਾਰੇ ਪਹਿਲੇ ਲੇਖ ਵੱਲ ਧਿਆਨ ਦੇਣ ਦੀ ਸਲਾਹ ਦਿੰਦਾ ਹਾਂ, ਕਿਉਂਕਿ ਇਸ ਕੇਸ ਵਿੱਚ ਕੁਝ ਨੁਕਤੇ ਛੱਡ ਦਿੱਤੇ ਗਏ ਹਨ ਤਾਂ ਜੋ ਡੁਪਲੀਕੇਟ ਨਾ ਕੀਤਾ ਜਾ ਸਕੇ।

ਇਸ ਲਈ, ਇਸ ਲੇਖ ਦੇ ਹੀਰੋ:

ਪੀਵੀਐਸ-ਸਟੂਡੀਓ ਇੱਕ ਸਥਿਰ ਕੋਡ ਵਿਸ਼ਲੇਸ਼ਣ ਟੂਲ ਹੈ ਜੋ C, C++, C# ਅਤੇ Java ਵਿੱਚ ਲਿਖੇ ਪ੍ਰੋਗਰਾਮਾਂ ਵਿੱਚ ਤਰੁੱਟੀਆਂ ਅਤੇ ਸੰਭਾਵੀ ਕਮਜ਼ੋਰੀਆਂ ਦੀ ਪਛਾਣ ਕਰਨ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ। 64-ਬਿੱਟ ਵਿੰਡੋਜ਼, ਲੀਨਕਸ, ਅਤੇ ਮੈਕੋਸ ਸਿਸਟਮਾਂ 'ਤੇ ਚੱਲਦਾ ਹੈ, ਅਤੇ 32-ਬਿੱਟ, 64-ਬਿੱਟ, ਅਤੇ ਏਮਬੈਡ ਕੀਤੇ ARM ਪਲੇਟਫਾਰਮਾਂ ਲਈ ਡਿਜ਼ਾਈਨ ਕੀਤੇ ਕੋਡ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰ ਸਕਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਪਹਿਲੀ ਵਾਰ ਆਪਣੇ ਪ੍ਰੋਜੈਕਟਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਸਥਿਰ ਕੋਡ ਵਿਸ਼ਲੇਸ਼ਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਅਸੀਂ ਸਿਫ਼ਾਰਿਸ਼ ਕਰਦੇ ਹਾਂ ਕਿ ਤੁਸੀਂ ਆਪਣੇ ਆਪ ਨੂੰ ਇਸ ਤੋਂ ਜਾਣੂ ਕਰੋ ਲੇਖ ਸਭ ਤੋਂ ਦਿਲਚਸਪ PVS-ਸਟੂਡੀਓ ਚੇਤਾਵਨੀਆਂ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਕਿਵੇਂ ਵੇਖਣਾ ਹੈ ਅਤੇ ਇਸ ਟੂਲ ਦੀਆਂ ਸਮਰੱਥਾਵਾਂ ਦਾ ਮੁਲਾਂਕਣ ਕਰਨਾ ਹੈ।

Azure DevOps - ਕਲਾਉਡ ਸੇਵਾਵਾਂ ਦਾ ਇੱਕ ਸਮੂਹ ਜੋ ਸਾਂਝੇ ਤੌਰ 'ਤੇ ਪੂਰੀ ਵਿਕਾਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਕਵਰ ਕਰਦਾ ਹੈ। ਇਸ ਪਲੇਟਫਾਰਮ ਵਿੱਚ Azure Pipelines, Azure Boards, Azure Artifacts, Azure Repos, Azure Test Plans ਵਰਗੇ ਟੂਲ ਸ਼ਾਮਲ ਹਨ, ਜੋ ਤੁਹਾਨੂੰ ਸੌਫਟਵੇਅਰ ਬਣਾਉਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਤੇਜ਼ ਕਰਨ ਅਤੇ ਇਸਦੀ ਗੁਣਵੱਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਨ।

ਚੈਕਕੀਲੀ ਵਿੰਡੋਜ਼ ਲਈ ਇੱਕ ਓਪਨ ਸੋਰਸ ਪੈਕੇਜ ਮੈਨੇਜਰ ਹੈ। ਪ੍ਰੋਜੈਕਟ ਦਾ ਟੀਚਾ ਵਿੰਡੋਜ਼ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮਾਂ 'ਤੇ ਇੰਸਟਾਲੇਸ਼ਨ ਤੋਂ ਲੈ ਕੇ ਅਪਡੇਟ ਕਰਨ ਅਤੇ ਅਣਇੰਸਟੌਲੇਸ਼ਨ ਤੱਕ ਪੂਰੇ ਸੌਫਟਵੇਅਰ ਜੀਵਨ ਚੱਕਰ ਨੂੰ ਸਵੈਚਾਲਤ ਕਰਨਾ ਹੈ।

ਚਾਕਲੇਟ ਦੀ ਵਰਤੋਂ ਕਰਨ ਬਾਰੇ

ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਇਸ 'ਤੇ ਪੈਕੇਜ ਮੈਨੇਜਰ ਨੂੰ ਕਿਵੇਂ ਇੰਸਟਾਲ ਕਰਨਾ ਹੈ ਲਿੰਕ ਨੂੰ. ਵਿਸ਼ਲੇਸ਼ਕ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਲਈ ਪੂਰੇ ਦਸਤਾਵੇਜ਼ ਇੱਥੇ ਉਪਲਬਧ ਹਨ ਲਿੰਕ ਨੂੰ Chocolatey ਪੈਕੇਜ ਮੈਨੇਜਰ ਸੈਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੰਸਟਾਲੇਸ਼ਨ ਦੇਖੋ। ਮੈਂ ਉਥੋਂ ਕੁਝ ਨੁਕਤੇ ਸੰਖੇਪ ਵਿੱਚ ਦੁਹਰਾਵਾਂਗਾ।

ਵਿਸ਼ਲੇਸ਼ਕ ਦੇ ਨਵੀਨਤਮ ਸੰਸਕਰਣ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਲਈ ਕਮਾਂਡ:

choco install pvs-studio

PVS-ਸਟੂਡੀਓ ਪੈਕੇਜ ਦੇ ਇੱਕ ਖਾਸ ਸੰਸਕਰਣ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਲਈ ਕਮਾਂਡ:

choco install pvs-studio --version=7.05.35617.2075

ਮੂਲ ਰੂਪ ਵਿੱਚ, ਕੇਵਲ ਵਿਸ਼ਲੇਸ਼ਕ ਦਾ ਕੋਰ, ਕੋਰ ਕੰਪੋਨੈਂਟ, ਸਥਾਪਿਤ ਹੁੰਦਾ ਹੈ। ਹੋਰ ਸਾਰੇ ਫਲੈਗ (ਸਟੈਂਡਅਲੋਨ, JavaCore, IDEA, MSVS2010, MSVS2012, MSVS2013, MSVS2015, MSVS2017, MSVS2019) --package-ਪੈਰਾਮੀਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪਾਸ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ।

ਇੱਕ ਕਮਾਂਡ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਜੋ ਵਿਜ਼ੂਅਲ ਸਟੂਡੀਓ 2019 ਲਈ ਇੱਕ ਪਲੱਗਇਨ ਦੇ ਨਾਲ ਇੱਕ ਵਿਸ਼ਲੇਸ਼ਕ ਸਥਾਪਤ ਕਰੇਗੀ:

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

ਆਉ ਹੁਣ Azure DevOps ਦੇ ਅਧੀਨ ਵਿਸ਼ਲੇਸ਼ਕ ਦੀ ਸੁਵਿਧਾਜਨਕ ਵਰਤੋਂ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਵੇਖੀਏ।

ਵਿਵਸਥਾ

ਮੈਂ ਤੁਹਾਨੂੰ ਯਾਦ ਦਿਵਾਉਂਦਾ ਹਾਂ ਕਿ ਇੱਕ ਖਾਤਾ ਰਜਿਸਟਰ ਕਰਨਾ, ਇੱਕ ਬਿਲਡ ਪਾਈਪਲਾਈਨ ਬਣਾਉਣਾ ਅਤੇ GitHub ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਸਥਿਤ ਇੱਕ ਪ੍ਰੋਜੈਕਟ ਨਾਲ ਤੁਹਾਡੇ ਖਾਤੇ ਨੂੰ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ ਕਰਨ ਵਰਗੇ ਮੁੱਦਿਆਂ ਬਾਰੇ ਇੱਕ ਵੱਖਰਾ ਸੈਕਸ਼ਨ ਹੈ। ਲੇਖ. ਸਾਡਾ ਸੈੱਟਅੱਪ ਤੁਰੰਤ ਇੱਕ ਸੰਰਚਨਾ ਫਾਇਲ ਲਿਖਣ ਨਾਲ ਸ਼ੁਰੂ ਹੋਵੇਗਾ।

ਪਹਿਲਾਂ, ਆਓ ਇੱਕ ਲਾਂਚ ਟ੍ਰਿਗਰ ਸੈਟ ਅਪ ਕਰੀਏ, ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਅਸੀਂ ਸਿਰਫ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਲਈ ਲਾਂਚ ਕਰਦੇ ਹਾਂ ਮਾਸਟਰ ਸ਼ਾਖਾ:

trigger:
- master

ਅੱਗੇ ਸਾਨੂੰ ਇੱਕ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਦੀ ਚੋਣ ਕਰਨ ਦੀ ਲੋੜ ਹੈ. ਹੁਣ ਲਈ ਇਹ ਵਿੰਡੋਜ਼ ਸਰਵਰ 2019 ਅਤੇ ਵਿਜ਼ੂਅਲ ਸਟੂਡੀਓ 2019 ਦੇ ਨਾਲ ਇੱਕ ਮਾਈਕ੍ਰੋਸਾਫਟ-ਹੋਸਟਡ ਏਜੰਟ ਹੋਵੇਗਾ:

pool:
  vmImage: 'windows-latest'

ਆਉ ਸੰਰਚਨਾ ਫਾਇਲ ਦੇ ਮੁੱਖ ਭਾਗ (ਬਲਾਕ ਕਦਮ). ਇਸ ਤੱਥ ਦੇ ਬਾਵਜੂਦ ਕਿ ਤੁਸੀਂ ਇੱਕ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਵਿੱਚ ਆਪਹੁਦਰੇ ਸੌਫਟਵੇਅਰ ਨੂੰ ਸਥਾਪਿਤ ਨਹੀਂ ਕਰ ਸਕਦੇ, ਮੈਂ ਇੱਕ ਡੌਕਰ ਕੰਟੇਨਰ ਨਹੀਂ ਜੋੜਿਆ. ਅਸੀਂ Azure DevOps ਲਈ ਇੱਕ ਐਕਸਟੈਂਸ਼ਨ ਵਜੋਂ Chocolatey ਨੂੰ ਸ਼ਾਮਲ ਕਰ ਸਕਦੇ ਹਾਂ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਆਓ ਚਲੀਏ ਲਿੰਕ ਨੂੰ. ਕਲਿੱਕ ਕਰੋ ਇਹ ਮੁਫਤ ਪ੍ਰਾਪਤ ਕਰੋ. ਅੱਗੇ, ਜੇਕਰ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਅਧਿਕਾਰਤ ਹੋ, ਤਾਂ ਬਸ ਆਪਣਾ ਖਾਤਾ ਚੁਣੋ, ਅਤੇ ਜੇਕਰ ਨਹੀਂ, ਤਾਂ ਅਧਿਕਾਰ ਤੋਂ ਬਾਅਦ ਉਹੀ ਕੰਮ ਕਰੋ।

ਇੱਥੇ ਤੁਹਾਨੂੰ ਇਹ ਚੁਣਨ ਦੀ ਲੋੜ ਹੈ ਕਿ ਅਸੀਂ ਐਕਸਟੈਂਸ਼ਨ ਕਿੱਥੇ ਜੋੜਾਂਗੇ ਅਤੇ ਬਟਨ 'ਤੇ ਕਲਿੱਕ ਕਰੋ ਇੰਸਟਾਲ ਕਰੋ.

ਸਫਲ ਇੰਸਟਾਲੇਸ਼ਨ ਦੇ ਬਾਅਦ, ਕਲਿੱਕ ਕਰੋ ਸੰਗਠਨ ਨੂੰ ਅੱਗੇ ਵਧੋ:

ਤੁਸੀਂ ਹੁਣ ਵਿੰਡੋ ਵਿੱਚ ਚਾਕਲੇਟ ਟਾਸਕ ਲਈ ਟੈਂਪਲੇਟ ਦੇਖ ਸਕਦੇ ਹੋ ਕੰਮ ਇੱਕ ਸੰਰਚਨਾ ਫਾਇਲ ਨੂੰ ਸੰਪਾਦਿਤ ਕਰਨ ਵੇਲੇ azure-pipelines.yml:

ਚਾਕਲੇਟ 'ਤੇ ਕਲਿੱਕ ਕਰੋ ਅਤੇ ਖੇਤਰਾਂ ਦੀ ਸੂਚੀ ਵੇਖੋ:

ਇੱਥੇ ਸਾਨੂੰ ਚੋਣ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਇੰਸਟਾਲ ਕਰੋ ਟੀਮਾਂ ਨਾਲ ਮੈਦਾਨ ਵਿੱਚ। IN Nuspec ਫਾਈਲ ਦਾ ਨਾਮ ਲੋੜੀਂਦੇ ਪੈਕੇਜ ਦਾ ਨਾਮ ਦੱਸੋ - 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 

ਅਸੀਂ PlogConverter ਉਪਯੋਗਤਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਪਣੀ ਰਿਪੋਰਟ ਨੂੰ 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_exists.

ਵਿਚਾਰੇ ਗਏ ਟੁਕੜੇ ਵਿੱਚ, ਇਹ ਇੱਕ ਮਾਮੂਲੀ ਨੁਕਸ ਹੈ। ਹਾਂ, & operator ਨੂੰ && ਆਪਰੇਟਰ ਨਾਲ ਬਦਲ ਕੇ ਇਸ ਸਥਿਤੀ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ, ਪਰ ਵਿਹਾਰਕ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ, ਇਹ ਕਿਸੇ ਵੀ ਚੀਜ਼ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਨਹੀਂ ਕਰਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਦੂਜੇ ਮਾਮਲਿਆਂ ਵਿੱਚ, & ਅਤੇ && ਵਿਚਕਾਰ ਉਲਝਣ ਗੰਭੀਰ ਸਮੱਸਿਆਵਾਂ ਪੈਦਾ ਕਰ ਸਕਦੀ ਹੈ ਜਦੋਂ ਸਮੀਕਰਨ ਦੇ ਸੱਜੇ ਪਾਸੇ ਨੂੰ ਗਲਤ/ਅਵੈਧ ਮੁੱਲਾਂ ਨਾਲ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਸਾਡੇ ਗਲਤੀ ਸੰਗ੍ਰਹਿ ਵਿੱਚ, 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);
    }
    ....
  }
  ....
}

ਇੱਥੇ ਇੱਕ ਅਜੀਬ ਨੇਸਟਡ ਸਥਿਤੀ ਹੈ: ਇੰਸਟਾਲ ਪੈਕਜ ਵਰਜ਼ਨ. ਕਾਉਂਟ!= 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] 'installedPackage' ਵਸਤੂ ਨੂੰ null ਦੇ ਵਿਰੁੱਧ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਵਰਤਿਆ ਗਿਆ ਸੀ। ਲਾਈਨਾਂ ਦੀ ਜਾਂਚ ਕਰੋ: 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)
  {
    ....
  }
  ....
}

ਕਲਾਸਿਕ ਗਲਤੀ: ਪਹਿਲਾਂ ਵਸਤੂ ਇੰਸਟਾਲ ਪੈਕੇਜ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਫਿਰ ਜਾਂਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ null. ਇਹ ਡਾਇਗਨੌਸਟਿਕ ਸਾਨੂੰ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਦੋ ਸਮੱਸਿਆਵਾਂ ਵਿੱਚੋਂ ਇੱਕ ਬਾਰੇ ਦੱਸਦਾ ਹੈ: ਜਾਂ ਤਾਂ ਇੰਸਟਾਲ ਪੈਕੇਜ ਕਦੇ ਬਰਾਬਰ null, ਜੋ ਕਿ ਸ਼ੱਕੀ ਹੈ, ਅਤੇ ਫਿਰ ਜਾਂਚ ਬੇਲੋੜੀ ਹੈ, ਜਾਂ ਅਸੀਂ ਸੰਭਾਵੀ ਤੌਰ 'ਤੇ ਕੋਡ ਵਿੱਚ ਇੱਕ ਗੰਭੀਰ ਗਲਤੀ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਾਂ - ਇੱਕ ਨਲ ਸੰਦਰਭ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼।

ਸਿੱਟਾ

ਇਸ ਲਈ ਅਸੀਂ ਇੱਕ ਹੋਰ ਛੋਟਾ ਕਦਮ ਚੁੱਕਿਆ ਹੈ - ਹੁਣ PVS-ਸਟੂਡੀਓ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਹੋਰ ਵੀ ਆਸਾਨ ਅਤੇ ਸੁਵਿਧਾਜਨਕ ਹੋ ਗਿਆ ਹੈ। ਮੈਂ ਇਹ ਵੀ ਕਹਿਣਾ ਚਾਹਾਂਗਾ ਕਿ Chocolatey ਇੱਕ ਵਧੀਆ ਪੈਕੇਜ ਮੈਨੇਜਰ ਹੈ ਜਿਸ ਵਿੱਚ ਕੋਡ ਵਿੱਚ ਥੋੜ੍ਹੇ ਜਿਹੇ ਤਰੁੱਟੀਆਂ ਹਨ, ਜੋ PVS-Studio ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ ਹੋਰ ਵੀ ਘੱਟ ਹੋ ਸਕਦੀਆਂ ਹਨ।

ਸਾਨੂੰ ਸੱਦਾ скачать ਅਤੇ PVS-ਸਟੂਡੀਓ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ। ਇੱਕ ਸਥਿਰ ਵਿਸ਼ਲੇਸ਼ਕ ਦੀ ਨਿਯਮਤ ਵਰਤੋਂ ਤੁਹਾਡੀ ਟੀਮ ਦੁਆਰਾ ਵਿਕਸਤ ਕੀਤੇ ਕੋਡ ਦੀ ਗੁਣਵੱਤਾ ਅਤੇ ਭਰੋਸੇਯੋਗਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰੇਗੀ ਅਤੇ ਕਈਆਂ ਨੂੰ ਰੋਕਣ ਵਿੱਚ ਮਦਦ ਕਰੇਗੀ ਜ਼ੀਰੋ ਦਿਨ ਦੀਆਂ ਕਮਜ਼ੋਰੀਆਂ.

PS

ਪ੍ਰਕਾਸ਼ਨ ਤੋਂ ਪਹਿਲਾਂ, ਅਸੀਂ ਲੇਖ ਨੂੰ ਚਾਕਲੇਟ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਭੇਜਿਆ, ਅਤੇ ਉਹਨਾਂ ਨੇ ਇਸਨੂੰ ਚੰਗੀ ਤਰ੍ਹਾਂ ਪ੍ਰਾਪਤ ਕੀਤਾ। ਸਾਨੂੰ ਕੁਝ ਵੀ ਨਾਜ਼ੁਕ ਨਹੀਂ ਲੱਗਿਆ, ਪਰ ਉਹਨਾਂ ਨੇ, ਉਦਾਹਰਨ ਲਈ, "api-key" ਕੁੰਜੀ ਨਾਲ ਸਬੰਧਤ ਸਾਨੂੰ ਲੱਭਿਆ ਬੱਗ ਪਸੰਦ ਕੀਤਾ।

ਜੇਕਰ ਤੁਸੀਂ ਇਸ ਲੇਖ ਨੂੰ ਅੰਗ੍ਰੇਜ਼ੀ ਬੋਲਣ ਵਾਲੇ ਦਰਸ਼ਕਾਂ ਨਾਲ ਸਾਂਝਾ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਕਿਰਪਾ ਕਰਕੇ ਅਨੁਵਾਦ ਲਿੰਕ ਦੀ ਵਰਤੋਂ ਕਰੋ: ਵਲਾਦਿਸਲਾਵ ਸਟੋਲਯਾਰੋਵ। PVS-ਸਟੂਡੀਓ ਹੁਣ ਚਾਕਲੇਟ ਵਿੱਚ ਹੈ: Azure DevOps ਦੇ ਅਧੀਨ ਚਾਕਲੇਟ ਦੀ ਜਾਂਚ ਕਰ ਰਿਹਾ ਹੈ.

ਸਰੋਤ: www.habr.com