// Don't use this in your code.
#define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure)\
  GTEST_ASSERT_(pred_format(#v1, v1), \
                on_failure)

// Internal macro for implementing {EXPECT|ASSERT}_PRED1.  Don't use
// this in your code.
#define GTEST_PRED1_(pred, v1, on_failure)\
  GTEST_ASSERT_(::testing::AssertPred1Helper(#pred, \
                                             #v1, \

// Don't use this in your code.
#define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure)\
  GTEST_ASSERT_(pred_format(#v1, v1), \
                on_failure)

// Internal macro for implementing {EXPECT|ASSERT}_PRED1.  Don't use
// this in your code.
#define GTEST_PRED1_(pred, v1, on_failure)\
  GTEST_ASSERT_(::testing::AssertPred1Helper(#pred, \
                                             #v1, \

  }

  fun processResponse(response: Response) {
    response.use {
      if (!response.isSuccessful) {
        listener.onFailure(this, null, response)
        return
      }

      val body = response.body

      if (!body.isEventStream()) {
        listener.onFailure(
          this,
          IllegalStateException("Invalid content-type: ${body.contentType()}"),
          response,
        )

    }

    void shouldFail(@DelegatesTo(value = ExecutionFailure, strategy = Closure.DELEGATE_FIRST) Closure<?> onFailure) {
        expectSuccess = false
        if (onFailure == null) {
            throw new IllegalArgumentException("Please provide an explanation for the failure")
        }
        failureExpectations << onFailure
    }

    void noComponentPublished() {
        shouldFail {

            // Exception has already been reported
            executionListener.onFailure(e);
        } catch (ServiceCreationException e) {
            reporter.execute(new ContextAwareException(new InitializationException(e)));
            executionListener.onFailure(e);
        } catch (Throwable t) {
            reporter.execute(t);
            executionListener.onFailure(t);
        }
    }

            } catch (Throwable throwable) {
                onFailure(String.format("Failed to execute %s.", command), throwable);
            }
        }

        @Override
        public <T> T onExecute(Callable<T> command) throws Exception {
            try {
                return command.call();
            } catch (Exception exception) {
                onFailure(String.format("Failed to execute %s.", command), exception);

          @Override
          public void onSuccess(String result) {
            fail("Was not expecting onSuccess() to be called.");
          }

          @Override
          public synchronized void onFailure(Throwable t) {
            assertFalse(called);
            assertThat(t).isInstanceOf(CancellationException.class);
            called = true;
          }
        };
    addCallback(f, callback, directExecutor());

        then:
        1 * asyncConnection.run(!null, !null) >> {args ->
            adaptedHandler = args[1]
        }

        when:
        adaptedHandler.onFailure(failure)

        then:
        1 * handler.onFailure(!null) >> {args -> wrappedFailure = args[0] }
        _ * asyncConnection.displayName >> '[connection]'

          @Override
          public void onSuccess(String result) {
            fail("Was not expecting onSuccess() to be called.");
          }

          @Override
          public synchronized void onFailure(Throwable t) {
            assertFalse(called);
            assertThat(t).isInstanceOf(CancellationException.class);
            called = true;
          }
        };
    addCallback(f, callback, directExecutor());

        when:
        action.execute(listener)

        then:
        1 * target.execute(listener) >> { throw failure }
        1 * loggingOutput.flush()
        1 * reporter.execute(failure)
        1 * listener.onFailure(failure)
        0 * _._
    }

    def "service creation failure is reported as initialization exception"() {
        def failure = new ServiceCreationException("Service creation failed")