Java Assertions

Ang Assert statement Sa Java ay ginagamit upang subukan ang ilang mga pagpapalagay tungkol sa estado ng isang programa sa panahon ng pagpapatupad. Nakakatulong ito upang madaling makita ang mga error at i-debug ang program. Ang isang assertion statement sa Java ay isinulat gamit ang Java assert keyword na sinusundan ng boolean expression. Kung ang expression ay nag-evaluate sa true, ang assertion ay tahimik na pumasa at ang programa ay gumagana ang trabaho nito. Kung ito ay mag-evaluate sa false, ang assertion ay mabibigo at ang isang AssertionError ay itatapon. Magkaroon tayo ng isang halimbawa ng isang programa na may Java assertions.

//Assertion in Java example
public class AssertDemo1 {
   public static void main(String[] args) {
       int x = 5;
       assert x == 5 : "x should be 5";
       System.out.println(x);
   }
}

Narito ang expression ay totoo, kaya ang programa ay nagpapatuloy lamang sa trabaho nito. Ang output ay tulad ng inaasahan na:

Halimbawa ng AssertionError

Sa Java, ang AssertionError ay isang subclass ng Error class at ito ay itinapon kapag nabigo ang isang assertion. Karaniwang ginagamit ang mga assertion sa Java upang suriin kung totoo ang mga precondition, postcondition, o invariant. Tulad ng sinabi namin sa ibaba, ang isang AssertionError ay itinapon kapag ang isang pahayag ng assertion ay nabigong masuri sa totoo. Ngayon ay muling isulat natin ang ating programa upang ang boolean na expression ay mali.

//AssertionError example
public class AssertDemo1 {
   public static void main(String[] args) {
       int x = 5;
       assert x == 7 : "x should be 7";
       //here should be AssertionError
       System.out.println(x);
   }
}

Well, pinapatakbo namin ito at ang output ay… Tiyak na may nangyaring mali sa aming halimbawa! Dapat tayong magkaroon ng AssertionError dito dahil ang ating x ay 5 at ang assertion ay inaasahan na ito ay 7. Ano ang mali dito? Mahalagang tandaan na ang mga pahayag ng Java ay maaaring i-disable lamang sa JVM, kaya hindi dapat gamitin ang mga ito bilang ang tanging paraan ng pagsuri ng error sa isang programa. Kapaki-pakinabang ang mga ito para sa pag-debug at pagsubok, ngunit hindi dapat umasa para sa production code. Kaya para gumamit ng mga assertion, kailangan mong paganahin ang mga ito gamit ang pagpipiliang vm -ea (o -enableassertions). Kung nagtatrabaho ka sa command line, maaari mong gamitin ang susunod na command para sa iyong program na AssertDemo1: kung pinagana mo ang mga assertion at muling patakbuhin ang parehong program, makukuha mo ang susunod: Iyon ang punto.

Paano paganahin ang mga pagbubukod sa IntelliJ IDEA

1. Pumunta sa Run menu → Edit Configurations....
2. Ilagay ang -ea na parameter sa linya ng mga opsyon sa VM

Ngayon ang mga assertion ay pinagana at maaari mong gamitin ang mga ito.

Mga assertion para sa unit testing sa Java

Sa Java, ang unit testing ay isang pamamaraan na nagsasangkot ng pagsubok sa mga indibidwal na module ng code upang matiyak na gumagana ang mga ito nang tama. Karaniwang ginagamit ang mga assertion sa unit testing sa Java para i-verify na gumagana ang nasubok na code gaya ng inaasahan. Sa unit testing, ang isang unit ng code, halimbawa isang partikular na paraan, ay sinusuri nang hiwalay upang matiyak na ito ay gumagana nang tama sa ilalim ng iba't ibang mga kondisyon at input. Magkaroon tayo ng isang halimbawa. Narito mayroon kaming isang simpleng calculator para sa karagdagan, pagbabawas, pagpaparami at dibisyon 2 integer.

public class MyMath {

   public static int add (int a, int b) {
       return a + b;
   }

   public static int sub (int a, int b) {
       return a - b;
   }

   public static int mult (int a, int b) {
       return a*b;
   }

   public static double div (int a, int b) {
       return a/b;
   }
}

Siyempre, maraming mga tanong tungkol sa pagpapatupad na ito (halimbawa, kung ano ang mangyayari kung idagdag namin ang pinakamalaking int sa isa pang numero), ngunit sa ngayon ay iiwan namin ang pagpapatupad na ito kung ano ito. Ngayon magsulat tayo ng isang klase kung saan susuriin natin ang mga pamamaraan ng klase ng myMath sa tulong ng mga unit test. Totoo, dalawa lang sila. Sa katunayan, maaari kang magsulat ng mga pagsubok na sumusuri sa mga argumento para sa bisa, kung ang isang pamamaraan ay humahawak ng mga espesyal na kaso, at iba pa. Ngunit dito ay lilimitahan natin ang ating sarili sa ilang pagsubok lamang para sa mga layunin ng pagpapakita.

import org.junit.Test;

import static org.junit.Assert.assertEquals;

public class MyMathTesting {
   @Test
   public void testAdd() {
       MyMath calculator = new MyMath();
       int sum = calculator.add(2, 3);
       assertEquals(5, sum);
   }

   @Test
   public void testSub() {
       MyMath calculator = new MyMath();
       int sub = calculator.sub(5, 2);
       assertEquals(3, sub);
   }

}

Ang paraan ng assertEquals ay isang assertion na nagsusuri kung pantay ang dalawang value. Kung ang mga halaga ay hindi pantay, isang AssertionError ang itatapon, na nagpapahiwatig na ang pagsubok ay nabigo. Ang paggamit ng mga assertion sa mga unit test ay makakatulong sa iyong mahuli ang mga bug at matiyak na gumagana nang tama ang iyong code sa ilalim ng iba't ibang kundisyon at input. Subukang magdagdag ng mga pagsubok para sa paghahati at pagpaparami sa iyong sarili. Ito ay hindi mahirap.