DeleteReplication:       DeleteReplication{Status: Enabled},
					Filter:                  Filter{},
				},
			},
		},
		{ // Config1 - Replication config has no filters, delete,delete-marker replication disabled
			Rules: []Rule{
				{
					Status:                  Enabled,
					Priority:                3,
					DeleteMarkerReplication: DeleteMarkerReplication{Status: Disabled},

            // Test full access combination
            int fullAccess = ACE.GENERIC_ALL | ACE.DELETE | ACE.READ_CONTROL | ACE.WRITE_DAC | ACE.WRITE_OWNER;
            assertTrue((fullAccess & ACE.GENERIC_ALL) != 0, "Full access should contain GENERIC_ALL");
            assertTrue((fullAccess & ACE.DELETE) != 0, "Full access should contain DELETE");

            // Test inheritance flags combination

		t.Fatalf("Failed to find address, got error %v, length: %v", err, len(addresses1))
	}

	if err := DB.Model(&person).Association("Addresses").Delete(&person.Addresses[0]); err != nil {
		t.Fatalf("Failed to delete address, got error %v", err)
	}

	if len(person.Addresses) != 1 {
		t.Fatalf("Should have one address left")
	}

	}
	return canonicalizeETag(left) == canonicalizeETag(right)
}

// setPutObjHeaders sets all the necessary headers returned back
// upon a success Put/Copy/CompleteMultipart/Delete requests
// to activate delete only headers set delete as true
func setPutObjHeaders(w http.ResponseWriter, objInfo ObjectInfo, del bool, h http.Header) {
	// We must not use the http.Header().Set method here because some (broken)

     * After deletion, updates the related content helper to refresh the cache.
     *
     * @param relatedContent the RelatedContent entity to delete
     */
    public void delete(final RelatedContent relatedContent) {

        relatedContentBhv.delete(relatedContent, op -> op.setRefreshPolicy(Constants.TRUE));
        ComponentUtil.getRelatedContentHelper().update();
    }

    /**

	}
	return nil, BucketRemoteTargetNotFound{Bucket: bucket}
}

// Delete clears targets present for a bucket
func (sys *BucketTargetSys) Delete(bucket string) {
	sys.Lock()
	defer sys.Unlock()
	tgts, ok := sys.targetsMap[bucket]
	if !ok {
		return
	}
	for _, t := range tgts {
		delete(sys.arnRemotesMap, t.Arn)
	}
	delete(sys.targetsMap, bucket)
}

 */
package org.codelibs.fess.app.web.admin.elevateword;

/**
 * The search form for Elevate Word.
 */
public class SearchForm {

    /**
     * Default constructor for SearchForm.
     */
    public SearchForm() {
    }

    /**
     * The ID field for searching elevate words.
     */
    public String id;

        // do nothing
    }

    @Override
    public void update(final User user) {
        ComponentUtil.getLdapManager().insert(user);
    }

    @Override
    public void delete(final User user) {
        ComponentUtil.getLdapManager().delete(user);
    }

    @Override
    public boolean changePassword(final String username, final String password) {

            dataService.store(accessResult);
        }

        // Verify count
        assertEquals(5, dataService.getCount(sessionId));

        dataService.delete(sessionId);

        // After delete, count should be 0
        assertEquals(0, dataService.getCount(sessionId));
    }

     * @param id the ID of the Kuromoji item to delete
     * @return JSON response indicating the deletion status
     */
    // DELETE /api/admin/dict/kuromoji/setting/{dictId}/{id}
    @Execute
    public JsonResponse<ApiResult> delete$setting(final String dictId, final long id) {
        kuromojiService.getKuromojiItem(dictId, id).ifPresent(entity -> {
            kuromojiService.delete(dictId, entity);