AssertJ Array in Java with Examples

Table of Contents

為用 Java 編寫的測試程式提供了流暢的斷言語句，這些斷言語句通常與 JUnit 測試一起使用， AssertJ 斷言的基本方法是 assertThat 方法，驗證 Array 是否相同元素、大小， AssertJ Array in Java 本篇增加了範例，並透過單元測試來驗證產出結果。

檔案目錄

./
   +- src
       +- test
       |   +- org
       |       +- ruoxue
       |           +- spring_boot_168
       |               +- test
       |                   +- assertj
       |                       +- array
       |                           +- AssertJArrayWithExamplesTest.java

單元測試

AssertJ Array Java 斷言陣列的主要目的是取得陣列的正確元素以進行斷言。

has

驗證是否符合條件，若不成立，則會拋出 AssertionError 。

	@Test
	public void has() {
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		Condition<String[]> length = new Condition<String[]>(s -> s.length > 2, "length");
		assertThat(array).has(length);

		int[] intArray = new int[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		Condition<int[]> intLength = new Condition<int[]>(i -> i.length > 2, "length");
		assertThat(intArray).has(intLength);
	}

[Durian, Guava, Pitaya]
[1, 2, 3, 4, 5]

hasOnlyOneElementSatisfying

AssertJ Array Java 驗證只有一個元素符合條件，若不成立，則會拋出 AssertionError 。

	@Test
	public void hasOnlyOneElementSatisfying() {
		String[] array = new String[] { "Durian" };
		System.out.println(Arrays.toString(array));
		assertThat(array).hasOnlyOneElementSatisfying(e -> {
			assertThat(e).hasSize(6);
		});

		Integer[] intArray = new Integer[] { 5 };
		System.out.println(Arrays.toString(intArray));
		assertThat(intArray).hasOnlyOneElementSatisfying(e -> {
			assertThat(e).isGreaterThan(4);
		});
	}

[Durian]
[5]

hasSize

AssertJ Array Java 驗證大小是否為指定值，若不成立，則會拋出 AssertionError 。

	@Test
	public void hasSize() {
		int expectedSize = 3;
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		assertThat(array).hasSize(expectedSize);

		int[] intArray = new int[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		assertThat(intArray).hasSize(5);
	}

[Durian, Guava, Pitaya]
[1, 2, 3, 4, 5]

hasSizeBetween

AssertJ Array Java 驗證大小是否介於起始值之間，若不成立，則會拋出 AssertionError 。

	@Test
	public void hasSizeBetween() {
		int expectedSize = 3;
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		assertThat(array).hasSizeBetween(1, expectedSize);

		int[] intArray = new int[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		assertThat(intArray).hasSizeBetween(1, 5);
	}

[Durian, Guava, Pitaya]
[1, 2, 3, 4, 5]

hasSizeGreaterThan

AssertJ Array Java 驗證大小是否大於指定值，若不成立，則會拋出 AssertionError 。

	@Test
	public void hasSizeGreaterThan() {
		int expectedSize = 2;
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		assertThat(array).hasSizeGreaterThan(expectedSize);

		int[] intArray = new int[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		assertThat(intArray).hasSizeGreaterThan(expectedSize);
	}

[Durian, Guava, Pitaya]
[1, 2, 3, 4, 5]

hasSizeLessThan

Java AssertJ Array 驗證大小是否小於指定值，若不成立，則會拋出 AssertionError 。

	@Test
	public void hasSizeLessThan() {
		int expectedSize = 4;
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		assertThat(array).hasSizeLessThan(expectedSize);

		int[] intArray = new int[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		assertThat(intArray).hasSizeLessThan(6);
	}

[Durian, Guava, Pitaya]
[1, 2, 3, 4, 5]

hasToString

Java AssertJ Array 驗證 toString 是否相等，若不成立，則會拋出 AssertionError 。

	@Test
	public void hasToString() {
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		assertThat(array).hasToString(array.toString());

		int[] intArray = new int[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		assertThat(intArray).hasToString(intArray.toString());
	}

[Durian, Guava, Pitaya]
[1, 2, 3, 4, 5]

hasSameSizeAs

Java AssertJ Array 驗證大小是否相等，若不成立，則會拋出 AssertionError 。

	@Test
	public void hasSameSizeAs() {
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		List<String> list = Arrays.asList("Durian", "Guava", "Pitaya");
		System.out.println(Arrays.toString(array));
		System.out.println(list);
		assertThat(array).hasSameSizeAs(list);

		int[] intArray = new int[] { 1, 2, 3, 4, 5 };
		List<Integer> intList = Arrays.asList(1, 2, 3, 4, 5);
		System.out.println(Arrays.toString(intArray));
		System.out.println(intList);
		assertThat(intArray).hasSameSizeAs(intList);
	}

[Durian, Guava, Pitaya]
[Durian, Guava, Pitaya]
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]

hasSameElementsAs

Java AssertJ Array 驗證元素是否相等，若不成立，則會拋出 AssertionError 。

	@Test
	public void hasSameElementsAs() {
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		List<String> list = Arrays.asList("Durian", "Guava", "Pitaya");
		System.out.println(Arrays.toString(array));
		System.out.println(list);
		assertThat(array).hasSameElementsAs(list);

		Integer[] intArray = new Integer[] { 1, 2, 3, 4, 5 };
		List<Integer> intList = Arrays.asList(1, 2, 3, 4, 5);
		System.out.println(Arrays.toString(intArray));
		System.out.println(intList);
		assertThat(intArray).hasSameElementsAs(intList);
	}

[Durian, Guava, Pitaya]
[Durian, Guava, Pitaya]
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]

doesNotHave

Java AssertJ Array Example 驗證是否不符合條件，若不成立，則會拋出 AssertionError 。

	@Test
	public void doesNotHave() {
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		Condition<String[]> length = new Condition<String[]>(s -> s.length > 3, "length");
		assertThat(array).doesNotHave(length);

		int[] intArray = new int[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		Condition<int[]> intLength = new Condition<int[]>(i -> i.length > 5, "length");
		assertThat(intArray).doesNotHave(intLength);
	}

[Durian, Guava, Pitaya]
[1, 2, 3, 4, 5]

doesNotHaveDuplicates

Java AssertJ Array Example 驗證元素是否不重複，若不成立，則會拋出 AssertionError 。

	@Test
	public void doesNotHaveDuplicates() {
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		assertThat(array).doesNotHaveDuplicates();

		int[] intArray = new int[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		assertThat(intArray).doesNotHaveDuplicates();
	}

[Durian, Guava, Pitaya]
[1, 2, 3, 4, 5]

AssertJArrayWithExamplesTest.java

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

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

import static org.assertj.core.api.Assertions.*;

import java.util.Arrays;
import java.util.List;

import org.assertj.core.api.Condition;
import org.junit.jupiter.api.Test;

public class AssertJArrayWithExamplesTest {

	@Test
	public void has() {
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		Condition<String[]> length = new Condition<String[]>(s -> s.length > 2, "length");
		assertThat(array).has(length);

		int[] intArray = new int[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		Condition<int[]> intLength = new Condition<int[]>(i -> i.length > 2, "length");
		assertThat(intArray).has(intLength);
	}

	@Test
	public void hasOnlyOneElementSatisfying() {
		String[] array = new String[] { "Durian" };
		System.out.println(Arrays.toString(array));
		assertThat(array).hasOnlyOneElementSatisfying(e -> {
			assertThat(e).hasSize(6);
		});

		Integer[] intArray = new Integer[] { 5 };
		System.out.println(Arrays.toString(intArray));
		assertThat(intArray).hasOnlyOneElementSatisfying(e -> {
			assertThat(e).isGreaterThan(4);
		});
	}

	@Test
	public void hasSize() {
		int expectedSize = 3;
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		assertThat(array).hasSize(expectedSize);

		int[] intArray = new int[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		assertThat(intArray).hasSize(5);
	}

	@Test
	public void hasSizeBetween() {
		int expectedSize = 3;
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		assertThat(array).hasSizeBetween(1, expectedSize);

		int[] intArray = new int[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		assertThat(intArray).hasSizeBetween(1, 5);
	}

	@Test
	public void hasSizeGreaterThan() {
		int expectedSize = 2;
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		assertThat(array).hasSizeGreaterThan(expectedSize);

		int[] intArray = new int[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		assertThat(intArray).hasSizeGreaterThan(expectedSize);
	}

	@Test
	public void hasSizeLessThan() {
		int expectedSize = 4;
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		assertThat(array).hasSizeLessThan(expectedSize);

		int[] intArray = new int[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		assertThat(intArray).hasSizeLessThan(6);
	}

	@Test
	public void hasToString() {
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		assertThat(array).hasToString(array.toString());

		int[] intArray = new int[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		assertThat(intArray).hasToString(intArray.toString());
	}

	@Test
	public void hasSameSizeAs() {
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		List<String> list = Arrays.asList("Durian", "Guava", "Pitaya");
		System.out.println(Arrays.toString(array));
		System.out.println(list);
		assertThat(array).hasSameSizeAs(list);

		int[] intArray = new int[] { 1, 2, 3, 4, 5 };
		List<Integer> intList = Arrays.asList(1, 2, 3, 4, 5);
		System.out.println(Arrays.toString(intArray));
		System.out.println(intList);
		assertThat(intArray).hasSameSizeAs(intList);
	}

	@Test
	public void hasSameElementsAs() {
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		List<String> list = Arrays.asList("Durian", "Guava", "Pitaya");
		System.out.println(Arrays.toString(array));
		System.out.println(list);
		assertThat(array).hasSameElementsAs(list);

		Integer[] intArray = new Integer[] { 1, 2, 3, 4, 5 };
		List<Integer> intList = Arrays.asList(1, 2, 3, 4, 5);
		System.out.println(Arrays.toString(intArray));
		System.out.println(intList);
		assertThat(intArray).hasSameElementsAs(intList);
	}

	@Test
	public void doesNotHave() {
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		Condition<String[]> length = new Condition<String[]>(s -> s.length > 3, "length");
		assertThat(array).doesNotHave(length);

		int[] intArray = new int[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		Condition<int[]> intLength = new Condition<int[]>(i -> i.length > 5, "length");
		assertThat(intArray).doesNotHave(intLength);
	}

	@Test
	public void doesNotHaveDuplicates() {
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		assertThat(array).doesNotHaveDuplicates();

		int[] intArray = new int[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		assertThat(intArray).doesNotHaveDuplicates();
	}
}