}).orElse(() -> {
                throw new FessUserNotFoundException(username);
            });
        }

    }

    public void delete(final User user) {
        ComponentUtil.getAuthenticationManager().delete(user);

        userBhv.delete(user, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });

    }

		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkDecodeFileInfoMsgp(b *testing.B) {

			}
		case "Created":
			z.Created, bts, err = msgp.ReadTimeBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Created")
				return
			}
		case "Deleted":
			z.Deleted, bts, err = msgp.ReadTimeBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Deleted")
				return
			}
		case "Versioning":
			z.Versioning, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Versioning")

					"runtime.wasmExit": (sp) => {
						sp >>>= 0;
						const code = this.mem.getInt32(sp + 8, true);
						this.exited = true;
						delete this._inst;
						delete this._values;
						delete this._goRefCounts;
						delete this._ids;
						delete this._idPool;
						this.exit(code);
					},

					// func wasmWrite(fd uintptr, p unsafe.Pointer, n int32)
					"runtime.wasmWrite": (sp) => {

  }
  delete(file)
  return false
}

/** Delete file we expect but don't require to exist. */
internal fun FileSystem.deleteIfExists(path: Path) {
  try {
    delete(path)
  } catch (fnfe: FileNotFoundException) {
    return
  }
}

/** Tolerant delete, try to clear as many files as possible even after a failure. */
internal fun FileSystem.deleteContents(directory: Path) {
  var exception: IOException? = null

stale_uploads_cleanup_interval  (duration)  set to change intervals when stale multipart uploads are expired (default: '6h')
delete_cleanup_interval         (duration)  set to change intervals when deleted objects are permanently deleted from ".trash" folder (default: '5m')
odirect                         (boolean)   set to enable or disable O_DIRECT for writes under special conditions. NOTE: do not disable O_DIRECT without prior testing (default: 'on')

	// Delete policy.
	request, err = newTestSignedRequest(http.MethodDelete, getDeletePolicyURL(s.endPoint, bucketName), 0, nil,
		s.accessKey, s.secretKey, s.signer)
	c.Assert(err, nil)

	response, err = s.client.Do(request)
	c.Assert(err, nil)
	c.Assert(response.StatusCode, http.StatusNoContent)

	// Verify if the policy was indeed deleted.

  EXPECT_EQ(22, product[3]);
  TF_DeleteStatus(status);
}
TEST(CAPI, Executor_MatMul_CPU) { Executor_MatMul_CPU(false); }
TEST(CAPI, Executor_MatMul_CPUAsync) { Executor_MatMul_CPU(true); }

void Deleter(void* data, size_t unused, void* tensor_handle) {
  TFE_DeleteTensorHandle(static_cast<TFE_TensorHandle*>(tensor_handle));
}

TEST(CAPI, TensorHandleOnDeviceMemory) {
  TF_Status* status = TF_NewStatus();

        failureUrlBhv.insertOrUpdate(failureUrl, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });

    }

    public void delete(final FailureUrl failureUrl) {

        failureUrlBhv.delete(failureUrl, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });

    }

        } finally {
            if (dfos != null && !dfos.isInMemory()) {
                final File file = dfos.getFile();
                if (!file.delete()) {
                    logger.warn("Failed to delete {}.", file.getAbsolutePath());
                }
            }
        }

    }

    protected String getMimeType(final DeferredFileOutputStream out) throws IOException {