}

// supportedSignatureAlgorithms returns the supported signature algorithms.
func supportedSignatureAlgorithms() []SignatureScheme {
	if !needFIPS() {
		return defaultSupportedSignatureAlgorithms
	}
	return defaultSupportedSignatureAlgorithmsFIPS
}

func isSupportedSignatureAlgorithm(sigAlg SignatureScheme, supportedSignatureAlgorithms []SignatureScheme) bool {

		}
	}
	for _, id := range hello.supportedCurves {
		if !isBoringCurve(id) {
			t.Errorf("client offered disallowed curve %d", id)
		}
	}
	for _, sigHash := range hello.supportedSignatureAlgorithms {
		if !isBoringSignatureScheme(sigHash) {
			t.Errorf("client offered disallowed signature-and-hash %v", sigHash)
		}
	}
}

func TestBoringCertAlgs(t *testing.T) {

		PrivateKey:  testRSAPrivateKey,
	}
	pkcs1Cert := &Certificate{
		Certificate:                  [][]byte{testRSACertificate},
		PrivateKey:                   testRSAPrivateKey,
		SupportedSignatureAlgorithms: []SignatureScheme{PKCS1WithSHA1, PKCS1WithSHA256},
	}
	ecdsaCert := &Certificate{
		// ECDSA P-256 certificate
		Certificate: [][]byte{testP256Certificate},
		PrivateKey:  testP256PrivateKey,
	}

		{"Certificate.Leaf", Field, 0},
		{"Certificate.OCSPStaple", Field, 0},
		{"Certificate.PrivateKey", Field, 0},
		{"Certificate.SignedCertificateTimestamps", Field, 5},
		{"Certificate.SupportedSignatureAlgorithms", Field, 14},
		{"CertificateRequestInfo", Type, 8},
		{"CertificateRequestInfo.AcceptableCAs", Field, 8},
		{"CertificateRequestInfo.SignatureSchemes", Field, 8},
		{"CertificateRequestInfo.Version", Field, 14},

pkg crypto/tls, method (*CertificateRequestInfo) SupportsCertificate(*Certificate) error
pkg crypto/tls, method (*ClientHelloInfo) SupportsCertificate(*Certificate) error
pkg crypto/tls, type Certificate struct, SupportedSignatureAlgorithms []SignatureScheme
pkg crypto/tls, type CertificateRequestInfo struct, Version uint16
pkg crypto/tls, type CipherSuite struct
pkg crypto/tls, type CipherSuite struct, ID uint16