Saskaņotāju klases Hamcrest 1.3 Javadoc dokumentācija papildina vairāku šīs klases metožu dokumentāciju, nekā bija pieejama sadaļā Hamcrest 1.2. Piemēram, četrām pārslogotajām metodēm ir aprakstošāka Javadoc dokumentācija, kā parādīts divos nākamajos parādītajos salīdzināšanas ekrāna momentuzņēmumos.
Lai gan var uzzināt, kā darbojas "satur" sērkociņi, tikai izmēģinot tos, Javadoc Hamcrest 1.3 ļauj vieglāk lasīt, kā viņi strādā. Iespējams, ka lielākā daļa Java izstrādātāju domā par tādu rīcību kā String.contains (CharSequence) vai Collection.contains (Object), domājot par satur () metodi. Citiem vārdiem sakot, lielākā daļa Java izstrādātāju, iespējams, domā, ka "satur" apraksta, vai virkne / kolekcija satur norādītās rakstzīmes / objektus starp citām iespējamām rakstzīmēm / objektiem. Tomēr Hemresta spēlētājiem "satur" ir daudz specifiskāka nozīme. Tā kā Hamcrest 1.3 dokumentācija padara daudz skaidrāku, "satur" atbilstītāji ir daudz jutīgāki pret vienību skaitu un priekšmetu secību, kas tiek nodota šīm metodēm.
Mani šeit parādītie piemēri izmanto JUnit un Hamcrest. Šeit ir svarīgi uzsvērt, ka Hamcrest JAR failam ir jāparādās vienības testu klases ceļā pirms JUnit JAR faila, pretējā gadījumā man jāizmanto "īpašais" JUnit JAR fails, kas izveidots lietošanai kopā ar atsevišķo Hamcrest JAR. Izmantojot kādu no šīm pieejām, tiek novērsta kļūda NoSuchMethodError un citas kļūdas (kļūdas kā org.hamcrest.Matcher.describeMismatch kļūda), kas rodas neatbilstošu klašu versiju dēļ. Par šo JUnit / Hamcrest niansi esmu rakstījis bloga ierakstā Moving Beyond Core Hamcrest in JUnit.
Nākamie divi ekrāna momentuzņēmumi norāda vienības testa koda fragmentu, kurus es vēlāk parādīju emuārā, rezultātus (kā parādīts NetBeans 7.3), lai parādītu Hamcrest saturošos sakritības. Paredzams, ka testos ir dažas neveiksmes (7 pārbaudījumi nokārtoti un 4 testi neizdevās), lai būtu skaidrs, kur Hemresta mačisti var nedarboties tā, kā paredzēts, ja neizlasa Javadoc. Pirmajā attēlā redzami tikai 5 testu nokārtošana, 2 testu neizpilde un 4 testu izraisīšana. Tas ir tāpēc, ka man ir JUnit, kas pirms Hamcrest ir iekļauts NetBeans projekta "Test Libraries" klases ceļā. Otrais attēls parāda gaidītos rezultātus, jo Hamcrest JAR notiek pirms JUnit JAR projekta klases “Test Libaries”.
Šīs demonstrācijas vajadzībām man ir jāpārbauda vienkārša izdomāta klase. Avota kods tam Galvenais klase tiek parādīta nākamā.
Main.java
iepakojums dustin.piemēri; importēt java.util.Collections; importēt java.util.HashSet; importēt java.util.Set; / ** * Galvenā pārbaudāmā klase. * * @author Dustin * / public class Main {/ ** Izmanto Java 7 dimantu operatoru. * / private Set virknes = new HashSet (); public Main () {} public Boolean addString (final String newString) {return this.strings.add (newString); } public Set getStrings () {return Collections.unmodifiableSet (this.strings); }} Kad ir parādīta pārbaudāmā klase, tagad ir pienācis laiks aplūkot dažus uz JUnit balstītus testus kopā ar Hamcrest spēlētājiem. Konkrēti, testiem ir jānodrošina virkņu pievienošana, izmantojot klases addString (virkne) metode ir tās pamatā Iestatiet un pieejams caur getStrings () metodi. Tālāk parādītās vienības testa metodes parāda, kā pareizi izmantot Hamcrest sakritējus, lai noteiktu, vai klases pamatā ir pievienotās virknes Iestatiet
Izmantojot Hamcrest, komplekta darbos ir () Matcher ar vienu virkni
/ ** * Šis tests izturēs, jo ir tikai viena virkne, un tāpēc tajā būs * šī virkne, un secība netieši būs pareiza. * / @Test public void testAddStringAndGetStringsWithContainsForSingleStringSoWorks () {final Main subject = new Main (); galīgais būla rezultātsJava = subject.addString ("Java"); galīgās virknes = subject.getStrings (); assertThat (virknes, satur ("Java")); } Iepriekš parādītais vienības tests iztur, jo Iestatiet tajā ir tikai viena virkne, tāpēc ar. testēto virkņu secība un skaits satur spēlētāju spēles.
Izmantojot Hamcrest satur arī vienādu elementu skaitu, darbojas, ja pasūtījums atbilst
/ ** * Atbilstošais vienums "satur" sagaida precīzu secību, kas patiešām nozīmē, ka to * nedrīkst izmantot kopā ar {@code Set} s. Parasti vai nu šī metode * darbosies, un metode ar tādu pašu nosaukumu un "2" beigās nedarbosies, vai * otrādi. * / @Test public void testAddStringAndGetStringsWithContainsForMultipleStringsNotWorks1 () {final Main subject = new Main (); galīgais būla rezultātsJava = subject.addString ("Java"); galīgais būla rezultātsGroovy = subject.addString ("Groovy"); galīgās virknes = subject.getStrings (); assertThat (virknes, satur ("Java", "Groovy")); } / ** * Atbilstošais vienums “satur” sagaida precīzu secību, kas patiešām nozīmē, ka to * nevajadzētu lietot kopā ar {@code Set} s. Parasti vai nu šī metode * darbosies, un metode ar tādu pašu nosaukumu un "1" beigās nedarbosies, vai * otrādi. * / @Test public void testAddStringAndGetStringsWithContainsForMultipleStringsNotWorks2 () {final Main subject = new Main (); galīgais būla rezultātsJava = subject.addString ("Java"); galīgais būla rezultātsGroovy = subject.addString ("Groovy"); galīgās virknes = subject.getStrings (); assertThat (virknes, satur ("Groovy", "Java")); } Divi iepriekš parādītie vienības testu piemēri un to rezultāts, veicot šo testu, kā parādīts iepriekšējā ekrāna momentuzņēmumā, parāda, ka tik ilgi, cik argumentu skaits satur () matcher ir tāds pats kā virknes skaits pārbaudāmajā kolekcijā, mačs maijs darbs ja pārbaudītie elementi ir tieši tādā pašā secībā kā kolekcijas elementi. Ar nesakārtotu Iestatiet, uz šo rīkojumu nevar paļauties, tātad satur () visticamāk, nebūs piemērots spēlētājs, ko izmantot ar vienības testu Iestatiet vairāk nekā viena elementa.
Izmantojot Hamcrest, kas satur atšķirīgu elementu skaitu, nekad nedarbojas
/ ** * Parādiet, kas satur, NETIKS izturēts, ja par saturiem, par kuriem tiek jautāts, ir atšķirīgs skaits * elementu nekā kolekcijā. * / @Test public void testAddStringAndGetStringsWithContainsNotWorksDifferNumberElements1 () {final Main subject = new Main (); galīgais būla rezultātsJava = subject.addString ("Java"); galīgais būla rezultātsGroovy = subject.addString ("Groovy"); galīgās virknes = subject.getStrings (); assertThat (virknes, satur ("Java")); } / ** * Parādiet, kas satur, NETIKS nodots, ja par citiem jautājumiem, par kuriem tiek prasīts cits saturs *, nekā kolekcijā, pat tad, ja * citā secībā. * / @Test public void testAddStringAndGetStringsWithContainsNotWorksDifferNumberElements2 () {final Main subject = new Main (); galīgais būla rezultātsJava = subject.addString ("Java"); galīgais būla rezultātsGroovy = subject.addString ("Groovy"); galīgās virknes = subject.getStrings (); assertThat (virknes, satur ("Groovy")); } Kā norāda JUnit testa rezultāti, šie divi vienības testi nekad neiztur, jo testējamo elementu skaits Iestatiet ir mazāks par elementu skaitu Iestatiet. Citiem vārdiem sakot, tas pierāda, ka satur () matcher nepārbauda, vai konkrētais elements atrodas kolekcijā: tas pārbauda visus esošos elementus un noteiktā secībā. Dažos gadījumos tas var būt pārāk ierobežojošs, tāpēc tagad es pārietu uz dažām citām spēlēm, kuras Hamcrest paredz noteikt, vai elements ir iekļauts konkrētā kolekcijā.
Izmantojot Hamcrest's saturInAnyOrder () Matcher
The saturInAnyOrder spēlētājs nav tik stingrs kā satur () matcher: tas ļauj pārbaudītajiem elementiem būt jebkurā secībā saturošajā kolekcijā.
/ ** * Galvenās klases addString un getStrings metožu pārbaude, izmantojot Hamcrest * matcher saturInAnyOrder. * / @Test public void testAddStringAndGetStringsWithContainsInAnyOrder () {final Main subject = new Main (); galīgais būla rezultātsJava = subject.addString ("Java"); galīgais būla rezultātsCSharp = subject.addString ("C #"); galīgais būla rezultātsGroovy = subject.addString ("Groovy"); galīgais būla rezultātsScala = subject.addString ("Scala"); galīgais būla rezultātsClojure = subject.addString ("Clojure"); galīgās virknes = subject.getStrings (); assertThat (virknes, saturInAnyOrder ("Java", "C #", "Groovy", "Scala", "Clojure")); } / ** * Izmantojiet includeInAnyOrder un parādiet, ka secībai nav nozīmes, kamēr * visi norādītie ieraksti ir kolekcijā noteiktā secībā. * / @Test public void testAddStringAndGetStringsWithContainsInAnyOrderAgain () {final Main subject = new Main (); galīgais būla rezultātsJava = subject.addString ("Java"); galīgais būla rezultātsGroovy = subject.addString ("Groovy"); galīgās virknes = subject.getStrings (); assertThat (virknes, saturInAnyOrder ("Java", "Groovy")); assertThat (virknes, saturInAnyOrder ("Groovy", "Java")); } Divi vienības testi, kas parādīti tieši virs abiem, iztur, neskatoties uz to, ka testējamās stīgas tiek piegādātas saturInAnyOrder () sērkociņš citā secībā, nekā tie varētu pastāvēt abām kolekcijām. Tomēr mazāk stingri saturInAnyOrder () matcher joprojām pieprasa, lai visi saturošās kolekcijas elementi tiktu nodoti. Šis vienības tests neiztur, jo šis nosacījums nav izpildīts.
/ ** * Tas neizdosies, jo saturInAnyOrder prasa, lai visi vienumi būtu saskaņoti *, pat ja tie ir citā secībā. Izmēģinot tikai vienu un divus * elementus kolekcijā, tas joprojām neizdosies. Citiem vārdiem sakot, pasūtījumam * nav nozīmes ar saturInAnyOrder, taču visi kolekcijas * elementi joprojām ir jānodod matchInternynyArder saskaņotājam, tikai ne tādā pašā secībā. * / @Test public void testAddStringAndGetStringsWithContainsInAnyOrderDiffNumberElements () {final Main subject = new Main (); galīgais būla rezultātsJava = subject.addString ("Java"); galīgais būla rezultātsGroovy = subject.addString ("Groovy"); galīgās virknes = subject.getStrings (); assertThat (virknes, saturInAnyOrder ("Java")); } Hamcrest hasItem () un hasItems () Matchers darbojas kā izklausās
Kā parādīts nākamajās divās vienības testa metodēs (kuras abas iztur), Hamkresta hasItem () (vienai precei) un hasItems (vairākiem priekšmetiem) veiksmīgi pārbauda, vai kolekcijā ir attiecīgi viens vai vairāki norādītie priekšmeti, neņemot vērā norādīto priekšmetu secību vai skaitu. Tas patiešām darbojas vairāk, tāpat kā lielākā daļa Java izstrādātāju ir pieraduši "saturēt" darbu, strādājot ar virknēm un kolekcijām.
/ ** * Demonstrēt hasItem () darbosies arī, lai noteiktu, vai kolekcijā ir * konkrēts vienums. * / @Test public void testAddStringAndGetStringsWithHasItem () {final Main subject = new Main (); galīgais būla rezultātsJava = subject.addString ("Java"); galīgais būla rezultātsGroovy = subject.addString ("Groovy"); galīgās virknes = subject.getStrings (); assertThat (virknes, hasItem ("Groovy")); assertThat (virknes, hasItem ("Java")); } / ** * Parādiet, ka hasItems darbojas, lai noteiktu, vai kolekcijā ir viens vai vairāki vienumi un ka vienību skaits un priekšmetu secība * nav nozīmīga, lai noteiktu izturēšanu / neizdošanos. * / @Test public void testAddStringAndGetStringsWithHasItems () {final Galvenais priekšmets = jauns Main (); galīgais būla rezultātsJava = subject.addString ("Java"); galīgais būla rezultātsGroovy = subject.addString ("Groovy"); galīgās virknes = subject.getStrings (); assertThat (virknes, hasItems ("Groovy", "Java")); assertThat (virknes, hasItems ("Java", "Groovy")); assertThat (virknes, hasItems ("Groovy")); assertThat (virknes, hasItems ("Java")); } Hamrests ir () Atbilstības spēlētājs pārbauda ierobežojumus citā virzienā
Tikko apspriestie hasItem () un hasItems () sērkociņi ir mazāk stingri nekā satur () un pat mazāk stingra nekā saturInAnyOrder () un bieži vien tas ir tas, ko kāds vēlas, ja vēlas vienkārši pārliecināties, ka viens vai vairāki priekšmeti atrodas kaut kur kolekcijā, neuztraucoties par preces secību šajā kolekcijā vai to, ka šajā kolekcijā ir citi iespējamie priekšmeti. Viens no citiem veidiem, kā izmantot Hamcrest, lai noteiktu vienas un tās pašas attiecības, bet no pretējās perspektīvas, ir izmantot ir iekšā sērkociņš. The ir iekšā matcher nosaka, vai prece atrodas kaut kur ar matcher sniegto kolekciju, neņemot vērā šīs preces secību kolekcijā, vai tajā ir vai nav citu priekšmetu tajā, kas satur kolekciju.
/ ** * Izmantojiet isIn matcher, lai pārbaudītu, vai atsevišķs elements ir paredzētajā kolekcijā. * / @Test public void testAddStringAndGetStringsWithIsIn () {final Main subject = new Main (); galīgais būla rezultātsJava = subject.addString ("Java"); galīgais būla rezultātsGroovy = subject.addString ("Groovy"); galīgās virknes = subject.getStrings (); assertThat ("Groovy", isIn (virknes)); assertThat ("Java", isIn (virknes)); } 
