Кодирование и декодирование строк в Java с помощью тестов JUnit

Опубликовано: 22 Февраля, 2023

Строки очень полезны, они могут содержать последовательности символов, и со строками связано множество методов. Кроме того, кодирование и декодирование возможны для данного варианта использования, и можно проверить, равны они или нет для данного требования. Их также можно проверить на достоверность с помощью JUnit. Учитывая требование для

кодировать:

Преобразовать все символы данной строки в верхний регистр
Проверьте первое вхождение ',' и замените его на '.'
Точно так же последнее вхождение '!' и замените это на '.'

расшифровать:

Верните исходную тестовую строку

Примечание:

For specific requirements, the code is written. Our task is to write the business logic and test the same with JUnit.

Давайте сделаем это через проект Maven, который содержит зависимость для JUnit.

Пример проекта Maven

Структура проекта:

пом.xml

XML

<?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.gfg.StringServicesJava</groupId>
    <artifactId>StringServicesJava</artifactId>
    <packaging>jar</packaging>
    <version>1.0-SNAPSHOT</version>
  
    <properties>
        <!-- https://maven.apache.org/general.html#encoding-warning -->
        <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>
  
        <!-- junit 5, unit test -->
        <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>
  
                <!-- https://github.com/hcoles/pitest/issues/284 -->
                <!-- Need this to support JUnit 5 -->
                <dependencies>
                    <dependency>
                        <groupId>org.pitest</groupId>
                        <artifactId>pitest-junit5-plugin</artifactId>
                        <version>0.8</version>
                    </dependency>
                </dependencies>
                <configuration>
                    <targetClasses>
                        <param>com.gfg.StringServicesJava.*StringServicesJava*</param>
                    </targetClasses>
                    <targetTests>
                        <param>com.gfg.StringServicesJava.*</param>
                    </targetTests>
                </configuration>
            </plugin>
  
        </plugins>
    </build>
  
</project>

Давайте проверим здесь логику методов кодирования и декодирования. Как сообщается, к конкретному сценарию она адресована.

StringEncodeDecodeServicesJava.java

Java

public class StringEncodeDecodeServicesJava {
    public static String encode(String message) {
        message = message.toUpperCase();
        for (int i = 0; i < message.length(); i++) {
            if (message.charAt(i) == ",") {
                message = message.replace(",", ".");
            }
            if (message.charAt(i) == "!") {
                message = message.replace("!", ".");
            }
        }
        return message;
    }
  
    public static String decode(String encodedMessage) {
        String decodedMessage = encodedMessage.substring(0, 1).toUpperCase()
                + encodedMessage.substring(1).toLowerCase();
        int count = 0;
  
        String newMessage = "";
  
        for (int i = 0; i < decodedMessage.length(); i++) {
            if (decodedMessage.charAt(i) == ".") {
                newMessage += decodedMessage.substring(0, i) + ",";
                count = i;
                break;
            }
        }
        for (int i = count + 1; i < decodedMessage.length(); i++) {
            if (decodedMessage.charAt(i) == ".") {
                newMessage += decodedMessage.substring(count + 1, i) + "!";
                count = i;
                break;
            }
        }
  
        return newMessage;
    }
  
    public static void main(String[] args) {
        String test = "Hello, this is fun!";
        String encoded = encode(test);
        //System.out.println("Encoded message : " + encoded);
        String decoded = decode(encoded);
        //System.out.println("Decoded message : " + decoded);
        if (decoded.equals(test)) {
            System.out.println("Success! At least for this example!");
        } else {
            System.out.println("Something went wrong!");
        }
    }
  
}

Код тестирования JUnit с утверждениями

TestStringEncodeDecodeServicesJava.java

Java

package com.gfg.StringServicesJava;
  
import static org.junit.jupiter.api.Assertions.assertAll;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
  
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
  
public class TestStringEncodeDecodeServicesJava {
    @DisplayName("Test check for Encode and Decode")
    @Test
    public void testCheckForEncodeAndDecode() {
        String testStr = "Hello, this is fun!";
        String encodedStr = StringEncodeDecodeServicesJava.encode(testStr);
        System.out.println("Encoded message : " + encodedStr);
        String decodedStr = StringEncodeDecodeServicesJava.decode(encodedStr);
        System.out.println("Decoded message : " + decodedStr);
          
        // This yields true when decodedStr.equals(testStr)
        // and we are checking against true
        assertEquals(true, decodedStr.equals(testStr));
          
        // We are checking for true
        assertTrue(decodedStr.equals(testStr));
          
        // We are checking for false by adding !condiition
        assertFalse(!decodedStr.equals(testStr));
        boolean[] expectedValues = { decodedStr.equals(testStr), "Hello, this is fun!".equals(testStr) };
        boolean[] actualValues = { true, true };
          
        // Sometimes there are possibilities to 
        // combine more than one condition
        assertArrayEquals(expectedValues, actualValues);
          
        // Sometimes we need to go with assertAll because even
        // the first assert might have gone wrong but the rest are correct
        // During that time when we combine everything, even 
        // if there is error it will indicate it
        assertAll("Should check whether encoding and decoding are correct",
                () -> assertEquals(true, decodedStr.equals(testStr)),
                () -> assertTrue(decodedStr.equals(testStr)),
                () -> assertArrayEquals(expectedValues, actualValues));
          
        assertAll("Should check whether encoding and decoding are correct by checking wrongly",
                () -> assertEquals(false, decodedStr.equals(testStr)),
                () -> assertFalse(decodedStr.equals(testStr)),
                () -> assertArrayEquals(expectedValues, actualValues));    
          
    }
}

Здесь нам нужно внимательно посмотреть на assertAll. Когда мы пишем код, также есть вероятность создания неправильных операторов, и из-за этого, если есть шанс, что утверждение не будет выполнено для первого оператора, остальные операторы вообще не будут выполняться. Мы можем обойти этот сценарий, добавив assertALL. Как группа, он проверит все утверждения, присутствующие в assertAll, и укажет ошибки под одним общим заголовком. Здесь мы сохранили заголовок «Следует проверять правильность кодирования и декодирования, проверяя неправильно». Увидев вывод, мы можем сделать вывод, что «assertAll» играет хорошую роль.

Technical Scripter Java

Кодирование и декодирование строк в Java с помощью тестов JUnit

Пример проекта Maven

XML

Java

Java

РЕКОМЕНДУЕМЫЕ СТАТЬИ