StringWriter sw = new StringWriter();
        properties.save(sw);
        String msg = sw.toString();
        assertTrue(sw.toString().endsWith(RESULT3), msg);
        List<String> rawValue = properties.getRaw(KEY1);
        assertEquals(2, (Object) rawValue.size());
        assertEquals(KEY1A + " = " + VALUE1, rawValue.get(0));
        assertEquals(VALUE1, rawValue.get(1));
    }

    @Test

	if err != nil {
		return Key{}, err
	}
	key := Key{
		Name:      uid.String(),
		Extension: store.fileExt,
	}
	return key, store.writeBytes(key, b)
}

// GetRaw - gets an item from the store.
func (store *QueueStore[I]) GetRaw(key Key) (raw []byte, err error) {
	store.RLock()

	defer func(store *QueueStore[I]) {
		store.RUnlock()
		if err != nil && !os.IsNotExist(err) {

}

// Store - Used to persist items.
type Store[I any] interface {
	Put(item I) (Key, error)
	PutMultiple(item []I) (Key, error)
	Get(key Key) (I, error)
	GetMultiple(key Key) ([]I, error)
	GetRaw(key Key) ([]byte, error)
	PutRaw(b []byte) (Key, error)
	Len() int
	List() []Key
	Del(key Key) error
	Open() error
	Delete() error
}

// Key denotes the key present in the store.
type Key struct {

	key := keys[0]
	if !key.Compress {
		t.Fatal("expected the item to be compressed")
	}
	if key.ItemCount != 10 {
		t.Fatalf("expected itemcount=10 but found %v", key.ItemCount)
	}

	raw, err := store.GetRaw(key)
	if err != nil {
		t.Fatalf("unable to get multiple items; %v", err)
	}

	if !bytes.Equal(buf.Bytes(), raw) {
		t.Fatalf("expected bytes: %d vs read bytes is wrong %d", len(buf.Bytes()), len(raw))
	}

        for (String key : properties.keySet()) {
            String v = this.get(key);
            List<String> comments = properties.getComments(key);
            List<String> value = properties.getRaw(key);
            if (v == null) {
                this.put(key, comments, value);
                modified = true;
            } else if (!v.equals(properties.get(key))) {
                if (comments.isEmpty()) {

        for (String key : properties.keySet()) {
            String v = this.get(key);
            List<String> comments = properties.getComments(key);
            List<String> value = properties.getRaw(key);
            if (v == null) {
                this.put(key, comments, value);
                modified = true;
            } else if (!v.equals(properties.get(key))) {
                if (comments.isEmpty()) {

	return h, nil
}

// SendFromStore - reads the log from store and sends it to webhook.
func (h *Target) SendFromStore(key store.Key) (err error) {
	var eventData []byte
	eventData, err = h.store.GetRaw(key)
	if err != nil {
		if os.IsNotExist(err) {
			return nil
		}
		return err
	}

	count := 1
	v := strings.Split(key.Name, ":")
	if len(v) == 2 {
		count, err = strconv.Atoi(v[0])

  public void testKeySetIteratorRemove() {
    int initialSize = getNumElements();
    Iterator<K> iterator = getMap().keySet().iterator();
    iterator.next();
    iterator.remove();
    assertEquals(initialSize - 1, getMap().size());
    assertEquals(initialSize - 1, getMap().inverse().size());
  }

    assertTrue(getMap().remove(k0(), v0()));
    expectMissing(e0());
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testRemove_supportedPresentKeyWrongValue() {
    assertFalse(getMap().remove(k0(), v3()));
    expectUnchanged();
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testRemove_supportedWrongKeyPresentValue() {
    assertFalse(getMap().remove(k3(), v0()));

    extends AbstractContainerTester<Map<K, V>, Entry<K, V>> {
  protected Map<K, V> getMap() {
    return container;
  }

  @Override
  protected Collection<Entry<K, V>> actualContents() {
    return getMap().entrySet();
  }

  /**
   * @see AbstractContainerTester#resetContainer()
   */
  protected final void resetMap() {
    resetContainer();
  }