AssertJ Class in Java with Examples

內容目錄

為用 Java 編寫的測試程式提供了流暢的斷言語句，這些斷言語句通常與 JUnit 測試一起使用， AssertJ 斷言的基本方法是 assertThat 方法，驗證 Class 是否符合條件、有父類別、是否為註解類別等， AssertJ Class in Java 本篇增加了範例，並透過單元測試來驗證產出結果。

檔案目錄

./
   +- src
       +- test
       |   +- org
       |       +- ruoxue
       |           +- spring_boot_168
       |               +- test
       |                   +- assertj
       |                       +- clazz
       |                           +- AssertJClassWithExamplesTest.java

單元測試

AssertJ Class Java 斷言類別的主要目的是取得類別以進行斷言。

has

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

	@Test
	public void has() {
		Class<?> clazz = Consumer.class;
		System.out.println(clazz);
		Condition<Class<?>> iface = new Condition<Class<?>>(c -> c.isInterface(), "iface");
		assertThat(clazz).has(iface);

		Class<?> clazz2 = int.class;
		System.out.println(clazz2);
		Condition<Class<?>> primitive = new Condition<Class<?>>(c -> c.isPrimitive(), "primitive");
		assertThat(clazz2).has(primitive);
	}

interface java.util.function.Consumer
int

hasPackage

AssertJ Class Java 驗證是否屬於指定 Package ，若不成立，則會拋出 AssertionError 。

	@Test
	public void hasPackage() {
		Class<?> clazz = Function.class;
		System.out.println(clazz);
		assertThat(clazz).hasPackage("java.util.function");
		assertThat(clazz).hasPackage(Package.getPackage("java.util.function"));

		Class<?> clazz2 = IntStream.class;
		System.out.println(clazz2);
		assertThat(clazz2).hasPackage("java.util.stream");
		assertThat(clazz2).hasPackage(Package.getPackage("java.util.stream"));
	}

interface java.util.function.Function
interface java.util.stream.IntStream

hasAnnotation

AssertJ Class Java 驗證是否屬於指定 Annotation，若不成立，則會拋出 AssertionError 。

	@Test
	public void hasAnnotation() {
		Class<?> clazz = UnaryOperator.class;
		System.out.println(clazz);
		assertThat(clazz).hasAnnotation(FunctionalInterface.class);

		Class<?> clazz2 = FunctionalInterface.class;
		System.out.println(clazz2);
		assertThat(clazz2).hasAnnotation(Target.class);
	}

interface java.util.function.UnaryOperator
interface java.lang.FunctionalInterface

hasSuperclass

Java AssertJ Class 驗證是否有指定父類別，若不成立，則會拋出 AssertionError 。

	@Test
	public void hasSuperclass() {
		Class<?> clazz = String.class;
		System.out.println(clazz);
		assertThat(clazz).hasSuperclass(Object.class);

		Class<?> clazz2 = Integer.class;
		System.out.println(clazz2);
		assertThat(clazz2).hasSuperclass(Number.class);
	}

class java.lang.String
class java.lang.Integer

hasNoSuperclass

Java AssertJ Class 驗證是否無父類別，若不成立，則會拋出 AssertionError 。

	@Test
	public void hasNoSuperclass() {
		Class<?> clazz = List.class;
		System.out.println(clazz);
		assertThat(clazz).hasNoSuperclass();

		Class<?> clazz2 = Collection.class;
		System.out.println(clazz2);
		assertThat(clazz2).hasNoSuperclass();
	}

interface java.util.List
interface java.util.Collection

doesNotHave

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

	@Test
	public void doesNotHave() {
		Class<?> clazz = BiConsumer.class;
		System.out.println(clazz);
		Condition<Class<?>> anno = new Condition<Class<?>>(c -> c.isAnnotation(), "annotation");
		assertThat(clazz).doesNotHave(anno);

		Class<?> clazz2 = Integer.class;
		System.out.println(clazz2);
		Condition<Class<?>> primitive = new Condition<Class<?>>(c -> c.isEnum(), "enum");
		assertThat(clazz2).doesNotHave(primitive);
	}

interface java.util.function.BiConsumer
class java.lang.Integer

AssertJClassWithExamplesTest.java

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

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

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

import java.lang.annotation.Target;
import java.util.Collection;
import java.util.List;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.UnaryOperator;
import java.util.stream.IntStream;

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

public class AssertJClassWithExamplesTest {

	@Test
	public void has() {
		Class<?> clazz = Consumer.class;
		System.out.println(clazz);
		Condition<Class<?>> iface = new Condition<Class<?>>(c -> c.isInterface(), "iface");
		assertThat(clazz).has(iface);

		Class<?> clazz2 = int.class;
		System.out.println(clazz2);
		Condition<Class<?>> primitive = new Condition<Class<?>>(c -> c.isPrimitive(), "primitive");
		assertThat(clazz2).has(primitive);
	}

	@Test
	public void hasPackage() {
		Class<?> clazz = Function.class;
		System.out.println(clazz);
		assertThat(clazz).hasPackage("java.util.function");
		assertThat(clazz).hasPackage(Package.getPackage("java.util.function"));

		Class<?> clazz2 = IntStream.class;
		System.out.println(clazz2);
		assertThat(clazz2).hasPackage("java.util.stream");
		assertThat(clazz2).hasPackage(Package.getPackage("java.util.stream"));
	}

	@Test
	public void hasAnnotation() {
		Class<?> clazz = UnaryOperator.class;
		System.out.println(clazz);
		assertThat(clazz).hasAnnotation(FunctionalInterface.class);

		Class<?> clazz2 = FunctionalInterface.class;
		System.out.println(clazz2);
		assertThat(clazz2).hasAnnotation(Target.class);
	}

	@Test
	public void hasSuperclass() {
		Class<?> clazz = String.class;
		System.out.println(clazz);
		assertThat(clazz).hasSuperclass(Object.class);

		Class<?> clazz2 = Integer.class;
		System.out.println(clazz2);
		assertThat(clazz2).hasSuperclass(Number.class);
	}

	@Test
	public void hasNoSuperclass() {
		Class<?> clazz = List.class;
		System.out.println(clazz);
		assertThat(clazz).hasNoSuperclass();

		Class<?> clazz2 = Collection.class;
		System.out.println(clazz2);
		assertThat(clazz2).hasNoSuperclass();
	}

	@Test
	public void doesNotHave() {
		Class<?> clazz = BiConsumer.class;
		System.out.println(clazz);
		Condition<Class<?>> anno = new Condition<Class<?>>(c -> c.isAnnotation(), "annotation");
		assertThat(clazz).doesNotHave(anno);

		Class<?> clazz2 = Integer.class;
		System.out.println(clazz2);
		Condition<Class<?>> primitive = new Condition<Class<?>>(c -> c.isEnum(), "enum");
		assertThat(clazz2).doesNotHave(primitive);
	}
}