b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *Endpoint) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Endpoint.Merge(m, src)
}
func (m *Endpoint) XXX_Size() int {
	return m.Size()
}
func (m *Endpoint) XXX_DiscardUnknown() {
	xxx_messageInfo_Endpoint.DiscardUnknown(m)
}

	80: "authentication error",
	81: "need authenticator",
	82: "identifier removed",
	83: "no message of desired type",
	84: "value too large to be stored in data type",
	85: "illegal byte sequence",
	86: "not supported",
	87: "operation Canceled",
	88: "bad or Corrupt message",
	89: "no message available",
	90: "no STREAM resources",
	91: "not a STREAM",
	92: "STREAM ioctl timeout",

	runSkips       = flag.Bool("run_skips", false, "run skipped tests (ignore skip and build tags)")
	linkshared     = flag.Bool("linkshared", false, "")
	updateErrors   = flag.Bool("update_errors", false, "update error messages in test file based on compiler output")
	runoutputLimit = flag.Int("l", defaultRunOutputLimit(), "number of parallel runoutput tests to run")
	force          = flag.Bool("f", false, "ignore expected-failure test lists")

											map[string]interface{}{
												"rule":    "self.startsWith('k8s')",
												"message": "strings must have k8s prefix",
											},
											map[string]interface{}{
												"rule":    "len(self) % 2 == 1",
												"message": "strings must have odd length",
											},
										},
									},
								},
							},
						},
					}},

	{117, "ECANCELED", "asynchronous I/O cancelled"},
	{118, "ENOSR", "out of STREAMS resources"},
	{119, "ETIME", "system call timed out"},
	{120, "EBADMSG", "next message has wrong type"},
	{121, "EPROTO", "error in protocol"},
	{122, "ENODATA", "no message on stream head read q"},
	{123, "ENOSTR", "fd not associated with a stream"},
	{124, "ENOTSUP", "unsupported attribute value"},
	{125, "EMULTIHOP", "multihop is not allowed"},

// when certain messages are seen.
type opensslOutputSink struct {
	handshakeComplete chan struct{}
	readKeyUpdate     chan struct{}
	all               []byte
	line              []byte
}

func newOpensslOutputSink() *opensslOutputSink {
	return &opensslOutputSink{make(chan struct{}), make(chan struct{}), nil, nil}
}

// opensslEndOfHandshake is a message that the “openssl s_server” tool will

	p.errorAt(pos, "syntax error: unexpected "+tok+msg)
}

// tokstring returns the English word for selected punctuation tokens
// for more readable error messages. Use tokstring (not tok.String())
// for user-facing (error) messages; use tok.String() for debugging
// output.
func tokstring(tok token) string {
	switch tok {
	case _Comma:
		return "comma"
	case _Semi:
		return "semicolon or newline"

			if tc.shouldFail && err == nil {
				t.Error("expecting failure, but err is nil")
			}
			if tc.initAttachErr != nil && err != nil {
				if tc.initAttachErr.Message != err.Error() {
					t.Errorf("expecting error [%v], got [%v]", tc.initAttachErr.Message, err.Error())
				}
			}
			if err == nil && retID != attachID {
				t.Errorf("attacher.WaitForAttach not returning attachment ID")
			}
			wg.Wait()
		})
	}

		t.Fatalf("expected violation %q, but got: %v", v, cond.Message)
	}
	if v := "spec.preserveUnknownFields: Invalid value: true: must be false"; !strings.Contains(cond.Message, v) {
		t.Fatalf("expected violation %q, but got: %v", v, cond.Message)
	}

	t.Log("fix schema")
	for retry := 0; retry < 5; retry++ {

	80: "authentication error",
	81: "need authenticator",
	82: "identifier removed",
	83: "no message of desired type",
	84: "value too large to be stored in data type",
	85: "illegal byte sequence",
	86: "not supported",
	87: "operation Canceled",
	88: "bad or Corrupt message",
	89: "no message available",
	90: "no STREAM resources",
	91: "not a STREAM",
	92: "STREAM ioctl timeout",