You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: helpers.go
    path of file: ./repos/flipt/build/testing
    
    the code of the file until where you have to start completion: package testing

import (
	"context"
	"errors"
	"fmt"
	"regexp"
	"strings"

	"dagger.io/dagger"
	"github.com/google/go-cmp/cmp"
)

func flipt(args ...string) []string {
	return append([]string{"/flipt"}, args
    
func assertExec(ctx context.Context, flipt *dagger.Container, args []string, opts ...assertOption) (*dagger.Container, error) {
	conf := assertConf{success: true}
	for _, opt := range opts {
		opt(&conf)
	}

	container, err := flipt.WithExec(args).Sync(ctx)

	var (
		execStdout = container.Stdout
		execStderr = container.Stderr
	)

	if err != nil {
		if conf.success {
			return nil, fmt.Errorf("unexpected error running flipt %q: %w", args, err)
		}

		var eerr *dagger.ExecError
		// get stdout and stderr from exec error instead
		if errors.As(err, &eerr) {
			execStdout = func(context.Context) (string, error) {
				return eerr.Stdout, nil
			}

			execStderr = func(context.Context) (string, error) {
				return eerr.Stderr, nil
			}
		}
	}

	if err == nil && !conf.success {
		return nil, fmt.Errorf("expected error running flipt %q: found success", args)
	}

	for _, a := range conf.stdout {
		stdout, err := execStdout(ctx)
		if err != nil {
			return nil, err
		}

		if err := a.assert(string(stdout)); err != nil {
			return nil, err
		}
	}

	for _, a := range conf.stderr {
		stderr, err := execStderr(ctx)
		if err != nil {
			return nil, err
		}

		if err := a.assert(string(stderr)); err != nil {
			return nil, err
		}
	}

	return container, nil
}