AssertJ Learning

AssertJArrayLearning.java

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

import org.assertj.core.util.Arrays;
import org.junit.Test;

public class AssertJArrayLearning {

    @Test
    public void contains() {
        String[] actuals = Arrays.array("Lucy", "Debit", "Anna", "Jack");

        // 並び順は検証しない
        // 期待値に検証対象の値が全て含まれていなくても OK
        assertThat(actuals).contains("Debit", "Lucy", "Anna")
                           .contains("Lucy", "Anna");
    }

    @Test
    public void containsOnly() {
        String[] actuals = Arrays.array("Lucy", "Debit", "Anna", "Jack");

        // 並び順は検証しない
        // 期待値に検証対象の値が全て含まれていないと NG
        assertThat(actuals).containsOnly("Debit", "Lucy", "Jack", "Anna");
    }

    @Test
    public void containsSequence() {
        String[] actuals = Arrays.array("Lucy", "Debit", "Anna", "Jack");

        // 並び順を検証
        // 期待値と検証対象の件数は検証しない
        assertThat(actuals).containsSequence("Lucy", "Debit")
                           .containsSequence("Debit", "Anna", "Jack");
    }

    @Test
    public void containsSubsequence() {
        String[] actuals = Arrays.array("Lucy", "Debit", "Anna", "Jack");

        // 並び順を検証
        // 期待値と検証対象の件数は検証しない
        // 期待値に検証対象の抜け盛れがあった場合でも OK
        assertThat(actuals).containsSubsequence("Lucy", "Anna")
                           .containsSubsequence("Debit", "Jack")
                           .containsSubsequence("Lucy", "Jack");
    }

    @Test
    public void containsExactly() {
        String[] actuals = Arrays.array("Lucy", "Debit", "Anna", "Jack");

        // 並び順を検証
        // 期待値と検証対象の件数も検証
        // 検証失敗時、失敗した値の情報しか結果に表示されない
        assertThat(actuals).containsExactly("Lucy", "Debit", "Anna", "Jack");
    }

    @Test
    public void containsNull() {
        String[] actuals = Arrays.array("Lucy", null, "Anna", "Jack");

        // 検証対象に null が含まれていることを検証
        assertThat(actuals).containsNull();
    }

    @Test
    public void containsOnlyOnce() {
        String[] actuals = Arrays.array("Lucy", "Debit", "Anna", "Lucy");

        // 期待値が検証対象に 1 つだけ含まれることを検証
        // 期待値が検証対象に 2 つ以上含まれる、もしくは 1 つも含まれないと NG
        assertThat(actuals).containsOnlyOnce("Debit", "Anna");
    }

    @Test
    public void 件数検証() {
        String[] actuals = Arrays.array("Lucy", "Debit", "Anna", "Jack");
        assertThat(actuals).hasSize(4);
    }

    @Test
    public void 空検証() {
        String[] actuals = Arrays.array();
        assertThat(actuals).isEmpty();
    }
}

AssertJBasicLearning.java

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

import org.junit.Ignore;
import org.junit.Test;

public class AssertJBasicLearning {

    @Test
    public void 同値検証() {
        assertThat("Foo").isEqualTo("Foo");
        assertThat("Foo").isNotEqualTo("Bar");
    }

    @Test
    public void null検証() {
        Object actual = null;
        assertThat(actual).isNull();

        actual = "Foo";
        assertThat(actual).isNotNull();
    }

    @Test
    public void compareToによる検証() {
        Foo foo1 = new Foo();
        Foo foo2 = new Foo();

        assertThat(foo1).isEqualByComparingTo(foo2);
    }

    private static final class Foo implements Comparable<Foo> {
        @Override
        public int compareTo(Foo other) {
            return 0;
        }
    }

    @Test
    public void インスタンス検証() {
        Bar bar1 = new Bar();
        Bar bar2 = bar1;

        assertThat(bar1).isSameAs(bar2);
    }

    private static class Bar {
    }

    @Test
    public void 型検証() {
        Baz baz = new Baz();
        Qux qux = new Qux();

        assertThat(baz).isInstanceOf(Baz.class);
        assertThat(qux).isInstanceOf(Baz.class).isInstanceOf(Qux.class);
    }

    private static class Baz {
    }

    private static final class Qux extends Baz {
    }

    @Test
    public void toStringによる検証() {
        FooBar fooBar = new FooBar();

        assertThat(fooBar).hasToString("FooBar");
    }

    private static final class FooBar {
        @Override
        public String toString() {
            return "FooBar";
        }
    }

    @Ignore
    @Test
    public void 失敗時に表示される検証内容を設定() {
        assertThat("Foo").as("AssertJ sample").isEqualTo("Bar");

        // org.junit.ComparisonFailure: [AssertJ sample] expected:<"[Bar]"> but was:<"[Foo]">
    }
}

AssertJCollectionLearning.java

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

import java.util.List;

import org.assertj.core.util.Lists;
import org.junit.Test;

public class CollectionLearning {

    @Test
    public void contains() {
        List<String> actuals = Lists.newArrayList("Lucy", "Debit", "Anna", "Jack");

        // 並び順は検証しない
        // 期待値に検証対象の値が全て含まれていなくても OK
        assertThat(actuals).contains("Debit", "Lucy", "Anna")
                           .contains("Lucy", "Anna");
    }

    @Test
    public void containsOnly() {
        List<String> actuals = Lists.newArrayList("Lucy", "Debit", "Anna", "Jack");

        // 並び順は検証しない
        // 期待値に検証対象の値が全て含まれていないと NG
        assertThat(actuals).containsOnly("Debit", "Lucy", "Jack", "Anna");
    }

    @Test
    public void containsSequence() {
        List<String> actuals = Lists.newArrayList("Lucy", "Debit", "Anna", "Jack");

        // 並び順を検証
        // 期待値と検証対象の件数は検証しない
        assertThat(actuals).containsSequence("Lucy", "Debit")
                           .containsSequence("Debit", "Anna", "Jack");
    }

    @Test
    public void containsSubsequence() {
        List<String> actuals = Lists.newArrayList("Lucy", "Debit", "Anna", "Jack");

        // 並び順を検証
        // 期待値と検証対象の件数は検証しない
        // 期待値に検証対象の抜け盛れがあった場合でも OK
        assertThat(actuals).containsSubsequence("Lucy", "Anna")
                           .containsSubsequence("Debit", "Jack")
                           .containsSubsequence("Lucy", "Jack");
    }

    @Test
    public void containsExactly() {
        List<String> actuals = Lists.newArrayList("Lucy", "Debit", "Anna", "Jack");

        // 並び順を検証
        // 期待値と検証対象の件数も検証
        assertThat(actuals).containsExactly("Lucy", "Debit", "Anna", "Jack");
    }

    @Test
    public void containsNull() {
        List<String> actuals = Lists.newArrayList("Lucy", null, "Anna", "Jack");

        // 検証対象に null が含まれていることを検証
        assertThat(actuals).containsNull();
    }

    @Test
    public void containsOnlyOnce() {
        List<String> actuals = Lists.newArrayList("Lucy", "Debit", "Anna", "Lucy");

        // 期待値が検証対象に 1 つだけ含まれることを検証
        // 期待値が検証対象に 2 つ以上含まれる、もしくは 1 つも含まれないと NG
        assertThat(actuals).containsOnlyOnce("Debit", "Anna");
    }

    @Test
    public void 件数検証() {
        List<String> actuals = Lists.newArrayList("Lucy", "Debit", "Anna", "Jack");
        assertThat(actuals).hasSize(4);
    }

    @Test
    public void 空検証() {
        List<String> actuals = Lists.newArrayList();
        assertThat(actuals).isEmpty();
    }
}

AssertJMapLearning.java

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

import java.util.Map;

import org.assertj.core.util.Maps;
import org.junit.Test;

public class AssertJMapLearning {

    @Test
    public void Entry検証() {
        Map<String, Integer> actuals = Maps.newHashMap();
        actuals.put("Key1", 101);
        actuals.put("Key2", 202);
        actuals.put("Key3", 303);

        assertThat(actuals).containsEntry("Key1", 101)
                           .containsEntry("Key2", 202)
                           .doesNotContainEntry("Key9", 999);
    }

    @Test
    public void Key検証() {
        Map<String, Integer> actuals = Maps.newHashMap();
        actuals.put("Key1", 101);
        actuals.put("Key2", 202);
        actuals.put("Key3", 303);

        assertThat(actuals).containsKey("Key1")
                           .containsKeys("Key2", "Key3")
                           .doesNotContainKey("Key9");
    }

    @Test
    public void Value検証() {
        Map<String, Integer> actuals = Maps.newHashMap();
        actuals.put("Key1", 101);
        actuals.put("Key2", 202);
        actuals.put("Key3", 303);

        assertThat(actuals).containsValue(101)
                           .containsValues(202, 303)
                           .doesNotContainValue(999);
    }

    @Test
    public void 件数検証() {
        Map<String, Integer> actuals = Maps.newHashMap();
        actuals.put("Key1", 101);
        actuals.put("Key2", 202);
        actuals.put("Key3", 303);

        assertThat(actuals).hasSize(3);
    }

    @Test
    public void 空検証() {
        Map<String, Integer> actuals = Maps.newHashMap();
        assertThat(actuals).isEmpty();
    }
}

AssertJNumberLearning.java

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

import org.junit.Ignore;
import org.junit.Test;

public class AssertJNumberLearning {

    @Ignore
    @Test
    public void 範囲検証() {
        assertThat(7).isBetween(0, 9).isBetween(7, 7);
        assertThat(7).isCloseTo(5, within(2)); // 5 ± 2 -> OK
        assertThat(7).isCloseTo(5, within(1)); // 5 ± 1 -> NG
    }

    @Test
    public void 大なり小なり検証() {
        assertThat(7).isGreaterThan(6).isGreaterThanOrEqualTo(7);
        assertThat(7).isLessThan(8).isLessThanOrEqualTo(7);
    }
}

AssertJStringLearning.java

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

import org.junit.Test;

public class AssertJStringLearning {

    @Test
    public void 接頭辞検証() {
        assertThat("FooBar").startsWith("Foo");
    }

    @Test
    public void 接尾辞検証() {
        assertThat("FooBar").endsWith("Bar");
    }

    @Test
    public void 大文字小文字検証検証() {
        assertThat("Foo").isNotEqualTo("FOO").isEqualToIgnoringCase("FOO");
    }

    /**
     * タブ (\t) も 1 つのスペースとしてカウントされる
     * 先頭と末尾のスペースは無視される
     * 複数のスペースは 1 つにまとめられる
     * 大文字小文字は無視しない
     */
    @Test
    public void スペース無視検証() {
        assertThat("Foo BAR baz").isEqualToIgnoringWhitespace(" Foo   BAR\tbaz ");
        assertThat(" Foo   BAR\tbaz ").isEqualToIgnoringWhitespace("Foo BAR baz");
    }

    @Test
    public void 空文字検証() {
        assertThat("").isEmpty();
    }

    @Test
    public void 空文字null検証() {
        String actual = "";
        assertThat(actual).isNullOrEmpty();

        actual = null;
        assertThat(actual).isNullOrEmpty();
    }

    @Test
    public void 正規表現検証() {
        String actual = "FooBarBaz";
        assertThat(actual).matches("F..B..B..").matches("F.*z");
    }

    @Test
    public void 数字検証() {
        String actual = "1234567890";
        assertThat(actual).containsOnlyDigits();
    }

    @Test
    public void 行数検証() {
        String actual = "foo";
        assertThat(actual).hasLineCount(1);

        actual = "foo\nbar\nbaz";
        assertThat(actual).hasLineCount(3);

        actual = "foo\r\nbar\r\nbaz";
        assertThat(actual).hasLineCount(3);
    }
}