void TF_DeleteOutputList(TF_OutputList* o) { delete unwrap(o); }
void TF_OutputListSetNumOutputs(TF_OutputList* o, int num_outputs,
                                TF_Status* s) {
  unwrap(o)->expected_num_outputs = num_outputs;
  unwrap(o)->outputs.clear();
  unwrap(o)->outputs.resize(num_outputs);
}
int TF_OutputListNumOutputs(TF_OutputList* o) {
  return unwrap(o)->outputs.size();
}

  tensorflow::unwrap(ctx)->StartStep();
}

void TFE_ContextEndStep(TFE_Context* ctx) {
  tensorflow::unwrap(ctx)->EndStep();
}

const TFE_OpAttrs* TFE_OpGetAttrs(const TFE_Op* op) {
  return tensorflow::wrap(tensorflow::unwrap(op)->GetOpAttrs());
}

void TFE_OpAddAttrs(TFE_Op* op, const TFE_OpAttrs* attrs) {
  tensorflow::unwrap(op)->AddAttrs(tensorflow::unwrap(attrs));
}

                                                          TF_Status* s) {
  return wrap(static_cast<AbstractTensorHandle*>(unwrap(t)));
}

TFE_TensorHandle* TF_AbstractTensorGetEagerTensor(TF_AbstractTensor* at,
                                                  TF_Status* s) {
  auto handle = dyn_cast<ImmediateExecutionTensorHandle>(unwrap(at));
  if (!handle) {
    string msg =

  tensorflow::unwrap(ctx)->SetExecutorForThread(executor->executor());
}

TFE_Executor* TFE_ContextGetExecutorForThread(TFE_Context* ctx) {
  return new TFE_Executor(&tensorflow::unwrap(ctx)->Executor());
}

void TFE_HostAddressSpace(TFE_Context* ctx, TF_Buffer* buf) {
  auto address_space = tensorflow::DeviceNameUtils::AddressSpace(
      tensorflow::unwrap(ctx)->HostCPUParsedName());

  public void testWrap() {
    assertThat(Primitives.wrap(int.class)).isSameInstanceAs(Integer.class);
    assertThat(Primitives.wrap(Integer.class)).isSameInstanceAs(Integer.class);
    assertThat(Primitives.wrap(String.class)).isSameInstanceAs(String.class);
  }

  public void testUnwrap() {
    assertThat(Primitives.unwrap(Integer.class)).isSameInstanceAs(int.class);
    assertThat(Primitives.unwrap(int.class)).isSameInstanceAs(int.class);

            Assert.assertEquals("b@r", na.getPassword());
        }

        try ( SmbFile f = new SmbFile(new URL("smb://foo:b%40r@127.0.0.1/")) ) {
            Assert.assertEquals("foo:b%40r", f.getLocator().getURL().getUserInfo());
            NtlmPasswordAuthenticator na = f.getContext().getCredentials().unwrap(NtlmPasswordAuthenticator.class);

  public void testWrap() {
    assertThat(Primitives.wrap(int.class)).isSameInstanceAs(Integer.class);
    assertThat(Primitives.wrap(Integer.class)).isSameInstanceAs(Integer.class);
    assertThat(Primitives.wrap(String.class)).isSameInstanceAs(String.class);
  }

  public void testUnwrap() {
    assertThat(Primitives.unwrap(Integer.class)).isSameInstanceAs(int.class);
    assertThat(Primitives.unwrap(int.class)).isSameInstanceAs(int.class);

   * returns {@code type} itself. Idempotent.
   *
   * <pre>
   *     unwrap(Integer.class) == int.class
   *     unwrap(int.class) == int.class
   *     unwrap(String.class) == String.class
   * </pre>
   */
  public static <T> Class<T> unwrap(Class<T> type) {
    checkNotNull(type);

    // cast is safe: long.class and Long.class are both of type Class<Long>

                .unwrap(SmbTransportInternal.class);
              SmbSession sess = trans.unwrap(SmbTransportInternal.class).getSmbSession(c, getTestServer(), null);
              SmbTreeInternal tree = sess.unwrap(SmbSessionInternal.class).getSmbTree(getTestShare(), null).unwrap(SmbTreeInternal.class) ) {

            if ( trans.isSMB2() ) {

                    SmbTransportInternal trans = this.exclusiveTransport;
                    try ( SmbSessionInternal smbSession = trans.getSmbSession(this.ctx, host, targetDomain).unwrap(SmbSessionInternal.class);
                          SmbTreeImpl uct = smbSession.getSmbTree(share, null).unwrap(SmbTreeImpl.class);