KeyFile: "../../client/testdata/mycertvalid.key",
			// TLS Configuration
			CAFile: "../../client/testdata/myCA.cer",
		},
	}

	rt, err := MakeTransport(config)
	if err != nil {
		t.Errorf("Not expecting an error %#v", err)
	}
	if rt == nil {
		t.Error("rt should not be nil")
	}
}

func TestMakeInsecureTransport(t *testing.T) {

		Body(yamlBody).
		DoRaw(context.TODO())
	if err == nil {
		t.Fatalf("Expecting to get conflicts when applying object, got no error: %s", result)
	}
	status, ok := err.(*errors.StatusError)
	if !ok {
		t.Fatalf("Expecting to get conflicts as API error")
	}
	if len(status.Status().Details.Causes) < 1 {
		t.Fatalf("Expecting to get at least one conflict when applying object, got: %v", status.Status().Details.Causes)
	}

	if c == 'r' {
		s.step = stateTr
		return scanContinue
	}
	return s.error(c, "in literal true (expecting 'r')")
}

// stateTr is the state after reading `tr`.
func stateTr(s *scanner, c byte) int {
	if c == 'u' {
		s.step = stateTru
		return scanContinue
	}
	return s.error(c, "in literal true (expecting 'u')")
}

// stateTru is the state after reading `tru`.
func stateTru(s *scanner, c byte) int {

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

func main() {
	i := 0
	for ; ; i++) { // ERROR "unexpected \), expecting { after for clause|expected .*{.*|expected .*;.*"
	}

	defer func() {
		if r := recover(); r != nil {
			return
		}
		t.Errorf("Expecting to panic when using bad scope name %s, but didn't", name)
	}()

	_ = RegisterScope(name, "A poorly named scope")
}

func TestBadWriter(t *testing.T) {
	o := testOptions()
	if err := Configure(o); err != nil {
		t.Errorf("Got err '%v', expecting success", err)
	}

	pt := funcs.Load().(patchTable)

				t.Fatalf("expected to match name printer for output format %q", tc.outputFormat)
			}

			if len(tc.expectedError) > 0 {
				if err == nil || !strings.Contains(err.Error(), tc.expectedError) {
					t.Errorf("expecting error %q, got %v", tc.expectedError, err)
				}
				return
			}
			if err != nil {
				t.Fatalf("unexpected error: %v", err)
			}

			out := bytes.NewBuffer([]byte{})

	vars := VarDescriptions()
	if vars[0].Name != "TESTXYZ1" {
		t.Errorf("Expecting TESTXYZ1, got %s", vars[0].Name)
	}
	if vars[0].Description != "A string" {
		t.Errorf("Expected 'A string', got '%s'", vars[0].Description)
	}

	if vars[1].Name != "TESTXYZ2" {
		t.Errorf("Expecting TESTXYZ2, got %s", vars[0].Name)
	}
	if vars[1].Description != "An int" {

	<-<-chan int // ERROR "unexpected <-, expected chan|expecting {" (new parser: same error as for type decl)

	type _ <-chan<-int // ERROR "unexpected int, expected chan|expected .*chan.*|expected chan|expected .*;.* or .*}.* or newline"
	<-chan<-int // ERROR "unexpected int, expected chan|expecting {" (new parser: same error as for type decl)

        withModuleMetadata(expectation)
        withoutModuleMetadata(expectation)
    }

    /**
     * Short-hand notation for expecting a list of files independently of the fact module metadata is used or not
     * @param fileNames
     */
    void expectFiles(String... fileNames) {
        always {
            expectFiles(fileNames as List<String>)

// Copyright 2009 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.

// Pipe adapter to connect code expecting an io.Reader
// with code expecting an io.Writer.

package io

import (
	"errors"
	"sync"
)

// onceError is an object that will only store an error once.
type onceError struct {
	sync.Mutex // guards following
	err        error
}