japicompat - Online in de cloud

PROGRAMMA:

NAAM

japicompat - Test Java API's op binaire achterwaartse compatibiliteit.

KORTE INHOUD

japicompat [-svqhtjw4] [-of uitbestand] [-l negeerbestanden]

PRODUCTBESCHRIJVING

japicompat is onderdeel van japitools, ontworpen om te testen op compatibiliteit tussen Java API's.

Ze waren oorspronkelijk ontworpen voor het testen van gratis implementaties van Java zelf
compatibiliteit met Sun's JDK, maar ze kunnen ook worden gebruikt voor het testen van achterwaartse compatibiliteit
tussen versies van welke API dan ook.

De tools zijn japize en japicompat. Japize is een Java-programma dat een lijst met een
API in een machinaal leesbaar formaat. Japicompat neemt vervolgens twee van dergelijke vermeldingen en vergelijkt deze
ze op binaire compatibiliteit, zoals gedefinieerd door Sun in de Java Language Specification.

OPTIES

-s schakel aanvullende binaire compatibiliteitscontroles uit (voer alleen controles uit die zijn gedefinieerd door de JLS).

-v controles op kleine compatibiliteitsproblemen inschakelen.

SerialVersionUID-controle: japicompat rapporteert een kleine fout als een serialiseerbare klasse
heeft een andere SerialVersionUID tussen de twee releases.

Beëindigingscontrole: japicompat rapporteert een kleine fout als een klasse of lid dat wel was
verouderd in de oorspronkelijke API, maar is niet verouderd in de API die wordt gecontroleerd.

-q schakelt voortgangsrapporten uit.

-h genereert uitvoer in HTML-formaat. De geproduceerde HTML-bestanden zijn afhankelijk van japi.css
bestand om een ​​aantrekkelijke presentatie te krijgen.

-t genereert uitvoer in tekstformaat. Dit is de standaardinstelling.

-j genereert uitvoer in onbewerkte, machinaal leesbare vorm. Het geproduceerde formaat wordt genoemd
"japio"-formaat, en moet volgens afspraak worden opgeslagen met de bestandsextensie ".japio".
De zelfstandige hulpprogramma's japiotext en japiohtml kunnen worden gebruikt om dit formaat te converteren
in html of tekst (eigenlijk roept japicompat japiotext of japiohtml intern aan if
de vlaggen -h of -t worden gebruikt). Japio-bestanden kunnen ook worden gebruikt met de vlag -i
ondersteuning voor het negeren van fouten veroorzaakt door incompatibiliteit tussen JDK-versies.

-w schakel waarschuwingen uit voor het uitvoeren van oude japi-bestanden met fouten. Standaard japicompat
zal waarschuwingen produceren als het wordt uitgevoerd tegen japi-bestanden die oorspronkelijk door oudere bestanden zijn gegenereerd
versies van japitools die bugs bevatten die japifix niet kan elimineren.

-4 gebruik de 1.4-compatibele modus. Dit werkt zolang de API's niet te vergelijken zijn
1.5-only artikelen.

-o
Stuur de uitvoer naar in plaats van stout. Het formaat van dit bestand is afhankelijk van
de vlaggen -h, -t en -j.

-i
Stel dat u probeert de Java API te implementeren. Je hebt (vrijwel)
voltooide dekking van de vroege JDK-versies (1.0 en 1.1), maar er zijn er nog steeds enkele
afstand om volledige dekking van 1.4 te bereiken (dit is een nauwkeurige beschrijving van alles
Vrije Software Java-implementaties op het moment van schrijven). Japicompat gebruiken om
Vergelijk uw implementatie met JDK 1.4 geeft nauwkeurige resultaten, maar dat zou ook kunnen
wil uw berichtgeving over de eerdere versies laten zien.

Helaas heeft Sun hun eigen regels voor binaire compatibiliteit tussen JDK niet gevolgd
releases, laat staan ​​de uitgebreide regels waar japicompat op test. Dus als je een
vergelijking tussen JDK 1.1 en uw implementatie, krijgt u een valse foutmelding
rapporteert wanneer u compatibel bent met 1.4 maar niet met 1.1.

Het is duidelijk dat je dit soort fouten wilt negeren, en japicompat
biedt een manier om dit te doen. Voer eerst een vergelijking uit tussen 1.1 en 1.4 met behulp van de -j
schakelaar. Voer vervolgens de vergelijking uit tussen 1.1 en uw implementatie, waarbij u de
"-i" optie met de uitvoer van de vorige run. Bijvoorbeeld:

$ japicompat -jo negeer-11-14.japio jdk11.japi.gz jdk14.japi.gz
$ japicompat -ho jdk11-myimpl.html -i negeer-11-14.japio jdk11.japi.gz
mijnimpl.japi.gz

Je kunt hetzelfde effect ook bereiken door het volgende uit te voeren:

$ japicompat -ho jdk11-mijnimpl.html -i jdk14.japi.gz jdk11.japi.gz mijnimpl.japi.gz

Dit is uiteraard eenvoudiger en sneller te typen, maar vereist een vergelijking tussen
jdk11 en jdk14 moeten elke keer worden uitgevoerd. Het handmatig maken van het japio-bestand staat dit toe
zodat het kan worden opgeslagen en de volgende keer opnieuw kan worden gebruikt, waardoor japicompat rond kan rennen
twee keer zo snel.


De japi-bestanden die overeenkomen met de te vergelijken API's.

japicompat test specifiek of het tweede argument achterwaarts compatibel is
met de eerste. Daarom zou een perfecte implementatie van JDK 1.1 nee opleveren
fouten ongeacht de volgorde van de argumenten, maar een perfecte implementatie van
JDK1.1 plus delen van JDK1.2 moeten als volgt worden getest:

$ japicompat jdk11.japi.gz mijnimpl.japi.gz
$ japicompat mijnimpl.japi.gz jdk12.japi.gz

Het is waarschijnlijk onmogelijk om een ​​implementatie te maken die beide tests doorstaat.
aangezien Sun's eigen JDK1.2 talloze fouten produceert wanneer hij wordt getest met JDK1.1. Zie de
bespreking van de -i-optie hierboven voor een manier om met deze situatie om te gaan.

Er kunnen gecomprimeerde (.japi.gz) of ongecomprimeerde (.japi) bestanden worden doorgegeven
japicompat: De bestandsextensie wordt gebruikt om te bepalen of invoer wel of niet moet worden doorgesluisd
via gzip of niet.

Gebruik japicompat online met behulp van onworks.net-services