Update dependencies to v0.19.0-rc.1 tag

Godeps/Godeps.json

@@ -128,7 +128,7 @@
 		},
 		{
 			"ImportPath": "github.com/evanphx/json-patch",
-			"Rev": "v4.9.0"
+			"Rev": "e83c0a1c26c8"
 		},
 		{
 			"ImportPath": "github.com/fsnotify/fsnotify",
@@ -336,7 +336,7 @@
 		},
 		{
 			"ImportPath": "golang.org/x/crypto",
-			"Rev": "75b288015ac9"
+			"Rev": "bac4c82f6975"
 		},
 		{
 			"ImportPath": "golang.org/x/exp",
@@ -360,7 +360,7 @@
 		},
 		{
 			"ImportPath": "golang.org/x/net",
-			"Rev": "ab3426394381"
+			"Rev": "d3edc9973b7e"
 		},
 		{
 			"ImportPath": "golang.org/x/oauth2",
@@ -440,11 +440,11 @@
 		},
 		{
 			"ImportPath": "k8s.io/api",
-			"Rev": "v0.19.5-rc.0"
+			"Rev": "v0.19.0-rc.1"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery",
-			"Rev": "v0.19.5-rc.0"
+			"Rev": "v0.19.0-rc.1"
 		},
 		{
 			"ImportPath": "k8s.io/gengo",
@@ -456,19 +456,19 @@
 		},
 		{
 			"ImportPath": "k8s.io/kube-openapi",
-			"Rev": "6aeccd4b50c6"
+			"Rev": "656914f816f9"
 		},
 		{
 			"ImportPath": "k8s.io/utils",
-			"Rev": "d5654de09c73"
+			"Rev": "6e3d28b6ed19"
 		},
 		{
 			"ImportPath": "rsc.io/binaryregexp",
 			"Rev": "v0.2.0"
 		},
 		{
-			"ImportPath": "sigs.k8s.io/structured-merge-diff/v4",
-			"Rev": "v4.0.1"
+			"ImportPath": "sigs.k8s.io/structured-merge-diff/v3",
+			"Rev": "43c19bbb7fba"
 		},
 		{
 			"ImportPath": "sigs.k8s.io/yaml",

discovery/cached/memory/memcache.go

@@ -19,6 +19,8 @@ package memory
 import (
 	"errors"
 	"fmt"
+	"net"
+	"net/url"
 	"sync"
 	"syscall"
 
@@ -62,11 +64,19 @@ var _ discovery.CachedDiscoveryInterface = &memCacheClient{}
 // "Connection reset" error which usually means that apiserver is temporarily
 // unavailable.
 func isTransientConnectionError(err error) bool {
-	var errno syscall.Errno
-	if errors.As(err, &errno) {
-		return errno == syscall.ECONNREFUSED || errno == syscall.ECONNRESET
+	urlError, ok := err.(*url.Error)
+	if !ok {
+		return false
 	}
-	return false
+	opError, ok := urlError.Err.(*net.OpError)
+	if !ok {
+		return false
+	}
+	errno, ok := opError.Err.(syscall.Errno)
+	if !ok {
+		return false
+	}
+	return errno == syscall.ECONNREFUSED || errno == syscall.ECONNRESET
 }
 
 func isTransientError(err error) bool {

go.mod

@@ -2,14 +2,14 @@
 
 module k8s.io/client-go
 
-go 1.15
+go 1.13
 
 require (
 	cloud.google.com/go v0.51.0 // indirect
 	github.com/Azure/go-autorest/autorest v0.9.6
 	github.com/Azure/go-autorest/autorest/adal v0.8.2
 	github.com/davecgh/go-spew v1.1.1
-	github.com/evanphx/json-patch v4.9.0+incompatible
+	github.com/evanphx/json-patch v0.0.0-20190815234213-e83c0a1c26c8
 	github.com/gogo/protobuf v1.3.1
 	github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7
 	github.com/golang/protobuf v1.4.2
@@ -22,18 +22,18 @@ require (
 	github.com/peterbourgon/diskv v2.0.1+incompatible
 	github.com/spf13/pflag v1.0.5
 	github.com/stretchr/testify v1.4.0
-	golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9
-	golang.org/x/net v0.0.0-20200707034311-ab3426394381
+	golang.org/x/crypto v0.0.0-20200220183623-bac4c82f6975
+	golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e
 	golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6
 	golang.org/x/time v0.0.0-20191024005414-555d28b269f0
-	k8s.io/api v0.19.5-rc.0
-	k8s.io/apimachinery v0.19.5-rc.0
+	k8s.io/api v0.19.0-rc.1
+	k8s.io/apimachinery v0.19.0-rc.1
 	k8s.io/klog/v2 v2.2.0
-	k8s.io/utils v0.0.0-20200729134348-d5654de09c73
+	k8s.io/utils v0.0.0-20200619165400-6e3d28b6ed19
 	sigs.k8s.io/yaml v1.2.0
 )
 
 replace (
-	k8s.io/api => k8s.io/api v0.19.5-rc.0
-	k8s.io/apimachinery => k8s.io/apimachinery v0.19.5-rc.0
+	k8s.io/api => k8s.io/api v0.19.0-rc.1
+	k8s.io/apimachinery => k8s.io/apimachinery v0.19.0-rc.1
 )

go.sum

@@ -56,8 +56,8 @@ github.com/elazarl/goproxy v0.0.0-20180725130230-947c36da3153/go.mod h1:/Zj4wYkg
 github.com/emicklei/go-restful v0.0.0-20170410110728-ff4f55a20633/go.mod h1:otzb+WCGbkyDHkqmQmT5YD2WR4BBwUdeQoFo8l/7tVs=
 github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
-github.com/evanphx/json-patch v4.9.0+incompatible h1:kLcOMZeuLAJvL2BPWLMIj5oaZQobrkAqrL+WFZwQses=
-github.com/evanphx/json-patch v4.9.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk=
+github.com/evanphx/json-patch v0.0.0-20190815234213-e83c0a1c26c8 h1:DM7gHzQfHwIj+St8zaPOI6iQEPAxOwIkskvw6s9rDaM=
+github.com/evanphx/json-patch v0.0.0-20190815234213-e83c0a1c26c8/go.mod h1:pmLOTb3x90VhIKxsA9yeQG5yfOkkKnkk1h+Ql8NDYDw=
 github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
@@ -157,6 +157,7 @@ github.com/onsi/gomega v1.7.0 h1:XPnZz8VVBHjVsy1vzJmRwIcSwiUO+JFfrv/xGiigmME=
 github.com/onsi/gomega v1.7.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
 github.com/peterbourgon/diskv v2.0.1+incompatible h1:UBdAOUP5p4RWqPBg048CAvpKN+vxiaj6gdUUzhl4XmI=
 github.com/peterbourgon/diskv v2.0.1+incompatible/go.mod h1:uqqh8zWWbv1HBMNONnaR/tNboyR3/BZd58JJSHlUSCU=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
@@ -179,8 +180,8 @@ golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8U
 golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20191206172530-e9b2fee46413/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9 h1:psW17arqaxU48Z5kZ0CQnkZWQJsqcURM6tKiBApRjXI=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200220183623-bac4c82f6975 h1:/Tl7pH94bvbAAHBdZJT947M/+gp0+CqQXDtMRC0fseo=
+golang.org/x/crypto v0.0.0-20200220183623-bac4c82f6975/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
@@ -214,8 +215,6 @@ golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLL
 golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k=
 golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU=
-golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
@@ -333,19 +332,20 @@ honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWh
 honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
-k8s.io/api v0.19.5-rc.0/go.mod h1:LXjwJ6bXO1A/5qwIyTuxOUXlomNguRwk9sQhuZhQWJw=
-k8s.io/apimachinery v0.19.5-rc.0/go.mod h1:DnPGDnARWFvYa3pMHgSxtbZb7gpzzAZ1pTfaUNDVlmA=
+k8s.io/api v0.19.0-rc.1/go.mod h1:NdiA9gl+9BuvhHU0WfqE5A7SrA4iO5TrmRE0caDteuA=
+k8s.io/apimachinery v0.19.0-rc.1/go.mod h1:eHbWZVMaaewmYBAUuRYnAmTTMtDhvpPNZuh8/6Yl7v0=
 k8s.io/gengo v0.0.0-20200413195148-3a45101e95ac/go.mod h1:ezvh/TsK7cY6rbqRK0oQQ8IAqLxYwwyPxAX1Pzy0ii0=
 k8s.io/klog/v2 v2.0.0/go.mod h1:PBfzABfn139FHAV07az/IF9Wp1bkk3vpT2XSJ76fSDE=
 k8s.io/klog/v2 v2.2.0 h1:XRvcwJozkgZ1UQJmfMGpvRthQHOvihEhYtDfAaxMz/A=
 k8s.io/klog/v2 v2.2.0/go.mod h1:Od+F08eJP+W3HUb4pSrPpgp9DGU4GzlpG/TmITuYh/Y=
-k8s.io/kube-openapi v0.0.0-20200805222855-6aeccd4b50c6 h1:+WnxoVtG8TMiudHBSEtrVL1egv36TkkJm+bA8AxicmQ=
-k8s.io/kube-openapi v0.0.0-20200805222855-6aeccd4b50c6/go.mod h1:UuqjUnNftUyPE5H64/qeyjQoUZhGpeFDVdxjTeEVN2o=
-k8s.io/utils v0.0.0-20200729134348-d5654de09c73 h1:uJmqzgNWG7XyClnU/mLPBWwfKKF1K8Hf8whTseBgJcg=
-k8s.io/utils v0.0.0-20200729134348-d5654de09c73/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA=
+k8s.io/kube-openapi v0.0.0-20200427153329-656914f816f9 h1:5NC2ITmvg8RoxoH0wgmL4zn4VZqXGsKbxrikjaQx6s4=
+k8s.io/kube-openapi v0.0.0-20200427153329-656914f816f9/go.mod h1:bfCVj+qXcEaE5SCvzBaqpOySr6tuCcpPKqF6HD8nyCw=
+k8s.io/utils v0.0.0-20200619165400-6e3d28b6ed19 h1:7Nu2dTj82c6IaWvL7hImJzcXoTPz1MsSCH7r+0m6rfo=
+k8s.io/utils v0.0.0-20200619165400-6e3d28b6ed19/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA=
 rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
-sigs.k8s.io/structured-merge-diff/v4 v4.0.1 h1:YXTMot5Qz/X1iBRJhAt+vI+HVttY0WkSqqhKxQ0xVbA=
-sigs.k8s.io/structured-merge-diff/v4 v4.0.1/go.mod h1:bJZC9H9iH24zzfZ/41RGcq60oK1F7G282QMXDPYydCw=
+sigs.k8s.io/structured-merge-diff/v3 v3.0.0-20200116222232-67a7b8c61874/go.mod h1:PlARxl6Hbt/+BC80dRLi1qAmnMqwqDg62YvvVkZjemw=
+sigs.k8s.io/structured-merge-diff/v3 v3.0.1-0.20200706213357-43c19bbb7fba h1:AAbnc5KQuTWKuh2QSnyghKIOTFzB0Jayv7/OFDn3Cy4=
+sigs.k8s.io/structured-merge-diff/v3 v3.0.1-0.20200706213357-43c19bbb7fba/go.mod h1:V06abazjHneE37ZdSY/UUwPVgcJMKI/jU5XGUjgIKoc=
 sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o=
 sigs.k8s.io/yaml v1.2.0 h1:kr/MCeFWJWTwyaHoR9c8EjH9OumOmoF9YGiZd7lFm/Q=
 sigs.k8s.io/yaml v1.2.0/go.mod h1:yfXDCHCao9+ENCvLSE62v9VSji2MKu5jeNfTrofGhJc=

plugin/pkg/client/auth/azure/azure_test.go

@@ -185,7 +185,7 @@ func TestAzureTokenSource(t *testing.T) {
 				expiresOn    = "foo"
 			)
 			cfg := map[string]string{
-				cfgConfigMode:   strconv.Itoa(int(configMode)),
+				cfgConfigMode:   string(configMode),
 				cfgApiserverID:  serverID,
 				cfgClientID:     clientID,
 				cfgTenantID:     tenantID,
@@ -365,7 +365,7 @@ func TestAzureTokenSourceScenarios(t *testing.T) {
 				persister := newFakePersister()
 
 				cfg := map[string]string{
-					cfgConfigMode: strconv.Itoa(int(configMode)),
+					cfgConfigMode: string(configMode),
 				}
 				if tc.configToken != nil {
 					cfg = token2Cfg(tc.configToken)

tools/cache/controller.go

@@ -144,11 +144,11 @@ func (c *controller) Run(stopCh <-chan struct{}) {
 	c.reflectorMutex.Unlock()
 
 	var wg wait.Group
+	defer wg.Wait()
 
 	wg.StartWithChannel(stopCh, r.Run)
 
 	wait.Until(c.processLoop, time.Second, stopCh)
-	wg.Wait()
 }
 
 // Returns true once this controller has completed an initial resource listing

tools/cache/controller_test.go

@@ -402,49 +402,3 @@ func TestUpdate(t *testing.T) {
 	testDoneWG.Wait()
 	close(stop)
 }
-
-func TestPanicPropagated(t *testing.T) {
-	// source simulates an apiserver object endpoint.
-	source := fcache.NewFakeControllerSource()
-
-	// Make a controller that just panic if the AddFunc is called.
-	_, controller := NewInformer(
-		source,
-		&v1.Pod{},
-		time.Millisecond*100,
-		ResourceEventHandlerFuncs{
-			AddFunc: func(obj interface{}) {
-				// Create a panic.
-				panic("Just panic.")
-			},
-		},
-	)
-
-	// Run the controller and run it until we close stop.
-	stop := make(chan struct{})
-	defer close(stop)
-
-	propagated := make(chan interface{})
-	go func() {
-		defer func() {
-			if r := recover(); r != nil {
-				propagated <- r
-			}
-		}()
-		controller.Run(stop)
-	}()
-	// Let's add a object to the source. It will trigger a panic.
-	source.Add(&v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "test"}})
-
-	// Check if the panic propagated up.
-	select {
-	case p := <-propagated:
-		if p == "Just panic." {
-			t.Logf("Test Passed")
-		} else {
-			t.Errorf("unrecognized panic in controller run: %v", p)
-		}
-	case <-time.After(wait.ForeverTestTimeout):
-		t.Errorf("timeout: the panic failed to propagate from the controller run method!")
-	}
-}

tools/cache/reflector.go

@@ -570,26 +570,5 @@ func isExpiredError(err error) bool {
 }
 
 func isTooLargeResourceVersionError(err error) bool {
-	if apierrors.HasStatusCause(err, metav1.CauseTypeResourceVersionTooLarge) {
-		return true
-	}
-	// In Kubernetes 1.17.0-1.18.5, the api server doesn't set the error status cause to
-	// metav1.CauseTypeResourceVersionTooLarge to indicate that the requested minimum resource
-	// version is larger than the largest currently available resource version. To ensure backward
-	// compatibility with these server versions we also need to detect the error based on the content
-	// of the error message field.
-	if !apierrors.IsTimeout(err) {
-		return false
-	}
-	apierr, ok := err.(apierrors.APIStatus)
-	if !ok || apierr == nil || apierr.Status().Details == nil {
-		return false
-	}
-	for _, cause := range apierr.Status().Details.Causes {
-		// Matches the message returned by api server 1.17.0-1.18.5 for this error condition
-		if cause.Message == "Too large resource version" {
-			return true
-		}
-	}
-	return false
+	return apierrors.HasStatusCause(err, metav1.CauseTypeResourceVersionTooLarge)
 }

tools/cache/reflector_test.go

@@ -738,14 +738,9 @@ func TestReflectorFullListIfTooLarge(t *testing.T) {
 				err := apierrors.NewTimeoutError("too large resource version", 1)
 				err.ErrStatus.Details.Causes = []metav1.StatusCause{{Type: metav1.CauseTypeResourceVersionTooLarge}}
 				return nil, err
-			// relist after the initial list (covers the error format used in api server 1.17.0-1.18.5)
-			case "30":
-				err := apierrors.NewTimeoutError("too large resource version", 1)
-				err.ErrStatus.Details.Causes = []metav1.StatusCause{{Message: "Too large resource version"}}
-				return nil, err
 			// relist from etcd after "too large" error
 			case "":
-				return &v1.PodList{ListMeta: metav1.ListMeta{ResourceVersion: "30"}}, nil
+				return &v1.PodList{ListMeta: metav1.ListMeta{ResourceVersion: "10"}}, nil
 			default:
 				return nil, fmt.Errorf("unexpected List call: %s", options.ResourceVersion)
 			}
@@ -764,15 +759,12 @@ func TestReflectorFullListIfTooLarge(t *testing.T) {
 	// may be synced to a different version and they will never converge.
 	// TODO: We should use etcd progress-notify feature to avoid this behavior but until this is
 	// done we simply try to relist from now to avoid continuous errors on relists.
-	for i := 1; i <= 2; i++ {
-		// relist twice to cover the two variants of TooLargeResourceVersion api errors
-		stopCh = make(chan struct{})
-		if err := r.ListAndWatch(stopCh); err != nil {
-			t.Fatal(err)
-		}
+	stopCh = make(chan struct{})
+	if err := r.ListAndWatch(stopCh); err != nil {
+		t.Fatal(err)
 	}
 
-	expectedRVs := []string{"0", "20", "", "30", ""}
+	expectedRVs := []string{"0", "20", ""}
 	if !reflect.DeepEqual(listCallRVs, expectedRVs) {
 		t.Errorf("Expected series of list calls with resource version of %#v but got: %#v", expectedRVs, listCallRVs)
 	}

tools/leaderelection/leaderelection.go

@@ -290,12 +290,8 @@ func (le *LeaderElector) release() bool {
 	if !le.IsLeader() {
 		return true
 	}
-	now := metav1.Now()
 	leaderElectionRecord := rl.LeaderElectionRecord{
-		LeaderTransitions:    le.observedRecord.LeaderTransitions,
-		LeaseDurationSeconds: 1,
-		RenewTime:            now,
-		AcquireTime:          now,
+		LeaderTransitions: le.observedRecord.LeaderTransitions,
 	}
 	if err := le.config.Lock.Update(context.TODO(), leaderElectionRecord); err != nil {
 		klog.Errorf("Failed to release lock: %v", err)

tools/leaderelection/leaderelection_test.go

@@ -917,284 +917,3 @@ func TestTryAcquireOrRenewEndpointsLeases(t *testing.T) {
 func TestTryAcquireOrRenewConfigMapsLeases(t *testing.T) {
 	testTryAcquireOrRenewMultiLock(t, "configmapsleases")
 }
-
-func testReleaseLease(t *testing.T, objectType string) {
-	tests := []struct {
-		name           string
-		observedRecord rl.LeaderElectionRecord
-		observedTime   time.Time
-		reactors       []Reactor
-
-		expectSuccess    bool
-		transitionLeader bool
-		outHolder        string
-	}{
-		{
-			name: "release acquired lock from no object",
-			reactors: []Reactor{
-				{
-					verb:       "get",
-					objectType: objectType,
-					reaction: func(action fakeclient.Action) (handled bool, ret runtime.Object, err error) {
-						return true, nil, errors.NewNotFound(action.(fakeclient.GetAction).GetResource().GroupResource(), action.(fakeclient.GetAction).GetName())
-					},
-				},
-				{
-					verb:       "create",
-					objectType: objectType,
-					reaction: func(action fakeclient.Action) (handled bool, ret runtime.Object, err error) {
-						return true, action.(fakeclient.CreateAction).GetObject(), nil
-					},
-				},
-				{
-					verb:       "update",
-					objectType: objectType,
-					reaction: func(action fakeclient.Action) (handled bool, ret runtime.Object, err error) {
-						return true, action.(fakeclient.UpdateAction).GetObject(), nil
-					},
-				},
-			},
-			expectSuccess: true,
-			outHolder:     "",
-		},
-	}
-
-	for i := range tests {
-		test := &tests[i]
-		t.Run(test.name, func(t *testing.T) {
-			// OnNewLeader is called async so we have to wait for it.
-			var wg sync.WaitGroup
-			wg.Add(1)
-			var reportedLeader string
-			var lock rl.Interface
-
-			objectMeta := metav1.ObjectMeta{Namespace: "foo", Name: "bar"}
-			resourceLockConfig := rl.ResourceLockConfig{
-				Identity:      "baz",
-				EventRecorder: &record.FakeRecorder{},
-			}
-			c := &fake.Clientset{}
-			for _, reactor := range test.reactors {
-				c.AddReactor(reactor.verb, objectType, reactor.reaction)
-			}
-			c.AddReactor("*", "*", func(action fakeclient.Action) (bool, runtime.Object, error) {
-				t.Errorf("unreachable action. testclient called too many times: %+v", action)
-				return true, nil, fmt.Errorf("unreachable action")
-			})
-
-			switch objectType {
-			case "endpoints":
-				lock = &rl.EndpointsLock{
-					EndpointsMeta: objectMeta,
-					LockConfig:    resourceLockConfig,
-					Client:        c.CoreV1(),
-				}
-			case "configmaps":
-				lock = &rl.ConfigMapLock{
-					ConfigMapMeta: objectMeta,
-					LockConfig:    resourceLockConfig,
-					Client:        c.CoreV1(),
-				}
-			case "leases":
-				lock = &rl.LeaseLock{
-					LeaseMeta:  objectMeta,
-					LockConfig: resourceLockConfig,
-					Client:     c.CoordinationV1(),
-				}
-			}
-
-			lec := LeaderElectionConfig{
-				Lock:          lock,
-				LeaseDuration: 10 * time.Second,
-				Callbacks: LeaderCallbacks{
-					OnNewLeader: func(l string) {
-						defer wg.Done()
-						reportedLeader = l
-					},
-				},
-			}
-			observedRawRecord := GetRawRecordOrDie(t, objectType, test.observedRecord)
-			le := &LeaderElector{
-				config:            lec,
-				observedRecord:    test.observedRecord,
-				observedRawRecord: observedRawRecord,
-				observedTime:      test.observedTime,
-				clock:             clock.RealClock{},
-			}
-			if !le.tryAcquireOrRenew(context.Background()) {
-				t.Errorf("unexpected result of tryAcquireOrRenew: [succeeded=%v]", true)
-			}
-
-			le.maybeReportTransition()
-
-			// Wait for a response to the leader transition, and add 1 so that we can track the final transition.
-			wg.Wait()
-			wg.Add(1)
-
-			if test.expectSuccess != le.release() {
-				t.Errorf("unexpected result of release: [succeeded=%v]", !test.expectSuccess)
-			}
-
-			le.observedRecord.AcquireTime = metav1.Time{}
-			le.observedRecord.RenewTime = metav1.Time{}
-			if le.observedRecord.HolderIdentity != test.outHolder {
-				t.Errorf("expected holder:\n\t%+v\ngot:\n\t%+v", test.outHolder, le.observedRecord.HolderIdentity)
-			}
-			if len(test.reactors) != len(c.Actions()) {
-				t.Errorf("wrong number of api interactions")
-			}
-			if test.transitionLeader && le.observedRecord.LeaderTransitions != 1 {
-				t.Errorf("leader should have transitioned but did not")
-			}
-			if !test.transitionLeader && le.observedRecord.LeaderTransitions != 0 {
-				t.Errorf("leader should not have transitioned but did")
-			}
-			le.maybeReportTransition()
-			wg.Wait()
-			if reportedLeader != test.outHolder {
-				t.Errorf("reported leader was not the new leader. expected %q, got %q", test.outHolder, reportedLeader)
-			}
-		})
-	}
-}
-
-// Will test leader election using endpoints as the resource
-func TestReleaseLeaseEndpoints(t *testing.T) {
-	testReleaseLease(t, "endpoints")
-}
-
-// Will test leader election using endpoints as the resource
-func TestReleaseLeaseConfigMaps(t *testing.T) {
-	testReleaseLease(t, "configmaps")
-}
-
-// Will test leader election using endpoints as the resource
-func TestReleaseLeaseLeases(t *testing.T) {
-	testReleaseLease(t, "leases")
-}
-
-func TestReleaseOnCancellation_Endpoints(t *testing.T) {
-	testReleaseOnCancellation(t, "endpoints")
-}
-
-func TestReleaseOnCancellation_ConfigMaps(t *testing.T) {
-	testReleaseOnCancellation(t, "configmaps")
-}
-
-func TestReleaseOnCancellation_Leases(t *testing.T) {
-	testReleaseOnCancellation(t, "leases")
-}
-
-func testReleaseOnCancellation(t *testing.T, objectType string) {
-	var (
-		onNewLeader   = make(chan struct{})
-		onRenewCalled = make(chan struct{})
-		onRenewResume = make(chan struct{})
-		onRelease     = make(chan struct{})
-
-		lockObj runtime.Object
-		updates int
-	)
-
-	resourceLockConfig := rl.ResourceLockConfig{
-		Identity:      "baz",
-		EventRecorder: &record.FakeRecorder{},
-	}
-	c := &fake.Clientset{}
-
-	c.AddReactor("get", objectType, func(action fakeclient.Action) (handled bool, ret runtime.Object, err error) {
-		if lockObj != nil {
-			return true, lockObj, nil
-		}
-		return true, nil, errors.NewNotFound(action.(fakeclient.GetAction).GetResource().GroupResource(), action.(fakeclient.GetAction).GetName())
-	})
-
-	// create lock
-	c.AddReactor("create", objectType, func(action fakeclient.Action) (handled bool, ret runtime.Object, err error) {
-		lockObj = action.(fakeclient.CreateAction).GetObject()
-		return true, lockObj, nil
-	})
-
-	c.AddReactor("update", objectType, func(action fakeclient.Action) (handled bool, ret runtime.Object, err error) {
-		updates++
-
-		// Second update (first renew) should return our canceled error
-		// FakeClient doesn't do anything with the context so we're doing this ourselves
-		if updates == 2 {
-			close(onRenewCalled)
-			<-onRenewResume
-			return true, nil, context.Canceled
-		} else if updates == 3 {
-			close(onRelease)
-		}
-
-		lockObj = action.(fakeclient.UpdateAction).GetObject()
-		return true, lockObj, nil
-
-	})
-
-	c.AddReactor("*", "*", func(action fakeclient.Action) (bool, runtime.Object, error) {
-		t.Errorf("unreachable action. testclient called too many times: %+v", action)
-		return true, nil, fmt.Errorf("unreachable action")
-	})
-
-	lock, err := rl.New(objectType, "foo", "bar", c.CoreV1(), c.CoordinationV1(), resourceLockConfig)
-	if err != nil {
-		t.Fatal("resourcelock.New() = ", err)
-	}
-
-	lec := LeaderElectionConfig{
-		Lock:          lock,
-		LeaseDuration: 15 * time.Second,
-		RenewDeadline: 2 * time.Second,
-		RetryPeriod:   1 * time.Second,
-
-		// This is what we're testing
-		ReleaseOnCancel: true,
-
-		Callbacks: LeaderCallbacks{
-			OnNewLeader:      func(identity string) {},
-			OnStoppedLeading: func() {},
-			OnStartedLeading: func(context.Context) {
-				close(onNewLeader)
-			},
-		},
-	}
-
-	elector, err := NewLeaderElector(lec)
-	if err != nil {
-		t.Fatal("Failed to create leader elector: ", err)
-	}
-
-	ctx, cancel := context.WithCancel(context.Background())
-
-	go elector.Run(ctx)
-
-	// Wait for us to become the leader
-	select {
-	case <-onNewLeader:
-	case <-time.After(10 * time.Second):
-		t.Fatal("failed to become the leader")
-	}
-
-	// Wait for renew (update) to be invoked
-	select {
-	case <-onRenewCalled:
-	case <-time.After(10 * time.Second):
-		t.Fatal("the elector failed to renew the lock")
-	}
-
-	// Cancel the context - stopping the elector while
-	// it's running
-	cancel()
-
-	// Resume the update call to return the cancellation
-	// which should trigger the release flow
-	close(onRenewResume)
-
-	select {
-	case <-onRelease:
-	case <-time.After(10 * time.Second):
-		t.Fatal("the lock was not released")
-	}
-}

tools/leaderelection/resourcelock/configmaplock.go

@@ -92,12 +92,8 @@ func (cml *ConfigMapLock) Update(ctx context.Context, ler LeaderElectionRecord)
 		cml.cm.Annotations = make(map[string]string)
 	}
 	cml.cm.Annotations[LeaderElectionRecordAnnotationKey] = string(recordBytes)
-	cm, err := cml.Client.ConfigMaps(cml.ConfigMapMeta.Namespace).Update(ctx, cml.cm, metav1.UpdateOptions{})
-	if err != nil {
-		return err
-	}
-	cml.cm = cm
-	return nil
+	cml.cm, err = cml.Client.ConfigMaps(cml.ConfigMapMeta.Namespace).Update(ctx, cml.cm, metav1.UpdateOptions{})
+	return err
 }
 
 // RecordEvent in leader election while adding meta-data

tools/leaderelection/resourcelock/endpointslock.go

@@ -87,12 +87,8 @@ func (el *EndpointsLock) Update(ctx context.Context, ler LeaderElectionRecord) e
 		el.e.Annotations = make(map[string]string)
 	}
 	el.e.Annotations[LeaderElectionRecordAnnotationKey] = string(recordBytes)
-	e, err := el.Client.Endpoints(el.EndpointsMeta.Namespace).Update(ctx, el.e, metav1.UpdateOptions{})
-	if err != nil {
-		return err
-	}
-	el.e = e
-	return nil
+	el.e, err = el.Client.Endpoints(el.EndpointsMeta.Namespace).Update(ctx, el.e, metav1.UpdateOptions{})
+	return err
 }
 
 // RecordEvent in leader election while adding meta-data

tools/leaderelection/resourcelock/leaselock.go

@@ -71,14 +71,9 @@ func (ll *LeaseLock) Update(ctx context.Context, ler LeaderElectionRecord) error
 		return errors.New("lease not initialized, call get or create first")
 	}
 	ll.lease.Spec = LeaderElectionRecordToLeaseSpec(&ler)
-
-	lease, err := ll.Client.Leases(ll.LeaseMeta.Namespace).Update(ctx, ll.lease, metav1.UpdateOptions{})
-	if err != nil {
-		return err
-	}
-
-	ll.lease = lease
-	return nil
+	var err error
+	ll.lease, err = ll.Client.Leases(ll.LeaseMeta.Namespace).Update(ctx, ll.lease, metav1.UpdateOptions{})
+	return err
 }
 
 // RecordEvent in leader election while adding meta-data

tools/record/event_test.go

@@ -24,7 +24,7 @@ import (
 	"testing"
 	"time"
 
-	v1 "k8s.io/api/core/v1"
+	"k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	k8sruntime "k8s.io/apimachinery/pkg/runtime"
@@ -509,7 +509,7 @@ func TestLotsOfEvents(t *testing.T) {
 			APIVersion: "version",
 		}
 		// we need to vary the reason to prevent aggregation
-		go recorder.Eventf(ref, v1.EventTypeNormal, "Reason-"+strconv.Itoa(i), strconv.Itoa(i))
+		go recorder.Eventf(ref, v1.EventTypeNormal, "Reason-"+string(i), strconv.Itoa(i))
 	}
 	// Make sure no events were dropped by either of the listeners.
 	for i := 0; i < maxQueuedEvents; i++ {

tools/record/events_cache_test.go

@@ -18,7 +18,6 @@ package record
 
 import (
 	"reflect"
-	"strconv"
 	"strings"
 	"testing"
 	"time"
@@ -70,10 +69,10 @@ func makeUniqueEvents(num int) []v1.Event {
 	events := []v1.Event{}
 	kind := "Pod"
 	for i := 0; i < num; i++ {
-		reason := strings.Join([]string{"reason", strconv.Itoa(i)}, "-")
-		message := strings.Join([]string{"message", strconv.Itoa(i)}, "-")
-		name := strings.Join([]string{"pod", strconv.Itoa(i)}, "-")
-		namespace := strings.Join([]string{"ns", strconv.Itoa(i)}, "-")
+		reason := strings.Join([]string{"reason", string(i)}, "-")
+		message := strings.Join([]string{"message", string(i)}, "-")
+		name := strings.Join([]string{"pod", string(i)}, "-")
+		namespace := strings.Join([]string{"ns", string(i)}, "-")
 		involvedObject := makeObjectReference(kind, name, namespace)
 		events = append(events, makeEvent(reason, message, involvedObject))
 	}
@@ -83,7 +82,7 @@ func makeUniqueEvents(num int) []v1.Event {
 func makeSimilarEvents(num int, template v1.Event, messagePrefix string) []v1.Event {
 	events := makeEvents(num, template)
 	for i := range events {
-		events[i].Message = strings.Join([]string{messagePrefix, strconv.Itoa(i), events[i].Message}, "-")
+		events[i].Message = strings.Join([]string{messagePrefix, string(i), events[i].Message}, "-")
 	}
 	return events
 }

transport/cache.go

@@ -47,9 +47,12 @@ type tlsCacheKey struct {
 	keyData            string
 	certFile           string
 	keyFile            string
+	getCert            string
 	serverName         string
 	nextProtos         string
+	dial               string
 	disableCompression bool
+	proxy              string
 }
 
 func (t tlsCacheKey) String() string {
@@ -57,24 +60,22 @@ func (t tlsCacheKey) String() string {
 	if len(t.keyData) > 0 {
 		keyText = "<redacted>"
 	}
-	return fmt.Sprintf("insecure:%v, caData:%#v, certData:%#v, keyData:%s, serverName:%s, disableCompression:%t", t.insecure, t.caData, t.certData, keyText, t.serverName, t.disableCompression)
+	return fmt.Sprintf("insecure:%v, caData:%#v, certData:%#v, keyData:%s, getCert: %s, serverName:%s, dial:%s disableCompression:%t, proxy: %s", t.insecure, t.caData, t.certData, keyText, t.getCert, t.serverName, t.dial, t.disableCompression, t.proxy)
 }
 
 func (c *tlsTransportCache) get(config *Config) (http.RoundTripper, error) {
-	key, canCache, err := tlsConfigKey(config)
+	key, err := tlsConfigKey(config)
 	if err != nil {
 		return nil, err
 	}
 
-	if canCache {
-		// Ensure we only create a single transport for the given TLS options
-		c.mu.Lock()
-		defer c.mu.Unlock()
+	// Ensure we only create a single transport for the given TLS options
+	c.mu.Lock()
+	defer c.mu.Unlock()
 
-		// See if we already have a custom transport for this config
-		if t, ok := c.transports[key]; ok {
-			return t, nil
-		}
+	// See if we already have a custom transport for this config
+	if t, ok := c.transports[key]; ok {
+		return t, nil
 	}
 
 	// Get the TLS options for this client config
@@ -109,7 +110,8 @@ func (c *tlsTransportCache) get(config *Config) (http.RoundTripper, error) {
 		proxy = config.Proxy
 	}
 
-	transport := utilnet.SetTransportDefaults(&http.Transport{
+	// Cache a single transport for these options
+	c.transports[key] = utilnet.SetTransportDefaults(&http.Transport{
 		Proxy:               proxy,
 		TLSHandshakeTimeout: 10 * time.Second,
 		TLSClientConfig:     tlsConfig,
@@ -117,33 +119,24 @@ func (c *tlsTransportCache) get(config *Config) (http.RoundTripper, error) {
 		DialContext:         dial,
 		DisableCompression:  config.DisableCompression,
 	})
-
-	if canCache {
-		// Cache a single transport for these options
-		c.transports[key] = transport
-	}
-
-	return transport, nil
+	return c.transports[key], nil
 }
 
 // tlsConfigKey returns a unique key for tls.Config objects returned from TLSConfigFor
-func tlsConfigKey(c *Config) (tlsCacheKey, bool, error) {
+func tlsConfigKey(c *Config) (tlsCacheKey, error) {
 	// Make sure ca/key/cert content is loaded
 	if err := loadTLSFiles(c); err != nil {
-		return tlsCacheKey{}, false, err
+		return tlsCacheKey{}, err
 	}
-
-	if c.TLS.GetCert != nil || c.Dial != nil || c.Proxy != nil {
-		// cannot determine equality for functions
-		return tlsCacheKey{}, false, nil
-	}
-
 	k := tlsCacheKey{
 		insecure:           c.TLS.Insecure,
 		caData:             string(c.TLS.CAData),
+		getCert:            fmt.Sprintf("%p", c.TLS.GetCert),
 		serverName:         c.TLS.ServerName,
 		nextProtos:         strings.Join(c.TLS.NextProtos, ","),
+		dial:               fmt.Sprintf("%p", c.Dial),
 		disableCompression: c.DisableCompression,
+		proxy:              fmt.Sprintf("%p", c.Proxy),
 	}
 
 	if c.TLS.ReloadTLSFiles {
@@ -154,5 +147,5 @@ func tlsConfigKey(c *Config) (tlsCacheKey, bool, error) {
 		k.keyData = string(c.TLS.KeyData)
 	}
 
-	return k, true, nil
+	return k, nil
 }

transport/cache_test.go

@@ -21,6 +21,7 @@ import (
 	"crypto/tls"
 	"net"
 	"net/http"
+	"net/url"
 	"testing"
 )
 
@@ -36,24 +37,16 @@ func TestTLSConfigKey(t *testing.T) {
 	}
 	for nameA, valueA := range identicalConfigurations {
 		for nameB, valueB := range identicalConfigurations {
-			keyA, canCache, err := tlsConfigKey(valueA)
+			keyA, err := tlsConfigKey(valueA)
 			if err != nil {
 				t.Errorf("Unexpected error for %q: %v", nameA, err)
 				continue
 			}
-			if !canCache {
-				t.Errorf("Unexpected canCache=false")
-				continue
-			}
-			keyB, canCache, err := tlsConfigKey(valueB)
+			keyB, err := tlsConfigKey(valueB)
 			if err != nil {
 				t.Errorf("Unexpected error for %q: %v", nameB, err)
 				continue
 			}
-			if !canCache {
-				t.Errorf("Unexpected canCache=false")
-				continue
-			}
 			if keyA != keyB {
 				t.Errorf("Expected identical cache keys for %q and %q, got:\n\t%s\n\t%s", nameA, nameB, keyA, keyB)
 				continue
@@ -139,12 +132,12 @@ func TestTLSConfigKey(t *testing.T) {
 	}
 	for nameA, valueA := range uniqueConfigurations {
 		for nameB, valueB := range uniqueConfigurations {
-			keyA, canCacheA, err := tlsConfigKey(valueA)
+			keyA, err := tlsConfigKey(valueA)
 			if err != nil {
 				t.Errorf("Unexpected error for %q: %v", nameA, err)
 				continue
 			}
-			keyB, canCacheB, err := tlsConfigKey(valueB)
+			keyB, err := tlsConfigKey(valueB)
 			if err != nil {
 				t.Errorf("Unexpected error for %q: %v", nameB, err)
 				continue
@@ -155,18 +148,33 @@ func TestTLSConfigKey(t *testing.T) {
 				if keyA != keyB {
 					t.Errorf("Expected identical cache keys for %q and %q, got:\n\t%s\n\t%s", nameA, nameB, keyA, keyB)
 				}
-				if canCacheA != canCacheB {
-					t.Errorf("Expected identical canCache %q and %q, got:\n\t%v\n\t%v", nameA, nameB, canCacheA, canCacheB)
-				}
 				continue
 			}
 
-			if canCacheA && canCacheB {
-				if keyA == keyB {
-					t.Errorf("Expected unique cache keys for %q and %q, got:\n\t%s\n\t%s", nameA, nameB, keyA, keyB)
-					continue
-				}
+			if keyA == keyB {
+				t.Errorf("Expected unique cache keys for %q and %q, got:\n\t%s\n\t%s", nameA, nameB, keyA, keyB)
+				continue
 			}
 		}
 	}
 }
+
+func TestTLSConfigKeyFuncPtr(t *testing.T) {
+	keys := make(map[tlsCacheKey]struct{})
+	makeKey := func(p func(*http.Request) (*url.URL, error)) tlsCacheKey {
+		key, err := tlsConfigKey(&Config{Proxy: p})
+		if err != nil {
+			t.Fatalf("Unexpected error creating cache key: %v", err)
+		}
+		return key
+	}
+
+	keys[makeKey(http.ProxyFromEnvironment)] = struct{}{}
+	keys[makeKey(http.ProxyFromEnvironment)] = struct{}{}
+	keys[makeKey(http.ProxyURL(nil))] = struct{}{}
+	keys[makeKey(nil)] = struct{}{}
+
+	if got, want := len(keys), 3; got != want {
+		t.Fatalf("Unexpected number of keys: got=%d want=%d", got, want)
+	}
+}

util/jsonpath/jsonpath_test.go

@@ -263,8 +263,6 @@ func TestStructInput(t *testing.T) {
 		{"allarray", "{.Book[*].Author}", storeData, "Nigel Rees Evelyn Waugh Herman Melville", false},
 		{"allfields", `{range .Bicycle[*]}{ "{" }{ @.* }{ "} " }{end}`, storeData, "{red 19.95 true} {green 20.01 false} ", false},
 		{"recurfields", "{..Price}", storeData, "8.95 12.99 8.99 19.95 20.01", false},
-		{"recurdotfields", "{...Price}", storeData, "8.95 12.99 8.99 19.95 20.01", false},
-		{"superrecurfields", "{............................................................Price}", storeData, "", true},
 		{"allstructsSlice", "{.Bicycle}", storeData,
 			`[{"Color":"red","Price":19.95,"IsNew":true},{"Color":"green","Price":20.01,"IsNew":false}]`, false},
 		{"allstructs", `{range .Bicycle[*]}{ @ }{ " " }{end}`, storeData,

util/jsonpath/parser.go

@@ -214,11 +214,8 @@ func (p *Parser) parseIdentifier(cur *ListNode) error {
 	return p.parseInsideAction(cur)
 }
 
-// parseRecursive scans the recursive descent operator ..
+// parseRecursive scans the recursive desent operator ..
 func (p *Parser) parseRecursive(cur *ListNode) error {
-	if lastIndex := len(cur.Nodes) - 1; lastIndex >= 0 && cur.Nodes[lastIndex].Type() == NodeRecursive {
-		return fmt.Errorf("invalid multiple recursive descent")
-	}
 	p.pos += len("..")
 	p.consumeText()
 	cur.append(newRecursive())

util/jsonpath/parser_test.go

@@ -141,7 +141,6 @@ func TestFailParser(t *testing.T) {
 		{"invalid number", "{+12.3.0}", "cannot parse number +12.3.0"},
 		{"unterminated array", "{[1}", "unterminated array"},
 		{"unterminated filter", "{[?(.price]}", "unterminated filter"},
-		{"invalid multiple recursive descent", "{........}", "invalid multiple recursive descent"},
 	}
 	for _, test := range failParserTests {
 		_, err := Parse(test.name, test.text)