@devicelab/maestro-runner-darwin-arm64 1.1.27 → 1.1.29

package/drivers/ios/devicelab-ios-agent/simulator/DevicelabIOSAgentUITests-Runner.app/Frameworks/XCTest.framework/Headers/XCTAttachment.h

@@ -0,0 +1,219 @@
+#if __has_include(<XCTestCore/XCTAttachment.h>)
+#import <XCTestCore/XCTAttachment.h>
+#else
+
+//
+//  Copyright © 2017 Apple. All rights reserved.
+//
+
+#import <XCTest/XCTestDefines.h>
+#import <XCTest/XCTAttachmentLifetime.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*!
+ * @class XCTAttachment
+ * Represents the concept of data attached to an XCTActivity. Allows reporting more context about the test run
+ * for debugging, such as screenshots, log files, and configuration dictionaries.
+ *
+ * Each attachment must be added to an activity to be handed off to XCTest. There are two ways to get an activity:
+ * 1. XCTestCase conforms to the XCTActivity protocol, attachments can be added to it directly.
+ * 2. Create a nested activity with +[XCTContext runActivityNamed:block:], the parameter inside the block is a new activity to which attachments can be added.
+ *
+ * Once you have an XCTActivity-conforming object:
+ * • Create a new XCTAttachment with one of the initializers provided.
+ * • Optionally customize the attachment's `lifetime`, `name` and `userInfo` properties.
+ * • Add the attachment to the activity with -[XCTActivity addAttachment:].
+ *
+ * @textblock
+ 
+    - (void)testFoo
+    {
+        // ...
+        NSString *logs = ...
+        XCTAttachment *attachment = [XCTAttachment attachmentWithString:logs];
+        attachment.name = @"Build logs";
+        [self addAttachment:attachment];
+    }
+
+    - (void)testNestedFoo
+    {
+        // ...
+        [XCTContext runActivityNamed:@"Collect logs" block:^(id<XCTActivity> activity){
+            NSString *logs = ...
+            XCTAttachment *attachment = [XCTAttachment attachmentWithString:logs];
+            attachment.name = @"Build logs";
+            [activity addAttachment:attachment];
+        }];
+    }
+ 
+ * @/textblock
+ *
+ * Attachments have the default lifetime of .deleteOnSuccess, which means they are deleted when
+ * their test passes. This ensures attachments are only kept when test fails. To override this
+ * behavior, change the value of the `lifetime` property to .keepAlways before adding it to an activity.
+ *
+ * @textblock
+ 
+     - (void)testImportantAttachment
+     {
+         XCTAttachment *attachment = ...
+         attachment.lifetime = XCTAttachmentLifetimeKeepAlways;
+         [self addAttachment:attachment];
+     }
+ 
+ * @/textblock
+ */
+@interface XCTAttachment : NSObject <NSSecureCoding>
+
++ (instancetype)new NS_UNAVAILABLE;
+- (instancetype)init NS_UNAVAILABLE;
+
+/*!
+ * @method -initWithUniformTypeIdentifier:name:payload:userInfo:
+ */
+- (instancetype)initWithUniformTypeIdentifier:(nullable NSString *)identifier
+                                         name:(nullable NSString *)name
+                                      payload:(nullable NSData *)payload
+                                     userInfo:(nullable NSDictionary *)userInfo NS_DESIGNATED_INITIALIZER;
+
++ (instancetype)attachmentWithUniformTypeIdentifier:(nullable NSString *)identifier
+                                               name:(nullable NSString *)name
+                                            payload:(nullable NSData *)payload
+                                           userInfo:(nullable NSDictionary *)userInfo;
+
+/*!
+ * @property uniformTypeIdentifier
+ * Uniform Type Identifier of the payload data.
+ * Examples: "public.png", "public.jpeg", "public.plain-text", "public.data", "com.apple.xml-property-list".
+ */
+@property (readonly, copy) NSString *uniformTypeIdentifier;
+
+/*!
+ * @property name
+ * Attachment name.
+ */
+@property (copy, nullable) NSString *name;
+
+/*!
+ * @property userInfo
+ * Container for additional metadata, such as pixel density with images.
+ */
+@property (copy, nullable) NSDictionary *userInfo;
+
+/*
+ * @property lifetime
+ * Attachment lifetime. Controls whether the attachment is persisted.
+ * @see XCTAttachmentLifetime
+ * Default: XCTAttachmentLifetimeDeleteOnSuccess
+ */
+@property XCTAttachmentLifetime lifetime;
+
+@end
+
+#if TARGET_OS_OSX
+@class NSImage;
+#else
+@class UIImage;
+#endif
+
+/*!
+ * @enum XCTImageQuality
+ */
+typedef NS_ENUM(NSInteger, XCTImageQuality) {
+    
+    /* Original quality, lossless PNG. */
+    XCTImageQualityOriginal,
+    
+    /* High quality, lossy JPEG or HEIC. */
+    XCTImageQualityMedium,
+    
+    /* Highly compressed, lossy JPEG or HEIC. */
+    XCTImageQualityLow
+};
+
+@interface XCTAttachment (ConvenienceInitializers)
+
+/*!
+ * @method -attachmentWithData:
+ * Creates a new data attachment (type "public.data") with the specified payload.
+ */
++ (instancetype)attachmentWithData:(NSData *)payload;
+
+/*!
+ * @method -attachmentWithData:uniformTypeIdentifier:
+ * Creates a new attachment with the specified payload and type.
+ */
++ (instancetype)attachmentWithData:(NSData *)payload uniformTypeIdentifier:(NSString *)identifier;
+
+/*!
+ * @method -attachmentWithString:
+ * Creates a new plain UTF-8 encoded text attachment (type "public.plain-text") with the specified string.
+ */
++ (instancetype)attachmentWithString:(NSString *)string;
+
+/*!
+ * @method -attachmentWithArchivableObject:
+ * Creates an attachment with an object that can be encoded with NSSecureCoding.
+ * Defaults to type "public.data".
+ */
++ (instancetype)attachmentWithArchivableObject:(id<NSSecureCoding>)object;
+
+/*!
+ * @method -attachmentWithArchivableObject:uniformTypeIdentifier:
+ * Creates an attachment with an object that can be encoded with NSSecureCoding and type.
+ */
++ (instancetype)attachmentWithArchivableObject:(id<NSSecureCoding>)object uniformTypeIdentifier:(NSString *)identifier;
+
+/*!
+ * @method -attachmentWithPlistObject:
+ * Creates an attachment with an object that can be encoded into an XML property list.
+ */
++ (instancetype)attachmentWithPlistObject:(id)object;
+
+/*!
+ * @method -attachmentWithContentsOfFileAtURL:
+ * Creates an attachment with an existing file on disk. Attachment's uniform type identifier is inferred from the file extension.
+ * If no type can be inferred from the extension, fallback is "public.data".
+ * @note Only works for files, not directories.
+ */
++ (instancetype)attachmentWithContentsOfFileAtURL:(NSURL *)url;
+
+/*!
+ * @method -attachmentWithContentsOfFileAtURL:uniformTypeIdentifier:
+ * Creates an attachment with an existing file on disk and type.
+ * @note Only works for files, not directories.
+ */
++ (instancetype)attachmentWithContentsOfFileAtURL:(NSURL *)url uniformTypeIdentifier:(NSString *)identifier;
+
+/*!
+ * @method -attachmentWithCompressedContentsOfDirectoryAtURL:
+ * Creates an attachment with an existing directory on disk. Automatically zips the directory, the content type is "public.zip-archive".
+ */
++ (instancetype)attachmentWithCompressedContentsOfDirectoryAtURL:(NSURL *)url;
+
+/*!
+ * @method +attachmentWithImage:
+ * Creates an attachment with a platform-specific image class.
+ */
+#if TARGET_OS_OSX
++ (instancetype)attachmentWithImage:(NSImage *)image;
+#else
++ (instancetype)attachmentWithImage:(UIImage *)image;
+#endif
+
+/*!
+ * @method +attachmentWithImage:quality:
+ * Creates an attachment with a platform-specific image class and specified quality.
+ */
+#if TARGET_OS_OSX
++ (instancetype)attachmentWithImage:(NSImage *)image quality:(XCTImageQuality)quality;
+#else
++ (instancetype)attachmentWithImage:(UIImage *)image quality:(XCTImageQuality)quality;
+#endif
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif

package/drivers/ios/devicelab-ios-agent/simulator/DevicelabIOSAgentUITests-Runner.app/Frameworks/XCTest.framework/Headers/XCTAttachmentLifetime.h

@@ -0,0 +1,28 @@
+#if __has_include(<XCTestCore/XCTAttachmentLifetime.h>)
+#import <XCTestCore/XCTAttachmentLifetime.h>
+#else
+
+//
+//  Copyright © 2017 Apple. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef NS_ENUM(NSInteger, XCTAttachmentLifetime) {
+    
+    /*
+     * Attachment will be kept regardless of the outcome of the test.
+     */
+    XCTAttachmentLifetimeKeepAlways = 0,
+    
+    /*
+     * Attachment will only be kept when the test fails, and deleted otherwise.
+     */
+    XCTAttachmentLifetimeDeleteOnSuccess = 1
+};
+
+NS_ASSUME_NONNULL_END
+
+#endif

package/drivers/ios/devicelab-ios-agent/simulator/DevicelabIOSAgentUITests-Runner.app/Frameworks/XCTest.framework/Headers/XCTContext.h

@@ -0,0 +1,65 @@
+#if __has_include(<XCTestCore/XCTContext.h>)
+#import <XCTestCore/XCTContext.h>
+#else
+
+//
+//  Copyright © 2017 Apple. All rights reserved.
+//
+
+#import <XCTest/XCTestDefines.h>
+
+@protocol XCTActivity;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface XCTContext : NSObject
+
+- (instancetype)init XCT_UNAVAILABLE("XCTContext is not to be instantiated directly, use +[XCTContext runActivityNamed:block:] to run an activity.");
++ (instancetype)new XCT_UNAVAILABLE("XCTContext is not to be instantiated directly, use +[XCTContext runActivityNamed:block:] to run an activity.");
+
+/*!
+ * @method -runActivityNamed:block:
+ *
+ * Call to create a named activity around the block.
+ * Can be used to group low level actions, such as typing and tapping, into high level
+ * tasks, such as filling of a form in a UI test.
+ * @textblock
+ 
+ - (void)testSignUpFlow {
+     XCUIElement *form = ...
+     [XCTContext runActivityNamed:@"Fill in account information" block:^{
+         [form.textFields[@"Email"] typeText:@"john.appleseed@icloud.com"];
+         [form.secureTextFields[@"New Password"] typeText:@"myPassword"];
+     }];
+     [XCTContext runActivityNamed:@"Create account" block:^{
+         XCUIElement *submit = form.buttons[@"Create"];
+         XCTAssert(submit.isEnabled);
+         [submit tap];
+     }];
+ }
+ 
+ * @/textblock
+ * Such test would result in an activity hierarchy of:
+ * @textblock
+ 
+ - Fill in account information
+     - Type "john.appleseed@icloud.com" into "Email"
+     - Type "myPassword" into "New Password"
+ - Create account
+     - Tap "Create"
+ 
+ * @/textblock
+ *
+ * Must be called from the main thread.
+ *
+ * @param name A string that will help identify the activity.
+ *
+ * @param block A block whose contents are wrapped in the new activity.
+ */
++ (void)runActivityNamed:(NSString *)name block:(XCT_NOESCAPE void(^)(id<XCTActivity> activity))block NS_REFINED_FOR_SWIFT;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif

package/drivers/ios/devicelab-ios-agent/simulator/DevicelabIOSAgentUITests-Runner.app/Frameworks/XCTest.framework/Headers/XCTDarwinNotificationExpectation.h

@@ -0,0 +1,60 @@
+#if __has_include(<XCTestCore/XCTDarwinNotificationExpectation.h>)
+#import <XCTestCore/XCTDarwinNotificationExpectation.h>
+#else
+
+//
+//  Copyright © 2016-2017 Apple Inc. All rights reserved.
+//
+
+#import <XCTest/XCTestExpectation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*!
+ * @typedef
+ * Handler called when the expectation has received the Darwin notification. If the handler is not
+ * provided the first posting of the notification will fulfill the expectation. If provided, the handler
+ * will be queried each time the notification is received to determine whether the expectation should
+ * be fulfilled or not. This allows the caller to check Darwin state variables or perform other logic
+ * beyond simply verifying that the notification has been posted.
+ */
+typedef BOOL (^XCT_SWIFT_SENDABLE XCTDarwinNotificationExpectationHandler)(void);
+
+/*!
+ * @class XCTDarwinNotificationExpectation
+ * Expectation subclass for waiting on a condition defined by a Darwin notification. The notification
+ * which may be posted in the same process or by other processes. Be aware that Darwin notifications
+ * may be coalesced when posted in quick succession, so be careful especially when using the
+ * `expectedFulfillmentCount` property with this class.
+ */
+@interface XCTDarwinNotificationExpectation : XCTestExpectation
+
++ (instancetype)new NS_UNAVAILABLE;
+- (instancetype)init NS_UNAVAILABLE;
+- (instancetype)initWithDescription:(NSString *)expectationDescription NS_UNAVAILABLE;
+
+/*!
+ * @method -initWithNotificationName:
+ *
+ * @discussion
+ * Initializes an expectation that waits for a Darwin notification to be posted.
+ */
+- (instancetype)initWithNotificationName:(NSString *)notificationName NS_DESIGNATED_INITIALIZER;
+
+/*!
+ * @property notificationName
+ * Returns the value of the notification name that was provided to the initializer.
+ */
+@property (readonly, copy) NSString *notificationName;
+
+/*!
+ * @property handler
+ * Allows the caller to install a special handler to do custom evaluation when the notification is posted.
+ */
+@property (nullable, copy) XCTDarwinNotificationExpectationHandler handler;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif

package/drivers/ios/devicelab-ios-agent/simulator/DevicelabIOSAgentUITests-Runner.app/Frameworks/XCTest.framework/Headers/XCTExpectedFailure.h

@@ -0,0 +1,134 @@
+#if __has_include(<XCTestCore/XCTExpectedFailure.h>)
+#import <XCTestCore/XCTExpectedFailure.h>
+#else
+
+//
+//  Copyright © 2020 Apple Inc. All rights reserved.
+//
+
+#import <XCTest/XCTestDefines.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class XCTIssue;
+@class XCTSourceCodeContext;
+@class XCTExpectedFailureOptions;
+
+/*!
+ * @function XCTExpectFailure()
+ * Declares that the test is expected to fail at some point beyond the call. This can be used to both document and
+ * suppress a known issue when immediate resolution is not possible. Issues caught by XCTExpectFailure do not
+ * impact the aggregate results of the test suites which own them.
+ *
+ * This function may be invoked repeatedly and has stack semantics. Failures are associated with the closest
+ * matching expected failure and the stack is cleaned up by the test after it runs. If a failure is expected
+ * but none is recorded, a distinct failure for the unmatched expected failure will be recorded instead.
+ *
+ * By default XCTExpectFailure matches all issues, including issues with warning severity.
+ *
+ * Threading considerations: when XCTExpectFailure is called on the test's primary thread it will match against
+ * any issue recorded on any thread. When XCTExpectFailure is called on any other thread, it will only match
+ * against issues recorded on the same thread.
+ *
+ * @param failureReason Explanation of the issue being suppressed. If it contains
+ * a URL, that URL can be extracted and presented as a link in reporting UI (Xcode and CI).
+ */
+XCT_EXPORT void XCTExpectFailure(NSString *_Nullable failureReason) NS_SWIFT_UNAVAILABLE("Use XCTExpectFailure(_:options:) instead");
+
+/*!
+ * @function XCTExpectFailureWithOptions()
+ * Like XCTExpectFailure, but takes an options object that can be used to customize the behavior.
+ *
+ * @param options The options can include a custom issue matching block as well as the ability to
+ * disable "strict" behavior, which relaxes the requirement that a call to XCTExpectFailure must be matched
+ * against at least one recorded issue.
+ */
+XCT_EXPORT void XCTExpectFailureWithOptions(NSString *_Nullable failureReason,
+                                            XCTExpectedFailureOptions *options) NS_REFINED_FOR_SWIFT;
+
+/*!
+ * @function XCTExpectFailureInBlock()
+ * Like XCTExpectFailure, but limits the scope in which issues are matched.
+ *
+ * @param failingBlock The scope of code in which the failure is expected. Note that this will only
+ * match against failures in that scope on the same thread; failures in dispatch callouts or other code
+ * running on a different thread will not be matched.
+ */
+XCT_EXPORT void XCTExpectFailureInBlock(NSString *_Nullable failureReason,
+                                        XCT_NOESCAPE void (^failingBlock)(void)) NS_SWIFT_UNAVAILABLE("Use XCTExpectFailure(_:options:failingBlock:) instead");
+
+/*!
+ * @function XCTExpectFailureWithOptionsInBlock()
+ * Like XCTExpectFailure, but takes an options object that can be used to customize the behavior and
+ * limits the scope in which issues are matched.
+ */
+XCT_EXPORT void XCTExpectFailureWithOptionsInBlock(NSString *_Nullable failureReason,
+                                                   XCTExpectedFailureOptions *options,
+                                                   XCT_NOESCAPE void (^failingBlock)(void)) NS_REFINED_FOR_SWIFT;
+
+/*!
+ * @class XCTExpectedFailureOptions
+ * Describes the rules for matching issues to expected failures and other behaviors related to
+ * expected failure handling.
+ */
+@interface XCTExpectedFailureOptions : NSObject <NSCopying, NSSecureCoding>
+
+/*!
+ * @property issueMatcher
+ * An optional filter can be used to determine whether or not an issue recorded inside an expected
+ * failure block should be matched to the expected failure. Issues that are not matched to an expected
+ * failure will be recorded as normal issues (real test failures). By default the filter is nil and
+ * all issues are matched, including issues with warning severity.
+ */
+@property (copy) BOOL (^issueMatcher)(XCTIssue *);
+
+/*!
+ * @property enabled
+ * For expected failures that only occur under certain circumstances, this flag can be used to
+ * disable the expected failure. In the closure-based variants of XCTExpectFailure, the failing block
+ * will be executed normally. Defaults to YES/true.
+ */
+@property (getter=isEnabled) BOOL enabled;
+
+/*!
+ * @property strict
+ * If true (the default) and no issue is matched to the expected failure, then an issue will be
+ * recorded for the unmatched expected failure itself.
+ */
+@property (getter=isStrict) BOOL strict;
+
+/*!
+ * @method nonStrictOptions
+ * Convenience factory method which returns a new instance of XCTExpectedFailureOptions that has `isStrict` set to NO, with every other value set to its default.
+ */
++ (XCTExpectedFailureOptions *)nonStrictOptions;
+
+@end
+
+/*!
+ * @class XCTExpectedFailure
+ * Contains the details about a single instance of an expected failure, including the failure
+ * reason and the underlying issue that was recorded.
+ */
+@interface XCTExpectedFailure : NSObject <NSSecureCoding>
+
+- (instancetype)init XCT_UNAVAILABLE("Instances of XCTExpectedFailure should not be created directly, they are provided by the framework.");
++ (instancetype)new XCT_UNAVAILABLE("Instances of XCTExpectedFailure should not be created directly, they are provided by the framework.");
+
+/*!
+ * @property failureReason
+ * Explanation of the problem requiring the issue to be suppressed.
+ */
+@property (readonly, nullable, copy) NSString *failureReason;
+
+/*!
+ * @property issue
+ * The issue being suppressed.
+ */
+@property (readonly, copy) XCTIssue *issue;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif

package/drivers/ios/devicelab-ios-agent/simulator/DevicelabIOSAgentUITests-Runner.app/Frameworks/XCTest.framework/Headers/XCTIssue.h

@@ -0,0 +1,143 @@
+#if __has_include(<XCTestCore/XCTIssue.h>)
+#import <XCTestCore/XCTIssue.h>
+#else
+
+//
+//  Copyright © 2019 Apple Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/*!
+ * @enum XCTIssueType
+ * Types of failures and other issues that can be reported for tests.
+ */
+typedef NS_ENUM(NSInteger, XCTIssueType) {
+    /// Issue raised by a failed XCTAssert or related API.
+    XCTIssueTypeAssertionFailure = 0,
+    /// Issue raised by the test throwing an error in Swift. This could also occur if an Objective C test is implemented in the form `- (BOOL)testFoo:(NSError **)outError` and returns NO with a non-nil out error.
+    XCTIssueTypeThrownError = 1,
+    /// Code in the test throws and does not catch an exception, Objective C, C++, or other.
+    XCTIssueTypeUncaughtException = 2,
+    /// One of the XCTestCase(measure:) family of APIs detected a performance regression.
+    XCTIssueTypePerformanceRegression = 3,
+    /// One of the framework APIs failed internally. For example, XCUIApplication was unable to launch or terminate an app or XCUIElementQuery was unable to complete a query.
+    XCTIssueTypeSystem = 4,
+    /// Issue raised when XCTExpectFailure is used but no matching issue is recorded.
+    XCTIssueTypeUnmatchedExpectedFailure = 5,
+};
+
+/// An enum representing the severity of a test issue.
+///
+/// The numeric values of this enum's cases are comparable. A case which represents
+/// higher severity has a larger numeric value than one which represents lower
+/// severity. Specifying a numeric severity value other than one corresponding to
+/// a case defined below when initializing an ``XCTIssue`` is unsupported.
+typedef NS_ENUM(NSInteger, XCTIssueSeverity) {
+    /// The severity level for an issue which should be noted but is not
+    /// necessarily an error.
+    /// 
+    /// An issue with warning severity does not cause the test it's associated
+    /// with to be marked as a failure, but is noted in the results.
+    XCTIssueSeverityWarning = 4,
+
+    /// The severity level for an issue which represents an error in a test.
+    ///
+    /// An issue with error severity causes the test it's associated with to be
+    /// marked as a failure.
+    XCTIssueSeverityError = 8,
+} NS_SWIFT_NAME(XCTIssue.Severity);
+
+@class XCTAttachment;
+@class XCTSourceCodeContext;
+
+/*!
+ * @class XCTIssue
+ * Encapsulates all data concerning a test failure or other issue.
+ */
+@interface XCTIssue : NSObject <NSCopying, NSMutableCopying, NSSecureCoding>
+
+- (instancetype)initWithType:(XCTIssueType)type
+          compactDescription:(NSString *)compactDescription
+         detailedDescription:(nullable NSString *)detailedDescription
+           sourceCodeContext:(XCTSourceCodeContext *)sourceCodeContext
+             associatedError:(nullable NSError *)associatedError
+                 attachments:(NSArray<XCTAttachment *> *)attachments NS_DESIGNATED_INITIALIZER;
+
+- (instancetype)initWithType:(XCTIssueType)type
+          compactDescription:(NSString *)compactDescription
+         detailedDescription:(nullable NSString *)detailedDescription
+           sourceCodeContext:(XCTSourceCodeContext *)sourceCodeContext
+             associatedError:(nullable NSError *)associatedError
+                 attachments:(NSArray<XCTAttachment *> *)attachments
+                    severity:(XCTIssueSeverity)severity NS_DESIGNATED_INITIALIZER;
+                    
+- (instancetype)initWithType:(XCTIssueType)type
+          compactDescription:(NSString *)compactDescription
+                    severity:(XCTIssueSeverity)severity;
+
+- (instancetype)initWithType:(XCTIssueType)type compactDescription:(NSString *)compactDescription;
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+/// The type of the issue.
+@property (readonly) XCTIssueType type;
+
+/// A concise description of the issue, expected to be free of transient data and suitable for use in test run
+/// summaries and for aggregation of results across multiple test runs.
+@property (readonly, copy) NSString *compactDescription;
+
+/// A detailed description of the issue designed to help diagnose the issue. May include transient data such as
+/// numbers, object identifiers, timestamps, etc.
+@property (readonly, copy, nullable) NSString *detailedDescription;
+
+/// The source code location (file and line number) and the call stack associated with the issue.
+@property (readonly, strong) XCTSourceCodeContext *sourceCodeContext;
+
+/// Error associated with the issue.
+@property (readonly, strong, nullable) NSError *associatedError;
+
+/// All attachments associated with the issue.
+@property (readonly, copy) NSArray<XCTAttachment *> *attachments;
+
+/// The severity of the issue.
+@property (readonly) XCTIssueSeverity severity;
+
+/// Whether or not this issue should cause the test it's associated with to be
+/// considered a failure.
+///
+/// The value of this property is `YES` for issues which have a severity level of
+/// ``XCTIssueSeverityError`` or higher.
+/// Otherwise, the value of this property is `NO`.
+///
+/// Use this property to determine if an issue should be considered a failure, instead of
+/// directly comparing the value of the ``severity`` property.
+@property (readonly) BOOL isFailure;
+
+@end
+
+/*!
+* @class XCTMutableIssue
+* Mutable variant of XCTIssue, suitable for modifying by overrides in the reporting chain.
+*/
+@interface XCTMutableIssue : XCTIssue
+
+@property (readwrite) XCTIssueType type;
+@property (readwrite, copy) NSString *compactDescription;
+@property (readwrite, copy, nullable) NSString *detailedDescription;
+@property (readwrite, strong) XCTSourceCodeContext *sourceCodeContext;
+@property (readwrite, strong, nullable) NSError *associatedError;
+@property (readwrite, copy) NSArray<XCTAttachment *> *attachments;
+@property (readwrite) XCTIssueSeverity severity;
+
+/// Add an attachment to this issue.
+- (void)addAttachment:(XCTAttachment *)attachment;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif