if !key.Compress {
		t.Fatal("expected key.Compress=true; but got false")
	}
	if key.ItemCount != int(limit) {
		t.Fatalf("expected key.ItemCount=%d; but got %v", limit, key.ItemCount)
	}
	items, err := store.GetMultiple(key)
	if err != nil {
		t.Fatalf("unable to read key %v; %v", key.String(), err)
	}
	if len(items) != int(limit) {
		t.Fatalf("expected len(items)=%d; but got %v", limit, len(items))
	}
}

	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)
	}

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

	if !reflect.DeepEqual(resultItems, items) {
		t.Fatalf("expected item list: %v; but got %v", items, resultItems)
	}

		return item, os.ErrNotExist
	}

	if err = json.Unmarshal(eventData, &item); err != nil {
		return item, err
	}

	return item, nil
}

// GetMultiple will read the multi payload file and fetch the items
func (store *QueueStore[I]) GetMultiple(key Key) (items []I, err error) {
	store.RLock()

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

	Name() string
	SendFromStore(key Key) error
}

// 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
}

			if os.IsNotExist(err) {
				return nil
			}
			return err
		}
		err = target.send(event)
	case key.ItemCount > 1:
		var events []event.Event
		events, err = target.store.GetMultiple(key)
		if err != nil {
			if os.IsNotExist(err) {
				return nil
			}
			return err
		}
		err = target.sendMultiple(events)
	}
	if err != nil {
		if isKafkaConnErr(err) {