PVS-ಸ್ಟುಡಿಯೋ ಈಗ ಚಾಕೊಲೇಟಿಯಲ್ಲಿದೆ: Azure DevOps ಅಡಿಯಲ್ಲಿ ಚಾಕೊಲೇಟಿಯನ್ನು ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿದೆ

ನಾವು PVS-ಸ್ಟುಡಿಯೋವನ್ನು ಹೆಚ್ಚು ಅನುಕೂಲಕರವಾಗಿ ಬಳಸುವುದನ್ನು ಮುಂದುವರಿಸುತ್ತೇವೆ. ನಮ್ಮ ವಿಶ್ಲೇಷಕವು ಈಗ Windows ಗಾಗಿ ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್ ಆಗಿರುವ ಚಾಕೊಲೇಟಿಯಲ್ಲಿ ಲಭ್ಯವಿದೆ. ಇದು 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-ಸ್ಟುಡಿಯೋ ಎಚ್ಚರಿಕೆಗಳನ್ನು ತ್ವರಿತವಾಗಿ ವೀಕ್ಷಿಸುವುದು ಮತ್ತು ಈ ಉಪಕರಣದ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುವುದು ಹೇಗೆ ಎಂಬುದರ ಕುರಿತು.

ಅಜುರೆ ಡೆವೊಪ್ಸ್ - ಸಂಪೂರ್ಣ ಅಭಿವೃದ್ಧಿ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಜಂಟಿಯಾಗಿ ಒಳಗೊಂಡಿರುವ ಕ್ಲೌಡ್ ಸೇವೆಗಳ ಒಂದು ಸೆಟ್. ಈ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಅಜುರೆ ಪೈಪ್‌ಲೈನ್‌ಗಳು, ಅಜುರೆ ಬೋರ್ಡ್‌ಗಳು, ಅಜೂರ್ ಆರ್ಟಿಫ್ಯಾಕ್ಟ್‌ಗಳು, ಅಜುರೆ ರೆಪೋಸ್, ಅಜುರೆ ಟೆಸ್ಟ್ ಪ್ಲಾನ್‌ಗಳಂತಹ ಸಾಧನಗಳನ್ನು ಒಳಗೊಂಡಿದೆ, ಇದು ಸಾಫ್ಟ್‌ವೇರ್ ರಚಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ವೇಗಗೊಳಿಸಲು ಮತ್ತು ಅದರ ಗುಣಮಟ್ಟವನ್ನು ಸುಧಾರಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಚಾಕೊಟ್ಟಿ ವಿಂಡೋಸ್‌ಗಾಗಿ ಓಪನ್ ಸೋರ್ಸ್ ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್ ಆಗಿದೆ. ವಿಂಡೋಸ್ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂಗಳಲ್ಲಿ ಅನುಸ್ಥಾಪನೆಯಿಂದ ನವೀಕರಣ ಮತ್ತು ಅಸ್ಥಾಪನೆಯವರೆಗೆ ಸಂಪೂರ್ಣ ಸಾಫ್ಟ್‌ವೇರ್ ಜೀವನಚಕ್ರವನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವುದು ಯೋಜನೆಯ ಗುರಿಯಾಗಿದೆ.

ಚಾಕೊಲೇಟಿ ಬಳಸುವ ಬಗ್ಗೆ

ಇದರಲ್ಲಿ ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್ ಅನ್ನು ಹೇಗೆ ಸ್ಥಾಪಿಸಬೇಕು ಎಂಬುದನ್ನು ನೀವು ನೋಡಬಹುದು ಲಿಂಕ್. ವಿಶ್ಲೇಷಕವನ್ನು ಸ್ಥಾಪಿಸಲು ಸಂಪೂರ್ಣ ದಸ್ತಾವೇಜನ್ನು ಇಲ್ಲಿ ಲಭ್ಯವಿದೆ ಲಿಂಕ್ ಚಾಕೊಲೇಟಿ ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್ ವಿಭಾಗವನ್ನು ಬಳಸಿಕೊಂಡು ಅನುಸ್ಥಾಪನೆಯನ್ನು ನೋಡಿ. ನಾನು ಅಲ್ಲಿಂದ ಕೆಲವು ಅಂಶಗಳನ್ನು ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಪುನರಾವರ್ತಿಸುತ್ತೇನೆ.

ವಿಶ್ಲೇಷಕದ ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಯನ್ನು ಸ್ಥಾಪಿಸಲು ಆಜ್ಞೆ:

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

ಮುಂದೆ ನಾವು ವರ್ಚುವಲ್ ಯಂತ್ರವನ್ನು ಆಯ್ಕೆ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಇದೀಗ ಇದು ವಿಂಡೋಸ್ ಸರ್ವರ್ 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 и 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_ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ.

ಪರಿಗಣಿಸಲಾದ ತುಣುಕಿನಲ್ಲಿ, ಇದು ಒಂದು ಸಣ್ಣ ನ್ಯೂನತೆಯಾಗಿದೆ. ಹೌದು, ಈ ಸ್ಥಿತಿಯನ್ನು & ಆಪರೇಟರ್ ಅನ್ನು && ಆಪರೇಟರ್ ಅನ್ನು ಬದಲಿಸುವ ಮೂಲಕ ಆಪ್ಟಿಮೈಸ್ ಮಾಡಬಹುದು, ಆದರೆ ಪ್ರಾಯೋಗಿಕ ದೃಷ್ಟಿಕೋನದಿಂದ, ಇದು ಯಾವುದಕ್ಕೂ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ. ಆದಾಗ್ಯೂ, ಇತರ ಸಂದರ್ಭಗಳಲ್ಲಿ, & ಮತ್ತು && ನಡುವಿನ ಗೊಂದಲವು ಅಭಿವ್ಯಕ್ತಿಯ ಬಲಭಾಗವನ್ನು ತಪ್ಪಾದ/ಅಮಾನ್ಯ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಪರಿಗಣಿಸಿದಾಗ ಗಂಭೀರ ಸಮಸ್ಯೆಗಳನ್ನು ಉಂಟುಮಾಡಬಹುದು. ಉದಾಹರಣೆಗೆ, ನಮ್ಮ ದೋಷ ಸಂಗ್ರಹಣೆಯಲ್ಲಿ, 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-ಸ್ಟುಡಿಯೋವನ್ನು ಬಳಸುವಾಗ ಇನ್ನೂ ಕಡಿಮೆಯಿರಬಹುದು.

ನಾವು ನಿಮ್ಮನ್ನು ಆಹ್ವಾನಿಸುತ್ತೇವೆ скачать ಮತ್ತು PVS-ಸ್ಟುಡಿಯೋ ಪ್ರಯತ್ನಿಸಿ. ಸ್ಥಿರ ವಿಶ್ಲೇಷಕದ ನಿಯಮಿತ ಬಳಕೆಯು ನಿಮ್ಮ ತಂಡವು ಅಭಿವೃದ್ಧಿಪಡಿಸುವ ಕೋಡ್‌ನ ಗುಣಮಟ್ಟ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ ಮತ್ತು ಅನೇಕವನ್ನು ತಡೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ ಶೂನ್ಯ ದಿನದ ದುರ್ಬಲತೆಗಳು.

ಪಿಎಸ್

ಪ್ರಕಟಣೆಯ ಮೊದಲು, ನಾವು ಲೇಖನವನ್ನು ಚಾಕೊಲೇಟಿ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಕಳುಹಿಸಿದ್ದೇವೆ ಮತ್ತು ಅವರು ಅದನ್ನು ಚೆನ್ನಾಗಿ ಸ್ವೀಕರಿಸಿದರು. ನಾವು ವಿಮರ್ಶಾತ್ಮಕವಾಗಿ ಏನನ್ನೂ ಕಂಡುಹಿಡಿಯಲಿಲ್ಲ, ಆದರೆ ಅವರು, ಉದಾಹರಣೆಗೆ, "ಎಪಿ-ಕೀ" ಕೀಗೆ ಸಂಬಂಧಿಸಿದಂತೆ ನಾವು ಕಂಡುಕೊಂಡ ದೋಷವನ್ನು ಇಷ್ಟಪಟ್ಟಿದ್ದಾರೆ.

ನೀವು ಈ ಲೇಖನವನ್ನು ಇಂಗ್ಲಿಷ್ ಮಾತನಾಡುವ ಪ್ರೇಕ್ಷಕರೊಂದಿಗೆ ಹಂಚಿಕೊಳ್ಳಲು ಬಯಸಿದರೆ, ದಯವಿಟ್ಟು ಅನುವಾದ ಲಿಂಕ್ ಅನ್ನು ಬಳಸಿ: ವ್ಲಾಡಿಸ್ಲಾವ್ ಸ್ಟೋಲಿಯಾರೋವ್. PVS-ಸ್ಟುಡಿಯೋ ಈಗ ಚಾಕೊಲೇಟಿಯಲ್ಲಿದೆ: Azure DevOps ಅಡಿಯಲ್ಲಿ ಚಾಕೊಲೇಟಿಯನ್ನು ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿದೆ.

ಮೂಲ: www.habr.com