Introduction

Recently, I was solving a straightforward issue. The technical documentation about the input format was straightforward. A particular column in the CSV document represented numbers in double format. However, users were allowed to interact with CSV files and make manual edits. This lead to a situation where the user or the processing program changes the number to a standardized format or even to an incorrect one. In most cases, users change the dot to a comma.

Thus, if possible, I needed to devise a simple way to fix the incorrect input and cast the string to double.

Implementation

I have created a simple util class with a single static method to fix the incorrect string format.

The method implementation catches and solves the following cases:

• The method throws an exception if the input string is null or empty.
• The method throws an exception if the input string contains more than one separator or a mix of different separators.
• The method throws an exception if the input string is not a number.
• Otherwise, the process replaces the comma with a dot and parses the string to double.

Casting can still fail and throw NumberFormatException if the input string is not a number. parseStringToDouble() method will not handle the failure, and it will be up to the caller to catch the exception and manage it. Feel free to adjust the method according to your needs.

Here is a simple algorithm for how to cast string to double:

public static class StringUtil {
  
  private static final String DOT = ".";
  private static final String COMMA = ",";
  private static final String EMPTY = "";
  
  /**
   * Parses a string to a double.
   *
   * @param numberStr
   * @return the parsed double
   * @throws IllegalArgumentException if the input string is null or empty, or if the number is ambiguous
   */
  public static Double parseStringToDouble(final String numberStr) {
      if (numberStr == null || numberStr.isEmpty()) {
          throw new IllegalArgumentException("Input string is null or empty");
      }

      val numberStrWithReplacedCommas = numberStr.replace(COMMA, DOT);

      int dotCount = numberStr.length() - numberStr.replace(DOT, EMPTY).length();
      int commaCount = numberStr.length() - numberStrWithReplacedCommas.length();

      if (dotCount + commaCount > 1) {
          throw new IllegalArgumentException("There is more than one separator, or a mix of them, the number is ambiguous");
      }

      return Double.parseDouble(numberStrWithReplacedCommas);
  }

}

Feel free to use this simple algorithm in your projects and extend it according to your will. You may not need to throw an exception if the input string is null or empty or if the number is ambiguous. You may want to catch NumberFormatException from parseDouble method and return 0.0 in such case. You could return empty Optional. It is up to you.

Tests

I also wrote a few tests to verify that the algorithm works correctly. Please check it and adjust it according to your will. Here are the tests:

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

import lombok.val;

class StringUtilTest {

    @Test
    public void testParseValidStringWithDot() {
        val result = StringUtil.parseStringToDouble("123.45");
        Assertions.assertEquals(123.45, result, 0.000);
    }

    @Test
    public void testParseValidStringWithComma() {
        val result = StringUtil.parseStringToDouble("123,45");
        Assertions.assertEquals(123.45, result, 0.000);
    }

    @Test
    public void testParseStringWithMultipleSeparatorsShouldThrowException() {
        Assertions.assertThrows(IllegalArgumentException.class,
            () -> StringUtil.parseStringToDouble("123,45.67"));
    }

    @Test
    public void testParseStringWithInvalidCharactersShouldThrowException() {
        Assertions.assertThrows(IllegalArgumentException.class,
            () -> StringUtil.parseStringToDouble("123..45"));
    }

    @Test
    public void testParseStringWithOtherInvalidCharactersShouldThrowException() {
        Assertions.assertThrows(IllegalArgumentException.class,
            () -> StringUtil.parseStringToDouble("123,,45"));
    }

    @Test
    public void testParseNonNumericStringShouldThrowException() {
        Assertions.assertThrows(NumberFormatException.class,
            () -> StringUtil.parseStringToDouble("not a number"));
    }

    @Test
    public void testParseEmptyStringShouldThrowException() {
        Assertions.assertThrows(IllegalArgumentException.class,
            () -> StringUtil.parseStringToDouble(""));
    }

    @Test
    public void testParseNullShouldThrowException() {
        Assertions.assertThrows(IllegalArgumentException.class,
            () -> StringUtil.parseStringToDouble(null));
    }

}

Conclusion

In simple algorithms, we have seen how to handle multiple cases of incorrect string input and how to cast string to double.

But in the end, it is up to you how to handle the cases when the input string is null or empty or if the number is ambiguous. You can throw a custom exception, return 0.0, empty Optional, or do something else.

Did you find an algorithm for casting strings to double easily? Do you have your trick or know another way how to change arbitrary string to double? Let us know in the comments below the article. We would like to hear your ideas and stories.

Introduction

In this article we will continue and spin from the previous article about generating OpenAPI with Spring Boot for multipart endpoint and uploading files through it. We strongly recommend reading the last article if you want to import more than one file. But in this article, we will focus only on the optional import of a single file.

But instead of multiple files, we will try to upload only one file and one serialized object, for example, the information about the new user.

We will also show how to handle the deserialization of the incoming object from the string at the Spring Boot backend and how to control proper deconstruction if some fields are optional or not mandatory.

OpenAPI User import definition YAML

So we start where we end the last time. Let’s generate the Spring Boot endpoint through the OpenAPI schema, which will be able to receive objects and, optionally, a file through multipart form data.

openapi: 3.0.2
info:
  title: User management module
  description: User management
  version: '0.1'
  contact:
  email: optional@email.com
servers:
  - url: https://localhost:8080/api/user-management

paths:
  /users/import:
    post:
      summary: Create new Users with optional attachment
      tags:
        - users
      operationId: createUserWithOptionalFile
      requestBody:
        content:
          multipart/form-data:
            schema:
              type: object
              properties:
                createUser:
                  description: Wrapper containing information for new user creation
                  type: object
                  properties:
                    username:
                      description: Users username
                      type: string
                    age:
                      description: Users password
                      type: number
                    creationTimestamp:
                      description: Time when the user will be defined as created in the system
                      type: string
                      format: date-time
                      example: "2024-02-29T12:30:00.000Z"
                    email:
                      description: Email of the user
                      type: string
                    addressId:
                      description: ID of the users address
                      type: string
                    accessRights:
                      description: List of access rights for the user
                      type: array
                      items:
                        type: object
                        properties:
                          accessRightId:
                            description: ID of the access right
                            type: string
                          note:
                            description: Note for the access right
                            type: string
                  required:
                    - username
                    - email
                    - accessRights
                optionalFile:
                  description: Optional file attachment
                  type: string
                  format: binary
              required:
              - createUser
      responses:
        '200':
          description: Successful operation
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateUserResponse'
        '400':
          description: Bad Request

As you can see, we have defined the endpoint /users/import, which will be able to receive the object createUser and optionally also a single file. The createUser object is defined in the schema and is required, while the file is optional. CreateUser object also has various definitions of fields, although unimportant and displayed only for current examples.

You can refer to the object schema to make the YAML file more readable and concise. The object’s schema can be defined in self-standing section dedicated to components.

openapi: 3.0.2
info:
  title: User management module
  description: User management
  version: '0.1'
  contact:
  email: optional@email.com
servers:
  - url: https://localhost:8080/api/user-management

paths:
  /users/import:
    post:
      summary: Create new Users with optional attachment
      tags:
        - users
      operationId: createUserWithOptionalFile
      requestBody:
        content:
          multipart/form-data:
            schema:
              type: object
              properties:
                createUser:
                  $ref: '#/components/schemas/CreateUser'
                optionalFile:
                  description: Optional file attachment
                  type: string
                  format: binary
              required:
              - createUser
      responses:
        '200':
          description: Successful operation
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateUserResponse'
        '400':
          description: Bad Request

components:
  schemas:
    CreateUser:
      description: Wrapper containing information for new user creation
      type: object
      properties:
        username:
          description: Users username
          type: string
        age:
          description: Users password
          type: number
        creationTimestamp:
          description: Time when the user will be defined as created in the system
          type: string
          format: date-time
          example: "2024-02-29T12:30:00.000Z"
        email:
          description: Email of the user
          type: string
        addressId:
          description: ID of the users address
          type: string
        accessRights:
          description: List of access rights for the user
          type: array
          items:
            type: object
            properties:
              accessRightId:
                description: ID of the access right
                type: string
              note:
                description: Note for the access right
                type: string
      required:
        - username
        - email
        - accessRights

Enforcing and casting mandatory properties of multipart request

Multipart file can accept only the Strings or Files (better visible in testing with Postman section). So any string input – Java’s serialized object, or JSON, is at the end nothing more than just a string of bytes.

The problem will arise during the deserialization of autogenerated code. It does not matter if you declare the object cast as required. With proper mapping, the input will be taken as a String and not as the type you want to use from the method signature.

Mapper and validator factory beans can solve the issue and handle the input.

First, register one new bean for object Validation. Optionally, you can register the ObjectMapper with JavaTimeModule to handle the date-time format, as we will use the date-time string in ISO format (“YYYY-MM-DDTHH:MM:SS.mmmZ”). The Validator is created through LocalValidatorFactoryBean.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;

import jakarta.validation.Validator;
import lombok.val;

@Configuration
public class AppConfig {

  //@Bean
  //public ObjectMapper objectMapper() {
  //  val objectMapper = new ObjectMapper();
  //  objectMapper.registerModule(new JavaTimeModule());
  //  return objectMapper;
  //}

  @Bean
  public Validator validator() {
    return new LocalValidatorFactoryBean();
  }

}

The code was written for Java 21 dependencies with Lombok.

To enforce the proper conversion, you must create a new Spring component to convert the incoming string to the object. The component will be able to handle the deserialization and validation of the object.

import java.util.Set;

import org.springframework.core.convert.converter.Converter;
import org.springframework.stereotype.Component;

import com.fasterxml.jackson.databind.ObjectMapper;

import jakarta.validation.ConstraintViolation;
import jakarta.validation.ConstraintViolationException;
import jakarta.validation.Validator;
import lombok.val;

@Component
public class StringToCreateUserDtoConverter implements Converter<String, CreateUserDto> {

  private final Validator validator;
  private final ObjectMapper objectMapper;

  public StringToCreateUserDtoConverter(final Validator validator, final ObjectMapper objectMapper) {
    this.validator = validator;
    this.objectMapper = objectMapper;
  }

  @Override
  public CreateUserDto convert(final String source) {
    CreateUserDto createUserDto;
    try {
        createUserDto = objectMapper.readValue(source, CreateUserDto.class);
    } catch (JsonProcessingException e) {
        throw new CreateUserDeserializationException("Input mapping and processing error: " + e.getMessage());
    }
    val violations = validator.validate(createUserDto);
    if (!violations.isEmpty()) {
        throw new ConstraintViolationException(violations);
    }
    return createUserDto;
  }

}

Just for the record, I will also add here the custom exception you can throw and catch in the custom exception handler:

import java.io.Serial;

import lombok.Getter;

@Getter
public class CreateUserDeserializationException extends RuntimeException {

  @Serial
  private static final long serialVersionUID = 1659771269447893294L;

  public CreateUserDeserializationException(String msg) {
    super(msg);
  }

}

Unit tests

I recommend writing the unit tests for the converter. It is a good practice to test the conversion and validation of the object. As we rely heavily upon Spring magic, a lot can unintentionally influence the component’s behaviour without us discovering it.

The code below is just an example of the unit tests with the usage of SpringBootTest and LocalTestcontainers which ties to get close to real-world use scenarios. We highly recommend to accommodate tests to your environment and needs.

import org.testcontainers.containers.PostgreSQLContainer;

public class LocalTestcontainers {

    public static void startPostgres(){
        PostgreSQLContainer postgre = new PostgreSQLContainer<>("postgres:16.0")
            .withDatabaseName("INSERT_DATABASE_NAME")
            .withUsername("INSERT_DATABASE_USERNAME")
            .withPassword("INSERT_DATABASE_PASSWORD");
        postgre.start();

        System.setProperty("spring.datasource.url", postgre.getJdbcUrl());
        System.setProperty("spring.datasource.username", postgre.getUsername());
        System.setProperty("spring.datasource.password", postgre.getPassword());
    }

}

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;

import java.math.BigDecimal;
import java.time.Instant;
import java.time.format.DateTimeFormatter;
import java.util.UUID;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.testcontainers.junit.jupiter.Testcontainers;

import com.codepills.usermanagementmodule.api.exception.CreateUserDeserializationException;
import com.codepills.usermanagementmodule.utils.LocalTestcontainers;

import jakarta.validation.ConstraintViolationException;
import lombok.val;

@SpringBootTest
@Testcontainers
class StringToCreateUserDtoConverterTest {

    static {
        LocalTestcontainers.startPostgres();
    }

    @Autowired
    private StringToCreateUserDtoConverter stringToCreateUserDtoConverter;

    @Test
    void testConvertValidInputString() {
        // Arrange
        val username = "JohnDoe";
        val age = 25;
        val formatter = DateTimeFormatter.ISO_INSTANT;
        val now4CreationTime = Instant.now();
        val email = "john.doe@noemail.com";
        val addressId = UUID.randomUUID();
        val accessRightId1 = UUID.randomUUID();
        val accessRightId2 = UUID.randomUUID();

        val stringBuilder = new StringBuilder();
        stringBuilder.append("{");
        stringBuilder.append("\"username\" : \"").append(username).append("\",");
        stringBuilder.append("\"age\" : ").append(age).append(",");
        stringBuilder.append("\"creationTimestamp\" : \"").append(formatter.format(now4CreationTime)).append("\",");
        stringBuilder.append("\"email\" : \"").append(email).append("\",");
        stringBuilder.append("\"addressId\" : \"").append(addressId).append("\",");
        stringBuilder.append("\"accessRights\" : [");
        stringBuilder.append("{");
        stringBuilder.append("\"accessRightId\" : \"").append(accessRightId1).append("\",");
        stringBuilder.append("}, {");
        stringBuilder.append("\"accessRightId\" : \"").append(accessRightId2).append("\"");
        stringBuilder.append("}]}");
        val validInput = stringBuilder.toString();

        // Act
        val createUserDto = stringToCreatUserDtoConverter.convert(validInput);

        // Assert
        assertNotNull(createUserDto);
        assertEquals(username, createUserDto.getUsername());
        assertEquals(age, createUserDto.getAge());
        assertEquals(now4CreationTime, createUserDto.getCreationTimestamp());
        assertEquals(email, createUserDto.getEmail());
        assertEquals(addressId.toString(), createUserDto.getAddressId());
        assertEquals(2, createUserDto.getAccessRights().size());
        assertEquals(accessRightId1.toString(), createUserDto.getAccessRights().get(0).getAccessRightId());
        assertEquals(accessRightId2.toString(), createUserDto.getAccessRights().get(1).getAccessRightId());
    }

    @Test
    void testConvertInvalidInputString() {
        // Arrange
        val invalidInput = "invalid input string";
        // Act & Assert
        try {
            stringToCreateUserDtoConverter.convert(invalidInput);
        } catch (CreateUserDeserializationException ex) {
            assertEquals("Input mapping and processing error: Unrecognized token 'invalid': was expecting (JSON String, Number, Array, "
                             + "Object or token 'null', 'true' or 'false')\n at [Source: (String)\"invalid input string\"; line: 1, "
                             + "column: 8]", ex.getMessage());
        }
    }

    @Test
    void testConvertInputWithValidationErrors() {
        // Arrange
        val username = "JohnDoe";
        val age = 25;
        val formatter = DateTimeFormatter.ISO_INSTANT;
        val now4CreationTime = Instant.now();
        val email = "john.doe@noemail.com";
        val addressId = UUID.randomUUID();
        val accessRightId1 = UUID.randomUUID();
        val accessRightId2 = UUID.randomUUID();

        val stringBuilder = new StringBuilder();
        stringBuilder.append("{");
        stringBuilder.append("\"username\" : \"").append(username).append("\",");
        stringBuilder.append("\"age\" : ").append(age).append(",");
        stringBuilder.append("\"creationTimestamp\" : \"").append(formatter.format(now4CreationTime)).append("\",");
        stringBuilder.append("\"email\" : \"").append(email).append("\",");
        // Missing addressId
        stringBuilder.append("\"addressId\" : null,");
        stringBuilder.append("\"accessRights\" : [");
        stringBuilder.append("{");
        stringBuilder.append("\"accessRightId\" : \"").append(accessRightId1).append("\",");
        stringBuilder.append("}, {");
        stringBuilder.append("\"accessRightId\" : \"").append(accessRightId2).append("\"");
        stringBuilder.append("}]}");
        val validInput = stringBuilder.toString();

        // Act & Assert
        try {
            stringToCreateUserDtoConverter.convert(inputWithValidationErrors);
        } catch (ConstraintViolationException ex) {
            assertEquals(1, ex.getConstraintViolations().size());
        }
    }

}

User Management Controller

Now, all we need to do is create a controller to implement the OpenAPI schema.

Here is an example of the controller:

@Logger
@RestController
@RequiredArgsConstructor
public class UserManagementController implements UserManagementApi {

  @Override
  public ResponseEntity<Void>> createUserWithOptionalFile(
        @RequestPart(name = "createUser") final CreateUserDto createUserDto,
        @RequestPart(name = "optionalFile", required = false) MultipartFile optionalFile
     ) {
    if (optionalFile == null || optionalFile.isEmpty()) {
        log.info("No optionalFile uploaded.");
    } else {
        log.info("PDF optionalFile {} uploaded but not saved.", optionalFile.getOriginalFilename());
    }

    // You can work with createUserDto here

    return ResponseEntity.ok().build();
  }

}

I will leave the implementation of createUserWithOptionalFile() method up to you as it is not the main focus of this article.

Again, notice the optionalFile and createUser keywords in the method arguments. It is the same as the keyword as defined in the OpenAPI schema.

Testing with Postman

Nothing blocks our development anymore, and we can start testing the endpoint with Postman. The endpoint will be able to receive the serialized object in the form of string and also the file. However, attaching the file to the request is, of course, optional.

As it might need to be stressed more, the most important thing is using the exact keywords defined in the OpenAPI schema. In our case, for importing object, it will be createUser and for optional file, it will be optionalFile.

Let’s run the SpringBoot app at localhost.

Backend should be running at localhost. And if added the necessary logic for file processing into the controller, we should be able to upload serialized objects in JSON format and optional file through the /users/import endpoint.

When using Postman, you also need to define the type of multipart key. It is either the String or File. For files, use File, and for the object, use String. Do not forget that in the previous article we discuss the implementation of sending multiple files through multipart request.

All you need to do is to define your endpoint POST request in Postman. Select POST request, add the URL, and in the body tab, select form-data and add the keywords createUser set as String and optionalFile as File .

The most important part is to really define serialized object as String and not File.

Here is an example of createUser as String:

{
	"username" : "johndoe",
	"age" : "25",
	"creationTimestamp" : "2024-02-29T12:30:00.000Z",
	"email" : "john.doe@noemail.com",
	"addressId" : "f8935f28-8d7b-40a4-96d7-a3288976617e",
	"accessRights" : [
		{
      "accessRightId" : "712d5a0a-11b5-4a44-9e92-6e67d16be2aa"
    }
	]
}

Conclusion

This article has shown how to create a Spring Boot endpoint to receive objects and, optionally, file through multipart form data. We have also demonstrated how to handle the deserialization of the incoming object from the string at the Spring Boot backend and how to control proper deconstruction if some fields are optional or not mandatory.

Is it applicable to auto-generating infrastructure code through OpenAPI with Spring Boot for multipart endpoint and uploading files? Let us know in the comments below. Do you have your trick or see another way how to enforce and deserialize multipart object? Let us know in the comments below the article. We would like to hear your ideas and stories.

We will use the following simple code to print a code into the terminal or command prompt for demonstration purposes.

public class MyJavaApp {

    public static void main(String[] args) {
        System.out.println("Hello World!");
    }

}

Compile and run Java code in a few steps

You must follow only a few basic steps to compile and run Java code.

1. As a precondition, ensuring the installation of Java Development Kit (JDK) on your system and the accessibility of the javac and java commands from the terminal or command prompt is important.
2. First, you have to have a Java source code in Java files. Open a text editor and write your Java code. Save the file with a .java file extension.
3. Then you are ready to compile the Java source file. Open a terminal or command prompt and navigate to the directory where your Java source file is placed. Utilize the javac command for compiling the Java source file into bytecode. For example:

   javac MyJavaApp.java

   You will generate a bytecode file named MyJavaApp.java if there are no compilation errors.

4. When you have successfully compiled the Java source file into a bytecode file, you can execute the bytecode using the java command. However, select the class which contains valid public static void main(String args[]) Java method in order for JVM to have an access point to your code.

   Here is an example of running MyJavaApp:

   java MyJavaApp

   And here is the output:

   

   java MyJavaApp will run your Java program, and if everything is correct, you should see the output in the console.

Compiling and running nested classes

So far, we have seen compile and run only a single class. However, running a multi-class project is no different from compiling and running a single class. Here is an example of a multi-class project we will use next.

public class MyJavaApp {

    public static void main(String[] args) {
        InsertedClass.printToWorld();
    }

}

public class InsertedClass {

    public static void printToWorld() {
        System.out.println("Hello World from other class!");
    }

}

For sure, the same as in a single class, you need to pick a class for compiling the class which contains the public static void main(String args[]). That is the only way the compiler can reach and compile all classes in your project.

And again, same as in the single class, you need to run the multi-class project with the java command on the file, which contains public static void main(String args[]) method.

Conclusion

This article has shown how to compile and run Java code on the Windows platform.

Did you find compiling and running your Java code easy? Do you have your trick or know another way how to compile and run Java code from the terminal or command prompt? Let us know in the comments below the article. We would like to hear your ideas and stories.

What is NumberFormatException

The NumberFormatException is an unchecked Java exception which happens when there is incorrect string input converted to a numeric value. When the input is wrong, NumberFormatException is thrown to inform the user that the conversion requires a correct input and the transformation did not happen. For example, the NumberFormatException is thrown when a numerical string is parsed to an integer, but the string contains also space.

As the NumberFormatException is an unchecked exception, it does not need to be declared in the throws clause of a method or constructor. However, when in doubt of input correctness, it should be handled in code using a try-catch block.

NumberFormatException Example

Let’s take a look at the simple example of NumberFormatException being thrown:

public class NumberFormatExceptionExample {
    public static void main(String args[]) {
        int orderNumber = Integer.parseInt("Order 66");
        System.out.println(orderNumber);
    }
}

The above code will throw NumberFormatException. While pure input of string “66” is a valid input, a string with non-numerical characters like “Order 66” is unsuitable for creating a number.

Exception in thread "main" java.lang.NumberFormatException: For input string: "Order 66"
    at java.base/java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.base/java.lang.Integer.parseInt(Integer.java:652)
	at java.base/java.lang.Integer.parseInt(Integer.java:770)
    at NumberFormatExceptionExample.main(NumberFormatExceptionExample.java:6)

8 Different Ways How To Get NumberFormatException

There are various causes for throwing NumberFormatException, and the improper conversion of invalid input mainly causes them. Here is a list of different ways how to get NumberFormatException:

1. Input string is empty:

Integer.parseInt("");

2. Input string is null:

Integer.parseInt(null);

3. Input string with non-numeric data:

This case has several different options why it can happen.

a. Input string contains space character:

Integer.parseInt("66 66");

b. Input string contains non-numeric character:

Integer.parseInt("Sixty");

c. Numeric input with non-numeric character in input string

Integer.parseInt("Catch22");

4. Input string with inappropriate symbols in it:

Double.parseDouble("66,12345");

5. Input string with leading or tailing white space

Integer randomExample = new Integer("  12345  ");

Integer, Long, Short, Byte throw NumberFormatException; Double, Float does not.

6. Mismatch of data type between input string and the target data type

Integer.parseInt("12.34");

7. Input string exceeding the range of the target data type

Integer.parseInt("2147483648");

The example shown above is a case of NumberFormatException upon placing a numeric input string exceeding the range of the target data type, which is in our case Integer class object. The maximum range for Integer class object is from -2_147_483_648 to 2_147_483_647.

How to handle NumberFormatException

The NumberFormatException is an unchecked exception in Java. Therefore it can be handled as any other Java exception by wrapping critical code to try-catch block.

Look at the following example of catching NumberFormatException with a try-catch block:

public class NumberFormatExceptionExample {

    public static void main(String args[]) {
        String userInput = "Order 66";
        Optional<Integer> orderNumber = processOrder(userInput);
        if (orderNumber.isPresent()) {
            System.out.println("Execute order " + orderNumber.get());
        } else {
            System.out.println("Unrecognized order number. Please try again.");
        }
    }

    public static Optional<Integer> processOrder(String userInput) {
        try {
            int order = Integer.parseInt(userInput);
            return Optional.of(order);
        } catch (NumberFormatException ex) {
            System.out.println("Order exception: Invalid user input!");
        }
        return Optional.empty();
    }

}

Depending on the requirements of the application, take necessary action. For example, log the exception with an appropriate message or return an empty Optional object if you are using at least Java 8. Like in the example above, wrapping the code in try-catch blocks allows the program to continue execution after the code throws the exception.

Output:

Order exception: Invalid user input!
Unrecognized order number. Please try again.

Conclusion

This article led us to explain what NumberFormatException and how to handle it. It also showed over seven different ways how the NumberFormatException can occur and how we can defensively take care of it.

Do you know NumberFormatException? In what case did it throw to you? Do you have your trick, or do you see another way how to handle NumberFormatException? Let us know in the comments below the article. We would like to hear your ideas and stories.

Using Character class

First option is to select a character from string with help of charAt() method and the character position; and use Character class static method isDigit() to return boolean value.

String movie = "101 dalmatians";
System.out.println(movie);
boolean result = Character.isDigit(movie.charAt(0));
System.out.println("Is first letter number? Answer: " + result)

The output will be:

101 dalmatians
Is first letter number? true

If we want to check if several characters are numbers, we can place the isDigit() method call inside the loop.

String movie = "101 dalmatians";
for (int i = 0; i <= movie.length() - 1; i++) {
    System.out.println(movie.charAt(i) + " -> " + Character.isDigit(movie.charAt(i)));
}

The output of the above code will be:

1 -> true
0 -> true
1 -> true
  -> false
d -> false
a -> false
l -> false
m -> false
a -> false
t -> false
i -> false
a -> false
n -> false
s -> false

Using Unicode check

Using Character class static method isDigit() can be used on any Unicode character, not just 0-9 number range. You can use create number check at any Unicode character.

Here is an example of checking a number through a check of Unicode characters:

String movie = "101 dalmatians";
System.out.println(movie);
boolean char c = word.charAt(0);
boolean isDigit = (c >= '0' && c <= '9');
System.out.println(isDigit)

101 dalmatians
true

Using Regex

Alternative way to using Character class static method isDigit() is to use solution based on regex output. However, this will require string to be instance of String class as we can conduct regex pattern search only on String.

Let us show you first regex pattern for searching digit in substring of length 1 on the instance String class named word:

word.substring(0, 1).matches("\\d")

The alternative and equivalent version uses the regex search pattern with the search of digit range.

word.substring(0, 1).matches("[0-9]")

The regex solution should be discouraged as it is an over-engineered solution. While there might be a minor performance hit, we can argue it would not affect simple coding solutions. But be aware that regex brings complexity. A solution implementing regular expression should be used with caution and with a fair amount of tests.

Note: Regular expressions are very strong, but expensive tool. It is valid to use regular expressions for character check if, e.g. the first character is a digit. But performance-wise, it is also like shooting birds with cannon.

Using casting

The last way to check if the character in a string is a number is to use Java casting feature. We will cast string values into one of the numerical object classes. However, this is the worst way how to do it. If you find a code using casting, you should refactor it immediately.

public boolean isNumber(String word) {
    boolean isNumber = true;
    try {
        Integer.valueOf(word.substring(0,1));
    } catch (Exception e) {
        isNumber = false;
    }
    return isNumber;
}

There is a lot that can go wrong with the method above. If the entering argument word is an empty string, casting will throw NumberFormatException and catch it. If the first character is not a digit, e.g. letter or special symbol, casting will also throw NumberFormatException and catch it. But if the first character is a digit, it will return true.

You can place any numerical object class to the code such as Integer, Double, Float or Long. But please do not! Using casting with valueOf() method is wrong for two reason:

• In general, we want to avoid throwing Exceptions, checked or unchecked, as they slow the program and have tremendous performance hit.
• Second reason, we can see above at least 3 different ways which provide shorter, more effective and readable way for solving the same problem.

Conclusion

In the article, we have demonstrated four different ways to find out if the single character or characters from a string is a number or not. The solutions ranged from best to worst, from easiest to most cumbersome. Use as much as possible the first option which use Character class static method isDigit() for determining if the character is a string. Using isDigit() method is, without instantiation of any variables, the most effective and readable solution.

I hope you learned something new and had fun. Thanks for the reading. And if you have any tricks or know a better way how to find out if the character is a string, let us know in the comments below. We would like to hear your ideas.

Introduction

I have been recently doing code review on other developer pull-request when I found the piece of code below:

private static final String DOCUMENT_VERSION = "document_version-";

public String getDocumentVersion(int version) {
    String documentVersion = "";
    if (version > 999) {
        throw new IllegalStateException("Version number " + version + " is too large.");
    } else if (version > 99) {
        documentVersion += version;
    } else if (version > 9) {
        documentVersion += "0" + version;
    } else {
        documentVersion += "00" + version;
    }

    return "DOCUMENT_VERSION_" + documentVersion;
}

As you can immediately see, the code is bad and can be surely rewritten to something more simple. Creating a string from a number can not be so declarative, right? There needs to be a simpler way how to do it. And surely it can. Like many other general-purpose programming languages, Java has multiple libraries and functions for processing text. String class itself has a static method format() which can be fully utilized on the text changes like this.

Java String format()

The Java String class format() method returns the formatted string. Let’s look little bit on parameters of format() method.

String.format() signature

There are two type of String format() method:

public static String format(String format, Object... args)

and

public static String format(Locale locale, String format, Object... args)  

Therefore, method parameters are described as:

• locale is specifies the locale to be applied on the format() method.
• format is format of the string.
• args represent arguments for the format string. It may be zero or more.

format() method returns new String. However, it is also good to be prepared for possibility of two unchecked exception:

• NullPointerException is thrown if format is null.
• IllegalFormatException is thrown if format is illegal or incompatible.

String.format() internal implementation

In reality, String.format() method allows usage of multiple Object arguments because internal implementation use nothing else than new instance of Formatter class.

public static String format(String format, Object... args) {
    return new Formatter().format(format, args).toString();
}

Usage of quiet Formatter class explains why we can take multiple arguments depending on the number of elements we want to format inside the string. Formatter class can use several different option of “%” character combination in order to define string formatting. In the table below are all options explained:

format() examples

Let us show you few tricks with format()

System.out.println(String.format("%d", 100)); // Integer
System.out.println(String.format("%s", "Anna Smith")); // String
System.out.println(String.format("%f", 42.42)); // Float
System.out.println(String.format("%x", 100)); // Hexadecimal
System.out.println(String.format("%c", 'a')); // Char
System.out.println("-----");
System.out.println(String.format("number with text: %d", 100)); // number with other text
System.out.println(String.format("%f", 42.12345)); // prints floating number
System.out.println(String.format("%10.10f", 42.12345)); // prints 10 digits for fractions padded with 0
System.out.println("-----");
System.out.println(String.format("|<-%10d->|", 222)); // Align right, padding with empty space
System.out.println(String.format("|<-%-10d->|", 555)); // Align left, padding with empty space
System.out.println(String.format("|<-% d->|", 777)); // Single space between % and conversion type is allowed
System.out.println(String.format("|<-%010d->|", 999)); // Filling space with zeros

100
Anna Smith
42.420000
64
a
-----
number with text: 100
42.123450
42.1234500000
-----
|<-       222->|
|<-555       ->|
|<- 777->|
|<-0000000999->|

Using format() to turn number into formatted string

To take for first exemplary code from code review, all what we needed to do in getDocumentVersion() method was to place custom format of string into the String class format method.

private static final String DOCUMENT_VERSION = "document_version-";

public String getDocumentVersion(int version) {
    return String.format(DOCUMENT_VERSION + "%03d", revisionNumber);
}

If we place number 1 into the method getDocumentVersion() we will get the same result as boilerplate code from code review:

Output

document_version-001

We can still quickly write some custom code to test our beliefs. But be thorough and do not forget edge cases as zero and negative numbers.

System.out.println(String.format("%03d", 999));
System.out.println(String.format("%03d", 99));
System.out.println(String.format("%03d", 9));
System.out.println(String.format("%03d", 0));
System.out.println(String.format("%03d", -9));

999
099
009
000
-09

As you can notice format() takes negative number into account its length with minus sign.

Note : If you have any crazy idea how to use format() method, let us know in comments below.

Conclusion

This article showed us how to turn a number into a string with a specific length where additional space is padded.

Did you find the String.format() method useful? Do you have your trick, or do you know another way how to turn a number into a string of specific length? Let us know in the comments below the article. We would like to hear your ideas and stories.

Introduction

The answer is simply to use flatMap to flatten the lists of elements into one coherent list of the same elements. flatMap converts lists to streams in a single Stream and then collects the result into a list.

The best explanation will probably show the example of flatMap in action.

Flattening the List with flatMap – Simple Example

Let’s start with a simple example and continue with a more complex case later in the article. Our simple example will have a list of list with String elements. Each inner list contains a list of String elements which is a tuplet denoting at the first position the level of list and in the second position the overall total position of String element.

List<List<String>> nestedList = asList(
    asList("1-1", "1-2", "1-3"),
    asList("2-4", "2-5", "2-6", "2-7", "2-8"),
    asList("3-9", "3-10")
);

We take this simple list above, and we will push it to our simple flattening method flatteningTheListOfLists(List<List<String>> list).

public  List<String> flattenListOfLists(List<List<String>> list) {
    return list.stream()
               .flatMap(Collection::stream)
               .collect(Collectors.toList());
}

As a result, we will get a list with all the String elements in one list.

@Test
public void testFlatteningTheListOfLists_simpleScenario() {
     List<String> flattenedList = flattenListOfLists(nestedList);

    assertNotNull(flattenedList);
    assertEquals(10, flattenedList.size());

    for (String element : flattenedList) {
        System.out.print(element);
    }
}

Output

1-1, 1-2, 1-3, 2-4, 2-5, 2-6, 2-7, 2-8, 3-9, 3-10, 

Flattening the List with flatMap – Realistic Scenario

Instead of a simple play with a happy case scenario, hypothetically, let’s have a more advanced system where we will generate the list of objects directly in the stream. We will have a list of employees with their job position. And we would like to collect all their possible career options for employees above junior engineer level into a single list of all career options across all employees through a department. The resulting list will give us a list of possible combinations of employee promotions above the junior level.

Here is an example of Employee class:

public class Employee {

    private Position position;

    public Employee(Position position) {
        this.position = position;
    }

    public int getPosition() {
        return this.position;
    }
}

And here is an example of Employee and Position class:

public class Employee {

    private final String name;
    private final Position position;

    public Employee(String name, Position position) {
        this.name = name;
        this.position = position;
    }

    public Position getPosition() {
        return position;
    }

}

public enum Position {

    JUNIOR_ENGINEER(1),
    SENIOR_ENGINEER(2),
    SOFTWARE_ARCHITECT(3),
    ENGINEERING_MANAGER(4);

    private final int level;

    Position(int level) {
        this.level = level;
    }

    public int getLevel() {
        return this.level;
    }
}

In order to get the list of all possible career options for all employees above junior level we would create for example something like getAllCareerOptionsAboveJunior(List<Employee> employees) where class employee property is a list of employees of Employee class. getAllCareerOptionsAboveJunior(List<Employee> employees) method will go through all the employees, filter employees from the list with level above junior level and create a list of possible career options for that specific employee. All the career options should be than pushed to List and outputted from stream to List collector.

public List<Position> getAllCareerOptionsAboveJunior(List<Employee> employees) {
    return employees.stream()
                    .filter(employee -> employee.getPosition().getLevel() > Position.JUNIOR_ENGINEER.getLevel())
                    .map(employee -> createPossibleCareerOptions(employee.getPosition().getLevel())) // This is bad practice and will not work
                    .collect(Collectors.toList());
}

Example of createPossibleCareerOptions():

public List<Position> createPossibleCareerOptions(int level) {
    return Arrays.stream(Position.values())
                 .filter(position -> position.getLevel() > level)
                 .collect(Collectors.toList());
}

As we can see above, we mapped an employee to the list of her/his career options. But we want to collect list of all possibilities, not list of lists. Therefore, the code above does not work while stream map function maps employee instance into the list, but stream collector can not collect list of position list into the single list.

To make this code work, we need to introduce a consequent function in a stream that will flatten the list’s mapping into one stream. We need to place flatMap function for flattening the stream of list of positions into single steam positions for our Java stream.

public List<Position> getAllCareerOptionsAboveJunior(List<Employee> employees) {
    return employees.stream()
                    .filter(employee -> employee.getPosition().getLevel() > Position.JUNIOR_ENGINEER.getLevel())
                    .map(employee -> createPossibleCareerOptions(employee.getPosition().getLevel()))
                    .flatMap(List::stream) // I need to flatten list streams into one stream
                    .collect(Collectors.toList());
}

Finally, let’s put all parts together and try the solution on the list of employees.

List<Employee> employees = asList(
        new Employee("Mark", Position.JUNIOR_ENGINEER),
        new Employee("Thomas", Position.SENIOR_ENGINEER),
        new Employee("Janet", Position.SOFTWARE_ARCHITECT),
        new Employee("Percy", Position.ENGINEERING_MANAGER)
);

We can test the result with the test written below:

@Test
public void testFlatteningTheListOfLists_realisticScenario() {
    List<Position> allPossiblePromotions = getAllCareerOptionsAboveJunior(employees);

    assertNotNull(allPossiblePromotions);
    assertEquals(3, allPossiblePromotions.size());

    for (Position position : allPossiblePromotions) {
        System.out.print(position + ", ");
    }
}

Output

SOFTWARE_ARCHITECT, ENGINEERING_MANAGER, ENGINEERING_MANAGER, 

Note : If you have better idea for Map sorting, let me know in comments below.

Flattening the List With forEach

To flatten this nested collection into a list of the same elements, we can also use forEach together with a Java 8 method reference. However, the solution with forEach might be discouraged by some developers as it needs to create a new reference on the list with results before it returns the complete results. Thus, creating the result variable will make the code more cumbersome and brittle. And while it might be suitable for small lists and simple applications, it brings pointlessly more complexity with its wrapping code for more complex scenarios as described above. On the contrary, it provides no advantage in the form of, for example, code readability.

Neither to say, let’s take a look at the option of flattening the stream of element’s list with the help of forEach method.

public List<String> useOfForEach(Stream<List<String>> streamOfLists) {
    List<String> result = new ArrayList<>();
    streamOfLists.forEach(result::addAll);
    return result;
}

If we use the same list of simple String elements as for happy case scenario with flatMap we will get the same results.

Conclusion

We have seen in this article how to use a Java 8 Stream method flatMap first on a simple example and then on a more realistic scenario. We have also seen the option of flattening the stream with forEach. However, use of forEach might be discouraged on more realistic scenario when used on stream of Objects which generates the lists.

Did you find use of flatMap hard? Do you have your trick or you know another way how to use flatMap? Let us know in the comments below the article. We would like to hear your ideas and stories.

As always, you can find all our examples on our GitHub project!

Introduction

Let’s start with a practical example of removing elements from DOM. Imagine scrapping a website with Selenium and taking a screenshot of the page. However, the timed modal window will unannounced pop up when Selenium’s driver spin the browser window. So it is probably a good idea to remove the window before taking a picture in such a case.

When scrapping sites, removing excessive advertisement and disturbing elements is hard enough. But pop-up windows in the wrong moments are an overall user experience nowadays on many sites and blogs.

For example, we want to scrap stock time-series from famous sites like finviz.com. Unfortunately, after the first few seconds on the page, the cookies modal window pop-up and block the stock graph. Therefore, I will need to remove the cookie allowance modal window to take a clear screenshot.

Finviz.com cookie popup window

Let me show you two different ways to remove elements from Selenium’s HTML DOM. One way will be about eliminating parts that load with the page load and can be removed immediately. The second way will require calling WebDriverWait instance, and the way will be used for elements that pop up or load to page letter.

However, both options do not remove the element from the DOM. Instead, they hide it and make it invisible in the Selenium web driver.

Remove elements from Selenium’s DOM without waiting

FirefoxOptions options = new FirefoxOptions();
options.addArguments("-width=1920");
options.addArguments("-height=1080");
FirefoxDriver driver = new FirefoxDriver(options);

String stock = "T"; // AT&T Inc.
driver.get("https://finviz.com/quote.ashx?t=" + stock + "&ty=c&ta=1&p=d");

driver.executeScript("return document.getElementsByClassName('snapshot-table2')[0].remove();");

If we look at the code, it might look straightforward. But I will go through it briefly. Initially, we set options for our Selenium Driver. Then, we pick Firefox as Selenium driver and put options (browser windows dimensions) into the driver itself.

After setting drivers options and instantiating Firefox drivers, we are clear to the call page in Firefox. We call finviz.com stock page for AT&T Inc. company. The page which is loaded is immediately available for changes. If we want to remove any element we do not like, we can call script execution upon the loaded HTML DOM. We call executed script, which will remove the first (0-th) element of the specific class name. It will be the first data table under the stock time-series graph.

Note : If you have better idea for elements removal from Selenium’s HTML DOM, let me know in comments below.

Remove elements from Selenium’s DOM with waiting

FirefoxOptions options = new FirefoxOptions();
options.addArguments("-width=1920");
options.addArguments("-height=1080");
FirefoxDriver driver = new FirefoxDriver(options);

String stock = "T"; // AT&T Inc.
driver.get("https://finviz.com/quote.ashx?t=" + stock + "&ty=c&ta=1&p=d");

WebDriverWait wait = new WebDriverWait(driver, 10);

WebElement cookieWindow = wait.until(ExpectedConditions.visibilityOfElementLocated(By.className("ConsentManager__Overlay-np32r2-0")));
driver.executeScript("return arguments[0].remove();", cookieWindow);

The code above looks straightforward also. Initially, we set options for our Selenium Driver and picked Firefox as Selenium driver.

After setting drivers options and instantiating Firefox driver, we are clear to the call page in Firefox. We call the finviz.com stock page for AT&T Inc. company and wait for 10 seconds or until HTML DOM does not contain an element with a specific class name. If it does, we will execute the script upon it, which will remove the first (the 0-th) element when it is found. Action means removing the whole pop-up modal window that appeared in the first 10 seconds of finviz.com page duration.

Class name “ConsentManager__Overlay-np32r2-0” is class name of pop-up cookie modal window. However, this class name might and surely will change in the future. So I would not rely on it for 100%. But for now, it serves our purpose.

Conclusion

This article has shown how remove elements from HTML DOM when using automated web-browser framework Selenium. Articles provide two different ways how to remove element on the page. Elements which load with page load can be removed immediately, without calling WebDriverWait instance. However, elements which pop-up or load to page letter needs to be removed with help of WebDriverWait instance.

However, if you look better, code snippets in the article can help you to build your Selenium web-scrapper 😉

Did you find element removal easy? Do you have your trick or know another way how to remove elements from HTML DOM in Selenium? Let us know in the comments below the article. We would like to hear your ideas and stories, and you might help others as well.

What is Java classpath?

If we want to be wordy, classpath is the path where the Java Virtual Machine looks for user-defined classes, packages, and resources in Java programs. However, plain and straightforward, classpath is the route where the Java Virtual Machine will know where to find your compiled class.

Think of classpath as Java’s version of PATH environment variables – OSes search for executable files on the system environment PATH, Java searches for classes and packages on the classpath.

It would generally be impractical to have the JVM look through every folder on your machine. So you have to provide the JVM with a list of places where to look. Then, when we place folders and jar files on the classpath, we can automatically look up classes.

How to print classpath?

In Java, we can use a single line of code to print out the current project classpath. The only issue is with the system based classpath separator. On Unix based systems (Mac OS, CentOS, etc.), the colon character : is the classpath separator. However, on Windows, the separator is the semicolon ;.

To print classpath at Unix based systems use:

System.out.println(System.getProperty("java.class.path").replace(':', '\n'));

To print classpath at Windows use:

System.out.println(System.getProperty("java.class.path").replace(';', '\n'));

Output

The code will work like a charm in new versions of Java (8, 11, …). However, the Java code snippet will also print library dependencies.

On Windows, the output can look something like the following example:

C:\DEV\programming\interview-preparation\trees\target\test-classes
C:\DEV\programming\interview-preparation\trees\target\classes
C:\Users\computer_user\.m2\repository\junit\junit\4.13.1\junit-4.13.1.jar
C:\Users\computer_user\.m2\repository\org\hamcrest\hamcrest-core\1.3\hamcrest-core-1.3.jar
C:\Users\computer_user\.m2\repository\org\projectlombok\lombok\1.18.12\lombok-1.18.12.jar
...

Note: If you have a better idea for printing classpath, let us know in the comments below.

Conclusion

Concisely, this article summarized what the classpath is and how to print classpath in your current Java project.

Did you find printing classpath easy? Do you have your trick or know another way how to print classpath? Let us know in the comments below the article. We would like to hear your ideas and stories.

Introduction

We often encounter the problem during testing that we do not care about the data correctness, as much as we care about correct algorithm flow. In this situations, we want to check if specific methods were hit and executed. Sometimes we need to go deeper and seek an answer on how often these methods were called or verify that the methods called at all.

The necessary method, which will help us in our testing quest, is called verify() and is part of Mockito testing framework.

Mockito verify verification options

public static  T verify(T mock, VerificationMode mode)

mock is object of type T you are placing into the verify() method for verification. As a second method argument is VerificationMode mode variable, which describes how the mock should be verified. Possible verification modes are:

verify(mock, times(5)).someMethod("was called exactly five times");
verify(mock, never()).someMethod("was never called");
verify(mock, atLeast(5)).someMethod("was called at least five times");
verify(mock, atLeastOnce()).someMethod("was called at least once");
verify(mock, atMost(5)).someMethod("was called at most five times");

There is also one special VerificationMode mode called only(). This mode verifies that no other method was called on the mock so far.

verify(mock, only()).someMethod("only someMethod was called");

Mockito verify verification modes in action

In order to test individual verification modes, we will write a simple test. For testing purposes it will consist from two classes. (Both are inner private classes for MockitoVerifyTest.java.) First will be a fake class Account which trough dependency injection will use second class Counter. Counter class will be used as a Mock in our test.

Here is a Counter class:

private class Counter {

    private int counter;

    public Counter() {
        this.counter = 0;
    }

    public void increment() {
        this.counter++;
    }

    public void reset() {
        this.counter = 0;
    }

    public int getCount() {
        return this.counter;
    }
}

And here is the Account class:

private class Account {

    private Counter counter;

    public Account(Counter counter) {
        this.counter = counter;
    }

    public void incrementCounter() {
        this.counter.increment();
    }

    public void resetCounter() {
        this.counter.reset();
    }

    public int getCounterValue() {
        return this.counter.getCount();
    }
}

And finally, here is an exemplary test where you can see usage of individual verification modes:

import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;

import static org.mockito.Mockito.atLeast;
import static org.mockito.Mockito.atLeastOnce;
import static org.mockito.Mockito.atMost;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.only;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;

@RunWith(MockitoJUnitRunner.class)
public class MockitoVerifyTest {

    @Mock
    Counter counter;

    @Test
    public void testMockitoVerifyMethodCalls() {

        Account account = new Account(counter);

        // Verification using only() and atLeastOnce()
        account.incrementCounter();
        Mockito.verify(counter, only()).increment();
        Mockito.verify(counter, atLeastOnce()).increment();

        // Verification using times(X)
        for (int i = 0; i < 4; i++) {
            account.incrementCounter();
        }
        Mockito.verify(counter, times(5)).increment();

        // Verification using atLeast(X), atMost(X), never()
        for (int i = 0; i < 5; i++) {
            account.incrementCounter();
        }
        Mockito.verify(counter, atLeast(5)).increment();
        Mockito.verify(counter, atMost(10)).increment();
        Mockito.verify(counter, never()).getCount();
    }
}

Let's discuss little but example code.

Account account = new Account(counter);

// Verification using only() and atLeastOnce()
account.incrementCounter();
Mockito.verify(counter, only()).increment();
Mockito.verify(counter, atLeastOnce()).increment();

First, we will create new instance of Account class which trough dependency injection is injected with Mock instance of our Counter class.

As first we verify that there was no method, except increment() method, has been called on our mock at all. And as second verification, we will check that it was called at least once,

for (int i = 0; i < 4; i++) {
    account.incrementCounter();
}
Mockito.verify(counter, times(5)).increment();

Now we call incrementCounter() method four more times, remember we already called it once, and we will check that it was mock method injected to instance was called exactly five times.

for (int i = 0; i < 5; i++) {
    account.incrementCounter();
}
Mockito.verify(counter, atLeast(5)).increment();
Mockito.verify(counter, atMost(10)).increment();
Mockito.verify(counter, never()).getCount();

In the last section, we are incrementing the counter again five more times, and now we are checking if it was called at least five times and at most ten times.

On the last line we are checking method call for Mock' getCount() method that was never called.

Conclusion

This article contains a straightforward test on which we have demonstrated how to use Mockito verify method for mock' method call verification.

As always, you can find all our examples on our GitHub project!