anchor.diff:  Try<String> result = Try.of(checkedSupplier)
           .recover((throwable) -> "Hello Recovery");
   
  -//Then
  +//Then the function should be a success, because the exception could be recovered
   assertThat(result.isSuccess()).isTrue();
  +// and the result must match the result of the recovery function.
   assertThat(result.get()).isEqualTo("Hello Recovery");
   ----
   
   === Example of how to ignore exceptions
   
  -The following test cases shows how to add exceptions to the ignore list so that the CircuitBreaker is not triggered.
  -
  -[source,java]
  -----
  -// Given
  +The following test cases shows how to add exceptions to the ignore list which must not trigger the CircuitBreaker.
  +
  +[source,java]
  +----
  +// Given I add the IOException to the ignore list
   CircuitBreakerConfig circuitBreakerConfig = new CircuitBreakerConfig.Builder()
           .maxFailures(1)
           .waitInterval(1000)
  
positive.code: CircuitBreakerRegistry circuitBreakerRegistry = CircuitBreakerRegistry.ofDefaults();
  CircuitBreaker circuitBreaker = circuitBreakerRegistry.circuitBreaker("uniqueName");
  
  //When
  Try.CheckedSupplier<String> checkedSupplier = CircuitBreaker.decorateCheckedSupplier(() -> {
          Thread.sleep(1000);
          throw new RuntimeException("BAM!");
  
negative.code: assertThat(result.get()).isEqualTo("This can be any method which returns: 'Hello world'");
  ----
  
  === OPEN CircuitBreaker example
  
  In this test case `map` is not invoked, because the CircuitBreaker is OPEN. The call to `Try.of` returns a `Failure<Throwable>` Monad so that the chained function is not invoked.
  
  [source,java]
  ----
  // Given
  CircuitBreakerRegistry circuitBreakerRegistry = CircuitBreakerRegistry.ofDefaults();
  // Create a custom configration so that only 1 failure is allowed and the wait interval is 1[s]
  CircuitBreakerConfig circuitBreakerConfig = new CircuitBreakerConfig.Builder()
      .maxFailures(1)
      .waitInterval(1000)
      .build();
  CircuitBreaker circuitBreaker = circuitBreakerRegistry.circuitBreaker("uniqueName", circuitBreakerConfig);
  
  // CircuitBreaker is initially CLOSED
  assertThat(circuitBreaker.getState()).isEqualTo(CircuitBreaker.State.CLOSED); 
  // Simulate a failure attempt
  circuitBreaker.recordFailure(new RuntimeException());
  // CircuitBreaker is still CLOSED, because 1 failure is allowed
  assertThat(circuitBreaker.getState()).isEqualTo(CircuitBreaker.State.CLOSED); 
  // Simulate a failure attempt
  circuitBreaker.recordFailure(new RuntimeException());
  // CircuitBreaker is OPEN, because maxFailures > 1
  assertThat(circuitBreaker.getState()).isEqualTo(CircuitBreaker.State.OPEN); 
  
  // When I decorate my function and invoke the decorated function
  Try<String> result = Try.of(CircuitBreaker.decorateCheckedSupplier(() -> "Hello", circuitBreaker))
          .map(value -> value + " world");
  
  // Then the call fails, because CircuitBreaker is OPEN
  assertThat(result.isFailure()).isTrue();
  // and the exception is a CircuitBreakerOpenException
  assertThat(result.failed().get()).isInstanceOf(CircuitBreakerOpenException.class); 
  ----
  
  === Recovery example
  
  If you want to recover from any exception, you can chain the method `Try.recover()`. The recovery method is only invoked, if `Try.of()` returns a `Failure<Throwable>` Monad.
  
  