func (c *fcmClient) SendAllDryRun(ctx context.Context, messages []*Message) (*BatchResponse, error) {
	return c.sendBatch(ctx, messages, true)
}
SendAllDryRun sends the messages in the given array via Firebase Cloud Messaging in the
dry run (validation only) mode.

This function does not actually deliver any messages to target devices. Instead, it performs all
the SDK-level and backend validations on the messages, and emulates the send operation.

The messages array may contain up to 500 messages. SendAllDryRun employs batching to send the
entire array of mssages as a single RPC call. Compared to the `SendDryRun()` function, this
is a significantly more efficient way to validate sending multiple messages. The responses list
obtained from the return value corresponds to the order of the input messages. An error from
SendAllDryRun indicates a total failure -- i.e. none of the messages in the array could be sent
for validation. Partial failures are indicated by a `BatchResponse` return value.
package messaging
import (
	"bufio"
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"io/ioutil"
	"mime"
	"mime/multipart"
	"net/http"
	"net/textproto"
	"firebase.google.com/go/v4/internal"
)
const maxMessages = 500
const multipartBoundary = "__END_OF_PART__"
type MulticastMessage struct {
	Tokens       []string
	Data         map[string]string
	Notification *Notification
	Android      *AndroidConfig
	Webpush      *WebpushConfig
	APNS         *APNSConfig
}
func (mm *MulticastMessage) toMessages() ([]*Message, error) {
	if len(mm.Tokens) == 0 {
		return nil, errors.New("tokens must not be nil or empty")
	}
	if len(mm.Tokens) > maxMessages {
		return nil, fmt.Errorf("tokens must not contain more than %d elements", maxMessages)
	}
	var messages []*Message
	for _, token := range mm.Tokens {
		temp := &Message{
			Token:        token,
			Data:         mm.Data,
			Notification: mm.Notification,
			Android:      mm.Android,
			Webpush:      mm.Webpush,
			APNS:         mm.APNS,
		}
		messages = append(messages, temp)
	}
	return messages, nil
}
type SendResponse struct {
	Success   bool
	MessageID string
	Error     error
}
type BatchResponse struct {
	SuccessCount int
	FailureCount int
	Responses    []*SendResponse
}
func (c *fcmClient) SendAll(ctx context.Context, messages []*Message) (*BatchResponse, error) {
	return c.sendBatch(ctx, messages, false)
}