if err != nil {
		return errInvalidArgument
	}
	data := &syscall.Win32finddata{}
	handle, err := syscall.FindFirstFile(globAllP, data)
	if err != nil {
		if err = syscallErrToFileErr(dirPath, err); err == errFileNotFound {
			return nil
		}
		return err
	}
	defer syscall.FindClose(handle)

	for ; ; err = syscall.FindNextFile(handle, data) {
		if err != nil {
			if err == syscall.ERROR_NO_MORE_FILES {
				break

 */
package jcifs.dcerpc.msrpc;


import jcifs.dcerpc.rpc.policy_handle;
import jcifs.dcerpc.msrpc.lsarpc.LsarClose;


/**
 * 
 */
public class MsrpcLsarClose extends LsarClose {

    /**
     * @param handle
     */
    public MsrpcLsarClose ( policy_handle handle ) {
        super(handle);
        this.ptype = 0;
        this.flags = DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG;
    }

		auth = NoAuthMiddleware
	}
	metricsRouter.Handle(prometheusMetricsPathLegacy, auth(metricsHandler()))
	metricsRouter.Handle(prometheusMetricsV2ClusterPath, auth(metricsServerHandler()))
	metricsRouter.Handle(prometheusMetricsV2BucketPath, auth(metricsBucketHandler()))
	metricsRouter.Handle(prometheusMetricsV2NodePath, auth(metricsNodeHandler()))
	metricsRouter.Handle(prometheusMetricsV2ResourcePath, auth(metricsResourceHandler()))

  TFE_OpSetDevice(op.get(), device, status);
  if (TF_GetCode(status) != TF_OK) return nullptr;
  TFE_TensorHandle* var_handle = nullptr;
  int num_retvals = 1;
  TFE_Execute(op.get(), &var_handle, &num_retvals, status);
  if (TF_GetCode(status) != TF_OK) return nullptr;
  return new Variable(var_handle, type);
}

void Variable::Destroy(TFE_Context* context, TF_Status* status) {
  // Free the backing buffer for the variable.

                              "VarHandleOp", TFE_OpGetAttrs(handle_op.get()),
                              /*expected_max_outputs=*/1, status.get());
  ASSERT_TRUE(TF_GetCode(status.get()) == TF_OK) << TF_Message(status.get());
  const std::vector<std::unique_ptr<ParallelTensor>>& handles = *outputs;
  std::vector<ParallelTensor*> handle_inputs;
  handle_inputs.reserve(handles.size());
  for (auto& handle : handles) {
    handle_inputs.push_back(handle.get());

     */
    synchronized SmbFileHandleImpl ensureOpen () throws CIFSException {
        if ( this.handle == null || !this.handle.isValid() ) {
            // one extra acquire to keep this open till the stream is released
            if ( this.file instanceof SmbNamedPipe ) {
                this.handle = this.file.openUnshared(
                    SmbConstants.O_EXCL,

public class SmbPipeInputStream extends SmbFileInputStream {

    private SmbPipeHandleImpl handle;


    /**
     * @param handle
     * @param th
     * @throws SmbException
     */
    SmbPipeInputStream ( SmbPipeHandleImpl handle, SmbTreeHandleImpl th ) throws CIFSException {
        super(handle.getPipe(), th, null);
        this.handle = handle;
    }

// Creates or truncates the given filename and returns a handle to be used for
// appending data to the file. If status is TF_OK, *handle is updated and the
// caller is responsible for freeing it (see TF_CloseWritableFile).
TF_CAPI_EXPORT extern void TF_NewWritableFile(const char* filename,
                                              TF_WritableFileHandle** handle,
                                              TF_Status* status);

    @Test
    public void testSRVS () throws DcerpcException, IOException {
        try ( DcerpcHandle handle = DcerpcHandle
                .getHandle("ncacn_np:" + getTestServer() + "[\\PIPE\\srvsvc]", withTestNTLMCredentials(getContext())) ) {
            MsrpcShareEnum rpc = new MsrpcShareEnum(handle.getServerWithDfs());
            handle.sendrecv(rpc);
            assertEquals(0, rpc.retval);
        }
    }


    @Test

        ::tensorflow::io::JoinPath(dirpath, "somefile.txt");
    TF_WritableFileHandle* handle;
    TF_NewWritableFile(filepath.c_str(), &handle, s);
    ASSERT_TF_OK(s) << "NewWritableFile failed for " << filepath << ": "
                    << TF_Message(s);

    const char* data = "Hello, world!\n";
    TF_AppendWritableFile(handle, data, strlen(data), s);
    ASSERT_TF_OK(s) << "TF_AppendWritableFile failed to append data to file at "