Maven-Projekt mit Junit – Bankkontonummer prüfen

Alle Anwendungen, unabhängig von ihrer Größe, müssen eine Reihe von Prozessen zum Erstellen, Generieren, Kompilieren und Ausführen von Quellcode durchlaufen. Diese Reihe von Prozessen wird manuell von Programmierern ausgeführt. Mit dem Start des Apache Maven-Projekts können jedoch alle diese Prozesse automatisiert werden und manuelle Arbeit entfallen. Daher ist Maven Project ein Open-Source-Tool, mit dem mehrere Projekte gleichzeitig erstellt und bereitgestellt werden können, um ein besseres Projektmanagement zu ermöglichen.

In diesem Artikel besprechen wir ein Maven-Projekt, um zu überprüfen, ob ein Bankkonto gültig ist, und es mit Junit zu testen.

Was ist Junit?

JUnit ist ein Open-Source-Unit-Test-Framework, das von Java-Sprachorganisationen auf der ganzen Welt verwendet wird. In der Java-Sprache müssen Testfälle jedes Mal erneut ausgeführt werden, wenn neuer Code hinzugefügt wird. Diese Funktion wird vom Junit-Framework implementiert. Es wird zum Schreiben und Ausführen automatisierter Testfälle in der Java-Sprache verwendet.

Maven-Projekt zur Überprüfung von Bankkonten

Immer wenn es um Banksoftware oder verwandte Anwendungen geht, ist die Verifizierung der Kontonummer zwingend erforderlich. Damit ein Konto gültig ist, müssen drei Bedingungen erfüllt sein.

Die drei Bedingungen lauten wie folgt -

• Bankkontonummer darf nur 14 Ziffern enthalten.

• Alle 14 Ziffern der Kontonummer dürfen nicht Null sein.

• Das Kontonummernfeld darf nicht leer oder leer sein.

Jetzt schreiben wir die Geschäftslogik, die alle diese drei Bedingungen im Maven-Projekt erfüllt.

Algorithmus

• Schritt 1 – Erstellen Sie zunächst einen Ordner BankingAccountNoServices, der eine Java-Datei namens BankingAccountNoServices.java zum Schreiben der Geschäftslogik und zweitens TestBankingAccountNoServices.java zum Testen der Geschäftslogik enthält.

• Schritt 2 – Erstellen Sie eine weitere Datei pom.xml, eine XML-Datei, die die Projekt- und Konfigurationsdetails des Maven-Projekts enthält.

• Schritt 3 – Ein Schlüsselfaktor für das Erreichen positiver Ergebnisse ist die Dokumentation relevanter Projekt- und Konfigurationsinformationen in der pom.xml-Datei.

• Schritt 4 – Schreiben Sie die Geschäftslogik, indem Sie alle notwendigen Bedingungen erfüllen, die zur Verifizierung des Kontos erforderlich sind.

• Schritt 5 – Schreiben Sie Unit-Testfälle mit Junit in die Datei Test BankingAccountNoServices.java.

Sie sollten den Inhalt der pom.xml-Datei überprüfen, bevor Sie fortfahren. Es ist über alle besprochenen Methoden hinweg konsistent und enthält wichtige Konfigurationsdetails für Maven-Projekte.

Beispiel

<?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>

Der pom.xml-Code oben enthält alle Projekt- und Konfigurationsdetails, die für unser Maven-Projekt erforderlich sind.

Methode

• Methode 1 – In dieser Methode sehen wir die Geschäftslogik unter Verwendung von Long.parseLong.

• Methode 2 – In dieser Methode schreiben wir Geschäftslogik mit der Funktion Character.isDigit().

• Methode 3 – In dieser Methode schreiben wir Geschäftslogik unter Verwendung regulärer Ausdrücke in Java.

Methode 1: Verwenden Sie Long.parseLong

Da die Kontonummer eine 14-stellige Zahl sein sollte, verwenden wir die Funktion Long.parseLong, um sie in einen langen Typ umzuwandeln und überprüfen dann die drei notwendigen Bedingungen.

Beispiel

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;
      }
   }
}

Im obigen Code prüfen wir zunächst, ob die Kontonummer null oder leer ist, prüfen zweitens, ob die Länge der Kontonummer 14 beträgt, und zählen dann die Anzahl der darin enthaltenen Nullen. Gibt „false“ zurück, wenn alle 14 Ziffern Null sind, andernfalls „true“.

Schauen wir uns nun Unit-Testfälle mit JUnit an.

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"));
   }
}

Im obigen Code prüfen wir 4 verschiedene Unit-Testfälle, um das Konto zu verifizieren.

Methode 2: Verwenden Sie Character.isDigit()

Bei dieser Methode überprüfen wir die Kontonummer mit der Funktion Character.isDigit(). Wir prüfen alle drei notwendigen Voraussetzungen zur Verifizierung des Kontos.

Beispiel

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;
      }
   }
}

Im obigen Code prüfen wir zunächst, ob die Kontonummer null oder leer ist, zweitens prüfen wir, ob die Länge der Kontonummer 14 beträgt, und prüfen dann, ob die Zeichen der Variable accNo Zahlen sind oder nicht. Drittens prüfen Sie, ob die Zahl eine Null enthält.

Schauen wir uns nun Unit-Testfälle mit JUnit an.

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"));
   }
}

Im obigen Code prüfen wir 4 verschiedene Unit-Testfälle, um das Konto zu verifizieren.

Methode 3: Verwenden Sie ein reguläres Ausdrucksmuster

Bei dieser Methode definieren wir ein reguläres Ausdrucksmuster für Zahlen und prüfen alle drei notwendigen Bedingungen für die Kontoverifizierung.

Beispiel

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;
      }
   }
}

Im obigen Code prüfen wir zunächst, ob die Kontonummer null oder leer ist, prüfen zweitens, ob die Länge der Kontonummer 14 beträgt, definieren dann einen regulären Ausdruck einer Zahl und prüfen die erforderlichen Bedingungen für diese drei Werte unter Verwendung der Klassen Pattern und Matcher.

Schauen wir uns nun Unit-Testfälle mit JUnit an.

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"));
   }
}

Im obigen Code prüfen wir 4 verschiedene Unit-Testfälle, um das Konto zu verifizieren.

Fazit

In diesem Artikel haben wir ein Maven-Projekt mit Junit speziell für die Überprüfung von Bankkontonummern erstellt. Wir haben drei verschiedene Möglichkeiten besprochen, Geschäftslogik zur Validierung von Bankkontonummern zu schreiben, nämlich die Verwendung von Long.parseLong, Character.isDigit() und die Verwendung von Mustern für reguläre Ausdrücke. Jedes davon kann zur Überprüfung von Bankkontonummern in Java verwendet werden.

Das obige ist der detaillierte Inhalt vonMaven-Projekt mit Junit – Bankkontonummer prüfen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!