Scala för backendutveckling och funktionell programmering · Lektion

Egenskapsbaserad testning

ScalaCheck.

Lektion 3 av 413 steg

Egenskapsbaserad testning är en gratis lektion i Scala för backendutveckling och funktionell programmering på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Scala för backendutveckling och funktionell programmering, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Scala för backendutveckling och funktionell programmering innehåller totalt 4 lektioner.

Vad är egenskapsbaserad testning?

Vid egenskapsbaserad testning anger ni en generell egenskap som ska gälla för alla indata, och ramverket genererar många slumpmässiga indata för att försöka motbevisa den. På så sätt hittas specialfall som handskrivna exempel missar.

Exempel kontra egenskap

Ett exempeltest kontrollerar ett fall: reverse(List(1,2,3)) == List(3,2,1). En egenskap anger en regel: att vända en lista två gånger ger den ursprungliga listan, för vilken lista som helst. Ramverket kontrollerar regeln på hundratals genererade listor.

ScalaCheck

ScalaCheck är biblioteket för egenskapsbaserad testning i Scala. Lägg till det som ett testberoende; det integreras med ScalaTest.

libraryDependencies += "org.scalatestplus" %% "scalacheck-1-17" % "3.2.18.0" % Test

forAll

Den centrala konstruktionen är forAll: den genererar slumpmässiga värden och verifierar egenskapens kropp för varje värde. Här testar vi att addition är kommutativ.

import org.scalatest.flatspec.AnyFlatSpec
import org.scalatest.matchers.should.Matchers
import org.scalatestplus.scalacheck.ScalaCheckPropertyChecks

class AddSpec extends AnyFlatSpec with Matchers with ScalaCheckPropertyChecks {
  "addition" should "be commutative" in {
    forAll { (a: Int, b: Int) =>
      a + b shouldBe b + a
    }
  }
}

En rundreseegenskap

Ett kraftfullt mönster är en rundresa: kodning följt av avkodning (eller att vända något två gånger) ska ge tillbaka det ursprungliga värdet, för vilken indata som helst.

import org.scalatest.flatspec.AnyFlatSpec
import org.scalatest.matchers.should.Matchers
import org.scalatestplus.scalacheck.ScalaCheckPropertyChecks

class RevSpec extends AnyFlatSpec with Matchers with ScalaCheckPropertyChecks {
  "reverse" should "be its own inverse" in {
    forAll { (xs: List[Int]) =>
      xs.reverse.reverse shouldBe xs
    }
  }
}

Generatorer

ScalaCheck tillhandahåller automatiskt Gen-generatorer för inbyggda typer. Ni kan också skapa egna, till exempel Gen.choose(1, 100) för ett heltal inom ett begränsat intervall.

import org.scalacheck.Gen

val smallInt: Gen[Int] = Gen.choose(1, 100)
val nonEmpty: Gen[List[Int]] = Gen.nonEmptyListOf(Gen.choose(0, 9))

Använda en anpassad generator

Skicka en generator till forAll för att begränsa indata, till exempel till enbart positiva tal.

import org.scalatest.flatspec.AnyFlatSpec
import org.scalatest.matchers.should.Matchers
import org.scalatestplus.scalacheck.ScalaCheckPropertyChecks
import org.scalacheck.Gen

class PosSpec extends AnyFlatSpec with Matchers with ScalaCheckPropertyChecks {
  "abs" should "stay positive" in {
    forAll(Gen.choose(1, 1000)) { (n: Int) =>
      math.abs(n) should be > 0
    }
  }
}

Förminskning

När en egenskap misslyckas förminskar ScalaCheck den felande indatan till det minsta exempel som fortfarande misslyckas. I stället för en stor slumpmässig lista får ni ett minimalt motexempel som är enkelt att felsöka.

Villkorade egenskaper

Använd whenever för att begränsa en egenskap till indata som uppfyller ett förvillkor. Indata som inte uppfyller villkoret kastas bort.

import org.scalatest.flatspec.AnyFlatSpec
import org.scalatest.matchers.should.Matchers
import org.scalatestplus.scalacheck.ScalaCheckPropertyChecks

class DivSpec extends AnyFlatSpec with Matchers with ScalaCheckPropertyChecks {
  "division" should "hold for nonzero divisors" in {
    forAll { (a: Int, b: Int) =>
      whenever(b != 0) {
        (a / b) * b + (a % b) shouldBe a
      }
    }
  }
}

Bra egenskaper att testa

Användbara kategorier av egenskaper:

Rundresor: koda/avkoda, vänd/vänd.
Invarianter: sortering bevarar längden.
Algebraiska lagar: kommutativitet, associativitet, identitet.

När ska det användas?

Egenskapsbaserad testning kompletterar exempeltester, men ersätter dem inte. Använd den för rena funktioner med tydliga matematiska eller strukturella regler. Behåll riktade exempeltester för specifika kända fall och regressioner.

Snabb kontroll

Testa era kunskaper om egenskapsbaserad testning.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt er egenskapsbaserad testning med ScalaCheck:

Ange egenskaper som är sanna för all indata; ramverket genererar många fall.
forAll styr genereringen; Gen skapar anpassad indata.
whenever lägger till förvillkor; fel förminskas till minimala exempel.
Det passar utmärkt för rundresor, invarianter och algebraiska lagar.

Gratis att börja

Lär dig Scala med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 39
Lektioner: 143

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Egenskapsbaserad testning” gratis?

Ja – hela texten till ”Egenskapsbaserad testning” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Scala för backendutveckling och funktionell programmering, kan Ni uppgradera till CoddyKit PRO. Kursen i Scala för backendutveckling och funktionell programmering innehåller totalt 4 lektioner.

Vad lär jag mig i ”Egenskapsbaserad testning”?

ScalaCheck. Ni övar på Scala för backendutveckling och funktionell programmering med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Scala för backendutveckling och funktionell programmering?

Du behöver inga förkunskaper. Utbildningen i Scala för backendutveckling och funktionell programmering på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Egenskapsbaserad testning”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Scala för backendutveckling och funktionell programmering-lektionen?

Ja. Varje Scala för backendutveckling och funktionell programmering-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Scala för backendutveckling och funktionell programmering