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: coverage_test.go
    path of file: ./repos/go-starter-kit/vendor/golang.org/x/text/language
    
    the code of the file until where you have to start completion: // Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package language

import (
	"fmt"
	"reflect"
	"testing"
)

func TestSupported(t *testing.T) {
	// To prove the results are correct for a type, we test that the number of
	// results is identical to the number of 
    
func TestNewCoverage(t *testing.T) {
	bases := []Base{Base{0}, Base{3}, Base{7}}
	scripts := []Script{Script{11}, Script{17}, Script{23}}
	regions := []Region{Region{101}, Region{103}, Region{107}}
	tags := []Tag{Make("pt"), Make("en"), Make("en-GB"), Make("en-US"), Make("pt-PT")}
	fbases := func() []Base { return bases }
	fscripts := func() []Script { return scripts }
	fregions := func() []Region { return regions }
	ftags := func() []Tag { return tags }

	tests := []struct {
		desc    string
		list    []interface{}
		bases   []Base
		scripts []Script
		regions []Region
		tags    []Tag
	}{
		{
			desc: "empty",
		},
		{
			desc:  "bases",
			list:  []interface{}{bases},
			bases: bases,
		},
		{
			desc:    "scripts",
			list:    []interface{}{scripts},
			scripts: scripts,
		},
		{
			desc:    "regions",
			list:    []interface{}{regions},
			regions: regions,
		},
		{
			desc:  "bases derives from tags",
			list:  []interface{}{tags},
			bases: []Base{Base{_en}, Base{_pt}},
			tags:  tags,
		},
		{
			desc:  "tags and bases",
			list:  []interface{}{tags, bases},
			bases: bases,
			tags:  tags,
		},
		{
			desc:    "fully specified",
			list:    []interface{}{tags, bases, scripts, regions},
			bases:   bases,
			scripts: scripts,
			regions: regions,
			tags:    tags,
		},
		{
			desc:  "bases func",
			list:  []interface{}{fbases},
			bases: bases,
		},
		{
			desc:    "scripts func",
			list:    []interface{}{fscripts},
			scripts: scripts,
		},
		{
			desc:    "regions func",
			list:    []interface{}{fregions},
			regions: regions,
		},
		{
			desc:  "tags func",
			list:  []interface{}{ftags},
			bases: []Base{Base{_en}, Base{_pt}},
			tags:  tags,
		},
		{
			desc:  "tags and bases",
			list:  []interface{}{ftags, fbases},
			bases: bases,
			tags:  tags,
		},
		{
			desc:    "fully specified",
			list:    []interface{}{ftags, fbases, fscripts, fregions},
			bases:   bases,
			scripts: scripts,
			regions: regions,
			tags:    tags,
		},
	}

	for i, tt := range tests {
		l := NewCoverage(tt.list...)
		if a := l.BaseLanguages(); !reflect.DeepEqual(a, tt.bases) {
			t.Errorf("%d:%s: BaseLanguages was %v; want %v", i, tt.desc, a, tt.bases)
		}
		if a := l.Scripts(); !reflect.DeepEqual(a, tt.scripts) {
			t.Errorf("%d:%s: Scripts was %v; want %v", i, tt.desc, a, tt.scripts)
		}
		if a := l.Regions(); !reflect.DeepEqual(a, tt.regions) {
			t.Errorf("%d:%s: Regions was %v; want %v", i, tt.desc, a, tt.regions)
		}
		if a := l.Tags(); !reflect.DeepEqual(a, tt.tags) {
			t.Errorf("%d:%s: Tags was %v; want %v", i, tt.desc, a, tt.tags)
		}
	}
}