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: table_dsl.go
    path of file: ./repos/podman/vendor/github.com/onsi/ginkgo/v2
    
    the code of the file until where you have to start completion: package ginkgo

import (
	"context"
	"fmt"
	"reflect"
	"strings"

	"github.com/onsi/ginkgo/v2/internal"
	"github.com/onsi/ginkgo/v2/types"
)

/*
The EntryDescription decorator allows you to pass a format string to DescribeTable() and Entry().  This format string is used to generate entry names via:

	fmt.Sprintf(formatString, parameters...)

where parameters are the parameters passed into the entry.

When passed into an Entry the EntryDescription is used to generate the name or that entry.  When passed to DescribeTable, the EntryDescription is used to generate the names for any entries that have `nil` descriptions.

You can learn more about generating EntryDescriptions here: https://onsi.github.io/ginkgo/#generating-entry-descriptions
*/
type EntryDescription string

func (ed EntryDescription) render(args ...interface{}) string {
	return fmt.Sprintf(string(ed), args...)
}

/*
DescribeTable describes a table-driven spec.

For example:

	DescribeTable("a simple table",
	    func(x int, y int, expected bool) {
	        Î©(x > y).Should(Equal(expected))
	    },
	    Entry("x > y", 1, 0, true),
	    Entry("x == y", 0, 0, false),
	    Entry("x < y", 0, 1, false),
	)

You can learn more about DescribeTable here: https://onsi.github.io/ginkgo/#table-specs
And can explore some Table patterns here: https://onsi.github.io/ginkgo/#table-specs-patterns
*/
func DescribeTable(description string, args ...interface{}) bool {
	GinkgoHelper()
	generateTable(description, false, args...)
	return true
}

/*
You can focus a table with `FDescribeTable`.  This is equivalent to `FDescribe`.
*/
func FDescribeTable(description string, args ...interface{}) bool {
	GinkgoHelper()
	args = append(args, internal.Focus)
	generateTable(description, false, args...)
	return true
}

/*
You can mark a table as pending with `PDescribeTable`.  This is equivalent to `PDescribe`.
*/
func PDescribeTable(description string, args ...interface{}) bool {
	GinkgoHelper()
	args = append(args, internal.Pending)
	generateTable(description, false, args...)
	return true
}

/*
You can mark a table as pending with `XDescribeTable`.  This is equivalent to `XDescribe`.
*/
var XDescribeTable = PDescribeTable

/*
DescribeTableSubtree describes a table-driven spec that generates a set of tests for each entry.

For example:

	DescribeTableSubtree("a subtree table",
	    func(url string, code int, message string) {
			var resp *http.Response
			BeforeEach(func() {
				var err error
				resp, err = http.Get(url)
				Expect(err).NotTo(HaveOccurred())
				DeferCleanup(resp.Body.Close)
			})

			It("should return the expected status code", func() {
				Expect(resp.StatusCode).To(Equal(code))
			})

			It("should return the expected message", func() {
				body, err := ioutil.ReadAll(resp.Body)
				Expect(err).NotTo(HaveOccurred())
				Expect(string(body)).To(Equal(message))
			})
	    },
	    Entry("default response", "example.com/response", http.StatusOK, "hello world"),
	    Entry("missing response", "example.com/missing", http.StatusNotFound, "wat?"),
	)

Note that you **must** place define an It inside the body function.

You can learn more about DescribeTableSubtree here:
    
func generateTable(description string, isSubtree bool, args ...interface{}) {
	GinkgoHelper()
	cl := types.NewCodeLocation(0)
	containerNodeArgs := []interface{}{cl}

	entries := []TableEntry{}
	var internalBody interface{}
	var internalBodyType reflect.Type

	var tableLevelEntryDescription interface{}
	tableLevelEntryDescription = func(args ...interface{}) string {
		out := []string{}
		for _, arg := range args {
			out = append(out, fmt.Sprint(arg))
		}
		return "Entry: " + strings.Join(out, ", ")
	}

	if len(args) == 1 {
		exitIfErr(types.GinkgoErrors.MissingParametersForTableFunction(cl))
	}

	for i, arg := range args {
		switch t := reflect.TypeOf(arg); {
		case t == nil:
			exitIfErr(types.GinkgoErrors.IncorrectParameterTypeForTable(i, "nil", cl))
		case t == reflect.TypeOf(TableEntry{}):
			entries = append(entries, arg.(TableEntry))
		case t == reflect.TypeOf([]TableEntry{}):
			entries = append(entries, arg.([]TableEntry)...)
		case t == reflect.TypeOf(EntryDescription("")):
			tableLevelEntryDescription = arg.(EntryDescription).render
		case t.Kind() == reflect.Func && t.NumOut() == 1 && t.Out(0) == reflect.TypeOf(""):
			tableLevelEntryDescription = arg
		case t.Kind() == reflect.Func:
			if internalBody != nil {
				exitIfErr(types.GinkgoErrors.MultipleEntryBodyFunctionsForTable(cl))
			}
			internalBody = arg
			internalBodyType = reflect.TypeOf(internalBody)
		default:
			containerNodeArgs = append(containerNodeArgs, arg)
		}
	}

	containerNodeArgs = append(containerNodeArgs, func() {
		for _, entry := range entries {
			var err error
			entry := entry
			var description string
			switch t := reflect.TypeOf(entry.description); {
			case t == nil:
				err = validateParameters(tableLevelEntryDescription, entry.parameters, "Entry Description function", entry.codeLocation, false)
				if err == nil {
					description = invokeFunction(tableLevelEntryDescription, entry.parameters)[0].String()
				}
			case t == reflect.TypeOf(EntryDescription("")):
				description = entry.description.(EntryDescription).render(entry.parameters...)
			case t == reflect.TypeOf(""):
				description = entry.description.(string)
			case t.Kind() == reflect.Func && t.NumOut() == 1 && t.Out(0) == reflect.TypeOf(""):
				err = validateParameters(entry.description, entry.parameters, "Entry Description function", entry.codeLocation, false)
				if err == nil {
					description = invokeFunction(entry.description, entry.parameters)[0].String()
				}
			default:
				err = types.GinkgoErrors.InvalidEntryDescription(entry.codeLocation)
			}

			internalNodeArgs := []interface{}{entry.codeLocation}
			internalNodeArgs = append(internalNodeArgs, entry.decorations...)

			hasContext := false
			if internalBodyType.NumIn() > 0. {
				if internalBodyType.In(0).Implements(specContextType) {
					hasContext = true
				} else if internalBodyType.In(0).Implements(contextType) && (len(entry.parameters) == 0 || !reflect.TypeOf(entry.parameters[0]).Implements(contextType)) {
					hasContext = true
				}
			}

			if err == nil {
				err = validateParameters(internalBody, entry.parameters, "Table Body function", entry.codeLocation, hasContext)
			}

			if hasContext {
				internalNodeArgs = append(internalNodeArgs, func(c SpecContext) {
					if err != nil {
						panic(err)
					}
					invokeFunction(internalBody, append([]interface{}{c}, entry.parameters...))
				})
				if isSubtree {
					exitIfErr(types.GinkgoErrors.ContextsCannotBeUsedInSubtreeTables(cl))
				}
			} else {
				internalNodeArgs = append(internalNodeArgs, func() {
					if err != nil {
						panic(err)
					}
					invokeFunction(internalBody, entry.parameters)
				})
			}

			internalNodeType := types.NodeTypeIt
			if isSubtree {
				internalNodeType = types.NodeTypeContainer
			}

			pushNode(internal.NewNode(deprecationTracker, internalNodeType, description, internalNodeArgs...))
		}
	})

	pushNode(internal.NewNode(deprecationTracker, types.NodeTypeContainer, description, containerNodeArgs...))
}