Projek Maven menggunakan Junit - Semak nombor akaun bank

Semua aplikasi, tanpa mengira saiz, perlu melalui satu siri proses membina, menjana, menyusun dan menjalankan kod sumber. Set proses ini dilakukan secara manual oleh pengaturcara. Walau bagaimanapun, dengan pelancaran projek Apache Maven, semua proses ini boleh diautomasikan, menghapuskan kerja manual. Oleh itu, projek maven ialah alat sumber terbuka yang digunakan untuk membina dan menggunakan berbilang projek sekaligus untuk menyediakan pengurusan projek yang lebih baik.

Dalam artikel ini, kami akan membincangkan projek Maven untuk menyemak sama ada akaun bank sah dan diuji menggunakan Junit.

Junit Apa itu?

JUnit ialah rangka kerja ujian unit sumber terbuka yang digunakan oleh organisasi bahasa Java di seluruh dunia. Dalam bahasa Java, setiap kali kod baharu ditambahkan, kes ujian perlu dilaksanakan semula Fungsi ini dilaksanakan oleh rangka kerja Junit. Ia digunakan untuk menulis dan melaksanakan kes ujian automatik dalam bahasa Java.

Projek Maven untuk menyemak akaun bank

Setiap kali kita berurusan dengan perisian perbankan atau aplikasi berkaitan, satu perkara wajib ialah mengesahkan nombor akaun. Untuk akaun sah, tiga syarat perlu dipenuhi.

Tiga syarat tersebut adalah seperti berikut -

• Nombor akaun bank hanya boleh mengandungi 14 digit.

• Semua 14 digit dalam nombor akaun tidak boleh sifar.

• Medan nombor akaun tidak boleh kosong atau kosong.

Sekarang, mari tulis logik perniagaan yang memenuhi ketiga-tiga syarat ini dalam projek Maven.

Algoritma

• Langkah 1 - Mula-mula buat folder BankingAccountNoServices, yang mengandungi fail Java bernama BankingAccountNoServices.java untuk menulis logik perniagaan, dan TestBankingAccountNoServices yang kedua adalah digunakan untuk perniagaan. logik.

• Langkah 2 - Buat fail lain pom.xml iaitu fail xml yang mengandungi butiran projek dan konfigurasi projek Maven.

• Langkah 3 - Faktor utama dalam mencapai hasil yang positif ialah mendokumentasikan projek yang berkaitan dan maklumat konfigurasi dalam fail pom.xml.

• Langkah 4 - Tulis logik perniagaan dengan memenuhi semua syarat yang diperlukan untuk mengesahkan akaun.

• Langkah 5 - Tulis kes ujian unit menggunakan Junit dalam fail Test BankingAccountNoServices.java.

Kandungan fail pom.xml hendaklah disemak sebelum meneruskan. Ia konsisten merentas semua kaedah yang dibincangkan dan mengandungi butiran konfigurasi penting untuk projek Maven.

Contoh

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
                              http://maven.apache.org/xsd/maven-4.0.0.xsd">
  
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.example.BankingAccountNoServices </groupId>
   <artifactId>BankingAccountNoServices </artifactId>
   <packaging>jar</packaging>
   <version>1.0-SNAPSHOT</version>
  
   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <maven.compiler.source>1.8</maven.compiler.source>
      <maven.compiler.target>1.8</maven.compiler.target>
      <junit.version>5.3.1</junit.version>
      <pitest.version>1.4.3</pitest.version>
   </properties>
  
   <dependencies>
      <dependency>
         <groupId>org.junit.jupiter</groupId>
         <artifactId>junit-jupiter-engine</artifactId>
         <version>${junit.version}</version>
         <scope>test</scope>
      </dependency>
   </dependencies>
   <build>
      <finalName>maven-mutation-testing</finalName>
      <plugins>
         <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>3.0.0-M1</version>
         </plugin>
  
         <plugin>
            <groupId>org.pitest</groupId>
            <artifactId>pitest-maven</artifactId>
            <version>${pitest.version}</version>
  
            <executions>
               <execution>
                  <id>pit-report</id>
                  <phase>test</phase>
                  <goals>
                     <goal>mutationCoverage</goal>
                  </goals>
               </execution>
            </executions>
  
            <dependencies>
               <dependency>
                  <groupId>org.pitest</groupId>
                  <artifactId>pitest-junit5-plugin</artifactId>
                  <version>0.8</version>
               </dependency>
            </dependencies>
            <configuration>
               <targetClasses>
                  <param>com.example.BankingAccountNoServices.* BankingAccountNoServices *</param>
               </targetClasses>
               <targetTests>
                  <param>com.example.BankingAccountNoServices.*</param>
               </targetTests>
            </configuration>
         </plugin>
  
      </plugins>
   </build>
  
</project>

Kod pom.xml di atas mengandungi semua butiran projek dan konfigurasi yang diperlukan untuk projek maven kami.

kaedah

• Kaedah 1 - Dalam kaedah ini kita akan melihat logik perniagaan menggunakan Long.parseLong.

• Kaedah 2 - Dalam kaedah ini, kami akan menulis logik perniagaan menggunakan fungsi Character.isDigit().

• Kaedah 3 - Dalam kaedah ini kita akan menulis logik perniagaan menggunakan ungkapan biasa dalam Java.

Kaedah 1: Gunakan Long.parseLong

Memandangkan nombor akaun mestilah nombor 14 digit, kami menggunakan fungsi Long.parseLong untuk menukarnya kepada jenis panjang, dan kemudian semak tiga syarat yang diperlukan.

Contoh

import java.util.*;  
public class BankingAccountNoServices {
   public boolean isValid1(String accNo) {
      if (accNo == null || accNo.equalsIgnoreCase("")) {
         return false; 
      }
      try {
         Long.parseLong(accNo); 
         if (accNo.length() == 14) {
            int c = 0;
            int n = accNo.length();
            for (int i = 0; i < n; i++) {
               if (accNo.charAt(i) == '0') {
                  c += 1;
               }
            }
            if (c == 14) { 
               return false;
            } else {
               return true;
            }
         } else {
            return false;
         }
      }
      catch (NumberFormatException exception) {
         return false;
      }
   }
}

Dalam kod di atas, kami mula-mula menyemak sama ada nombor akaun adalah batal atau kosong, kedua semak sama ada panjang nombor akaun ialah 14, dan kemudian mengira bilangan sifar di dalamnya. Mengembalikan palsu jika semua 14 digit adalah sifar, benar sebaliknya.

Sekarang, mari lihat kes ujian unit menggunakan JUnit.

import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test; 
public class TestBankingAccountNoServices {
   public void testForBankAccountNo() {
      BankingAccountNoServices ob = new BankingAccountNoServices();
      assertEquals(false, ob.isValid1(null));
      assertEquals(false, ob.isValid1("8378939"));
      assertEquals(true, ob.isValid1("67874864837684"));
      assertEquals(true, ob.isValid1("23451234543214"));
   }
}

Dalam kod di atas, kami menyemak 4 kes ujian unit berbeza untuk mengesahkan akaun.

Kaedah 2: Gunakan Character.isDigit()

Dalam kaedah ini, kami akan menggunakan fungsi Character.isDigit() untuk menyemak nombor akaun. Kami akan menyemak ketiga-tiga syarat yang diperlukan untuk mengesahkan akaun.

Contoh

import java.util.*;  
public class BankingAccountNoServices {
   public boolean isValid2(String accNo){
      if (accNo == null || accNo.equalsIgnoreCase("")) {
         return false; 
      }
      if (accNo.length() == 14) {
         int c = 0;
         for (int i = 0; i < accNo.length(); i++) {
            if (!Character.isDigit(accNo.charAt(i))) {
               return false;
            }
            if (accNo.charAt(i) == '0') {
               c += 1;
            }
         }
         if (c == 14) {
            return false;
         } else {
            return true;
         }
      } else {
         return false;
      }
   }
}

Dalam kod di atas, kami mula-mula menyemak sama ada nombor akaun adalah batal atau kosong, kedua semak sama ada panjang nombor akaun ialah 14, dan kemudian semak sama ada aksara pembolehubah accNo adalah nombor atau tidak. Ketiga, semak sama ada terdapat sifar dalam nombor tersebut.

Sekarang, mari lihat kes ujian unit menggunakan JUnit.

import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test; 
public class TestBankingAccountNoServices {
   public void testForBankAccountNo() {
      BankingAccountNoServices ob = new BankingAccountNoServices();
      assertEquals(false, ob.isValid2(""));
      assertEquals(false, ob.isValid2("00000000000000"));
      assertEquals(true, ob.isValid2("67874864837684"));
      assertEquals(true, ob.isValid2("34324353488345"));
   }
}

Dalam kod di atas, kami menyemak 4 kes ujian unit berbeza untuk mengesahkan akaun.

Kaedah 3: Gunakan pola ungkapan biasa

Dalam pendekatan ini, kami mentakrifkan corak ungkapan biasa untuk nombor dan menyemak ketiga-tiga syarat yang diperlukan untuk pengesahan akaun.

Contoh

import java.util.regex.Matcher;
import java.util.regex.Pattern;
  
public class BankingAccountNoServices {
   public boolean isValid3(String accNo) {
      if (accNo == null || accNo.equalsIgnoreCase("")) {
         return false; 
      }
      if (accNo.length() == 14) {
         int c = 0;
         String r = "[0-9]+"; 
         Pattern p = Pattern.compile(r);
         Matcher matcher = p.matcher(accNo);
         if (matcher.matches()) { 
            for (int i = 0; i < accNo.length(); i++) {
               if (accNo.charAt(i) == '0') {
                  c += 1;
               }
            }
            if (c == 14) { 
               return false;
            } else {
               return true;
            }
         } else {
            return false;
         }
      } else {
         return false;
      }
   }
}

Dalam kod di atas, kami mula-mula menyemak sama ada nombor akaun adalah batal atau kosong, kedua semak sama ada panjang nombor akaun ialah 14, dan kemudian tentukan ungkapan biasa berangka dan semak keperluan menggunakan Corak dan Padanan kelas untuk ketiga-tiga nilai ini.

Sekarang, mari lihat kes ujian unit menggunakan JUnit.

import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test; 
public class TestBankingAccountNoServices {
   public void testForBankAccountNo() {
      BankingAccountNoServices ob = new BankingAccountNoServices();
      assertEquals(false, ob.isValid3("47283"));
      assertEquals(false, ob.isValid3("19037293284s32"));
      assertEquals(true, ob.isValid3("67874864837684"));
      assertEquals(true, ob.isValid3("34521678954632"));
   }
}

Dalam kod di atas, kami menyemak 4 kes ujian unit berbeza untuk mengesahkan akaun.

Kesimpulan

Dalam artikel ini, kami mencipta projek Maven menggunakan Junit khusus untuk menyemak nombor akaun bank. Kami membincangkan tiga cara berbeza untuk menulis logik perniagaan yang mengesahkan nombor akaun bank, iaitu menggunakan Long.parseLong, Character.isDigit() dan menggunakan corak ungkapan biasa. Mana-mana daripadanya boleh digunakan untuk melakukan pengesahan nombor akaun bank di Java.

Atas ialah kandungan terperinci Projek Maven menggunakan Junit - Semak nombor akaun bank. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!