errors_test.go - master - uzer_007/gopcsc

errors_test.go
196 строк6 KB
uzer_007
Release v1.0.0
03 авг 2026, 13:26
03 авг 2026, 13:2681a16b2
package gopcsc

import (
	"errors"
	"strings"
	"testing"
)

func TestErrorMapping(t *testing.T) {
	if !errors.Is(Error{Code: SCardWRemovedCard}, ErrCardRemoved) {
		t.Fatal("removed card error did not match ErrCardRemoved")
	}
	if !errors.Is(Error{Code: SCardENoSmartcard}, ErrNoCard) {
		t.Fatal("no smartcard error did not match ErrNoCard")
	}
	if !errors.Is(Error{Code: SCardENoReadersAvailable}, ErrNoReaders) {
		t.Fatal("no readers error did not match ErrNoReaders")
	}
	if !errors.Is(Error{Code: SCardWSecurityViolation}, ErrPermissionDenied) {
		t.Fatal("security violation did not match ErrPermissionDenied")
	}
	if !errors.Is(Error{Code: SCardETimeout}, ErrTimeout) {
		t.Fatal("timeout did not match ErrTimeout")
	}
	if !errors.Is(Error{Code: SCardECancelled}, ErrCancelled) {
		t.Fatal("cancelled did not match ErrCancelled")
	}
	if !errors.Is(Error{Code: SCardESharingViolation}, ErrSharingViolation) {
		t.Fatal("sharing violation did not match ErrSharingViolation")
	}
	if !errors.Is(Error{Code: SCardENoService}, ErrNoService) {
		t.Fatal("no service did not match ErrNoService")
	}
	if !errors.Is(Error{Code: SCardEServiceStopped}, ErrServiceStopped) {
		t.Fatal("service stopped did not match ErrServiceStopped")
	}
	if !errors.Is(Error{Code: SCardEUnknownReader}, ErrUnknownReader) {
		t.Fatal("unknown reader did not match ErrUnknownReader")
	}
	if !errors.Is(Error{Code: SCardEProtoMismatch}, ErrProtocolMismatch) {
		t.Fatal("protocol mismatch did not match ErrProtocolMismatch")
	}
	if !errors.Is(Error{Code: SCardEReaderUnavailable}, ErrReaderUnavailable) {
		t.Fatal("reader unavailable did not match ErrReaderUnavailable")
	}
	if !errors.Is(Error{Code: SCardECommDataLost}, ErrCommLost) {
		t.Fatal("comm data lost did not match ErrCommLost")
	}
	if !errors.Is(Error{Code: SCardECardUnsupported}, ErrCardUnsupported) {
		t.Fatal("card unsupported did not match ErrCardUnsupported")
	}
	if !errors.Is(Error{Code: SCardEUnsupportedFeaturePCSCLite}, ErrUnsupportedFeature) {
		t.Fatal("pcsc-lite unsupported feature did not match ErrUnsupportedFeature")
	}
	if !errors.Is(Error{Code: SCardEUnsupportedFeature}, ErrUnsupportedFeature) {
		t.Fatal("windows unsupported feature did not match ErrUnsupportedFeature")
	}
	if !errors.Is(Error{Code: SCardEInsufficientBuffer}, ErrInsufficientBuffer) {
		t.Fatal("insufficient buffer did not match ErrInsufficientBuffer")
	}
	if errors.Is(Error{Code: SCardEInvalidHandle}, ErrCardRemoved) {
		t.Fatal("invalid handle matched ErrCardRemoved")
	}
	if !errors.Is(UnsupportedError{Reason: "test"}, ErrUnsupported) {
		t.Fatal("UnsupportedError did not match ErrUnsupported")
	}
}

func TestErrorCodeNameAndTemporary(t *testing.T) {
	err := Error{Op: "wait", Code: SCardETimeout}
	if err.CodeName() != "SCARD_E_TIMEOUT" || CodeName(SCardETimeout) != "SCARD_E_TIMEOUT" {
		t.Fatalf("bad code name: %q", err.CodeName())
	}
	if !err.Timeout() || !err.Temporary() {
		t.Fatalf("timeout error did not report timeout/temporary")
	}
	if (Error{Code: SCardEInvalidHandle}).Temporary() {
		t.Fatalf("invalid handle reported temporary")
	}
	if CodeName(0xffffffff) != "" {
		t.Fatalf("unknown code had a name")
	}
	if !strings.Contains(err.Error(), "SCARD_E_TIMEOUT") {
		t.Fatalf("Error() lacks code name: %q", err.Error())
	}
}

func TestAllKnownErrorCodeNames(t *testing.T) {
	codes := []uint32{
		SCardSSuccess,
		SCardFInternalError,
		SCardECancelled,
		SCardEInvalidHandle,
		SCardEInvalidParameter,
		SCardEInvalidTarget,
		SCardENoMemory,
		SCardFWaitedTooLong,
		SCardEInsufficientBuffer,
		SCardEUnknownReader,
		SCardETimeout,
		SCardESharingViolation,
		SCardENoSmartcard,
		SCardEUnknownCard,
		SCardECantDispose,
		SCardEProtoMismatch,
		SCardENotReady,
		SCardEInvalidValue,
		SCardESystemCancelled,
		SCardFCommError,
		SCardFUnknownError,
		SCardEInvalidATR,
		SCardENotTransacted,
		SCardEReaderUnavailable,
		SCardPShutdown,
		SCardEPCISmall,
		SCardEReaderUnsupported,
		SCardEDuplicateReader,
		SCardECardUnsupported,
		SCardENoService,
		SCardEServiceStopped,
		SCardEUnexpected,
		SCardEUnsupportedFeature,
		SCardEICCInstallation,
		SCardEICCCreateOrder,
		SCardEDirNotFound,
		SCardEFileNotFound,
		SCardENoDir,
		SCardENoFile,
		SCardENoAccess,
		SCardEWriteTooMany,
		SCardEBadSeek,
		SCardEInvalidCHV,
		SCardEUnknownResMsg,
		SCardENoSuchCertificate,
		SCardECertificateUnavailable,
		SCardENoReadersAvailable,
		SCardECommDataLost,
		SCardENoKeyContainer,
		SCardEServerTooBusy,
		SCardWUnsupportedCard,
		SCardWUnresponsiveCard,
		SCardWUnpoweredCard,
		SCardWResetCard,
		SCardWRemovedCard,
		SCardWSecurityViolation,
		SCardWWrongCHV,
		SCardWCHVBlocked,
		SCardWEOF,
		SCardWCancelledByUser,
		SCardWCardNotAuthenticated,
	}
	for _, code := range codes {
		if name := CodeName(code); !strings.HasPrefix(name, "SCARD_") {
			t.Errorf("CodeName(0x%08x) = %q", code, name)
		}
	}

	for _, err := range []Error{
		{Code: 0xf0000001},
		{Op: "operation", Code: 0xf0000001},
		{Code: SCardETimeout},
		{Op: "operation", Code: SCardETimeout},
	} {
		if got := err.Error(); got == "" {
			t.Errorf("%#v.Error() is empty", err)
		}
	}
	if got := (ProtocolError{Reason: ProtocolReasonInvalidLength}).Error(); !strings.Contains(got, string(ProtocolReasonInvalidLength)) {
		t.Fatalf("ProtocolError without op = %q", got)
	}
	if got := (UnsupportedError{}).Error(); got != ErrUnsupported.Error() {
		t.Fatalf("UnsupportedError without reason = %q", got)
	}
	if !errors.Is(fmtInvalidValue("test"), ErrInvalidValue) {
		t.Fatal("fmtInvalidValue did not preserve ErrInvalidValue")
	}
}

func TestProtocolError(t *testing.T) {
	err := ProtocolError{Op: "decode", Reason: ProtocolReasonTruncatedResponse}
	if !errors.Is(err, ErrProtocol) || err.Reason != ProtocolReasonTruncatedResponse {
		t.Fatal("ProtocolError did not match ErrProtocol")
	}
}

func TestAttributeString(t *testing.T) {
	if AttrDeviceFriendlyName.String() != "SCARD_ATTR_DEVICE_FRIENDLY_NAME" {
		t.Fatalf("AttrDeviceFriendlyName.String() = %q", AttrDeviceFriendlyName.String())
	}
	if AttrDeviceFriendlyNameW.String() != "SCARD_ATTR_DEVICE_FRIENDLY_NAME_W" {
		t.Fatalf("AttrDeviceFriendlyNameW.String() = %q", AttrDeviceFriendlyNameW.String())
	}
	if got := Attribute(0xffffffff).String(); !strings.Contains(got, "0xffffffff") {
		t.Fatalf("unknown Attribute.String() = %q", got)
	}
}