Building block to define precise conditions on complex objects.

It allows to create readable assertions and produces beautiful assertion error messages.

Example:

 import static org.assertj.core.condition.NestableCondition.nestable;
import static org.assertj.core.condition.VerboseCondition.verboseCondition;

class Customer {
   final String name;
   final Address address;

   Customer(String name, Address address) {
     this.name = name;
     this.address = address;
   }
}

class Address {
   final String firstLine;
   final String postcode;

   Address(String firstLine, String postcode) {
     this.firstLine = firstLine;
     this.postcode = postcode;
   }
 }

static Condition<Customer> name(String expected) {
  return new Condition<>(
     it -> expected.equals(it.name),
     "name: " + expected
  );
}

static Condition<Customer> customer(Condition<Customer>... conditions) {
  return nestable("person", conditions);
}

static Condition<Address> firstLine(String expected) {
  return new Condition<>(
     it -> expected.equals(it.firstLine),
     "first line: " + expected
  );
}

static Condition<Address> postcode(String expected) {
  return new Condition<>(
     it -> expected.equals(it.postcode),
     "postcode: " + expected
  );
}

static Condition<Customer> address(Condition<Address>... conditions) {
  return nestable(
     "address",
     customer -> customer.address,
     conditions
  );
}

And assertions can be written like:

 assertThat(customer).is(
  customer(
    name("John"),
    address(
      firstLine("3"),
      postcode("KM3 8SP")
    )
  )
); 

leads to an easy-to-read assertion error:

 Expecting actual:
  org.assertj.core.condition.Customer@27ff5d15
to be:
  [✗] person:[
      [✓] name: John,
      [✗] address:[
        [✗] first line: 3,
        [✓] postcode: KM3 8SP
      ]
  ]

For an even better assertion error, see VerboseCondition.