import jcifs.smb1.dcerpc.*;

public class MsrpcSamrOpenAlias extends samr.SamrOpenAlias {

    public MsrpcSamrOpenAlias(SamrDomainHandle handle,
                    int access,
                    int rid,
                    SamrAliasHandle aliasHandle) {
        super(handle, access, rid, aliasHandle);
        ptype = 0;
        flags = DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG;
    }

    setDefault(Dispatcher.class, Dispatcher.immediate());
  }

  private static class DummySubscriber {

    private final EventBus eventBus = new EventBus();

    @Subscribe
    public void handle(@Nullable Object unused) {}

    Subscriber toSubscriber() throws Exception {
      return Subscriber.create(eventBus, this, subscriberMethod());
    }

    SubscriberExceptionContext toContext() {

import jcifs.smb1.dcerpc.*;

public class MsrpcSamrOpenDomain extends samr.SamrOpenDomain {

    public MsrpcSamrOpenDomain(SamrPolicyHandle handle,
                    int access,
                    rpc.sid_t sid,
                    SamrDomainHandle domainHandle) {
        super(handle, access, sid, domainHandle);
        ptype = 0;
        flags = DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG;
    }

const char* const kDlTensorCapsuleName = "dltensor";

// Converts eager tensor handle to DLPack (DLManagedTensor*), and return the
// void* for further PyCapsule construction.
TF_CAPI_EXPORT extern void* TFE_HandleToDLPack(TFE_TensorHandle* h,
                                               TF_Status* status);

// Converts DLPack (DLManagedTensor*) to eager tensor handle.
TF_CAPI_EXPORT extern TFE_TensorHandle* TFE_HandleFromDLPack(void* dlm,

  ~AbstractTensorHandle() override {}

 public:
  // Returns tensor dtype.
  virtual tensorflow::DataType DataType() const = 0;

  // Returns the status of the tensor handle. If it is a tfrt::TensorHandle,
  // the tensor handle can be an error and return non-OK status.
  virtual absl::Status TensorHandleStatus() const;

  // Returns tensor shape. If tensor has unknown rank, shape remains untouched.

            throw SmbException.wrap(e);
        }
    }


    SmbFileOutputStream ( SmbFile file, SmbTreeHandleImpl th, SmbFileHandleImpl handle, int openFlags, int access, int sharing )
            throws CIFSException {
        this.file = file;
        this.handle = handle;
        this.openFlags = openFlags;
        this.access = access;
        this.sharing = sharing;
        this.append = false;

  }

  public static class StringSubscriber {

    @Subscribe
    public void handle(String s) {}
  }

  public static class IntegerSubscriber {

    @Subscribe
    public void handle(Integer i) {}
  }

  public static class ObjectSubscriber {

    @Subscribe
    public void handle(Object o) {}
  }

  public void testFlattenHierarchy() {
    assertEquals(

    /**
     * @return the max_xmit
     */
    int getMaxXmit () {
        return this.max_xmit;
    }


    /**
     * Get a handle to a service
     * 
     * @param url
     * @param tc
     *            context to use
     * @return a DCERPC handle for the given url
     * @throws MalformedURLException
     * @throws DcerpcException
     */

      MemoryReleaser memory_releaser, void* memory_releaser_arg) = 0;

  // Create a handle to wrap and manage a Tensor
  virtual ImmediateExecutionTensorHandle* CreateLocalHandle(
      AbstractTensorInterface* t) = 0;
  // Copy the handle to another device.
  virtual ImmediateExecutionTensorHandle* CopyTensorHandleToDevice(
      ImmediateExecutionTensorHandle* handle, const char* device_name,
      absl::Status* status) = 0;

     */
    public static final int PIPE_TYPE_UNSHARED = 0x800;


    /**
     * @return the type of the pipe
     */
    int getPipeType ();


    /**
     * Create a pipe handle
     * 
     * @return pipe handle, needs to be closed when finished
     */
    SmbPipeHandle openPipe ();