} else if got && !want {
				t.Errorf("%s->%s present but not expected", n1, n2)
			} else if want && !got {
				t.Errorf("%s->%s missing but expected", n1, n2)
			}
		}
	}
}

func TestParse(t *testing.T) {
	// Basic smoke test for graph parsing.
	g := mustParse(t, diamond)

	wantNodes := strings.Fields("a b c d")
	if !reflect.DeepEqual(wantNodes, g.Nodes) {

// See the License for the specific language governing permissions and
// limitations under the License.

package ast

import (
	"testing"

	. "github.com/onsi/gomega"
)

func TestParse(t *testing.T) {
	cases := []struct {
		input    string
		expected *Metadata
	}{
		{
			input:    ``,
			expected: &Metadata{},
		},
		{
			input: `
resources:
  - kind:         "VirtualService"

// Package amztime implements AWS specific time parsing and deviations
package amztime

import (
	"errors"
	"testing"
	"time"
)

func TestParse(t *testing.T) {
	type testCase struct {
		expectedErr  error
		expectedTime time.Time
		timeStr      string
	}
	testCases := []testCase{
		{
			ErrMalformedDate,
			time.Time{},

)

func TestIsHTTP(t *testing.T) {
	if protocol.UDP.IsHTTP() {
		t.Errorf("UDP is not HTTP protocol")
	}
	if !protocol.GRPC.IsHTTP() {
		t.Errorf("gRPC is HTTP protocol")
	}
}

func TestParse(t *testing.T) {
	testPairs := []struct {
		name string
		out  protocol.Instance
	}{
		{"tcp", protocol.TCP},
		{"http", protocol.HTTP},
		{"HTTP", protocol.HTTP},
		{"Http", protocol.HTTP},

			t.Errorf("%s=(%q): got\n\t%v\nexpected\n\t%v", test.name, test.input, result, test.result)
		}
	}
}

func TestParse(t *testing.T) {
	testParse(false, t)
}

// Same as TestParse, but we copy the node first
func TestParseCopy(t *testing.T) {
	testParse(true, t)
}

func TestParseWithComments(t *testing.T) {
	textFormat = "%q"
	defer func() { textFormat = "%s" }()

	} else if f.Args()[0] != extra {
		t.Errorf("expected argument %q got %q", extra, f.Args()[0])
	}
}

func TestParse(t *testing.T) {
	ResetForTesting(func() { t.Error("bad parse") })
	testParse(CommandLine, t)
}

func TestFlagSetParse(t *testing.T) {
	testParse(NewFlagSet("test", ContinueOnError), t)
}

// Declare a user-defined flag type.
type flagVar []string

	{"1.19rc1", "1.19.0", -1},
	{"1.19alpha3", "1.19beta2", -1},
	{"1.19beta2", "1.19rc1", -1},
	{"1.1", "1.99999999999999998", -1},
	{"1.99999999999999998", "1.99999999999999999", -1},
}

func TestParse(t *testing.T) { test1(t, parseTests, "Parse", Parse) }

var parseTests = []testCase1[string, Version]{
	{"1", Version{"1", "0", "0", "", ""}},
	{"1.2", Version{"1", "2", "0", "", ""}},

				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("NewIAMRoleARN() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestParse(t *testing.T) {
	type args struct {
		arnStr string
	}
	tests := []struct {
		name    string
		args    args
		wantArn ARN
		wantErr bool
	}{
		{
			name: "valid ARN must succeed",

        StandardCrawlerContainer container = new StandardCrawlerContainer().singleton("robotsTxtHelper", RobotsTxtHelper.class);
        robotsTxtHelper = container.getComponent("robotsTxtHelper");
    }

    public void testParse() {
        RobotsTxt robotsTxt;
        final InputStream in = RobotsTxtHelperTest.class.getResourceAsStream("robots.txt");
        try {
            robotsTxt = robotsTxtHelper.parse(in);
        } finally {

	{String: "90402c78d2dccddee1e9e86222ce2c6361675f3529d26000ae2e900ff216b3cb59e130e092d8a2981e776f4d0bd60941-1", ShouldFail: true}, // 11
}

func TestParse(t *testing.T) {
	for i, test := range parseTests {
		etag, err := Parse(test.String)
		if err == nil && test.ShouldFail {
			t.Fatalf("Test %d: parse should have failed but succeeded", i)
		}