🥇 Analyse vu Verpflichtungen a Pull Ufroen am Travis CI, Buddy an AppVeyor mat PVS-Studio

Am PVS-Studio Analyser fir C an C++ Sproochen op Linux a MacOS, ab Versioun 7.04, ass eng Testoptioun erschéngt fir d'Lëscht vun spezifizéierte Dateien ze kontrolléieren. Mat den neie Modus kënnt Dir den Analyser konfiguréieren fir Verpflichtungen ze kontrolléieren an Ufroen ze zéien. Dësen Artikel wäert Iech soen wéi Dir d'Lëscht vun de geännerten Dateien vun engem GitHub-Projet an esou populäre CI (Continuous Integration) Systemer wéi Travis CI, Buddy an AppVeyor opstellt.

Dateilëscht Kontrollmodus

PVS-Studio ass en Tool fir Feeler a potenziell Schwachstelle am Quellcode vu Programmer ze identifizéieren déi an C, C++, C# a Java geschriwwe sinn. Schafft op 64-Bit Systemer op Windows, Linux a MacOS.

An der Versioun PVS-Studio 7.04 fir Linux a MacOS ass e Modus fir d'Lëscht vun de Quelldateien ze kontrolléieren. Dëst funktionnéiert fir Projeten, deenen hire Bausystem Iech erlaabt eng Datei ze generéieren compile_commands.json. Et ass néideg fir den Analysator fir Informatioun iwwer d'Kompilatioun vun de spezifizéierte Dateien ze extrahieren. Wann Äre Build-System net d'Generatioun vun der compile_commands.json Datei ënnerstëtzt, kënnt Dir probéieren esou eng Datei mat dem Utility ze generéieren Bier.

Och kann de Dateilëscht Iwwerpréiwungsmodus zesumme mam Strace Trace Log vu Compiler lancéiert ginn (pvs-studio-analyzer trace). Fir dëst ze maachen, musst Dir als éischt e komplette Bau vum Projet ausféieren an et verfollegen, sou datt den Analyser komplett Informatioun iwwer d'Kompilatiounsparameter vun all de gepréiften Dateien sammelt.

Wéi och ëmmer, dës Optioun huet e wesentlechen Nodeel - Dir musst entweder e komplette Spuer vum ganze Projet ausféieren all Kéier wann Dir et leeft, wat op sech selwer d'Iddi widdersprécht fir eng Verpflichtung séier z'iwwerpréiwen. Oder, wann Dir d'Spuerresultat selwer cache kënnt, kënne spéider Runen vum Analyser onkomplett sinn, wann d'Ofhängegkeetsstruktur vun de Quelldateien no der Spuer ännert (zum Beispill gëtt en neien #include zu enger vun de Quelldateien bäigefüügt).

Dofir empfeelen mir net de Dateielëscht Kontrollmodus mam Trace Log ze benotzen fir Verpflichtungen ze kontrolléieren oder Ufroen ze zéien. Am Fall wou Dir en inkrementelle Bau maache kënnt wann Dir e Verpflichtung iwwerpréift, betruecht de Modus ze benotzen inkrementell Analyse.

D'Lëscht vun de Quelldateien fir d'Analyse gëtt an enger Textdatei gespäichert an un den Analysator mat dem Parameter weiderginn -S:

pvs-studio-analyzer analyze ... -f build/compile_commands.json -S check-list.txt

Dëse Fichier spezifizéiert relativ oder absolut Weeër fir Dateien, an all nei Datei muss op enger neier Linn sinn. Et ass akzeptabel net nëmmen Dateinumm fir Analyse ze spezifizéieren, awer och verschidden Texter. Den Analyser wäert gesinn datt dëst keng Datei ass a wäert d'Linn ignoréieren. Dëst kann nëtzlech sinn fir ze kommentéieren wann Dateien manuell spezifizéiert ginn. Wéi och ëmmer, dacks gëtt eng Lëscht vu Dateien wärend der Analyse am CI generéiert, zum Beispill kënnen dës Dateien aus enger Verpflichtung oder Pull-Ufro sinn.

Elo, mat dësem Modus, kënnt Dir séier neie Code iwwerpréiwen ier en an d'Haaptentwécklungszweig kënnt. Fir sécherzestellen datt de Scannersystem op Analysatorwarnungen reagéiert, ass d'Utility Plog-Converter Fändel dobäi --indicate-warnungen:

plog-converter ... --indicate-warnings ... -o /path/to/report.tasks ...

Mat dësem Fändel gëtt de Konverter en Net-Nullcode zréck wann et Warnungen am Analyserbericht sinn. Mat Hëllef vum Retourcode kënnt Dir e Precommit Hook blockéieren, engagéieren oder zéien Ufro, an de generéierten Analyser Bericht kann ugewisen, gedeelt oder per E-Mail geschéckt ginn.

Note. Wann Dir éischt ufänkt eng Lëscht vun Dateien ze analyséieren, gëtt de ganze Projet analyséiert, well den Analyser muss eng Datei vun Ofhängegkeete vun de Projetquelldateien op den Headerdateien generéieren. Dëst ass eng Feature fir C an C ++ Dateien ze analyséieren. An Zukunft kann d'Ofhängegkeetsdatei cache ginn an et gëtt automatesch vum Analysator aktualiséiert. De Virdeel fir d'Verpflichtungen ze kontrolléieren wann Dir Dateielëscht Iwwerpréiwungsmodus benotzt iwwer d'Benotzung vun inkrementellen Analysemodus ass datt Dir nëmmen dës Datei muss cache an net d'Objetdateien.

Allgemeng Prinzipien vun Pull Ufro Analyse

D'Analyse vum ganze Projet brauch vill Zäit, sou datt et Sënn mécht nëmmen e bestëmmten Deel dovun z'iwwerpréiwen. De Problem ass datt Dir déi nei Dateie vun de Rescht vun de Projetdateien trennt.

Loosst eis e Beispill vun engem Verpflichtungsbaum mat zwee Branchen kucken:

Loosst eis dat engagéieren virstellen A1 enthält eng zimlech grouss Quantitéit vum Code dee scho getest gouf. E bësse méi fréi hu mir eng Branche aus dem Engagement gemaach A1 an e puer Fichieren geännert.

Dir, natierlech, gemierkt, datt no A1 zwee weider Engagementer koumen, mä dat waren och Fusioune vun anere Branchen, well mir eis net engagéieren Meeschtesch. An elo ass d'Zäit komm wéini Hotfix prett. Dofir koum eng Pull-Demande fir d'Fusioun op B3 и A3.

Natierlech wier et méiglech, dat ganzt Resultat vun hirer Fusioun ze kontrolléieren, awer dat wier ze laangwiereg an ongerechtfäerdegt, well nëmmen e puer Dossier geännert goufen. Dofir ass et méi effizient nëmmen déi geännert ze analyséieren.

Fir dëst ze maachen, kréie mir den Ënnerscheed tëscht de Branchen, am HEAD vun der Branche, aus deem mir an de Meeschter fusionéiere wëllen:

git diff --name-only HEAD origin/$MERGE_BASE > .pvs-pr.list

$MERGE_BASE mir wäerten et spéider am Detail kucken. D'Tatsaach ass datt net all CI Service déi néideg Informatioun iwwer d'Datebank fir d'Fusioun gëtt, also all Kéier musst Dir nei Weeër kommen fir dës Donnéeën ze kréien. Dëst wäert am Detail ënnendrënner an all eenzel vun de beschriwwenen Webservicer beschriwwe ginn.

Also hu mir den Ënnerscheed tëscht de Filialen, oder éischter, eng Lëscht vun Dateinumm déi geännert goufen. Elo musse mir de Fichier ginn .pvs-pr.lëscht (mir hunn d'Output hei uewen ëmgeleet) an den Analyser:

pvs-studio-analyzer analyze -j8 
                            -o PVS-Studio.log 
                            -S .pvs-pr.list

No der Analyse musse mir d'Protokolldatei (PVS-Studio.log) an en einfach ze liesen Format konvertéieren:

plog-converter -t errorfile PVS-Studio.log --cerr -w

Dëse Kommando wäert d'Feeler oplëschten stderr (Standard Feeler Message Output).

Nëmmen elo musse mir net nëmmen Feeler weisen, awer och eise Service fir d'Assemblée an d'Test iwwer d'Präsenz vu Probleemer informéieren. Fir dësen Zweck gouf e Fändel un den Converter bäigefüügt -W (--indicate-warnungen). Wann et op d'mannst eng Analyser Warnung gëtt, gëtt den Utility Code zréck Plog-Converter wäert op 2 änneren, wat am Tour de CI Service iwwer d'Präsenz vu potenzielle Feeler an de Pull-Ufrodateien informéiert.

Travis C.I.

D'Konfiguratioun gëtt als Datei gemaach .travis.yml. Fir d'Bequemlechkeet roden ech Iech alles an e separaten Bash-Skript ze setzen mat Funktiounen déi aus der Datei opgeruff ginn .travis.yml (bash script_name.sh function_name).

Mir wäerten déi néideg Code op d'Skript op ze brong, sou wäerte mir méi Funktionalitéit kréien. An der Rubrik installéieren schreiwen mer folgend:

install:
  - bash .travis.sh travis_install

Wann Dir Instruktiounen hutt, kënnt Dir se an d'Skript transferéieren, andeems Dir d'Bindstrik ewechhuelt.

Loosst eis d'Datei opmaachen .travis.sh a füügt den Analyser-Astellung un d'Funktioun travis_install():

travis_install() {
  wget -q -O - https://files.viva64.com/etc/pubkey.txt 
    | sudo apt-key add -
  sudo wget -O /etc/apt/sources.list.d/viva64.list 
    https://files.viva64.com/etc/viva64.list
  
  sudo apt-get update -qq
  sudo apt-get install -qq pvs-studio 
}

Loosst eis elo an d'Sektioun addéieren Schrëft Run Analyse:

script:
  - bash .travis.sh travis_script

An am Bash Skript:

travis_script() {
  pvs-studio-analyzer credentials $PVS_USERNAME $PVS_KEY
  
  if [ "$TRAVIS_PULL_REQUEST" != "false" ]; then
    git diff --name-only origin/HEAD > .pvs-pr.list
    pvs-studio-analyzer analyze -j8 
                                -o PVS-Studio.log 
                                -S .pvs-pr.list 
                                --disableLicenseExpirationCheck
  else
    pvs-studio-analyzer analyze -j8 
                                -o PVS-Studio.log 
                                --disableLicenseExpirationCheck
  fi
  
  plog-converter -t errorfile PVS-Studio.log --cerr -w
}

Dëse Code muss lafen nodeems de Projet gebaut gouf, zum Beispill, wann Dir e Build op CMake hat:

travis_script() {
  CMAKE_ARGS="-DCMAKE_EXPORT_COMPILE_COMMANDS=On ${CMAKE_ARGS}"
  cmake $CMAKE_ARGS CMakeLists.txt
  make -j8
}

Et wäert esou erauskommen:

travis_script() {
  CMAKE_ARGS="-DCMAKE_EXPORT_COMPILE_COMMANDS=On ${CMAKE_ARGS}"
  cmake $CMAKE_ARGS CMakeLists.txt
  make -j8
  
  pvs-studio-analyzer credentials $PVS_USERNAME $PVS_KEY
  
  if [ "$TRAVIS_PULL_REQUEST" != "false" ]; then
    git diff --name-only origin/HEAD > .pvs-pr.list
    pvs-studio-analyzer analyze -j8 
                                -o PVS-Studio.log 
                                -S .pvs-pr.list 
                                --disableLicenseExpirationCheck
  else
    pvs-studio-analyzer analyze -j8 
                                -o PVS-Studio.log 
                                --disableLicenseExpirationCheck
  fi
  
  plog-converter -t errorfile PVS-Studio.log --cerr -w
}

Dir hutt dës Ëmfeldvariablen wahrscheinlech scho gemierkt $TRAVIS_PULL_REQUEST и $TRAVIS_BRANCH. Travis CI deklaréiert se onofhängeg:

$TRAVIS_PULL_REQUEST Buttek der Pull Ufro Zuel oder falsch, wann dëst eng regulär Branche ass;
$TRAVIS_REPO_SLUG späichert den Numm vum Projet Repository.

Den Algorithmus fir dës Funktioun:

Travis CI reagéiert op Retourcoden, sou datt d'Präsenz vun Warnungen de Service erzielt fir d'Verpflichtung als Fehler ze markéieren.

Loosst eis elo dës Zeil vum Code méi no kucken:

git diff --name-only origin/HEAD > .pvs-pr.list

De Fakt ass datt Travis CI automatesch Filialen fusionéiert wärend eng Pull Ufro analyséiert:

Dofir analyséiere mir A4, an net B3->A3. Wéinst dëser Fonktioun, musse mir den Ënnerscheed berechnen mat A3, déi genee der Spëtzt vun der Branche vun Urspronk.

Et gëtt ee wichtegen Detail lénks - d'Caching vun den Ofhängegkeete vun den Headerdateien op kompiléierten Iwwersetzungsunitéiten (*.c, *.cc, *.cpp, etc.). Den Analyser berechent dës Ofhängegkeete wann et fir d'éischt am Modus vun der Iwwerpréiwung vun enger Lëscht vu Dateien lancéiert gëtt a späichert se dann am .PVS-Studio Verzeichnis. Travis CI erlaabt Iech Classeure ze cache, sou datt mir d'Verzeechnesdaten späicheren .PVS-Studio/:

cache:
  directories:
    - .PVS-Studio/

Dëse Code muss an d'Datei bäigefüügt ginn .travis.yml. Dëse Verzeichnis späichert verschidde Donnéeën, déi no der Analyse gesammelt ginn, déi spéider Runen vun der Dateilëschtanalyse oder inkrementeller Analyse wesentlech beschleunegen. Wann dëst net gemaach gëtt, analyséiert den Analyser tatsächlech all Dateien all Kéier.

Buddy

Wéi Travis CI, Buddy bitt d'Fäegkeet fir automatesch Projeten op GitHub ze bauen an ze testen. Am Géigesaz zu Travis CI ass et an der Webinterface konfiguréiert (bash-Ënnerstëtzung ass verfügbar), also ass et net néideg fir Konfiguratiounsdateien am Projet ze späicheren.

Als éischt musse mir eng nei Aktioun op d'Assemblée setzen:

Loosst eis de Compiler uginn deen benotzt gouf fir de Projet ze bauen. Notéiert den Docker Container deen an dëser Aktioun installéiert ass. Zum Beispill gëtt et e spezielle Container fir GCC:

Loosst eis elo PVS-Studio an déi néideg Utilities installéieren:

Loosst eis déi folgend Zeilen an den Editor addéieren:

apt-get update && apt-get -y install wget gnupg jq

wget -q -O - https://files.viva64.com/etc/pubkey.txt | apt-key add -
wget -O /etc/apt/sources.list.d/viva64.list 
  https://files.viva64.com/etc/viva64.list

apt-get update && apt-get -y install pvs-studio

Loosst eis elo op de Run Tab (éischt Ikon) goen a füügt de folgende Code an dat entspriechend Redakterfeld:

pvs-studio-analyzer credentials $PVS_USERNAME $PVS_KEY

if [ "$BUDDY_EXECUTION_PULL_REQUEST_NO" != '' ]; then
  PULL_REQUEST_ID="pulls/$BUDDY_EXECUTION_PULL_REQUEST_NO"
  MERGE_BASE=`wget -qO - 
    https://api.github.com/repos/${BUDDY_REPO_SLUG}/${PULL_REQUEST_ID} 
    | jq -r ".base.ref"`

  git diff --name-only HEAD origin/$MERGE_BASE > .pvs-pr.list
  pvs-studio-analyzer analyze -j8 
                              -o PVS-Studio.log 
                              --disableLicenseExpirationCheck 
                              -S .pvs-pr.list
else
  pvs-studio-analyzer analyze -j8 
                              -o PVS-Studio.log 
                              --disableLicenseExpirationCheck
fi

plog-converter -t errorfile PVS-Studio.log --cerr -w

Wann Dir d'Sektioun iwwer Travs-CI liest, dann ass dëse Code Iech scho vertraut, awer elo ass et eng nei Etapp:

De Fakt ass datt mir elo net d'Resultat vun der Fusioun analyséieren, mee de HEAD vun der Branche, aus där d'Pull-Ufro gemaach gëtt:

Also si mir an engem bedingte Engagement B3 a mir mussen den Ënnerscheed kréien aus A3:

PULL_REQUEST_ID="pulls/$BUDDY_EXECUTION_PULL_REQUEST_NO"
  MERGE_BASE=`wget -qO - 
    https://api.github.com/repos/${BUDDY_REPO_SLUG}/${PULL_REQUEST_ID} 
    | jq -r ".base.ref"`
git diff --name-only HEAD origin/$MERGE_BASE > .pvs-pr.list

Fir ze bestëmmen A3 Loosst eis d'GitHub API benotzen:

https://api.github.com/repos/${USERNAME}/${REPO}/pulls/${PULL_REQUEST_ID}

Mir hunn déi folgend Variabelen benotzt déi Buddy ubitt:

$BUDDY_EXECUTION_PULL_REQEUST_NO - zitt Ufro Zuel;
$BUDDY_REPO_SLUG - eng Kombinatioun vu Benotzernumm a Repository (zum Beispill Max / Test).

Loosst eis elo d'Ännerunge späicheren andeems Dir de Knäppchen hei drënner benotzt an d'Analyse vun der Pull-Ufro erméiglechen:

Am Géigesaz zum Travis CI brauche mir net ze spezifizéieren .pvs-studio fir Caching, well Buddy automatesch all Dateie fir spéider Starten caches. Dofir ass déi lescht Saach lénks ass de Login a Passwuert fir PVS-Studio am Buddy ze späicheren. Nodeems mir d'Ännerunge gespäichert hunn, gi mir zréck op Pipeline. Mir musse weidergoen fir Variabelen opzestellen an e Login a Schlëssel fir PVS-Studio derbäizefügen:

Duerno wäert d'Erscheinung vun enger neier Pull Ufro oder Engagement d'Iwwerpréiwung ausléisen. Wann e Verpflichtung Feeler enthält, wäert de Buddy dat op der Pull-Ufro Säit uginn.

AppVeyor

AppVeyor opsetzen ass ähnlech wéi Buddy, well alles geschitt an der Webinterface an et ass net néideg eng *.yml Datei an de Projet Repository ze addéieren.

Loosst eis op d'Astellunge Tab am Projet Iwwersiicht goen:

Loosst eis dës Säit erof scrollen an Cache-Späicheren aktivéieren fir Pull-Ufroen ze sammelen:

Loosst eis elo op d'Ëmfeld Tab goen, wou mir d'Bild fir d'Versammlung an déi néideg Ëmfeldvariablen spezifizéieren:

Wann Dir déi virdrun Sektioune gelies hutt, sidd Dir ganz vertraut mat dësen zwou Variabelen - PVS_KEY и PVS_USERNAME. Wann net, loosst mech Iech drun erënneren datt se néideg sinn fir d'Lizenz vum PVS-Studio Analyser z'iwwerpréiwen. Mir wäerten se an Zukunft erëm a Bash Scripten gesinn.

Op der selwechter Säit hei ënnen weisen mir den Dossier fir Cache un:

Wa mir dat net maachen, analyséiere mir de ganze Projet anstatt e puer Dateien, awer mir kréien d'Ausgab vun de spezifizéierte Dateien. Dofir ass et wichteg de richtege Verzeechnesnumm aginn.

Elo ass et Zäit fir de Skript ze testen. Öffnen d'Tester Tab a wielt Skript:

Dir musst de folgende Code an dëse Formulaire pechen:

sudo apt-get update && sudo apt-get -y install jq

wget -q -O - https://files.viva64.com/etc/pubkey.txt 
  | sudo apt-key add -
sudo wget -O /etc/apt/sources.list.d/viva64.list 
  https://files.viva64.com/etc/viva64.list

sudo apt-get update && sudo apt-get -y install pvs-studio

pvs-studio-analyzer credentials $PVS_USERNAME $PVS_KEY

PWD=$(pwd -L)
if [ "$APPVEYOR_PULL_REQUEST_NUMBER" != '' ]; then
  PULL_REQUEST_ID="pulls/$APPVEYOR_PULL_REQUEST_NUMBER"
  MERGE_BASE=`wget -qO - 
    https://api.github.com/repos/${APPVEYOR_REPO_NAME}/${PULL_REQUEST_ID} 
    | jq -r ".base.ref"`

  git diff --name-only HEAD origin/$MERGE_BASE > .pvs-pr.list
  pvs-studio-analyzer analyze -j8 
                              -o PVS-Studio.log 
                              --disableLicenseExpirationCheck 
                              --dump-files --dump-log pvs-dump.log 
                              -S .pvs-pr.list
else
  pvs-studio-analyzer analyze -j8 
                              -o PVS-Studio.log 
                              --disableLicenseExpirationCheck
fi

plog-converter -t errorfile PVS-Studio.log --cerr -w

Loosst eis op de folgenden Deel vum Code oppassen:

PWD=$(pwd -L)
if [ "$APPVEYOR_PULL_REQUEST_NUMBER" != '' ]; then
  PULL_REQUEST_ID="pulls/$APPVEYOR_PULL_REQUEST_NUMBER"
  MERGE_BASE=`wget -qO - 
   https://api.github.com/repos/${APPVEYOR_REPO_NAME}/${PULL_REQUEST_ID} 
   | jq -r ".base.ref"`

  git diff --name-only HEAD origin/$MERGE_BASE > .pvs-pr.list
  pvs-studio-analyzer analyze -j8 
                              -o PVS-Studio.log 
                              --disableLicenseExpirationCheck 
                              --dump-files --dump-log pvs-dump.log 
                              -S .pvs-pr.list
else
  pvs-studio-analyzer analyze -j8 
                              -o PVS-Studio.log 
                              --disableLicenseExpirationCheck
fi

Déi zimlech spezifesch Uweisung vum Wäert vum pwd Kommando un eng Variabel déi dëse Standardwäert späichere soll schéngt op den éischte Bléck komesch, awer ech wäert alles elo erklären.

Beim Astellung vum Analysator an AppVeyor hunn ech extrem komescht Verhalen vum Analyser begéint. Engersäits huet alles richteg geschafft, awer d'Analyse huet net ugefaang. Ech hunn vill Zäit gemierkt datt mir am /home/appveyor/projects/testcalc/ Verzeichnis sinn, an den Analyser ass sécher datt mir an /opt/appveyor/build-agent/ sinn. Dunn hunn ech gemierkt datt d'$PWD Variabel e bëssen gelunn huet. Aus dësem Grond hunn ech säi Wäert manuell aktualiséiert ier ech d'Analyse starten.

An dann ass alles wéi virdrun:

Elo betruecht de folgende Fragment:

PULL_REQUEST_ID="pulls/$APPVEYOR_PULL_REQUEST_NUMBER"
MERGE_BASE=`wget -qO - 
  https://api.github.com/repos/${APPVEYOR_REPO_NAME}/${PULL_REQUEST_ID} 
  | jq -r ".base.ref"`

An et kréie mir den Ënnerscheed tëscht de Branchen iwwer déi d'Pull-Ufro deklaréiert ass. Fir dëst ze maachen brauche mir déi folgend Ëmfeldvariablen:

$APPVEYOR_PULL_REQUEST_NUMBER - Pull Ufro Zuel;
$APPVEYOR_REPO_NAME - Benotzernumm a Projet Repository.

Konklusioun

Natierlech hu mir net all méiglech kontinuéierlech Integratiounsservicer berücksichtegt, awer si hunn all extrem ähnlech Operatiounsspezifizitéite mateneen. Mat Ausnam vum Caching mécht all Service säin eegene "Vëlo", sou datt alles ëmmer anescht ass.

Iergendwou, wéi an Travis-CI, e puer Zeilen Code a Cache funktionnéieren perfekt; iergendwou, wéi an AppVeyor, Dir musst just den Dossier an den Astellungen uginn; awer iergendwou musst Dir eenzegaarteg Schlësselen erstellen a probéieren de System ze iwwerzeegen fir Iech d'Méiglechkeet ze ginn de cache Fragment ze iwwerschreiwe. Dofir, wann Dir Analyse vun Pull-Ufroen op e kontinuéierlechen Integratiounsservice wëllt opstellen, deen net uewen diskutéiert gouf, da gitt als éischt sécher datt Dir keng Probleemer mam Cache hutt.

Merci fir är Opmierksamkeet. Wann eppes net klappt, schreiwt eis gratis um ënnerstëtzen. Mir beroden an hëllefen.

Wann Dir dësen Artikel mat engem engleschsproochege Publikum wëllt deelen, benotzt w.e.g. den Iwwersetzungslink: Maxim Zvyagintsev. Analyse vu Verpflichtungen a Pull Ufroen am Travis CI, Buddy an AppVeyor mat PVS-Studio.

Source: will.com

Analyse vu Verpflichtungen a Pull Ufroen am Travis CI, Buddy an AppVeyor mat PVS-Studio