*/

package v1beta1

import (
	"crypto/x509"
	"encoding/pem"
	"errors"
)

// ParseCSR decodes a PEM encoded CSR
func ParseCSR(pemBytes []byte) (*x509.CertificateRequest, error) {
	// extract PEM from request object
	block, _ := pem.Decode(pemBytes)
	if block == nil || block.Type != "CERTIFICATE REQUEST" {
		return nil, errors.New("PEM block type must be CERTIFICATE REQUEST")
	}

	"errors"
	"fmt"
	"reflect"
	"strings"

	"k8s.io/apimachinery/pkg/util/sets"
)

// ParseCSR extracts the CSR from the bytes and decodes it.
func ParseCSR(pemBytes []byte) (*x509.CertificateRequest, error) {
	block, _ := pem.Decode(pemBytes)
	if block == nil || block.Type != "CERTIFICATE REQUEST" {
		return nil, errors.New("PEM block type must be CERTIFICATE REQUEST")
	}
	csr, err := x509.ParseCertificateRequest(block.Bytes)

	client := &http.Client{
		Transport: http.DefaultTransport.(*http.Transport).Clone(),
	}

	pemBytes, err := os.ReadFile(certFile)
	if err != nil {
		return nil, err
	}

	certpool := x509.NewCertPool()
	if !certpool.AppendCertsFromPEM(pemBytes) {
		return nil, fmt.Errorf("no certificates found in %s", certFile)
	}
	client.Transport.(*http.Transport).TLSClientConfig = &tls.Config{

		{"Benchmark", Func, 0},
		{"BenchmarkResult", Type, 0},
		{"BenchmarkResult.Bytes", Field, 0},
		{"BenchmarkResult.Extra", Field, 13},
		{"BenchmarkResult.MemAllocs", Field, 1},
		{"BenchmarkResult.MemBytes", Field, 1},
		{"BenchmarkResult.N", Field, 0},
		{"BenchmarkResult.T", Field, 0},
		{"Cover", Type, 2},
		{"Cover.Blocks", Field, 2},
		{"Cover.Counters", Field, 2},

		X:     big.NewInt(1), Y: big.NewInt(2),
	})
	if err == nil {
		t.Errorf("expected error, got MarshalPKIXPublicKey success")
	}
}

func testParsePKIXPublicKey(t *testing.T, pemBytes string) (pub any) {
	block, _ := pem.Decode([]byte(pemBytes))
	pub, err := ParsePKIXPublicKey(block.Bytes)
	if err != nil {
		t.Fatalf("Failed to parse public key: %s", err)
	}

	pubBytes2, err := MarshalPKIXPublicKey(pub)
	if err != nil {

	if _, ok := err.(UnhandledCriticalExtension); !ok {
		t.Fatalf("error was not an UnhandledCriticalExtension: %v", err)
	}
}

func certificateFromPEM(pemBytes string) (*Certificate, error) {
	block, _ := pem.Decode([]byte(pemBytes))
	if block == nil {
		return nil, errors.New("failed to decode PEM")
	}
	return ParseCertificate(block.Bytes)
}

pkg testing, method (BenchmarkResult) AllocsPerOp() int64
pkg testing, method (BenchmarkResult) MemString() string
pkg testing, type BenchmarkResult struct, MemAllocs uint64
pkg testing, type BenchmarkResult struct, MemBytes uint64
pkg text/scanner, const Char = -5
pkg text/scanner, const Comment = -8
pkg text/scanner, const EOF = -1
pkg text/scanner, const Float = -4
pkg text/scanner, const GoTokens = 1012