// Delete
	if err := DB.Model(&user2).Association("Languages").Delete(&Language{}); err != nil {
		t.Fatalf("Error happened when delete language, got %v", err)
	}
	AssertAssociationCount(t, user2, "Languages", 1, "after delete non-existing data")

	if err := DB.Model(&user2).Association("Languages").Delete(&language2); err != nil {
		t.Fatalf("Error happened when delete Languages, got %v", err)
	}

                    CopyUtil.copy(is, os);
                } catch (final Exception e) {
                    if (tempFile.exists() && !tempFile.delete()) {
                        logger.warn("Failed to delete {}.", tempFile.getAbsolutePath());
                    }
                    logger.debug("Failed to copy {}", filename, e);

        groupBhv.insertOrUpdate(group, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });

    }

    public void delete(final Group group) {
        ComponentUtil.getLdapManager().delete(group);

        groupBhv.delete(group, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });

        userBhv.selectCursor(cb -> cb.query().setGroups_Equal(group.getId()), entity -> {

        roleBhv.insertOrUpdate(role, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });

    }

    public void delete(final Role role) {
        ComponentUtil.getLdapManager().delete(role);

        roleBhv.delete(role, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });

        userBhv.selectCursor(cb -> cb.query().setRoles_Equal(role.getId()), entity -> {

}

void TF_DeleteShapeAndTypeList(TF_ShapeAndTypeList* shape_list) {
  if (shape_list == nullptr) return;
  for (size_t i = 0; i < shape_list->num_items; ++i) {
    delete[] shape_list->items[i].dims;
  }
  delete[] shape_list->items;
  delete shape_list;
}

void TF_DeleteShapeAndTypeListArray(TF_ShapeAndTypeList** shape_list_array,
                                    int num_items) {

			</Policies>
			<DefaultRolloverStrategy fileIndex="max" min="1"
				max="${backup.max.history}" compressionLevel="9">
				<Delete basePath="${log.file.basedir}">
					<IfFileName glob="${domain.name}*.log.gz" />
					<IfLastModified age="P${backup.max.age}D" />
				</Delete>
			</DefaultRolloverStrategy>
		</RollingFile>
		<RollingFile name="AuditFile" fileName="${log.file.basedir}/audit.log"

	<property name="maven.release.repo.url" value="https://oss.sonatype.org/content/repositories/releases" />

	<target name="install.plugins">
		<mkdir dir="${target.dir}" />
		<delete dir="${plugins.dir}" />
		<mkdir dir="${plugins.dir}" />
		<!-- analysis-extension -->
		<antcall target="install.plugin">
			<param name="repo.url" value="${maven.release.repo.url}" />

		if file.IsDir() {
			continue
		}
		if fi, err := file.Info(); err == nil {
			store.entries[file.Name()] = fi.ModTime().UnixNano()
		}
	}

	return nil
}

// Delete - Remove the store directory from disk
func (store *QueueStore[_]) Delete() error {
	return os.Remove(store.directory)
}

// PutMultiple - puts an item to the store.
func (store *QueueStore[I]) PutMultiple(items []I) (Key, error) {

        doInsertOrUpdate(entity, null, null);
    }

    public void delete(CrawlingInfo entity) {
        doDelete(entity, null);
    }

    public void delete(CrawlingInfo entity, RequestOptionCall<DeleteRequestBuilder> opLambda) {
        entity.asDocMeta().deleteOption(opLambda);
        doDelete(entity, null);
    }

    public int queryDelete(CBCall<CrawlingInfoCB> cbLambda) {

        doInsertOrUpdate(entity, null, null);
    }

    public void delete(ElevateWordToLabel entity) {
        doDelete(entity, null);
    }

    public void delete(ElevateWordToLabel entity, RequestOptionCall<DeleteRequestBuilder> opLambda) {
        entity.asDocMeta().deleteOption(opLambda);
        doDelete(entity, null);
    }

    public int queryDelete(CBCall<ElevateWordToLabelCB> cbLambda) {