/*
 *
 *    Copyright (c) 2022 Project CHIP Authors
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    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.
 */

// module headers
#import <Matter/Matter.h>

#import "MTRErrorTestUtils.h"
#import "MTRTestKeys.h"
#import "MTRTestStorage.h"

#import <app/util/af-enums.h>

#import <math.h> // For INFINITY

// system dependencies
#import <XCTest/XCTest.h>

// Set the following to 1 in order to run individual test case manually.
#define MANUAL_INDIVIDUAL_TEST 0

static const uint16_t kPairingTimeoutInSeconds = 10;
static const uint16_t kCASESetupTimeoutInSeconds = 30;
static const uint16_t kTimeoutInSeconds = 3;
static const uint64_t kDeviceId = 0x12344321;
static NSString * kOnboardingPayload = @"MT:-24J0AFN00KA0648G00";
static const uint16_t kLocalPort = 5541;
static const uint16_t kTestVendorId = 0xFFF1u;

// This test suite reuses a device object to speed up the test process for CI.
// The following global variable holds the reference to the device object.
static MTRBaseDevice * sConnectedDevice;

// Singleton controller we use.
static MTRDeviceController * sController = nil;

// Keys we can use to restart the controller.
static MTRTestKeys * sTestKeys = nil;

static MTRBaseDevice * GetConnectedDevice(void)
{
    XCTAssertNotNil(sConnectedDevice);
    return sConnectedDevice;
}

@interface MTRBackwardsCompatTestPairingDelegate : NSObject <MTRDevicePairingDelegate>
@property (nonatomic, strong) XCTestExpectation * expectation;
@end

@implementation MTRBackwardsCompatTestPairingDelegate
- (id)initWithExpectation:(XCTestExpectation *)expectation
{
    self = [super init];
    if (self) {
        _expectation = expectation;
    }
    return self;
}

- (void)onPairingComplete:(NSError *)error
{
    XCTAssertEqual(error.code, 0);

    NSError * commissionError = nil;
    [sController commissionDevice:kDeviceId commissioningParams:[[MTRCommissioningParameters alloc] init] error:&commissionError];
    XCTAssertNil(commissionError);

    // Keep waiting for onCommissioningComplete
}

- (void)onCommissioningComplete:(NSError *)error
{
    XCTAssertEqual(error.code, 0);
    [_expectation fulfill];
    _expectation = nil;
}

@end

@interface MTRBackwardsCompatTests : XCTestCase
@end

@implementation MTRBackwardsCompatTests

- (void)setUp
{
    [super setUp];
    [self setContinueAfterFailure:NO];
}

- (void)tearDown
{
#if MANUAL_INDIVIDUAL_TEST
    [self shutdownStack];
#endif
    [super tearDown];
}

- (void)initStack
{
    XCTestExpectation * expectation = [self expectationWithDescription:@"Pairing Complete"];

    __auto_type * factory = [MTRControllerFactory sharedInstance];
    XCTAssertNotNil(factory);

    __auto_type * storage = [[MTRTestStorage alloc] init];
    __auto_type * factoryParams = [[MTRControllerFactoryParams alloc] initWithStorage:storage];
    factoryParams.port = @(kLocalPort);

    BOOL ok = [factory startup:factoryParams];
    XCTAssertTrue(ok);

    __auto_type * testKeys = [[MTRTestKeys alloc] init];
    XCTAssertNotNil(testKeys);

    sTestKeys = testKeys;

    // Needs to match what startControllerOnExistingFabric calls elsewhere in
    // this file do.
    __auto_type * params = [[MTRDeviceControllerStartupParams alloc] initWithSigningKeypair:testKeys fabricId:1 ipk:testKeys.ipk];
    params.vendorId = @(kTestVendorId);

    MTRDeviceController * controller = [factory startControllerOnNewFabric:params];
    XCTAssertNotNil(controller);

    sController = controller;

    __auto_type * pairing = [[MTRBackwardsCompatTestPairingDelegate alloc] initWithExpectation:expectation];
    dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.pairing", DISPATCH_QUEUE_SERIAL);

    [controller setPairingDelegate:pairing queue:callbackQueue];

    NSError * error;
    __auto_type * payload = [MTRSetupPayload setupPayloadWithOnboardingPayload:kOnboardingPayload error:&error];
    XCTAssertNotNil(payload);
    XCTAssertNil(error);

    [controller setupCommissioningSessionWithPayload:payload newNodeID:@(kDeviceId) error:&error];
    XCTAssertNil(error);

    [self waitForExpectationsWithTimeout:kPairingTimeoutInSeconds handler:nil];

    __block XCTestExpectation * connectionExpectation = [self expectationWithDescription:@"CASE established"];
    [controller getBaseDevice:kDeviceId
                        queue:dispatch_get_main_queue()
            completionHandler:^(MTRBaseDevice * _Nullable device, NSError * _Nullable error) {
                XCTAssertEqual(error.code, 0);
                [connectionExpectation fulfill];
                sConnectedDevice = device;
                connectionExpectation = nil;
            }];
    [self waitForExpectationsWithTimeout:kCASESetupTimeoutInSeconds handler:nil];
}

- (void)shutdownStack
{
    MTRDeviceController * controller = sController;
    XCTAssertNotNil(controller);

    [controller shutdown];
    XCTAssertFalse([controller isRunning]);

    [[MTRControllerFactory sharedInstance] shutdown];
}

#if !MANUAL_INDIVIDUAL_TEST
- (void)test000_SetUp
{
    [self initStack];
}
#endif

#define CHECK_RETURN_TYPE(sig, type)                                                                                               \
    do {                                                                                                                           \
        XCTAssertNotNil(sig);                                                                                                      \
        XCTAssertTrue(strcmp([sig methodReturnType], @encode(type)) == 0);                                                         \
    } while (0)

/**
 * Arguments 0 and 1 are the implicit self and _cmd arguments; the real arguments begin at index 2.
 */
#define CHECK_ARGUMENT(sig, index, type)                                                                                           \
    do {                                                                                                                           \
        XCTAssertTrue(strcmp([sig getArgumentTypeAtIndex:(index) + 2], @encode(type)) == 0);                                       \
    } while (0)

#define CHECK_READONLY_PROPERTY(instance, propName, type)                                                                          \
    do {                                                                                                                           \
        NSMethodSignature * signature = [instance methodSignatureForSelector:@selector(propName)];                                 \
        CHECK_RETURN_TYPE(signature, type);                                                                                        \
        /* Check that getting the property directly compiles too */                                                                \
        (void) instance.propName;                                                                                                  \
    } while (0)

#define CHECK_PROPERTY(instance, propName, setterName, type)                                                                       \
    do {                                                                                                                           \
        CHECK_READONLY_PROPERTY(instance, propName, type);                                                                         \
        NSMethodSignature * signature = [instance methodSignatureForSelector:@selector(setterName:)];                              \
        CHECK_RETURN_TYPE(signature, void);                                                                                        \
        CHECK_ARGUMENT(signature, 0, type);                                                                                        \
    } while (0)

/**
 * Basic tests that all the selectors we expect are in place.  This does some
 * limited checking of the argument types (enough to check for boxed numbers vs
 * primitives, say, but not enough to distinguish various object types).
 *
 * Also missing: checks for whether init/new are available or not
 * (NS_UNAVAILABLE), since the selector setup is the same in both cases.
 */

- (void)test001_MTRAsyncCallbackWorkQueue
{
    NSMethodSignature * sig;

    sig = [MTRAsyncCallbackWorkQueue instanceMethodSignatureForSelector:@selector(initWithContext:queue:)];
    CHECK_RETURN_TYPE(sig, id);
    CHECK_ARGUMENT(sig, 0, id);
    CHECK_ARGUMENT(sig, 1, dispatch_queue_t);

    sig = [MTRAsyncCallbackWorkQueue instanceMethodSignatureForSelector:@selector(invalidate)];
    CHECK_RETURN_TYPE(sig, void);

    sig = [MTRAsyncCallbackWorkQueue instanceMethodSignatureForSelector:@selector(enqueueWorkItem:)];
    CHECK_RETURN_TYPE(sig, void);
    CHECK_ARGUMENT(sig, 0, id);
}

- (void)test002_MTRAsyncCallbackQueueWorkItem
{
    NSMethodSignature * sig;

    sig = [MTRAsyncCallbackQueueWorkItem instanceMethodSignatureForSelector:@selector(initWithQueue:)];
    CHECK_RETURN_TYPE(sig, id);
    CHECK_ARGUMENT(sig, 0, dispatch_queue_t);

    __auto_type * item = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:dispatch_get_main_queue()];

    CHECK_PROPERTY(item, readyHandler, setReadyHandler, MTRAsyncCallbackReadyHandler);
    CHECK_PROPERTY(item, cancelHandler, setCancelHandler, dispatch_block_t);

    sig = [MTRAsyncCallbackQueueWorkItem instanceMethodSignatureForSelector:@selector(endWork)];
    CHECK_RETURN_TYPE(sig, void);

    sig = [MTRAsyncCallbackQueueWorkItem instanceMethodSignatureForSelector:@selector(retryWork)];
    CHECK_RETURN_TYPE(sig, void);
}

- (void)test003_MTRAttestationInfo
{
    __auto_type * info = [[AttestationInfo alloc] init];
    CHECK_PROPERTY(info, challenge, setChallenge, NSData *);
    CHECK_PROPERTY(info, nonce, setNonce, NSData *);
    CHECK_PROPERTY(info, elements, setElements, NSData *);
    CHECK_PROPERTY(info, elementsSignature, setElementsSignature, NSData *);
    CHECK_PROPERTY(info, dac, setDac, NSData *);
    CHECK_PROPERTY(info, pai, setPai, NSData *);
    CHECK_PROPERTY(info, certificationDeclaration, setCertificationDeclaration, NSData *);
    CHECK_PROPERTY(info, firmwareInfo, setFirmwareInfo, NSData *);

    NSMethodSignature * sig;

    sig = [AttestationInfo instanceMethodSignatureForSelector:@selector
                           (initWithChallenge:nonce:elements:elementsSignature:dac:pai:certificationDeclaration:firmwareInfo:)];
    CHECK_RETURN_TYPE(sig, id);
    CHECK_ARGUMENT(sig, 0, NSData *);
    CHECK_ARGUMENT(sig, 1, NSData *);
    CHECK_ARGUMENT(sig, 2, NSData *);
    CHECK_ARGUMENT(sig, 3, NSData *);
    CHECK_ARGUMENT(sig, 4, NSData *);
    CHECK_ARGUMENT(sig, 5, NSData *);
    CHECK_ARGUMENT(sig, 6, NSData *);
    CHECK_ARGUMENT(sig, 7, NSData *);
}

- (void)test004_MTRAttributeCacheContainer
{
    NSMethodSignature * sig;

    sig = [MTRAttributeCacheContainer
        instanceMethodSignatureForSelector:@selector(readAttributeWithEndpointId:clusterId:attributeId:clientQueue:completion:)];
    CHECK_RETURN_TYPE(sig, void);
    CHECK_ARGUMENT(sig, 0, NSNumber *);
    CHECK_ARGUMENT(sig, 1, NSNumber *);
    CHECK_ARGUMENT(sig, 2, NSNumber *);
    CHECK_ARGUMENT(sig, 3, dispatch_queue_t);
    CHECK_ARGUMENT(sig, 4, void (^)(NSArray<NSDictionary<NSString *, id> *> * _Nullable values, NSError * _Nullable error));
}

- (void)test005_MTRBaseClusters
{
    // TODO: Need to think a bit about how to test this exhaustively, but in the
    // meantime just test a representative cluster with commands and attributes
    // on it, including commands that have no fields and writable attributes.
    NSMethodSignature * sig;

    sig = [MTRBaseClusterOnOff instanceMethodSignatureForSelector:@selector(initWithDevice:endpoint:queue:)];
    CHECK_RETURN_TYPE(sig, id);
    CHECK_ARGUMENT(sig, 0, MTRBaseDevice *);
    CHECK_ARGUMENT(sig, 1, uint16_t);
    CHECK_ARGUMENT(sig, 2, dispatch_queue_t);

    sig = [MTRBaseClusterOnOff instanceMethodSignatureForSelector:@selector(offWithParams:completionHandler:)];
    CHECK_RETURN_TYPE(sig, void);
    CHECK_ARGUMENT(sig, 0, MTROnOffClusterOffParams *);
    CHECK_ARGUMENT(sig, 1, StatusCompletion);

    sig = [MTRBaseClusterOnOff instanceMethodSignatureForSelector:@selector(offWithCompletionHandler:)];
    CHECK_RETURN_TYPE(sig, void);
    CHECK_ARGUMENT(sig, 0, StatusCompletion);

    sig = [MTRBaseClusterOnOff instanceMethodSignatureForSelector:@selector(offWithEffectWithParams:completionHandler:)];
    CHECK_RETURN_TYPE(sig, void);
    CHECK_ARGUMENT(sig, 0, MTROnOffClusterOffWithEffectParams *);
    CHECK_ARGUMENT(sig, 1, StatusCompletion);

    sig = [MTRBaseClusterOnOff instanceMethodSignatureForSelector:@selector(readAttributeOnTimeWithCompletionHandler:)];
    CHECK_RETURN_TYPE(sig, void);
    CHECK_ARGUMENT(sig, 0, void (^)(NSNumber * _Nullable value, NSError * _Nullable error));

    sig = [MTRBaseClusterOnOff instanceMethodSignatureForSelector:@selector(writeAttributeOnTimeWithValue:completionHandler:)];
    CHECK_RETURN_TYPE(sig, void);
    CHECK_ARGUMENT(sig, 0, NSNumber *);
    CHECK_ARGUMENT(sig, 1, StatusCompletion);

    sig = [MTRBaseClusterOnOff instanceMethodSignatureForSelector:@selector(writeAttributeOnTimeWithValue:
                                                                                                   params:completionHandler:)];
    CHECK_RETURN_TYPE(sig, void);
    CHECK_ARGUMENT(sig, 0, NSNumber *);
    CHECK_ARGUMENT(sig, 1, MTRWriteParams *);
    CHECK_ARGUMENT(sig, 2, StatusCompletion);

    sig = [MTRBaseClusterOnOff instanceMethodSignatureForSelector:@selector
                               (subscribeAttributeOnTimeWithMinInterval:maxInterval:params:subscriptionEstablished:reportHandler:)];
    CHECK_RETURN_TYPE(sig, void);
    CHECK_ARGUMENT(sig, 0, NSNumber *);
    CHECK_ARGUMENT(sig, 1, NSNumber *);
    CHECK_ARGUMENT(sig, 2, MTRSubscribeParams *);
    CHECK_ARGUMENT(sig, 3, SubscriptionEstablishedHandler);
    CHECK_ARGUMENT(sig, 4, void (^)(NSNumber * _Nullable value, NSError * _Nullable error));

    sig = [MTRBaseClusterOnOff
        methodSignatureForSelector:@selector(readAttributeOnTimeWithAttributeCache:endpoint:queue:completionHandler:)];
    CHECK_RETURN_TYPE(sig, void);
    CHECK_ARGUMENT(sig, 0, MTRAttributeCacheContainer *);
    CHECK_ARGUMENT(sig, 1, NSNumber *);
    CHECK_ARGUMENT(sig, 2, dispatch_queue_t);
    CHECK_ARGUMENT(sig, 3, void (^)(NSNumber * _Nullable value, NSError * _Nullable error));
}

- (void)test006_MTRBaseDevice
{
    NSMethodSignature * sig;

    sig = [MTRBaseDevice instanceMethodSignatureForSelector:@selector
                         (subscribeWithQueue:
                                 minInterval:maxInterval:params:cacheContainer:attributeReportHandler:eventReportHandler
                                            :errorHandler:subscriptionEstablished:resubscriptionScheduled:)];
    CHECK_RETURN_TYPE(sig, void);
    CHECK_ARGUMENT(sig, 0, dispatch_queue_t);
    CHECK_ARGUMENT(sig, 1, uint16_t);
    CHECK_ARGUMENT(sig, 2, uint16_t);
    CHECK_ARGUMENT(sig, 3, MTRSubscribeParams *);
    CHECK_ARGUMENT(sig, 4, MTRAttributeCacheContainer *);
    CHECK_ARGUMENT(sig, 5, MTRDeviceReportHandler);
    CHECK_ARGUMENT(sig, 6, MTRDeviceReportHandler);
    CHECK_ARGUMENT(sig, 7, MTRDeviceErrorHandler);
    CHECK_ARGUMENT(sig, 8, dispatch_block_t);
    CHECK_ARGUMENT(sig, 9, MTRDeviceResubscriptionScheduledHandler);

    sig = [MTRBaseDevice instanceMethodSignatureForSelector:@selector
                         (readAttributeWithEndpointId:clusterId:attributeId:params:clientQueue:completion:)];
    CHECK_RETURN_TYPE(sig, void);
    CHECK_ARGUMENT(sig, 0, NSNumber *);
    CHECK_ARGUMENT(sig, 1, NSNumber *);
    CHECK_ARGUMENT(sig, 2, NSNumber *);
    CHECK_ARGUMENT(sig, 3, MTRReadParams *);
    CHECK_ARGUMENT(sig, 4, dispatch_queue_t);
    CHECK_ARGUMENT(sig, 5, MTRDeviceResponseHandler);

    sig = [MTRBaseDevice instanceMethodSignatureForSelector:@selector
                         (writeAttributeWithEndpointId:clusterId:attributeId:value:timedWriteTimeout:clientQueue:completion:)];
    CHECK_RETURN_TYPE(sig, void);
    CHECK_ARGUMENT(sig, 0, NSNumber *);
    CHECK_ARGUMENT(sig, 1, NSNumber *);
    CHECK_ARGUMENT(sig, 2, NSNumber *);
    CHECK_ARGUMENT(sig, 3, id);
    CHECK_ARGUMENT(sig, 4, NSNumber *);
    CHECK_ARGUMENT(sig, 5, dispatch_queue_t);
    CHECK_ARGUMENT(sig, 6, MTRDeviceResponseHandler);

    sig = [MTRBaseDevice instanceMethodSignatureForSelector:@selector
                         (invokeCommandWithEndpointId:
                                            clusterId:commandId:commandFields:timedInvokeTimeout:clientQueue:completion:)];
    CHECK_RETURN_TYPE(sig, void);
    CHECK_ARGUMENT(sig, 0, NSNumber *);
    CHECK_ARGUMENT(sig, 1, NSNumber *);
    CHECK_ARGUMENT(sig, 2, NSNumber *);
    CHECK_ARGUMENT(sig, 3, id);
    CHECK_ARGUMENT(sig, 4, NSNumber *);
    CHECK_ARGUMENT(sig, 5, dispatch_queue_t);
    CHECK_ARGUMENT(sig, 6, MTRDeviceResponseHandler);

    sig = [MTRBaseDevice instanceMethodSignatureForSelector:@selector
                         (subscribeAttributeWithEndpointId:
                                                 clusterId:attributeId:minInterval:maxInterval:params:clientQueue:reportHandler
                                                          :subscriptionEstablished:)];
    CHECK_RETURN_TYPE(sig, void);
    CHECK_ARGUMENT(sig, 0, NSNumber *);
    CHECK_ARGUMENT(sig, 1, NSNumber *);
    CHECK_ARGUMENT(sig, 2, NSNumber *);
    CHECK_ARGUMENT(sig, 3, NSNumber *);
    CHECK_ARGUMENT(sig, 4, NSNumber *);
    CHECK_ARGUMENT(sig, 5, MTRSubscribeParams *);
    CHECK_ARGUMENT(sig, 6, dispatch_queue_t);
    CHECK_ARGUMENT(sig, 7, MTRDeviceResponseHandler);
    CHECK_ARGUMENT(sig, 8, void (^)(void));

    sig = [MTRBaseDevice instanceMethodSignatureForSelector:@selector(deregisterReportHandlersWithClientQueue:completion:)];
    CHECK_RETURN_TYPE(sig, void);
    CHECK_ARGUMENT(sig, 0, dispatch_queue_t);
    CHECK_ARGUMENT(sig, 1, void (^)(void));

    sig = [MTRBaseDevice instanceMethodSignatureForSelector:@selector
                         (openCommissioningWindowWithSetupPasscode:discriminator:duration:queue:completion:)];
    CHECK_RETURN_TYPE(sig, void);
    CHECK_ARGUMENT(sig, 0, NSNumber *);
    CHECK_ARGUMENT(sig, 1, NSNumber *);
    CHECK_ARGUMENT(sig, 2, NSNumber *);
    CHECK_ARGUMENT(sig, 3, dispatch_queue_t);
    CHECK_ARGUMENT(sig, 4, MTRDeviceOpenCommissioningWindowHandler);

    // TODO add tests that actually invoking the old methods on an MTRBaseDevice calls the new methods.
}

- (void)test007_MTRAttributePath
{
    XCTAssertTrue([MTRAttributePath conformsToProtocol:@protocol(NSCopying)]);

    __auto_type * path = [MTRAttributePath attributePathWithEndpointId:@(0) clusterId:@(0) attributeId:@(0)];

    CHECK_READONLY_PROPERTY(path, endpoint, NSNumber *);
    CHECK_READONLY_PROPERTY(path, cluster, NSNumber *);
    CHECK_READONLY_PROPERTY(path, attribute, NSNumber *);

    NSMethodSignature * sig;

    sig = [MTRAttributePath methodSignatureForSelector:@selector(attributePathWithEndpointId:clusterId:attributeId:)];
    CHECK_RETURN_TYPE(sig, MTRAttributePath *);
    CHECK_ARGUMENT(sig, 0, NSNumber *);
    CHECK_ARGUMENT(sig, 1, NSNumber *);
    CHECK_ARGUMENT(sig, 2, NSNumber *);
}

- (void)test008_MTREventPath
{
    __auto_type * path = [MTREventPath eventPathWithEndpointId:@(0) clusterId:@(0) eventId:@(0)];

    CHECK_READONLY_PROPERTY(path, endpoint, NSNumber *);
    CHECK_READONLY_PROPERTY(path, cluster, NSNumber *);
    CHECK_READONLY_PROPERTY(path, event, NSNumber *);

    NSMethodSignature * sig;

    sig = [MTREventPath methodSignatureForSelector:@selector(eventPathWithEndpointId:clusterId:eventId:)];
    CHECK_RETURN_TYPE(sig, MTREventPath *);
    CHECK_ARGUMENT(sig, 0, NSNumber *);
    CHECK_ARGUMENT(sig, 1, NSNumber *);
    CHECK_ARGUMENT(sig, 2, NSNumber *);
}

- (void)test009_MTRCommandPath
{
    __auto_type * path = [MTRCommandPath commandPathWithEndpointId:@(0) clusterId:@(0) commandId:@(0)];

    CHECK_READONLY_PROPERTY(path, endpoint, NSNumber *);
    CHECK_READONLY_PROPERTY(path, cluster, NSNumber *);
    CHECK_READONLY_PROPERTY(path, command, NSNumber *);

    NSMethodSignature * sig;

    sig = [MTRCommandPath methodSignatureForSelector:@selector(commandPathWithEndpointId:clusterId:commandId:)];
    CHECK_RETURN_TYPE(sig, MTRCommandPath *);
    CHECK_ARGUMENT(sig, 0, NSNumber *);
    CHECK_ARGUMENT(sig, 1, NSNumber *);
    CHECK_ARGUMENT(sig, 2, NSNumber *);
}

- (void)test010_MTRAttributeReport
{
    __auto_type * report = [[MTRAttributeReport alloc] init];

    CHECK_READONLY_PROPERTY(report, path, MTRAttributePath *);
    CHECK_READONLY_PROPERTY(report, value, id);
    CHECK_READONLY_PROPERTY(report, error, NSError *);
}

- (void)test011_MTREventReport
{
    __auto_type * report = [[MTREventReport alloc] init];

    CHECK_READONLY_PROPERTY(report, path, MTREventPath *);
    CHECK_READONLY_PROPERTY(report, eventNumber, NSNumber *);
    CHECK_READONLY_PROPERTY(report, priority, NSNumber *);
    CHECK_READONLY_PROPERTY(report, timestamp, NSNumber *);
    CHECK_READONLY_PROPERTY(report, value, id);
    CHECK_READONLY_PROPERTY(report, error, NSError *);
}

- (void)test012_MTRCSRInfo
{
    __auto_type * info = [[CSRInfo alloc] init];

    CHECK_PROPERTY(info, nonce, setNonce, NSData *);
    CHECK_PROPERTY(info, elements, setElements, NSData *);
    CHECK_PROPERTY(info, elementsSignature, setElementsSignature, NSData *);
    CHECK_PROPERTY(info, csr, setCsr, NSData *);

    NSMethodSignature * sig;

    sig = [CSRInfo instanceMethodSignatureForSelector:@selector(initWithNonce:elements:elementsSignature:csr:)];
    CHECK_RETURN_TYPE(sig, CSRInfo *);
    CHECK_ARGUMENT(sig, 0, NSData *);
    CHECK_ARGUMENT(sig, 1, NSData *);
    CHECK_ARGUMENT(sig, 2, NSData *);
    CHECK_ARGUMENT(sig, 3, NSData *);
}

- (void)test013_MTRCertificates
{
    NSMethodSignature * sig;

    sig = [MTRCertificates methodSignatureForSelector:@selector(generateRootCertificate:issuerId:fabricId:error:)];
    CHECK_RETURN_TYPE(sig, NSData *);
    CHECK_ARGUMENT(sig, 0, id<MTRKeypair>);
    CHECK_ARGUMENT(sig, 1, NSNumber *);
    CHECK_ARGUMENT(sig, 2, NSNumber *);
    CHECK_ARGUMENT(sig, 3, NSError * __autoreleasing *);

    sig = [MTRCertificates methodSignatureForSelector:@selector
                           (generateIntermediateCertificate:rootCertificate:intermediatePublicKey:issuerId:fabricId:error:)];
    CHECK_RETURN_TYPE(sig, NSData *);
    CHECK_ARGUMENT(sig, 0, id<MTRKeypair>);
    CHECK_ARGUMENT(sig, 1, NSData *);
    CHECK_ARGUMENT(sig, 2, SecKeyRef);
    CHECK_ARGUMENT(sig, 3, NSNumber *);
    CHECK_ARGUMENT(sig, 4, NSNumber *);
    CHECK_ARGUMENT(sig, 5, NSError * __autoreleasing *);

    sig = [MTRCertificates methodSignatureForSelector:@selector
                           (generateOperationalCertificate:
                                        signingCertificate:operationalPublicKey:fabricId:nodeId:caseAuthenticatedTags:error:)];
    CHECK_RETURN_TYPE(sig, NSData *);
    CHECK_ARGUMENT(sig, 0, id<MTRKeypair>);
    CHECK_ARGUMENT(sig, 1, NSData *);
    CHECK_ARGUMENT(sig, 2, SecKeyRef);
    CHECK_ARGUMENT(sig, 3, NSNumber *);
    CHECK_ARGUMENT(sig, 4, NSNumber *);
    CHECK_ARGUMENT(sig, 5, NSArray<NSNumber *> *);
    CHECK_ARGUMENT(sig, 6, NSError * __autoreleasing *);

    sig = [MTRCertificates methodSignatureForSelector:@selector(keypair:matchesCertificate:)];
    CHECK_RETURN_TYPE(sig, BOOL);
    CHECK_ARGUMENT(sig, 0, id<MTRKeypair>);
    CHECK_ARGUMENT(sig, 1, NSData *);

    sig = [MTRCertificates methodSignatureForSelector:@selector(isCertificate:equalTo:)];
    CHECK_RETURN_TYPE(sig, BOOL);
    CHECK_ARGUMENT(sig, 0, NSData *);
    CHECK_ARGUMENT(sig, 1, NSData *);

    sig = [MTRCertificates methodSignatureForSelector:@selector(generateCertificateSigningRequest:error:)];
    CHECK_RETURN_TYPE(sig, NSData *);
    CHECK_ARGUMENT(sig, 0, id<MTRKeypair>);
    CHECK_ARGUMENT(sig, 1, NSError * __autoreleasing *);

    sig = [MTRCertificates methodSignatureForSelector:@selector(convertX509Certificate:)];
    CHECK_RETURN_TYPE(sig, NSData *);
    CHECK_ARGUMENT(sig, 0, NSData *);
}

- (void)test014_MTRWriteParams
{
    XCTAssertTrue([MTRWriteParams conformsToProtocol:@protocol(NSCopying)]);

    __auto_type * params = [[MTRWriteParams alloc] init];

    CHECK_PROPERTY(params, timedWriteTimeout, setTimedWriteTimeout, NSNumber *);
    CHECK_PROPERTY(params, dataVersion, setDataVersion, NSNumber *);
}

- (void)test015_MTRReadParams
{
    XCTAssertTrue([MTRReadParams conformsToProtocol:@protocol(NSCopying)]);

    __auto_type * params = [[MTRReadParams alloc] init];

    CHECK_PROPERTY(params, fabricFiltered, setFabricFiltered, NSNumber *);
}

- (void)test016_MTRSubscribeParams
{
    XCTAssertTrue([MTRSubscribeParams conformsToProtocol:@protocol(NSCopying)]);
    XCTAssertTrue([MTRSubscribeParams isSubclassOfClass:[MTRReadParams class]]);

    __auto_type * params = [[MTRSubscribeParams alloc] init];

    CHECK_PROPERTY(params, keepPreviousSubscriptions, setKeepPreviousSubscriptions, NSNumber *);
    CHECK_PROPERTY(params, autoResubscribe, setAutoResubscribe, NSNumber *);
}

- (void)test017_MTRClusterConstants
{
    // TODO: Figure out what and how to test here.
}

- (void)test018_MTRClusters
{
    // TODO: Need to think a bit about how to test this exhaustively, but in the
    // meantime just test a representative cluster with commands and attributes
    // on it, including commands that have no fields and writable attributes.
    NSMethodSignature * sig;

    sig = [MTRClusterOnOff instanceMethodSignatureForSelector:@selector(initWithDevice:endpoint:queue:)];
    CHECK_RETURN_TYPE(sig, MTRClusterOnOff *);
    CHECK_ARGUMENT(sig, 0, MTRDevice *);
    CHECK_ARGUMENT(sig, 1, uint16_t);
    CHECK_ARGUMENT(sig, 2, dispatch_queue_t);

    sig = [MTRClusterOnOff instanceMethodSignatureForSelector:@selector(offWithParams:
                                                                       expectedValues:expectedValueInterval:completionHandler:)];
    CHECK_RETURN_TYPE(sig, void);
    CHECK_ARGUMENT(sig, 0, MTROnOffClusterOffParams *);
    CHECK_ARGUMENT(sig, 1, NSArray *);
    CHECK_ARGUMENT(sig, 2, NSNumber *);
    CHECK_ARGUMENT(sig, 3, StatusCompletion);

    sig = [MTRClusterOnOff instanceMethodSignatureForSelector:@selector(offWithExpectedValues:
                                                                        expectedValueInterval:completionHandler:)];
    CHECK_RETURN_TYPE(sig, void);
    CHECK_ARGUMENT(sig, 0, NSArray *);
    CHECK_ARGUMENT(sig, 1, NSNumber *);
    CHECK_ARGUMENT(sig, 2, StatusCompletion);

    sig = [MTRClusterOnOff instanceMethodSignatureForSelector:@selector(readAttributeOnTimeWithParams:)];
    CHECK_RETURN_TYPE(sig, NSDictionary *);
    CHECK_ARGUMENT(sig, 0, MTRReadParams *);

    sig = [MTRClusterOnOff instanceMethodSignatureForSelector:@selector(writeAttributeOnTimeWithValue:expectedValueInterval:)];
    CHECK_RETURN_TYPE(sig, void);
    CHECK_ARGUMENT(sig, 0, NSDictionary *);
    CHECK_ARGUMENT(sig, 1, NSNumber *);

    sig = [MTRClusterOnOff instanceMethodSignatureForSelector:@selector(writeAttributeOnTimeWithValue:
                                                                                expectedValueInterval:params:)];
    CHECK_RETURN_TYPE(sig, void);
    CHECK_ARGUMENT(sig, 0, NSDictionary *);
    CHECK_ARGUMENT(sig, 1, NSNumber *);
    CHECK_ARGUMENT(sig, 2, MTRWriteParams *);
}

- (void)test019_MTRCommandPayloadsObjc
{
    // TODO: Figure out what and how to test here.
}

- (void)test020_MTRCommissioningParameters
{
    __auto_type * params = [[MTRCommissioningParameters alloc] init];

    CHECK_PROPERTY(params, CSRNonce, setCSRNonce, NSData *);
    CHECK_PROPERTY(params, attestationNonce, setAttestationNonce, NSData *);
    CHECK_PROPERTY(params, wifiSSID, setWifiSSID, NSData *);
    CHECK_PROPERTY(params, wifiCredentials, setWifiCredentials, NSData *);
    CHECK_PROPERTY(params, threadOperationalDataset, setThreadOperationalDataset, NSData *);
    CHECK_PROPERTY(params, deviceAttestationDelegate, setDeviceAttestationDelegate, id<MTRDeviceAttestationDelegate>);
    CHECK_PROPERTY(params, failSafeExpiryTimeoutSecs, setFailSafeExpiryTimeoutSecs, NSNumber *);
}

- (void)test021_MTRControllerFactoryParams
{
    __auto_type * storage = [[MTRTestStorage alloc] init];
    __auto_type * params = [[MTRControllerFactoryParams alloc] initWithStorage:storage];
    CHECK_READONLY_PROPERTY(params, storageDelegate, id<MTRPersistentStorageDelegate>);
    CHECK_PROPERTY(params, otaProviderDelegate, setOtaProviderDelegate, id<MTROTAProviderDelegate>);
    CHECK_PROPERTY(params, paaCerts, setPaaCerts, NSArray *);
    CHECK_PROPERTY(params, cdCerts, setCdCerts, NSArray *);
    CHECK_PROPERTY(params, port, setPort, NSNumber *);
    CHECK_PROPERTY(params, startServer, setStartServer, BOOL);

    NSMethodSignature * sig;

    sig = [MTRControllerFactoryParams instanceMethodSignatureForSelector:@selector(initWithStorage:)];
    CHECK_RETURN_TYPE(sig, MTRControllerFactoryParams *);
    CHECK_ARGUMENT(sig, 0, id<MTRPersistentStorageDelegate>);
}

- (void)test022_MTRControllerFactory
{
    __auto_type * instance = [MTRControllerFactory sharedInstance];
    CHECK_READONLY_PROPERTY(instance, isRunning, BOOL);

    NSMethodSignature * sig;

    sig = [MTRControllerFactory methodSignatureForSelector:@selector(sharedInstance)];
    CHECK_RETURN_TYPE(sig, MTRControllerFactory *);

    sig = [MTRControllerFactory instanceMethodSignatureForSelector:@selector(startup:)];
    CHECK_RETURN_TYPE(sig, BOOL);
    CHECK_ARGUMENT(sig, 0, MTRControllerFactoryParams *);

    sig = [MTRControllerFactory instanceMethodSignatureForSelector:@selector(shutdown)];
    CHECK_RETURN_TYPE(sig, void);

    sig = [MTRControllerFactory instanceMethodSignatureForSelector:@selector(startControllerOnExistingFabric:)];
    CHECK_RETURN_TYPE(sig, MTRDeviceController *);
    CHECK_ARGUMENT(sig, 0, MTRDeviceControllerStartupParams *);

    sig = [MTRControllerFactory instanceMethodSignatureForSelector:@selector(startControllerOnNewFabric:)];
    CHECK_RETURN_TYPE(sig, MTRDeviceController *);
    CHECK_ARGUMENT(sig, 0, MTRDeviceControllerStartupParams *);
}

- (void)test023_MTRDevice
{
    NSMethodSignature * sig;

    sig = [MTRDevice methodSignatureForSelector:@selector(deviceWithNodeID:deviceController:)];
    CHECK_RETURN_TYPE(sig, MTRDevice *);
    CHECK_ARGUMENT(sig, 0, uint64_t);
    CHECK_ARGUMENT(sig, 1, MTRDeviceController *);

    __auto_type * instance = [MTRDevice deviceWithNodeID:1 deviceController:sController];

    CHECK_READONLY_PROPERTY(instance, state, MTRDeviceState);

    sig = [MTRDevice instanceMethodSignatureForSelector:@selector(setDelegate:queue:)];
    CHECK_RETURN_TYPE(sig, void);
    CHECK_ARGUMENT(sig, 0, id<MTRDeviceDelegate>);
    CHECK_ARGUMENT(sig, 1, dispatch_queue_t);

    sig = [MTRDevice instanceMethodSignatureForSelector:@selector(readAttributeWithEndpointID:clusterID:attributeID:params:)];
    CHECK_RETURN_TYPE(sig, NSDictionary *);
    CHECK_ARGUMENT(sig, 0, NSNumber *);
    CHECK_ARGUMENT(sig, 1, NSNumber *);
    CHECK_ARGUMENT(sig, 2, NSNumber *);
    CHECK_ARGUMENT(sig, 3, MTRReadParams *);

    sig = [MTRDevice instanceMethodSignatureForSelector:@selector
                     (writeAttributeWithEndpointID:clusterID:attributeID:value:expectedValueInterval:timedWriteTimeout:)];
    CHECK_RETURN_TYPE(sig, void);
    CHECK_ARGUMENT(sig, 0, NSNumber *);
    CHECK_ARGUMENT(sig, 1, NSNumber *);
    CHECK_ARGUMENT(sig, 2, NSNumber *);
    CHECK_ARGUMENT(sig, 3, id);
    CHECK_ARGUMENT(sig, 4, NSNumber *);
    CHECK_ARGUMENT(sig, 5, NSNumber *);

    sig = [MTRDevice instanceMethodSignatureForSelector:@selector
                     (invokeCommandWithEndpointID:
                                        clusterID:commandID:commandFields:expectedValues:expectedValueInterval:timedInvokeTimeout
                                                 :clientQueue:completion:)];
    CHECK_RETURN_TYPE(sig, void);
    CHECK_ARGUMENT(sig, 0, NSNumber *);
    CHECK_ARGUMENT(sig, 1, NSNumber *);
    CHECK_ARGUMENT(sig, 2, NSNumber *);
    CHECK_ARGUMENT(sig, 3, id);
    CHECK_ARGUMENT(sig, 4, NSArray *);
    CHECK_ARGUMENT(sig, 5, NSNumber *);
    CHECK_ARGUMENT(sig, 6, NSNumber *);
    CHECK_ARGUMENT(sig, 7, dispatch_queue_t);
    CHECK_ARGUMENT(sig, 8, MTRDeviceResponseHandler);

    sig = [MTRDevice instanceMethodSignatureForSelector:@selector
                     (openCommissioningWindowWithSetupPasscode:discriminator:duration:queue:completion:)];
    CHECK_RETURN_TYPE(sig, void);
    CHECK_ARGUMENT(sig, 0, NSNumber *);
    CHECK_ARGUMENT(sig, 1, NSNumber *);
    CHECK_ARGUMENT(sig, 2, NSNumber *);
    CHECK_ARGUMENT(sig, 3, dispatch_queue_t);
    CHECK_ARGUMENT(sig, 4, MTRDeviceOpenCommissioningWindowHandler);

    // TODO add tests that actually invoking the old methods on an MTRBaseDevice calls the new methods.
}

- (void)test024_MTRDeviceDelegate
{
    // TODO: Figure out how to test this. conformsToProtocol does not do what we
    // want, since we want to check whether declaring a specific set of
    // selectors would conform to the protocol.
}

- (void)test025_MTRDeviceAttestationDeviceInfo
{
    // Cheating by not initializing the object....
    __auto_type * info = [MTRDeviceAttestationDeviceInfo alloc];
    CHECK_READONLY_PROPERTY(info, dacCertificate, NSData *);
    CHECK_READONLY_PROPERTY(info, dacPAICertificate, NSData *);
    CHECK_READONLY_PROPERTY(info, certificateDeclaration, NSData *);
}

- (void)test026_MTRDeviceAttestationDelegate
{
    // TODO: Figure out how to test this.
}

- (void)test027_MTRDeviceControllerXPC
{
    NSMethodSignature * sig;

    sig = [MTRDeviceController methodSignatureForSelector:@selector(sharedControllerWithId:xpcConnectBlock:)];
    CHECK_RETURN_TYPE(sig, MTRDeviceController *);
    CHECK_ARGUMENT(sig, 0, id<NSCopying>);
    CHECK_ARGUMENT(sig, 1, NSXPCConnection * (^)(void) );

    sig = [MTRDeviceController methodSignatureForSelector:@selector(encodeXPCResponseValues:)];
    CHECK_RETURN_TYPE(sig, NSArray *);
    CHECK_ARGUMENT(sig, 0, NSArray *);

    sig = [MTRDeviceController methodSignatureForSelector:@selector(decodeXPCResponseValues:)];
    CHECK_RETURN_TYPE(sig, NSArray *);
    CHECK_ARGUMENT(sig, 0, NSArray *);

    sig = [MTRDeviceController methodSignatureForSelector:@selector(encodeXPCReadParams:)];
    CHECK_RETURN_TYPE(sig, NSArray *);
    CHECK_ARGUMENT(sig, 0, MTRReadParams *);

    sig = [MTRDeviceController methodSignatureForSelector:@selector(decodeXPCReadParams:)];
    CHECK_RETURN_TYPE(sig, MTRReadParams *);
    CHECK_ARGUMENT(sig, 0, NSArray *);

    sig = [MTRDeviceController methodSignatureForSelector:@selector(encodeXPCSubscribeParams:)];
    CHECK_RETURN_TYPE(sig, NSArray *);
    CHECK_ARGUMENT(sig, 0, MTRSubscribeParams *);

    sig = [MTRDeviceController methodSignatureForSelector:@selector(decodeXPCSubscribeParams:)];
    CHECK_RETURN_TYPE(sig, MTRSubscribeParams *);
    CHECK_ARGUMENT(sig, 0, NSArray *);
}

- (void)test028_MTRDeviceControllerServerProtocol
{
    // TODO: Figure out how to test this.
}

- (void)test029_MTRDeviceControllerClientProtocol
{
    // TODO: Figure out how to test this.
}

- (void)test030_MTRDeviceController
{
    CHECK_READONLY_PROPERTY(sController, isRunning, BOOL);
    CHECK_READONLY_PROPERTY(sController, controllerNodeId, NSNumber *);

    NSMethodSignature * sig;

    sig = [MTRDeviceController instanceMethodSignatureForSelector:@selector(setupCommissioningSessionWithPayload:newNodeID:error:)];
    CHECK_RETURN_TYPE(sig, BOOL);
    CHECK_ARGUMENT(sig, 0, MTRSetupPayload *);
    CHECK_ARGUMENT(sig, 1, NSNumber *);
    CHECK_ARGUMENT(sig, 2, NSError * __autoreleasing *);

    sig = [MTRDeviceController instanceMethodSignatureForSelector:@selector(pairDevice:discriminator:setupPINCode:error:)];
    CHECK_RETURN_TYPE(sig, BOOL);
    CHECK_ARGUMENT(sig, 0, uint64_t);
    CHECK_ARGUMENT(sig, 1, uint16_t);
    CHECK_ARGUMENT(sig, 2, uint32_t);
    CHECK_ARGUMENT(sig, 3, NSError * __autoreleasing *);

    sig = [MTRDeviceController instanceMethodSignatureForSelector:@selector(pairDevice:address:port:setupPINCode:error:)];
    CHECK_RETURN_TYPE(sig, BOOL);
    CHECK_ARGUMENT(sig, 0, uint64_t);
    CHECK_ARGUMENT(sig, 1, NSString *);
    CHECK_ARGUMENT(sig, 2, uint16_t);
    CHECK_ARGUMENT(sig, 3, uint32_t);
    CHECK_ARGUMENT(sig, 4, NSError * __autoreleasing *);

    sig = [MTRDeviceController instanceMethodSignatureForSelector:@selector(pairDevice:onboardingPayload:error:)];
    CHECK_RETURN_TYPE(sig, BOOL);
    CHECK_ARGUMENT(sig, 0, uint64_t);
    CHECK_ARGUMENT(sig, 1, NSString *);
    CHECK_ARGUMENT(sig, 2, NSError * __autoreleasing *);

    sig = [MTRDeviceController instanceMethodSignatureForSelector:@selector(commissionDevice:commissioningParams:error:)];
    CHECK_RETURN_TYPE(sig, BOOL);
    CHECK_ARGUMENT(sig, 0, uint64_t);
    CHECK_ARGUMENT(sig, 1, MTRCommissioningParameters *);
    CHECK_ARGUMENT(sig, 2, NSError * __autoreleasing *);

    sig = [MTRDeviceController instanceMethodSignatureForSelector:@selector(continueCommissioningDevice:
                                                                               ignoreAttestationFailure:error:)];
    CHECK_RETURN_TYPE(sig, BOOL);
    CHECK_ARGUMENT(sig, 0, void *);
    CHECK_ARGUMENT(sig, 1, BOOL);
    CHECK_ARGUMENT(sig, 2, NSError * __autoreleasing *);

    sig = [MTRDeviceController instanceMethodSignatureForSelector:@selector(stopDevicePairing:error:)];
    CHECK_RETURN_TYPE(sig, BOOL);
    CHECK_ARGUMENT(sig, 0, uint64_t);
    CHECK_ARGUMENT(sig, 1, NSError * __autoreleasing *);

    sig = [MTRDeviceController instanceMethodSignatureForSelector:@selector(getDeviceBeingCommissioned:error:)];
    CHECK_RETURN_TYPE(sig, MTRBaseDevice *);
    CHECK_ARGUMENT(sig, 0, uint64_t);
    CHECK_ARGUMENT(sig, 1, NSError * __autoreleasing *);

    sig = [MTRDeviceController instanceMethodSignatureForSelector:@selector(getBaseDevice:queue:completionHandler:)];
    CHECK_RETURN_TYPE(sig, BOOL);
    CHECK_ARGUMENT(sig, 0, uint64_t);
    CHECK_ARGUMENT(sig, 1, dispatch_queue_t);
    CHECK_ARGUMENT(sig, 2, MTRDeviceConnectionCallback);

    sig = [MTRDeviceController instanceMethodSignatureForSelector:@selector(openPairingWindow:duration:error:)];
    CHECK_RETURN_TYPE(sig, BOOL);
    CHECK_ARGUMENT(sig, 0, uint64_t);
    CHECK_ARGUMENT(sig, 1, NSUInteger);
    CHECK_ARGUMENT(sig, 2, NSError * __autoreleasing *);

    sig = [MTRDeviceController
        instanceMethodSignatureForSelector:@selector(openPairingWindowWithPIN:duration:discriminator:setupPIN:error:)];
    CHECK_RETURN_TYPE(sig, NSString *);
    CHECK_ARGUMENT(sig, 0, uint64_t);
    CHECK_ARGUMENT(sig, 1, NSUInteger);
    CHECK_ARGUMENT(sig, 2, NSUInteger);
    CHECK_ARGUMENT(sig, 3, NSUInteger);
    CHECK_ARGUMENT(sig, 4, NSError * __autoreleasing *);

    sig = [MTRDeviceController instanceMethodSignatureForSelector:@selector(setPairingDelegate:queue:)];
    CHECK_RETURN_TYPE(sig, void);
    CHECK_ARGUMENT(sig, 0, id<MTRDevicePairingDelegate>);
    CHECK_ARGUMENT(sig, 1, dispatch_queue_t);

    sig = [MTRDeviceController instanceMethodSignatureForSelector:@selector(setNocChainIssuer:queue:)];
    CHECK_RETURN_TYPE(sig, void);
    CHECK_ARGUMENT(sig, 0, id<MTRNOCChainIssuer>);
    CHECK_ARGUMENT(sig, 1, dispatch_queue_t);

    sig = [MTRDeviceController instanceMethodSignatureForSelector:@selector(fetchAttestationChallengeForDeviceId:)];
    CHECK_RETURN_TYPE(sig, NSData *);
    CHECK_ARGUMENT(sig, 0, uint64_t);

    sig = [MTRDeviceController instanceMethodSignatureForSelector:@selector(computePaseVerifier:iterations:salt:)];
    CHECK_RETURN_TYPE(sig, NSData *);
    CHECK_ARGUMENT(sig, 0, uint32_t);
    CHECK_ARGUMENT(sig, 1, uint32_t);
    CHECK_ARGUMENT(sig, 2, NSData *);

    sig = [MTRDeviceController instanceMethodSignatureForSelector:@selector(shutdown)];
    CHECK_RETURN_TYPE(sig, void);
}

- (void)test031_MTRDeviceControllerStartupParams
{
    __auto_type * params = [[MTRDeviceControllerStartupParams alloc] initWithSigningKeypair:sTestKeys fabricId:1 ipk:sTestKeys.ipk];
    CHECK_READONLY_PROPERTY(params, nocSigner, id<MTRKeypair>);
    CHECK_READONLY_PROPERTY(params, fabricId, uint64_t);
    CHECK_READONLY_PROPERTY(params, ipk, NSData *);
    CHECK_PROPERTY(params, vendorId, setVendorId, NSNumber *);
    CHECK_PROPERTY(params, nodeId, setNodeId, NSNumber *);
    CHECK_PROPERTY(params, rootCertificate, setRootCertificate, NSData *);
    CHECK_PROPERTY(params, intermediateCertificate, setIntermediateCertificate, NSData *);
    CHECK_READONLY_PROPERTY(params, operationalCertificate, NSData *);
    CHECK_PROPERTY(params, operationalKeypair, setOperationalKeypair, id<MTRKeypair>);

    NSMethodSignature * sig;

    sig = [MTRDeviceControllerStartupParams instanceMethodSignatureForSelector:@selector(initWithSigningKeypair:fabricId:ipk:)];
    CHECK_RETURN_TYPE(sig, MTRDeviceControllerStartupParams *);
    CHECK_ARGUMENT(sig, 0, id<MTRKeypair>);
    CHECK_ARGUMENT(sig, 1, uint64_t);
    CHECK_ARGUMENT(sig, 2, NSData *);

    sig = [MTRDeviceControllerStartupParams
        instanceMethodSignatureForSelector:@selector(initWithOperationalKeypair:
                                                         operationalCertificate:intermediateCertificate:rootCertificate:ipk:)];
    CHECK_RETURN_TYPE(sig, MTRDeviceControllerStartupParams *);
    CHECK_ARGUMENT(sig, 0, id<MTRKeypair>);
    CHECK_ARGUMENT(sig, 1, NSData *);
    CHECK_ARGUMENT(sig, 2, NSData *);
    CHECK_ARGUMENT(sig, 3, NSData *);
    CHECK_ARGUMENT(sig, 4, NSData *);
}

- (void)test032_MTRDevicePairingDelegate
{
    // TODO: Figure out how to test this.
}

- (void)test033_MTRError
{
    // TODO: Figure out how to test this.
}

- (void)test034_MTRKeypair
{
    // TODO: Figure out how to test this.
}

- (void)test035_MTRManualSetupPayloadParser
{
    NSMethodSignature * sig;

    sig = [MTRManualSetupPayloadParser instanceMethodSignatureForSelector:@selector(initWithDecimalStringRepresentation:)];
    CHECK_RETURN_TYPE(sig, MTRManualSetupPayloadParser *);
    CHECK_ARGUMENT(sig, 0, NSString *);

    sig = [MTRManualSetupPayloadParser instanceMethodSignatureForSelector:@selector(populatePayload:)];
    CHECK_RETURN_TYPE(sig, MTRSetupPayload *);
    CHECK_ARGUMENT(sig, 0, NSError * __autoreleasing *);
}

- (void)test036_MTRQRCodeSetupPayloadParser
{
    NSMethodSignature * sig;

    sig = [MTRQRCodeSetupPayloadParser instanceMethodSignatureForSelector:@selector(initWithBase38Representation:)];
    CHECK_RETURN_TYPE(sig, MTRQRCodeSetupPayloadParser *);
    CHECK_ARGUMENT(sig, 0, NSString *);

    sig = [MTRQRCodeSetupPayloadParser instanceMethodSignatureForSelector:@selector(populatePayload:)];
    CHECK_RETURN_TYPE(sig, MTRSetupPayload *);
    CHECK_ARGUMENT(sig, 0, NSError * __autoreleasing *);
}

- (void)test037_MTROnboardingPayloadParser
{
    NSMethodSignature * sig;

    sig = [MTROnboardingPayloadParser methodSignatureForSelector:@selector(setupPayloadForOnboardingPayload:error:)];
    CHECK_RETURN_TYPE(sig, MTRSetupPayload *);
    CHECK_ARGUMENT(sig, 0, NSString *);
    CHECK_ARGUMENT(sig, 1, NSError * __autoreleasing *);
}

- (void)test038_MTRNOCChainIssuer
{
    // TODO: Figure out how to test this.
}

- (void)test039_MTROTAHeader
{
    __auto_type * header = [[MTROTAHeader alloc] init];
    CHECK_PROPERTY(header, vendorID, setVendorID, NSNumber *);
    CHECK_PROPERTY(header, productID, setProductID, NSNumber *);
    CHECK_PROPERTY(header, payloadSize, setPayloadSize, NSNumber *);
    CHECK_PROPERTY(header, softwareVersion, setSoftwareVersion, NSNumber *);
    CHECK_PROPERTY(header, softwareVersionString, setSoftwareVersionString, NSString *);
    CHECK_PROPERTY(header, releaseNotesURL, setReleaseNotesURL, NSString *);
    CHECK_PROPERTY(header, imageDigest, setImageDigest, NSData *);
    CHECK_PROPERTY(header, imageDigestType, setImageDigestType, MTROTAImageDigestType);
    CHECK_PROPERTY(header, minApplicableVersion, setMinApplicableVersion, NSNumber *);
    CHECK_PROPERTY(header, maxApplicableVersion, setMaxApplicableVersion, NSNumber *);
}

- (void)test040_MTROTAHeaderParser
{
    NSMethodSignature * sig;

    sig = [MTROTAHeaderParser methodSignatureForSelector:@selector(headerFromData:error:)];
    CHECK_RETURN_TYPE(sig, MTROTAHeader *);
    CHECK_ARGUMENT(sig, 0, NSData *);
    CHECK_ARGUMENT(sig, 1, NSError * __autoreleasing *);
}

- (void)test041_MTROTAProviderDelegate
{
    // TODO: Figure out how to test this.
}

- (void)test042_MTRPersistentStorageDelegate
{
    // TODO: Figure out how to test this.
}

- (void)test043_MTROptionalQRCodeInfo
{
    __auto_type * info = [[MTROptionalQRCodeInfo alloc] init];
    CHECK_PROPERTY(info, infoType, setInfoType, NSNumber *);
    CHECK_PROPERTY(info, tag, setTag, NSNumber *);
    CHECK_PROPERTY(info, integerValue, setIntegerValue, NSNumber *);
    CHECK_PROPERTY(info, stringValue, setStringValue, NSString *);
}

- (void)test044_MTRSetupPayload
{
    XCTAssertTrue([MTRSetupPayload conformsToProtocol:@protocol(NSSecureCoding)]);

    __auto_type * payload = [[MTRSetupPayload alloc] init];
    CHECK_PROPERTY(payload, version, setVersion, NSNumber *);
    CHECK_PROPERTY(payload, vendorID, setVendorID, NSNumber *);
    CHECK_PROPERTY(payload, productID, setProductID, NSNumber *);
    CHECK_PROPERTY(payload, commissioningFlow, setCommissioningFlow, MTRCommissioningFlow);
    CHECK_PROPERTY(payload, rendezvousInformation, setRendezvousInformation, NSNumber *);
    CHECK_PROPERTY(payload, discriminator, setDiscriminator, NSNumber *);
    CHECK_PROPERTY(payload, hasShortDiscriminator, setHasShortDiscriminator, BOOL);
    CHECK_PROPERTY(payload, setUpPINCode, setSetUpPINCode, NSNumber *);
    CHECK_PROPERTY(payload, serialNumber, setSerialNumber, NSString *);

    NSMethodSignature * sig;

    sig = [MTRSetupPayload instanceMethodSignatureForSelector:@selector(getAllOptionalVendorData:)];
    CHECK_RETURN_TYPE(sig, NSArray *);
    CHECK_ARGUMENT(sig, 0, NSError * __autoreleasing *);

    sig = [MTRSetupPayload methodSignatureForSelector:@selector(generateRandomPIN)];
    CHECK_RETURN_TYPE(sig, NSUInteger);

    sig = [MTRSetupPayload methodSignatureForSelector:@selector(generateRandomSetupPasscode)];
    CHECK_RETURN_TYPE(sig, NSNumber *);

    sig = [MTRSetupPayload methodSignatureForSelector:@selector(setupPayloadWithOnboardingPayload:error:)];
    CHECK_RETURN_TYPE(sig, MTRSetupPayload *);
    CHECK_ARGUMENT(sig, 0, NSString *);
    CHECK_ARGUMENT(sig, 1, NSError * __autoreleasing *);

    sig = [MTRSetupPayload instanceMethodSignatureForSelector:@selector(initWithSetupPasscode:discriminator:)];
    CHECK_RETURN_TYPE(sig, MTRSetupPayload *);
    CHECK_ARGUMENT(sig, 0, NSNumber *);
    CHECK_ARGUMENT(sig, 1, NSNumber *);

    sig = [MTRSetupPayload instanceMethodSignatureForSelector:@selector(manualEntryCode)];
    CHECK_RETURN_TYPE(sig, NSString *);

    sig = [MTRSetupPayload instanceMethodSignatureForSelector:@selector(qrCodeString:)];
    CHECK_RETURN_TYPE(sig, NSString *);
    CHECK_ARGUMENT(sig, 0, NSError * __autoreleasing *);
}

- (void)test045_MTRStructsObjc
{
    // TODO: Figure out what and how to test here.
}

- (void)test046_MTRThreadOperationalDataset
{
    // Cheating by not initing the object.
    __auto_type * dataset = [MTRThreadOperationalDataset alloc];
    CHECK_READONLY_PROPERTY(dataset, networkName, NSString *);
    CHECK_READONLY_PROPERTY(dataset, extendedPANID, NSData *);
    CHECK_READONLY_PROPERTY(dataset, masterKey, NSData *);
    CHECK_READONLY_PROPERTY(dataset, PSKc, NSData *);
    CHECK_PROPERTY(dataset, channel, setChannel, uint16_t);
    CHECK_READONLY_PROPERTY(dataset, panID, NSData *);

    NSMethodSignature * sig;

    sig = [MTRThreadOperationalDataset
        instanceMethodSignatureForSelector:@selector(initWithNetworkName:extendedPANID:masterKey:PSKc:channel:panID:)];
    CHECK_RETURN_TYPE(sig, MTRThreadOperationalDataset *);
    CHECK_ARGUMENT(sig, 0, NSString *);
    CHECK_ARGUMENT(sig, 1, NSData *);
    CHECK_ARGUMENT(sig, 2, NSData *);
    CHECK_ARGUMENT(sig, 3, NSData *);
    CHECK_ARGUMENT(sig, 4, uint16_t);
    CHECK_ARGUMENT(sig, 5, NSData *);

    sig = [MTRThreadOperationalDataset instanceMethodSignatureForSelector:@selector(initWithData:)];
    CHECK_RETURN_TYPE(sig, MTRThreadOperationalDataset *);
    CHECK_ARGUMENT(sig, 0, NSData *);

    sig = [MTRThreadOperationalDataset instanceMethodSignatureForSelector:@selector(data)];
    CHECK_RETURN_TYPE(sig, NSData *);
}

#if !MANUAL_INDIVIDUAL_TEST
- (void)test999_TearDown
{
    // Put the device back in the state we found it: open commissioning window, no fabrics commissioned.
    MTRBaseDevice * device = GetConnectedDevice();
    dispatch_queue_t queue = dispatch_get_main_queue();

    // Get our current fabric index, for later deletion.
    XCTestExpectation * readFabricIndexExpectation = [self expectationWithDescription:@"Fabric index read"];

    __block NSNumber * fabricIndex;
    __auto_type * opCredsCluster = [[MTRBaseClusterOperationalCredentials alloc] initWithDevice:device endpoint:0 queue:queue];
    [opCredsCluster
        readAttributeCurrentFabricIndexWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable readError) {
            XCTAssertNil(readError);
            XCTAssertNotNil(value);
            fabricIndex = value;
            [readFabricIndexExpectation fulfill];
        }];

    [self waitForExpectations:@[ readFabricIndexExpectation ] timeout:kTimeoutInSeconds];

    // Open a commissioning window.
    XCTestExpectation * openCommissioningWindowExpectation = [self expectationWithDescription:@"Commissioning window opened"];

    __auto_type * adminCommissioningCluster = [[MTRBaseClusterAdministratorCommissioning alloc] initWithDevice:device
                                                                                                      endpoint:0
                                                                                                         queue:queue];
    __auto_type * openWindowParams = [[MTRAdministratorCommissioningClusterOpenBasicCommissioningWindowParams alloc] init];
    openWindowParams.commissioningTimeout = @(900);
    openWindowParams.timedInvokeTimeoutMs = @(50000);
    [adminCommissioningCluster openBasicCommissioningWindowWithParams:openWindowParams
                                                    completionHandler:^(NSError * _Nullable error) {
                                                        XCTAssertNil(error);
                                                        [openCommissioningWindowExpectation fulfill];
                                                    }];

    [self waitForExpectations:@[ openCommissioningWindowExpectation ] timeout:kTimeoutInSeconds];

    // Remove our fabric from the device.
    XCTestExpectation * removeFabricExpectation = [self expectationWithDescription:@"Fabric removed"];

    __auto_type * removeParams = [[MTROperationalCredentialsClusterRemoveFabricParams alloc] init];
    removeParams.fabricIndex = fabricIndex;

    [opCredsCluster removeFabricWithParams:removeParams
                         completionHandler:^(
                             MTROperationalCredentialsClusterNOCResponseParams * _Nullable data, NSError * _Nullable removeError) {
                             XCTAssertNil(removeError);
                             XCTAssertNotNil(data);
                             XCTAssertEqualObjects(data.statusCode, @(0));
                             [removeFabricExpectation fulfill];
                         }];

    [self waitForExpectations:@[ removeFabricExpectation ] timeout:kTimeoutInSeconds];

    [self shutdownStack];
}
#endif

@end