Testing with AssertJ Number in Java

Table of Contents

提供驗證數字條件判斷等方法，編寫的測試程式使用流暢的斷言語句，通常與 JUnit 測試一起使用， AssertJ 斷言的基本方法是 assertThat 方法，使用 Testing Java AssertJ Number 流式斷言，本篇增加了範例，並透過單元測試來驗證產出結果。

檔案目錄

./
   +- src
       +- test
       |   +- org
       |       +- ruoxue
       |           +- spring_boot_168
       |               +- test
       |                   +- assertj
       |                       +- number
       |                           +- TestingAssertJNumberTest.java

單元測試

Java AssertJ Number Testing 斷言數字的主要目的是取得數字以進行斷言。

isLessThan

驗證數字是否小於指定值，若不成立，則會拋出 AssertionError 。

	@Test
	public void isLessThan() {
		int value = 0;
		System.out.println(value);
		assertThat(value).isLessThan(1);

		double doubleValue = 0d;
		System.out.println(doubleValue);
		assertThat(doubleValue).isLessThan(1d);
	}

0
0.0

isLessThanOrEqualTo

Java AssertJ Number Testing 驗證數字是否小於或等於指定值，若不成立，則會拋出 AssertionError 。

	@Test
	public void isLessThanOrEqualTo() {
		int value = 0;
		System.out.println(value);
		assertThat(value).isLessThanOrEqualTo(0).isLessThanOrEqualTo(1);

		double doubleValue = 0d;
		System.out.println(doubleValue);
		assertThat(doubleValue).isLessThanOrEqualTo(0d).isLessThanOrEqualTo(1d);
	}

0
0.0

isGreaterThan

Java AssertJ Number Testing 驗證數字是否大於指定值，若不成立，則會拋出 AssertionError 。

	@Test
	public void isGreaterThan() {
		int value = 0;
		System.out.println(value);
		assertThat(value).isGreaterThan(-1);

		double doubleValue = 0d;
		System.out.println(doubleValue);
		assertThat(doubleValue).isGreaterThan(-1d);
	}

0
0.0

isGreaterThanOrEqualTo

Java AssertJ Number Testing 驗證數字是否大於或等於指定值，若不成立，則會拋出 AssertionError 。

	@Test
	public void isGreaterThanOrEqualTo() {
		int value = 0;
		System.out.println(value);
		assertThat(value).isGreaterThanOrEqualTo(0).isGreaterThanOrEqualTo(-1);

		double doubleValue = 0d;
		System.out.println(doubleValue);
		assertThat(doubleValue).isGreaterThanOrEqualTo(0d).isGreaterThanOrEqualTo(-1d);
	}

0
0.0

usingDefaultComparator

Java Testing AssertJ Number 使用自定義比較器，驗證數字是否符合條件判斷，若不成立，則會拋出 AssertionError 。

	@Test
	public void usingDefaultComparator() {
		int value = 1;
		System.out.println(value);
		assertThat(value).usingDefaultComparator().isPositive().isCloseTo(-4, within(5));

		double doubleValue = 1d;
		System.out.println(doubleValue);
		assertThat(doubleValue).usingDefaultComparator().isPositive().isCloseTo(-4d, within(5d));
	}

1
1.0

usingComparator

Java Testing AssertJ Number 使用自定義比較器，驗證數字是否符合條件判斷，若不成立，則會拋出 AssertionError 。

	@Test
	public void usingComparator() {
		int value = 1;
		System.out.println(value);
		Comparator<Integer> abs = (i1, i2) -> Integer.compare(i1, Math.abs(i2));
		assertThat(value).usingComparator(abs).isEqualTo(-1);

		double doubleValue = 1d;
		System.out.println(doubleValue);
		Comparator<Double> doubleAbs = (d1, d2) -> Double.compare(d1, Math.abs(d2));
		assertThat(doubleValue).usingComparator(doubleAbs).isEqualTo(-1d);
	}

1
1.0

usingComparatorWithDescription

Java Testing AssertJ Number 使用自定義比較器及描述，驗證數字是否符合條件判斷，顯示自定義訊息。

	@Test
	public void usingComparatorWithDescription() {
		int value = 1;
		System.out.println(value);
		Comparator<Integer> abs = (i1, i2) -> Integer.compare(i1, Math.abs(i2));
		assertThat(value).usingComparator(abs, "abs").isEqualTo(-1);

		double doubleValue = 1d;
		System.out.println(doubleValue);
		Comparator<Double> doubleAbs = (d1, d2) -> Double.compare(d1, Math.abs(d2));
		assertThat(doubleValue).usingComparator(doubleAbs, "doubleAbs").isEqualTo(-1d);
	}

1
1.0

TestingAssertJNumberTest.java

Java Testing AssertJ Number 新增單元測試，驗證是否符合預期。

package org.ruoxue.spring_boot_168.test.assertj.number;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.within;

import java.util.Comparator;
import org.junit.jupiter.api.Test;

public class TestingAssertJNumberTest {

	@Test
	public void isLessThan() {
		int value = 0;
		System.out.println(value);
		assertThat(value).isLessThan(1);

		double doubleValue = 0d;
		System.out.println(doubleValue);
		assertThat(doubleValue).isLessThan(1d);
	}

	@Test
	public void isLessThanOrEqualTo() {
		int value = 0;
		System.out.println(value);
		assertThat(value).isLessThanOrEqualTo(0).isLessThanOrEqualTo(1);

		double doubleValue = 0d;
		System.out.println(doubleValue);
		assertThat(doubleValue).isLessThanOrEqualTo(0d).isLessThanOrEqualTo(1d);
	}

	@Test
	public void isGreaterThan() {
		int value = 0;
		System.out.println(value);
		assertThat(value).isGreaterThan(-1);

		double doubleValue = 0d;
		System.out.println(doubleValue);
		assertThat(doubleValue).isGreaterThan(-1d);
	}

	@Test
	public void isGreaterThanOrEqualTo() {
		int value = 0;
		System.out.println(value);
		assertThat(value).isGreaterThanOrEqualTo(0).isGreaterThanOrEqualTo(-1);

		double doubleValue = 0d;
		System.out.println(doubleValue);
		assertThat(doubleValue).isGreaterThanOrEqualTo(0d).isGreaterThanOrEqualTo(-1d);
	}

	@Test
	public void usingDefaultComparator() {
		int value = 1;
		System.out.println(value);
		assertThat(value).usingDefaultComparator().isPositive().isCloseTo(-4, within(5));

		double doubleValue = 1d;
		System.out.println(doubleValue);
		assertThat(doubleValue).usingDefaultComparator().isPositive().isCloseTo(-4d, within(5d));
	}

	@Test
	public void usingComparator() {
		int value = 1;
		System.out.println(value);
		Comparator<Integer> abs = (i1, i2) -> Integer.compare(i1, Math.abs(i2));
		assertThat(value).usingComparator(abs).isEqualTo(-1);

		double doubleValue = 1d;
		System.out.println(doubleValue);
		Comparator<Double> doubleAbs = (d1, d2) -> Double.compare(d1, Math.abs(d2));
		assertThat(doubleValue).usingComparator(doubleAbs).isEqualTo(-1d);
	}

	@Test
	public void usingComparatorWithDescription() {
		int value = 1;
		System.out.println(value);
		Comparator<Integer> abs = (i1, i2) -> Integer.compare(i1, Math.abs(i2));
		assertThat(value).usingComparator(abs, "abs").isEqualTo(-1);

		double doubleValue = 1d;
		System.out.println(doubleValue);
		Comparator<Double> doubleAbs = (d1, d2) -> Double.compare(d1, Math.abs(d2));
		assertThat(doubleValue).usingComparator(doubleAbs, "doubleAbs").isEqualTo(-1d);
	}
}