t.Errorf("incorrect IDs encoded: %v, %v VS (expected) %v, %v", ids[0], ids[1], c.subjectIDs[0], c.subjectIDs[1])
			}
		}
		pool := x509.NewCertPool()
		pool.AddCert(signingCert)
		vo := x509.VerifyOptions{
			Roots: pool,
		}
		if _, err := out.Verify(vo); err != nil {
			t.Errorf("verification of the signed certificate failed %v", err)
		}
	}
}

func TestLoadSignerCredsFromFiles(t *testing.T) {

		} else {
			c.sendAlert(alertBadCertificate)
		}
		return errors.New("tls: client didn't provide a certificate")
	}

	if c.config.ClientAuth >= VerifyClientCertIfGiven && len(certs) > 0 {
		opts := x509.VerifyOptions{
			Roots:         c.config.ClientCAs,
			CurrentTime:   c.config.time(),
			Intermediates: x509.NewCertPool(),
			KeyUsages:     []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth},
		}

pkg crypto/x509, type Certificate struct, URIs []*url.URL
pkg crypto/x509, type CertificateInvalidError struct, Detail string
pkg crypto/x509, type CertificateRequest struct, URIs []*url.URL
pkg crypto/x509, type VerifyOptions struct, MaxConstraintComparisions int
pkg crypto/x509/pkix, method (Name) String() string
pkg crypto/x509/pkix, method (RDNSequence) String() string
pkg database/sql, func OpenDB(driver.Connector) *DB

		return
	}

	certificate := r.TLS.PeerCertificates[0]
	if !globalIAMSys.STSTLSConfig.InsecureSkipVerify { // Verify whether the client certificate has been issued by a trusted CA.
		_, err := certificate.Verify(x509.VerifyOptions{
			KeyUsages: []x509.ExtKeyUsage{
				x509.ExtKeyUsageClientAuth,
			},
			Roots: globalRootCAs,
		})
		if err != nil {
			writeSTSErrorResponse(ctx, w, ErrSTSInvalidClientCertificate, err)
			return

		{"UnknownSignatureAlgorithm", Const, 0},
		{"VerifyOptions", Type, 0},
		{"VerifyOptions.CurrentTime", Field, 0},
		{"VerifyOptions.DNSName", Field, 0},
		{"VerifyOptions.Intermediates", Field, 0},
		{"VerifyOptions.KeyUsages", Field, 1},
		{"VerifyOptions.MaxConstraintComparisions", Field, 10},
		{"VerifyOptions.Roots", Field, 0},
	},
	"crypto/x509/pkix": {

			t.Errorf("#%d: calculated bit-length of %d for %x, wanted %d", i, got, test.bytes, test.bitLen)
		}
	}
}

func TestVerifyEmptyCertificate(t *testing.T) {
	if _, err := new(Certificate).Verify(VerifyOptions{}); err != errNotParsed {
		t.Errorf("Verifying empty certificate resulted in unexpected error: %q (wanted %q)", err, errNotParsed)
	}
}

func TestInsecureAlgorithmErrorString(t *testing.T) {

pkg crypto/x509, type UnknownAuthorityError struct
pkg crypto/x509, type VerifyOptions struct
pkg crypto/x509, type VerifyOptions struct, CurrentTime time.Time
pkg crypto/x509, type VerifyOptions struct, DNSName string
pkg crypto/x509, type VerifyOptions struct, Intermediates *CertPool
pkg crypto/x509, type VerifyOptions struct, Roots *CertPool
pkg crypto/x509, var ErrUnsupportedAlgorithm error

pkg crypto/x509, method (SystemRootsError) Error() string
pkg crypto/x509, type Certificate struct, IPAddresses []net.IP
pkg crypto/x509, type PEMCipher int
pkg crypto/x509, type SystemRootsError struct
pkg crypto/x509, type VerifyOptions struct, KeyUsages []ExtKeyUsage
pkg crypto/x509, var IncorrectPasswordError error
pkg database/sql, method (*DB) Ping() error
pkg database/sql, method (*DB) SetMaxIdleConns(int)