Merge branch 'main' into gh-pages

Package.resolved

@@ -1,22 +1,22 @@
 {
-  "originHash" : "aba63bdc14b9431049b57af2080cd340ba4da0baa6a3bfbb3ffb8740ed9dfed2",
+  "originHash" : "0334db293306eafc7f9541f6ae0a8f3f10c0b5d1d3f585b7f5dcbe3247ffa790",
   "pins" : [
     {
       "identity" : "eudi-lib-ios-iso18013-data-model",
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/eu-digital-identity-wallet/eudi-lib-ios-iso18013-data-model.git",
       "state" : {
-        "revision" : "29f30a92427733db0c7b9cea9616607a1df24284",
-        "version" : "0.4.0"
+        "revision" : "ef353c447c7716c1fe5f5905ff98e089f5a29d43",
+        "version" : "0.5.1"
       }
     },
     {
       "identity" : "eudi-lib-ios-iso18013-security",
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/eu-digital-identity-wallet/eudi-lib-ios-iso18013-security.git",
       "state" : {
-        "revision" : "6d335f19cb5bdb590bf2f5557c4d91dda146555b",
-        "version" : "0.3.0"
+        "revision" : "d3d9935b24b05902f840471bb70f651caa7f4cb5",
+        "version" : "0.4.0"
       }
     },
     {

Package.swift

@@ -14,8 +14,8 @@ let package = Package(
     ],
     dependencies: [
         .package(url: "https://github.com/apple/swift-docc-plugin", from: "1.0.0"), 
-		.package(url: "https://github.com/eu-digital-identity-wallet/eudi-lib-ios-iso18013-security.git", exact: "0.3.0"),
-	],
+		.package(url: "https://github.com/eu-digital-identity-wallet/eudi-lib-ios-iso18013-security.git", exact: "0.4.0"),
+    ],
     targets: [
         // Targets are the basic building blocks of a package, defining a module or a test suite.
         // Targets can depend on other targets in this package and products from dependencies.

Sources/MdocDataTransfer18013/BLETransfer/MdocGATTServer.swift

@@ -36,6 +36,7 @@ public class MdocGattServer: @unchecked Sendable, ObservableObject {
 	public var deviceRequest: DeviceRequest?
 	public var sessionEncryption: SessionEncryption?
 	public var docs: [String: IssuerSigned]!
+	public var docDisplayNames: [String: [String: [String: String]]?]!
 	public var iaca: [SecCertificate]!
 	public var devicePrivateKeys: [String: CoseKeyPrivate]!
 	public var dauthMethod: DeviceAuthMethod
@@ -52,14 +53,13 @@ public class MdocGattServer: @unchecked Sendable, ObservableObject {
 	var subscribeCount: Int = 0
 	var initSuccess:Bool = false
 
-	public init(parameters: [String: Any]) throws {
-		guard let (docs, devicePrivateKeys, iaca, dauthMethod) = MdocHelpers.initializeData(parameters: parameters) else {
-			throw MdocHelpers.makeError(code: .documents_not_provided)
-		}
-		self.docs = docs
-		self.devicePrivateKeys = devicePrivateKeys
-		self.iaca = iaca
-		self.dauthMethod = dauthMethod
+	public init(parameters: InitializeTransferData) throws {
+		let objs = parameters.toInitializeTransferInfo()
+		self.docs = objs.documentObjects.mapValues { IssuerSigned(data: $0.bytes) }.compactMapValues { $0 }
+		docDisplayNames = objs.docDisplayNames
+		self.devicePrivateKeys = objs.privateKeyObjects
+		self.iaca = objs.iaca
+		self.dauthMethod = objs.deviceAuthMethod
 		status = .initialized
 		initPeripheralManager()
 		initSuccess = true
@@ -219,7 +219,7 @@ public class MdocGattServer: @unchecked Sendable, ObservableObject {
 		delegate?.didChangeStatus(newValue)
 		if newValue == .requestReceived {
 			peripheralManager.stopAdvertising()
-			let decodedRes = await MdocHelpers.decodeRequestAndInformUser(deviceEngagement: deviceEngagement, docs: docs, iaca: iaca, requestData: readBuffer, devicePrivateKeys: devicePrivateKeys, dauthMethod: dauthMethod, unlockData: unlockData, readerKeyRawData: nil, handOver: BleTransferMode.QRHandover)
+			let decodedRes = await MdocHelpers.decodeRequestAndInformUser(deviceEngagement: deviceEngagement, docs: docs, docDisplayNames: docDisplayNames, iaca: iaca, requestData: readBuffer, devicePrivateKeys: devicePrivateKeys, dauthMethod: dauthMethod, unlockData: unlockData, readerKeyRawData: nil, handOver: BleTransferMode.QRHandover)
 			switch decodedRes {
 			case .success(let decoded):
 				self.deviceRequest = decoded.deviceRequest
@@ -263,7 +263,7 @@ public class MdocGattServer: @unchecked Sendable, ObservableObject {
 		if let items {
 			do {
 				let docTypeReq = deviceRequest?.docRequests.first?.itemsRequest.docType ?? ""
-				guard let (drToSend, _, _) = try await MdocHelpers.getDeviceResponseToSend(deviceRequest: deviceRequest!, issuerSigned: docs, selectedItems: items, sessionEncryption: sessionEncryption, eReaderKey: sessionEncryption!.sessionKeys.publicKey, devicePrivateKeys: devicePrivateKeys, dauthMethod: dauthMethod, unlockData: unlockData) else {
+				guard let (drToSend, _, _) = try await MdocHelpers.getDeviceResponseToSend(deviceRequest: deviceRequest!, issuerSigned: docs, docDisplayNames: docDisplayNames, selectedItems: items, sessionEncryption: sessionEncryption, eReaderKey: sessionEncryption!.sessionKeys.publicKey, devicePrivateKeys: devicePrivateKeys, dauthMethod: dauthMethod, unlockData: unlockData) else {
 					errorToSend = MdocHelpers.getErrorNoDocuments(docTypeReq); return
 				}
 				guard let dts = drToSend.documents, !dts.isEmpty else { errorToSend = MdocHelpers.getErrorNoDocuments(docTypeReq); return  }

Sources/MdocDataTransfer18013/Enumerations.swift

@@ -67,21 +67,6 @@ public enum ErrorCode: Int, CustomStringConvertible, Sendable {
 	}
 }
 
-/// String keys for the initialization dictionary
-public enum InitializeKeys: String, Sendable {
-	case document_signup_issuer_signed_data
-	case document_signup_issuer_signed_obj
-	case device_private_key_obj
-	case trusted_certificates
-	case device_auth_method
-}
 
-/// String keys for the user request dictionary
-public enum UserRequestKeys: String, Sendable {
-	case valid_items_requested
-	case error_items_requested
-	case reader_certificate_issuer
-	case reader_auth_validated
-	case reader_certificate_validation_message
-	case reader_legal_name
-}
+
+

Sources/MdocDataTransfer18013/InitializeTransferInfo.swift

@@ -0,0 +1,57 @@
+import Foundation
+import MdocDataModel18013
+import MdocSecurity18013
+
+public struct InitializeTransferData: Sendable {
+
+	public init(dataFormats: [String : String], documentData: [String : Data], docDisplayNames: [String: [String: [String: String]]?], privateKeyData: [String : String], trustedCertificates: [Data], deviceAuthMethod: String, idsToDocTypes: [String : String]) {
+        self.dataFormats = dataFormats
+        self.documentData = documentData
+				self.docDisplayNames = docDisplayNames
+        self.privateKeyData = privateKeyData
+        self.trustedCertificates = trustedCertificates
+        self.deviceAuthMethod = deviceAuthMethod
+        self.idsToDocTypes = idsToDocTypes
+    }
+
+    public let dataFormats: [String: String]
+    /// doc-id to document data
+    public let documentData: [String: Data]
+		// doc-id to doc.fields display names
+		public let docDisplayNames: [String: [String: [String: String]]?]
+    /// doc-id to private key secure area name
+    public let privateKeyData: [String: String]
+    /// trusted certificates
+    public let trustedCertificates: [Data]
+    /// device auth method
+    public let deviceAuthMethod: String
+    // document id to document type map
+    public let idsToDocTypes: [String: String]
+
+    public func toInitializeTransferInfo() -> InitializeTransferInfo {
+        // filter data and private keys by format
+        let documentObjects = documentData
+        let dataFormats = Dictionary.init(uniqueKeysWithValues: dataFormats.map { k,v in (k, DocDataFormat(rawValue: v)) }).compactMapValues { $0 }    
+        let privateKeyObjects = Dictionary.init(uniqueKeysWithValues: privateKeyData.map { k,v in (k, CoseKeyPrivate(privateKeyId: k, secureArea: SecureAreaRegistry.shared.get(name: v))) })
+        let iaca = trustedCertificates.map { SecCertificateCreateWithData(nil, $0 as CFData)! }
+        let deviceAuthMethod = DeviceAuthMethod(rawValue: deviceAuthMethod) ?? .deviceMac
+			return InitializeTransferInfo(dataFormats: dataFormats, documentObjects: documentObjects, docDisplayNames: docDisplayNames, privateKeyObjects: privateKeyObjects, iaca: iaca, deviceAuthMethod: deviceAuthMethod, idsToDocTypes: idsToDocTypes)
+    }
+}
+
+public struct InitializeTransferInfo {
+    /// doc-id to data format
+    public let dataFormats: [String: DocDataFormat]
+    /// doc-id to document objects
+    public let documentObjects: [String: Data]
+		// doc-id to doc.fields display names
+		public let docDisplayNames: [String: [String: [String: String]]?]
+    /// doc-id to private key objects
+    public let privateKeyObjects: [String: CoseKeyPrivate]
+    /// trusted certificates
+    public let iaca: [SecCertificate]
+    /// device auth method
+    public let deviceAuthMethod: DeviceAuthMethod
+        // document id to document type map
+    public let idsToDocTypes: [String: String]
+}

Sources/MdocDataTransfer18013/MdocHelpers.swift

@@ -28,30 +28,11 @@ import SwiftCBOR
 import Logging
 import X509
 
-public typealias RequestItems = [String: [String: [RequestItem]]]
+public typealias RequestItems = [String: [NameSpace: [RequestItem]]]
 
 /// Helper methods
 public class MdocHelpers {
 
-	public static func initializeData(parameters: [String: Any]) -> (docs: [String: IssuerSigned], devicePrivateKeys: [String: CoseKeyPrivate], iaca: [SecCertificate]?, dauthMethod: DeviceAuthMethod)? {
-		var docs: [String: IssuerSigned]?
-		var devicePrivateKeys: [String: CoseKeyPrivate]?
-		var iaca: [SecCertificate]?
-		var deviceAuthMethod = DeviceAuthMethod.deviceMac
-		if let issObjs = parameters[InitializeKeys.document_signup_issuer_signed_obj.rawValue] as? [String: IssuerSigned], let dpk = parameters[InitializeKeys.device_private_key_obj.rawValue] as? [String: CoseKeyPrivate] {
-			docs = issObjs
-			devicePrivateKeys = dpk
-		}
-		if let i = parameters[InitializeKeys.trusted_certificates.rawValue] as? [Data] {
-			iaca = i.compactMap { SecCertificateCreateWithData(nil, $0 as CFData) }
-		}
-		if let d = parameters[InitializeKeys.device_auth_method.rawValue] as? String, let dam = DeviceAuthMethod(rawValue: d) {
-			deviceAuthMethod = dam
-		}
-		guard let docs, let devicePrivateKeys else { return nil }
-		return (docs, devicePrivateKeys, iaca, deviceAuthMethod)
-	}
-
 	static var errorNoDocumentsDescriptionKey: String { "doctype_not_found" }
 	static func getErrorNoDocuments(_ docType: String) -> Error { NSError(domain: "\(MdocGattServer.self)", code: 0, userInfo: ["key": Self.errorNoDocumentsDescriptionKey, "%s": docType]) }
 
@@ -83,7 +64,7 @@ public class MdocHelpers {
 	///   - handOver: handOver structure
 	/// - Returns: A ``DeviceRequest`` object
 
-	public static func decodeRequestAndInformUser(deviceEngagement: DeviceEngagement?, docs: [String: IssuerSigned], iaca: [SecCertificate], requestData: Data, devicePrivateKeys: [String: CoseKeyPrivate], dauthMethod: DeviceAuthMethod, unlockData: [String: Data], readerKeyRawData: [UInt8]?, handOver: CBOR) async -> Result<(sessionEncryption: SessionEncryption, deviceRequest: DeviceRequest, userRequestInfo: UserRequestInfo, isValidRequest: Bool), Error> {
+	public static func decodeRequestAndInformUser(deviceEngagement: DeviceEngagement?, docs: [String: IssuerSigned], docDisplayNames: [String: [String: [String: String]]?], iaca: [SecCertificate], requestData: Data, devicePrivateKeys: [String: CoseKeyPrivate], dauthMethod: DeviceAuthMethod, unlockData: [String: Data], readerKeyRawData: [UInt8]?, handOver: CBOR) async -> Result<(sessionEncryption: SessionEncryption, deviceRequest: DeviceRequest, userRequestInfo: UserRequestInfo, isValidRequest: Bool), Error> {
 		do {
 			guard let seCbor = try CBOR.decode([UInt8](requestData)) else { logger.error("Request Data is not Cbor"); return .failure(Self.makeError(code: .requestDecodeError)) }
 			guard var se = SessionEstablishment(cbor: seCbor) else { logger.error("Request Data cannot be decoded to session establisment"); return .failure(Self.makeError(code: .requestDecodeError)) }
@@ -96,9 +77,9 @@ public class MdocHelpers {
 			guard var sessionEncryption else { logger.error("Session Encryption not initialized"); return .failure(Self.makeError(code: .sessionEncryptionNotInitialized)) }
 			guard let requestData = try await sessionEncryption.decrypt(requestCipherData) else { logger.error("Request data cannot be decrypted"); return .failure(Self.makeError(code: .requestDecodeError)) }
 			guard let deviceRequest = DeviceRequest(data: requestData) else { logger.error("Decrypted data cannot be decoded"); return .failure(Self.makeError(code: .requestDecodeError)) }
-			guard let (drTest, validRequestItems, errorRequestItems) = try await Self.getDeviceResponseToSend(deviceRequest: deviceRequest, issuerSigned: docs, selectedItems: nil, sessionEncryption: sessionEncryption, eReaderKey: sessionEncryption.sessionKeys.publicKey, devicePrivateKeys: devicePrivateKeys, dauthMethod: dauthMethod, unlockData: unlockData) else { logger.error("Valid request items nil"); return .failure(Self.makeError(code: .requestDecodeError)) }
+			guard let (drTest, validRequestItems, errorRequestItems) = try await Self.getDeviceResponseToSend(deviceRequest: deviceRequest, issuerSigned: docs, docDisplayNames: docDisplayNames, selectedItems: nil, sessionEncryption: sessionEncryption, eReaderKey: sessionEncryption.sessionKeys.publicKey, devicePrivateKeys: devicePrivateKeys, dauthMethod: dauthMethod, unlockData: unlockData) else { logger.error("Valid request items nil"); return .failure(Self.makeError(code: .requestDecodeError)) }
 			let bInvalidReq = (drTest.documents == nil)
-			var userRequestInfo = UserRequestInfo(validItemsRequested: validRequestItems, errorItemsRequested: errorRequestItems)
+			var userRequestInfo = UserRequestInfo(docDataFormats: docs.mapValues { _ in .cbor }, validItemsRequested: validRequestItems, errorItemsRequested: errorRequestItems)
 			if let docR = deviceRequest.docRequests.first {
 				let mdocAuth = MdocReaderAuthentication(transcript: sessionEncryption.transcript)
 				if let readerAuthRawCBOR = docR.readerAuthRawCBOR, case let certData = docR.readerCertificates, certData.count > 0, let x509 = try? X509.Certificate(derEncoded: [UInt8](certData.first!)), let (b,reasonFailure) = try? mdocAuth.validateReaderAuth(readerAuthCBOR: readerAuthRawCBOR, readerAuthX5c: certData, itemsRequestRawData: docR.itemsRequestRawData!, rootCerts: iaca) {
@@ -122,27 +103,30 @@ public class MdocHelpers {
 	///   - sessionTranscript: Session Transcript object
 	///   - dauthMethod: Mdoc Authentication method
 	/// - Returns: (Device response object, valid requested items, error request items) tuple
-	public static func getDeviceResponseToSend(deviceRequest: DeviceRequest?, issuerSigned: [String: IssuerSigned], selectedItems: RequestItems? = nil, sessionEncryption: SessionEncryption? = nil, eReaderKey: CoseKey? = nil, devicePrivateKeys: [String: CoseKeyPrivate], sessionTranscript: SessionTranscript? = nil, dauthMethod: DeviceAuthMethod, unlockData: [String: Data]) async throws -> (response: DeviceResponse, validRequestItems: RequestItems, errorRequestItems: RequestItems)? {
+	public static func getDeviceResponseToSend(deviceRequest: DeviceRequest?, issuerSigned: [String: IssuerSigned], docDisplayNames: [String: [String: [String: String]]?], selectedItems: RequestItems? = nil, sessionEncryption: SessionEncryption? = nil, eReaderKey: CoseKey? = nil, devicePrivateKeys: [String: CoseKeyPrivate], sessionTranscript: SessionTranscript? = nil, dauthMethod: DeviceAuthMethod, unlockData: [String: Data]) async throws -> (deviceResponse: DeviceResponse, validRequestItems: RequestItems, errorRequestItems: RequestItems)? {
 		var docFiltered = [Document](); var docErrors = [[DocType: UInt64]]()
 		var validReqItemsDocDict = RequestItems(); var errorReqItemsDocDict = RequestItems()
 		guard deviceRequest != nil || selectedItems != nil else { fatalError("Invalid call") }
 		let haveSelectedItems = selectedItems != nil
 		// doc.id's (if have selected items), otherwise doc.types
 		let reqDocIdsOrDocTypes = if haveSelectedItems { Array(selectedItems!.keys) } else { deviceRequest!.docRequests.map(\.itemsRequest.docType) }
+		var docId: String?
 		for reqDocIdOrDocType in reqDocIdsOrDocTypes {
 			var docReq: DocRequest? // if selected items is null
 			if haveSelectedItems == false {
 				docReq = deviceRequest?.docRequests.findDoc(name: reqDocIdOrDocType)
-				guard let (_, _) = Array(issuerSigned.values).findDoc(name: reqDocIdOrDocType) else {
+				guard let pair = issuerSigned.first(where: { $1.issuerAuth.mso.docType == reqDocIdOrDocType}) else {
 					docErrors.append([reqDocIdOrDocType: UInt64(0)])
 					errorReqItemsDocDict[reqDocIdOrDocType] = [:]
 					continue
 				}
+				docId = pair.key
 			} else {
 				guard issuerSigned[reqDocIdOrDocType] != nil else { continue }
 			}
 			let devicePrivateKey = devicePrivateKeys[reqDocIdOrDocType] // used only if doc.id
 			let doc = if haveSelectedItems { issuerSigned[reqDocIdOrDocType]! } else { Array(issuerSigned.values).findDoc(name: reqDocIdOrDocType)!.0 }
+			let displayNames = if haveSelectedItems { docDisplayNames[reqDocIdOrDocType] } else { docDisplayNames[docId!] }
 			// Document's data must be in CBOR bytes that has the IssuerSigned structure according to ISO 23220-4
 			// Currently, the library does not support IssuerSigned structure without the nameSpaces field.
 			guard let issuerNs = doc.issuerNameSpaces else { logger.error("Document does not contain issuer namespaces"); return nil }
@@ -167,7 +151,7 @@ public class MdocHelpers {
 				}
 				if itemsToAdd.count > 0 {
 					nsItemsToAdd[reqNamespace] = itemsToAdd
-					validReqItemsNsDict[reqNamespace] = itemsToAdd.map { RequestItem(elementIdentifier: $0.elementIdentifier, intentToRetain: docReq?.itemsRequest.requestNameSpaces.nameSpaces[reqNamespace]?.dataElements[$0.elementIdentifier], isOptional: nil) }
+					validReqItemsNsDict[reqNamespace] = itemsToAdd.map { RequestItem(elementIdentifier: $0.elementIdentifier, displayName: displayNames??[reqNamespace]?[$0.elementIdentifier], intentToRetain: docReq?.itemsRequest.requestNameSpaces.nameSpaces[reqNamespace]?.dataElements[$0.elementIdentifier], isOptional: nil) }
 				}
 				let errorItemsSet = itemsReqSet.subtracting(itemsSet)
 				if errorItemsSet.count > 0 {

Sources/MdocDataTransfer18013/RequestItem.swift

@@ -16,24 +16,38 @@ limitations under the License.
 import Foundation
 
 /// A structure representing a request item for data transfer.
-public struct RequestItem: Equatable, Sendable {
-		public init(elementIdentifier: String, intentToRetain: Bool? = nil, isOptional: Bool? = nil) {
+public struct RequestItem: Equatable, Hashable, Sendable {
+		public init(elementIdentifier: String, displayName: String?, intentToRetain: Bool? = nil, isOptional: Bool? = nil) {
 				self.elementIdentifier = elementIdentifier
+				self.displayName = displayName
 				self.intentToRetain = intentToRetain
 				self.isOptional = isOptional
 		}
+
 		public init(elementIdentifier: String) {
 				self.elementIdentifier = elementIdentifier
+				self.displayName = nil
 				self.intentToRetain = nil
 				self.isOptional = nil
 		}
 
 		/// A unique identifier for the data element.
 		/// This identifier is used to distinguish between different elements within the data transfer process.
 		public let elementIdentifier: String
+	  // display name
+		public let displayName: String?
 		/// Indicates whether the mdoc verifier intends to retain the received data element
 		public let intentToRetain: Bool?
 		/// Indicates whether the data element is optional.
 		/// false or nil value of the property indicates the field is required
 		public let isOptional: Bool?
+
+		//implementation of Equatable and Hashable
+		public static func == (lhs: RequestItem, rhs: RequestItem) -> Bool {
+				return lhs.elementIdentifier == rhs.elementIdentifier
+		}
+
+		public func hash(into hasher: inout Hasher) {
+				hasher.combine(elementIdentifier)
+		}
 }

Sources/MdocDataTransfer18013/UserRequestInfo.swift

@@ -13,21 +13,31 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
+import Foundation
+import MdocDataModel18013
 
 public struct UserRequestInfo : Sendable {
-	public init(validItemsRequested: RequestItems, errorItemsRequested: RequestItems? = nil, readerAuthValidated: Bool? = nil, readerCertificateIssuer: String? = nil, readerCertificateValidationMessage: String? = nil, readerLegalName: String? = nil) {
+	public init(docDataFormats: [String: DocDataFormat], validItemsRequested: RequestItems, errorItemsRequested: RequestItems? = nil, readerAuthValidated: Bool? = nil, readerCertificateIssuer: String? = nil, readerCertificateValidationMessage: String? = nil, readerLegalName: String? = nil) {
+		self.docDataFormats = docDataFormats
 		self.validItemsRequested = validItemsRequested
 		self.errorItemsRequested = errorItemsRequested
 		self.readerAuthValidated = readerAuthValidated
 		self.readerCertificateIssuer = readerCertificateIssuer
 		self.readerCertificateValidationMessage = readerCertificateValidationMessage
 		self.readerLegalName = readerLegalName
 	}
-
+	/// docType to format map
+	public var docDataFormats: [String: DocDataFormat]
+	/// valid items requested
 	public var validItemsRequested: RequestItems
+	/// error items requested
 	public var errorItemsRequested: RequestItems?
+	/// reader authentication from verifer validated
 	public var readerAuthValidated: Bool?
+	/// reader certificate issuer
 	public var readerCertificateIssuer: String?
+	/// reader certificate validation message
 	public var readerCertificateValidationMessage: String?
+	/// reader legal name
 	public var readerLegalName: String?
 }

Tests/MdocDataTransfer18013Tests/MdocDataTransfer18013Tests.swift

@@ -14,18 +14,14 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import XCTest
+import Testing
 @testable import MdocDataTransfer18013
 
-final class MdocDataTransfer18013Tests: XCTestCase {
-	// XCTest Documenation
-	// https://developer.apple.com/documentation/xctest
-	// Defining Test Cases and Test Methods
-	// https://developer.apple.com/documentation/xctest/defining_test_cases_and_test_methods
+struct MdocDataTransfer18013Tests {
 
-	func test_uuids() {
-		XCTAssertEqual(MdocServiceCharacteristic.state.uuid.uuidString, "00000001-A123-48CE-896B-4C76973373E6")
-		XCTAssertEqual(MdocServiceCharacteristic.client2Server.uuid.uuidString, "00000002-A123-48CE-896B-4C76973373E6")
-		XCTAssertEqual(MdocServiceCharacteristic.server2Client.uuid.uuidString, "00000003-A123-48CE-896B-4C76973373E6")
+	@Test func testUuids() {
+		#expect(MdocServiceCharacteristic.state.uuid.uuidString == "00000001-A123-48CE-896B-4C76973373E6")
+		#expect(MdocServiceCharacteristic.client2Server.uuid.uuidString == "00000002-A123-48CE-896B-4C76973373E6")
+		#expect(MdocServiceCharacteristic.server2Client.uuid.uuidString == "00000003-A123-48CE-896B-4C76973373E6")
 	}
 }