delegate.pack(inputs, new DelegatingDataTarget(output) {
            @Override
            public OutputStream openOutput() throws IOException {
                return new GZIPOutputStream(super.openOutput());
            }
        });
    }

    @Override
    public void unpack(DataSource input, DataTargetFactory targetFactory) throws IOException {

  Tape tape(/*persistent=*/false);
  tape.Watch(inputs[0]);
  AbstractTensorHandle* neg_output;
  TF_RETURN_IF_ERROR(ops::Neg(ctx, inputs[0], &neg_output, "Neg"));
  tape.RecordOperation(inputs, {neg_output}, nullptr, "Neg");
  return tape.ComputeGradient(ctx,
                              /*targets=*/{neg_output},
                              /*sources=*/inputs,

        then:
        installation("build/install/main").exec().out == app.englishOutput

        then:
        file("build/libs/hello/shared/link/new_output/_hello.lib").assertExists()
        file("build/libs/hello/shared/runtime/new_output/_hello.dll").assertExists()
    }

    @Requires(UnitTestPreconditions.CanInstallExecutable)
    @ToBeFixedForConfigurationCache

        then:
        1 * listener.onOutput({ it.spans[0].text == toNative('message1\n') })
        1 * listener.onOutput({ it.spans[0].text == toNative('message2\n') })
        0 * listener._
    }

    def forwardsEmptyLinesToListener() {
        when:
        output.text(toNative('\n\n'))

        then:
        2 * listener.onOutput({ it.spans[0].text == toNative('\n') })
        0 * listener._

            stream.received(bytes1)
            thread.blockUntil.requested2
            stream.received(bytes2)
        }

        then:
        1 * dispatch.onOutput({ it instanceof ReadStdInEvent }) >> { instant.requested1 }
        1 * dispatch.onOutput({ it instanceof ReadStdInEvent }) >> { instant.requested2 }
    }

    def "read bytes returns when stream is closed"() {
        def dispatch = Mock(OutputEventListener)

    AbstractTensorHandle* conj_output;
    std::string name = "Conj_Exp_Grad";
    TF_RETURN_IF_ERROR(SafeConj(ctx, exp_.get(), &conj_output, name.c_str()));
    AbstractTensorHandlePtr conj_output_releaser(conj_output);

    name = "Mul_Exp_Grad";
    TF_RETURN_IF_ERROR(
        Mul(ctx, conj_output, grad_outputs[0], &grad_inputs[0], name.c_str()));
    return absl::OkStatus();
  }

        delegate.pack(inputs, new DelegatingDataTarget(output) {
            @Override
            public OutputStream openOutput() throws IOException {
                return new SnappyFramedOutputStream(super.openOutput());
            }
        });
    }

    @Override
    public void unpack(DataSource input, DataTargetFactory targetFactory) throws IOException {

        }

        @Override
        public void onOutput(CharSequence output) {
            OperationIdentifier buildOperationId = CurrentBuildOperationRef.instance().getId();
            StyledTextOutputEvent event = new StyledTextOutputEvent(clock.getCurrentTime(), category, null, buildOperationId, output.toString());
            listener.onOutput(event);
        }
    }

    }

    @Override
    public void completed(ProgressCompleteEvent event) {
        listener.onOutput(event);
    }

    @Override
    public void started(ProgressStartEvent event) {
        listener.onOutput(event);
    }

    @Override
    public void progress(ProgressEvent event) {
        listener.onOutput(event);
    }

    }

    @Override
    public void sendOutputEvent(LogEvent event) {
        outputEventListener.onOutput(event);
    }

    @Override
    public void sendOutputEvent(StyledTextOutputEvent event) {
        outputEventListener.onOutput(event);
    }