var b, c, d = twoResults() // ERROR "assignment mismatch: 3 variables but twoResults returns 2 values|cannot initialize"
var e, f = oneResult()     // ERROR "assignment mismatch: 2 variables but oneResult returns 1 value|cannot initialize"

func twoResults() (int, int) {
	return 1, 2
}

func oneResult() int {
	return 1

    IvyDescriptorArtifact expectArtifact(String name, String ext, String classifier = null) {
        return oneResult(artifacts.findAll({
            it.name == name && it.ext == ext && it.classifier == classifier
        }), [name, ext, classifier])
    }

    IvyDescriptorArtifact expectArtifact(String name) {
        return oneResult(artifacts.findAll({
            it.name == name && it.ext != 'module'
        }), [name])
    }

template <typename ConcreteType>
class IsIdempotent : public TraitBase<ConcreteType, IsIdempotent> {
 public:
  static LogicalResult verifyTrait(Operation* op) {
    static_assert(ConcreteType::template hasTrait<OneResult>(),
                  "expected operation to produce one result");
    static_assert(ConcreteType::template hasTrait<OneOperand>() ||
                      ConcreteType::template hasTrait<NOperands<2>::Impl>(),

          typename VerifierT, typename RootOpT = DequantizeOpT,
          typename = std::enable_if_t<
              QuantizeOpT::template hasTrait<OpTrait::OneOperand>() &&
              DequantizeOpT::template hasTrait<OpTrait::OneResult>()>>
class StableHloQuantizationPattern : public OpRewritePattern<RootOpT> {
 public:
  explicit StableHloQuantizationPattern(MLIRContext* context)
      // Set the benefit to a large number so that it is always preferred.

    def listener = new DefaultPhasedActionResultListener(projectsLoadedHandler, buildFinishedHandler)

    def "right handler is called"() {
        when:
        listener.onResult(new ProjectsLoadedResult<String>('result1'))
        listener.onResult(new BuildFinishedResult<String>('result2'))

        then:
        1 * projectsLoadedHandler.onComplete('result1')
        1 * buildFinishedHandler.onComplete('result2')
    }

    def "delegate to listener"() {
        when:
        failsafeListener.onResult(event)

        then:
        1 * delegateListener.onResult(event)
    }

    def "failure is caught"() {
        def failure = new RuntimeException()
        given:
        delegateListener.onResult(_) >> { throw failure }

        when:
        failsafeListener.onResult(event)

        then:
        noExceptionThrown()

        when:

        then:
        1 * phasedActionResultListener.onResult({
            it.getPhase() == PhasedActionResult.Phase.PROJECTS_LOADED &&
                it.getResult() == result1
        })
        1 * phasedActionResultListener.onResult({
            it.getPhase() == PhasedActionResult.Phase.BUILD_FINISHED &&
                it.getResult() == result2
        })

    public FailsafePhasedActionResultListener(PhasedActionResultListener delegate) {
        this.delegate = delegate;
    }

    @Override
    public void onResult(PhasedActionResult<?> event) {
        try {
            delegate.onResult(event);
        } catch (Throwable t) {
            listenerFailures.add(t);
        }
    }

    public void rethrowErrors() {
        if (!listenerFailures.isEmpty()) {

 *
 * @since 4.8
 */
public interface PhasedActionResultListener extends InternalProtocolInterface {

    /**
     * Method called when result is available.
     */
    void onResult(PhasedActionResult<?> result);

            def actionResult1 = protocolAction.getProjectsLoadedAction().execute(buildController)
            def actionResult3 = protocolAction.getBuildFinishedAction().execute(buildController)
            listener.onResult(new PhasedActionResult<Object>() {
                @Override
                Object getResult() {
                    return actionResult1
                }

                @Override