Initial commit

local_pod_repo/objcTox/Tests/CoreAudioMocks.h

@@ -0,0 +1,25 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#define PATCH_FAILING(funcname) funcname = (void *)FAILING ## funcname
+#define PATCH_PASSING(funcname) funcname = (void *)PASSING ## funcname
+
+// Restores all the CoreAudio function pointers to passing.
+#define RESTORE_PATCHES \
+    PATCH_PASSING(_AudioQueueAllocateBuffer); \
+    PATCH_PASSING(_AudioQueueDispose); \
+    PATCH_PASSING(_AudioQueueEnqueueBuffer); \
+    PATCH_PASSING(_AudioQueueFreeBuffer); \
+    PATCH_PASSING(_AudioQueueNewInput); \
+    PATCH_PASSING(_AudioQueueNewOutput); \
+    PATCH_PASSING(_AudioQueueSetProperty); \
+    PATCH_PASSING(_AudioQueueStart); \
+    PATCH_PASSING(_AudioQueueStop);
+
+// Implements a function named PASSING<funcname> that takes any number of args
+// and just returns 0. Handy when there's no need for special functionality.
+// They are not exactly valid C but it works for now (OS X 10.11.1, 64 bit)
+#define DECLARE_GENERIC_PASS(funcname) OSStatus PASSING ## funcname(void *a, ...) { return 0; }
+// Same, but return a failing error code.
+#define DECLARE_GENERIC_FAIL(funcname) OSStatus FAILING ## funcname(void *a, ...) { return -1; }

local_pod_repo/objcTox/Tests/OCTAudioEngineTests.m

@@ -0,0 +1,231 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#import <XCTest/XCTest.h>
+#import <OCMock/OCMock.h>
+#import "OCTCAsserts.h"
+#import "OCTAudioEngine+Private.h"
+#import "OCTAudioQueue.h"
+#import "OCTManagerConstants.h"
+
+@import AVFoundation;
+
+static void *refToSelf;
+
+@interface OCTAudioEngineTests : XCTestCase
+
+@property (strong, nonatomic) OCTAudioQueue *outputMock;
+@property (strong, nonatomic) OCTAudioQueue *inputMock;
+@property (strong, nonatomic) id audioSession;
+@property (strong, nonatomic) OCTAudioEngine *realAudioEngine;
+@property (strong, nonatomic) OCTAudioEngine *audioEngine;
+
+@property (strong, nonatomic) void (^sendDataBlock)(void *, OCTToxAVSampleCount, OCTToxAVSampleRate, OCTToxAVChannels);
+
+@end
+
+@implementation OCTAudioEngineTests
+
+- (void)setUp
+{
+    [super setUp];
+
+    refToSelf = (__bridge void *)(self);
+
+#if TARGET_OS_IPHONE
+    self.audioSession = OCMClassMock([AVAudioSession class]);
+    OCMStub([self.audioSession sharedInstance]).andReturn(self.audioSession);
+    OCMStub([self.audioSession sampleRate]).andReturn(44100.00);
+    [OCMStub([self.audioSession setPreferredSampleRate:0 error:[OCMArg anyObjectRef]]).andReturn(YES) ignoringNonObjectArgs];
+    OCMStub([self.audioSession setCategory:AVAudioSessionCategoryPlayAndRecord error:[OCMArg anyObjectRef]]).andReturn(YES);
+    [OCMStub([self.audioSession setPreferredIOBufferDuration:0 error:[OCMArg anyObjectRef]]).andReturn(YES) ignoringNonObjectArgs];
+    [OCMStub([self.audioSession overrideOutputAudioPort:0 error:[OCMArg anyObjectRef]]).andReturn(YES) ignoringNonObjectArgs];
+    OCMStub(([self.audioSession setMode:AVAudioSessionModeVoiceChat error:[OCMArg anyObjectRef]])).andReturn(YES);
+    OCMStub([self.audioSession setActive:YES error:[OCMArg anyObjectRef]]).andReturn(YES);
+    OCMStub([self.audioSession setActive:NO error:[OCMArg anyObjectRef]]).andReturn(YES);
+    // Put setup code here. This method is called before the invocation of each test method in the class.
+#endif
+
+    self.realAudioEngine = [[OCTAudioEngine alloc] init];
+    self.audioEngine = OCMPartialMock(self.realAudioEngine);
+
+    self.inputMock = OCMClassMock([OCTAudioQueue class]);
+    self.outputMock = OCMClassMock([OCTAudioQueue class]);
+}
+
+- (void)tearDown
+{
+    refToSelf = NULL;
+
+    self.audioSession = nil;
+    self.audioEngine = nil;
+    self.outputMock = nil;
+    self.inputMock = nil;
+    // Put teardown code here. This method is called after the invocation of each test method in the class.
+    [super tearDown];
+}
+
+- (void)enableMockQueues
+{
+    OCMStub([(id)self.audioEngine makeQueues:[OCMArg anyObjectRef]]).andDo(^(NSInvocation *invocation) {
+        id ae;
+        [invocation getArgument:&ae atIndex:0];
+
+        [ae setOutputQueue:self.outputMock];
+        [ae setInputQueue:self.inputMock];
+    });
+}
+
+- (void)testStartStopAudioFlow
+{
+    [self enableMockQueues];
+
+    id toxav = OCMClassMock([OCTToxAV class]);
+    OCMStub([toxav sendAudioFrame:[OCMArg anyPointer] sampleCount:0 channels:0 sampleRate:0 toFriend:0 error:[OCMArg anyObjectRef]]).andReturn(YES);
+    OCMStub([self.audioEngine toxav]).andReturn(toxav);
+
+    OCMStub([self.inputMock begin:[OCMArg anyObjectRef]]).andReturn(YES);
+    OCMStub([self.outputMock begin:[OCMArg anyObjectRef]]).andReturn(YES);
+
+    OCMStub([self.inputMock stop:[OCMArg anyObjectRef]]).andReturn(YES);
+    OCMStub([self.outputMock stop:[OCMArg anyObjectRef]]).andReturn(YES);
+
+    NSError *error = nil;
+    XCTAssertTrue([self.audioEngine startAudioFlow:&error]);
+    XCTAssertTrue([self.audioEngine stopAudioFlow:&error]);
+}
+
+- (void)testStartStopAudioFlowFail
+{
+    [self enableMockQueues];
+
+    OCMStub([self.inputMock begin:[OCMArg anyObjectRef]]).andDo(^(NSInvocation *invocation) {
+        NSError *__autoreleasing *err;
+        [invocation getArgument:&err atIndex:2];
+
+        if (err) {
+            *err = [NSError new];
+        }
+
+        BOOL no = NO;
+        [invocation setReturnValue:&no];
+    });
+
+    OCMStub([self.outputMock begin:[OCMArg anyObjectRef]]).andDo(^(NSInvocation *invocation) {
+        NSError *__autoreleasing *err;
+        [invocation getArgument:&err atIndex:2];
+
+        if (err) {
+            *err = [NSError new];
+        }
+
+        BOOL no = NO;
+        [invocation setReturnValue:&no];
+    });
+
+
+    NSError *error = nil;
+    XCTAssertFalse([self.audioEngine startAudioFlow:&error]);
+    XCTAssertNotNil(error);
+}
+
+- (void)testSettingDevice
+{
+#if ! TARGET_OS_IPHONE
+    XCTAssertTrue([self.audioEngine setOutputDeviceID:@"Sayle" error:nil]);
+    XCTAssertTrue([self.audioEngine setInputDeviceID:@"Laives" error:nil]);
+
+    // Device ID should stay in sync with set.
+    XCTAssertEqualObjects(self.audioEngine.outputDeviceID, @"Sayle");
+    XCTAssertEqualObjects(self.audioEngine.inputDeviceID, @"Laives");
+#else
+    XCTAssertTrue([self.audioEngine routeAudioToSpeaker:YES error:nil]);
+    OCMVerify([self.audioSession overrideOutputAudioPort:AVAudioSessionPortOverrideSpeaker error:[OCMArg anyObjectRef]]);
+#endif
+}
+
+// No test for iOS because it doesn't do anything anyway
+- (void)testSettingDevicesLive
+{
+#if ! TARGET_OS_IPHONE
+    NSError *err;
+    [self enableMockQueues];
+
+    OCMStub([self.inputMock begin:[OCMArg anyObjectRef]]).andReturn(YES);
+    OCMStub([self.outputMock begin:[OCMArg anyObjectRef]]).andReturn(YES);
+    XCTAssertTrue([self.audioEngine startAudioFlow:&err]);
+
+    OCMStub([self.outputMock setDeviceID:@"Crystinger" error:[OCMArg anyObjectRef]]).andReturn(YES);
+    OCMStub([self.inputMock setDeviceID:@"Daxx" error:[OCMArg anyObjectRef]]).andReturn(YES);
+    OCMStub([self.outputMock setDeviceID:@"Niles" error:[OCMArg anyObjectRef]]).andReturn(NO);
+
+    XCTAssertTrue([self.audioEngine setOutputDeviceID:@"Crystinger" error:nil]);
+    XCTAssertTrue([self.audioEngine setInputDeviceID:@"Daxx" error:nil]);
+
+    // Device ID should stay in sync with set.
+    XCTAssertEqualObjects(self.audioEngine.outputDeviceID, @"Crystinger");
+    XCTAssertEqualObjects(self.audioEngine.inputDeviceID, @"Daxx");
+
+    // Failed sets should not update the stored id.
+    XCTAssertFalse([self.audioEngine setOutputDeviceID:@"Niles" error:nil]);
+    XCTAssertNotEqualObjects(self.audioEngine.outputDeviceID, @"Niles");
+#endif
+}
+
+- (void)testSendDataBlock
+{
+    [self enableMockQueues];
+
+    id toxav = OCMClassMock([OCTToxAV class]);
+    OCMStub([self.audioEngine toxav]).andReturn(toxav);
+
+    OCMStub([self.inputMock setSendDataBlock:[OCMArg any]]).andDo(^(NSInvocation *invoc) {
+        void (^sendDataBlock)(void *, OCTToxAVSampleCount, OCTToxAVSampleRate, OCTToxAVChannels);
+        [invoc getArgument:&sendDataBlock atIndex:2];
+        self.sendDataBlock = sendDataBlock;
+    });
+
+    OCMStub([self.inputMock begin:[OCMArg anyObjectRef]]).andReturn(YES);
+    OCMStub([self.outputMock begin:[OCMArg anyObjectRef]]).andReturn(YES);
+
+    NSError *error = nil;
+    self.audioEngine.friendNumber = 0;
+    XCTAssertTrue([self.audioEngine startAudioFlow:&error]);
+
+    OCTToxAVPCMData pcm[] = {0x52, 0x2d, 0x4f, 0x2d, 0x4d, 0x2d, 0x41, 0x2d, 0x4e, 0x2d, 0x54, 0x2d, 0x49, 0x2d, 0x43, 0x2d, 0x21, 0x21};
+    self.sendDataBlock((void *)pcm, 9, 48000, 1);
+
+    OCMVerify([toxav sendAudioFrame:pcm sampleCount:9 channels:1 sampleRate:48000 toFriend:0 error:[OCMArg anyObjectRef]]);
+}
+
+- (void)testReceiveAudioPackets
+{
+    [self enableMockQueues];
+
+    TPCircularBuffer buffer;
+    TPCircularBufferInit(&buffer, 256);
+
+    OCMStub([self.inputMock begin:[OCMArg anyObjectRef]]).andReturn(YES);
+    OCMStub([self.outputMock begin:[OCMArg anyObjectRef]]).andReturn(YES);
+    OCMStub([self.outputMock getBufferPointer]).andReturn(&buffer);
+
+    NSError *error = nil;
+    self.audioEngine.friendNumber = 0;
+    XCTAssertTrue([self.audioEngine startAudioFlow:&error]);
+
+    OCTToxAVPCMData pcm[] = {0x52, 0x2d, 0x4f, 0x2d, 0x4d, 0x2d, 0x41, 0x2d, 0x4e, 0x2d, 0x54, 0x2d, 0x49, 0x2d, 0x43, 0x2d, 0x21, 0x21};
+    [self.audioEngine provideAudioFrames:pcm sampleCount:9 channels:1 sampleRate:12 fromFriend:0];
+
+    int32_t nbytes;
+    void *samples = TPCircularBufferTail(&buffer, &nbytes);
+
+    XCTAssertTrue(nbytes == 18);
+    XCTAssertTrue(memcmp(samples, pcm, 18) == 0);
+
+    TPCircularBufferCleanup(&buffer);
+
+    OCMVerify([self.outputMock updateSampleRate:12 numberOfChannels:1 error:[OCMArg anyObjectRef]]);
+}
+
+@end

local_pod_repo/objcTox/Tests/OCTAudioQueueTests.m

@@ -0,0 +1,450 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#import <XCTest/XCTest.h>
+#import <OCMock/OCMock.h>
+#import "OCTCAsserts.h"
+#import "OCTAudioEngine+Private.h"
+#import "OCTAudioQueue.h"
+#import "OCTManagerConstants.h"
+
+#include "CoreAudioMocks.h"
+
+@import AVFoundation;
+
+static void *refToSelf;
+static AudioQueueInputCallback callForInput;
+static AudioQueueOutputCallback callForOutput;
+
+const OCTToxAVPCMData pcm[8] = {2, 4, 6, 8, 10, 12, 14, 16};
+
+OSStatus PASSING_AudioQueueNewOutput(const AudioStreamBasicDescription *inFormat,
+                                     AudioQueueOutputCallback inCallbackProc,
+                                     void *inUserData,
+                                     CFRunLoopRef inCallbackRunLoop,
+                                     CFStringRef inCallbackRunLoopMode,
+                                     UInt32 inFlags,
+                                     AudioQueueRef *outAQ)
+{
+    *outAQ = (void *)0x1234567;
+    callForOutput = inCallbackProc;
+    return 0;
+}
+
+
+OSStatus PASSING_AudioQueueNewInput(const AudioStreamBasicDescription *inFormat,
+                                    AudioQueueInputCallback inCallbackProc,
+                                    void *inUserData,
+                                    CFRunLoopRef inCallbackRunLoop,
+                                    CFStringRef inCallbackRunLoopMode,
+                                    UInt32 inFlags,
+                                    AudioQueueRef *outAQ)
+{
+    *outAQ = (void *)0x1234567;
+    callForInput = inCallbackProc;
+    return 0;
+}
+
+typedef struct NotAudioQueueBuffer {
+    UInt32 mAudioDataBytesCapacity; // 4 (8)
+    void *mAudioData; // 8
+    UInt32 mAudioDataByteSize; // 4 (8)
+    void *__nullable mUserData; // 8
+
+    const UInt32 mPacketDescriptionCapacity; // 4 (8)
+    AudioStreamPacketDescription *const __nullable mPacketDescriptions; // (8)
+    UInt32 mPacketDescriptionCount; //  4
+} NotAudioQueueBuffer;
+
+OSStatus PASSING_AudioQueueAllocateBuffer(AudioQueueRef inAQ, UInt32 inBufferByteSize, AudioQueueBufferRef *outBuffer)
+{
+    NotAudioQueueBuffer *buf = calloc(sizeof(AudioQueueBuffer) + inBufferByteSize, 1);
+    buf->mAudioData = ((uint8_t *)buf) + sizeof(struct AudioQueueBuffer);
+    buf->mAudioDataBytesCapacity = inBufferByteSize;
+    buf->mAudioDataByteSize = inBufferByteSize;
+
+    *outBuffer = (AudioQueueBufferRef)buf;
+    return 0;
+}
+
+OSStatus PASSING_AudioQueueFreeBuffer(AudioQueueRef inAQ, AudioQueueBufferRef inBuffer)
+{
+    free(inBuffer);
+    return 0;
+}
+
+#if ! TARGET_OS_IPHONE
+OSStatus PASSING_AudioObjectGetPropertyData(AudioObjectID inObjectID,
+                                            const AudioObjectPropertyAddress *inAddress,
+                                            UInt32 inQualifierDataSize,
+                                            const void *inQualifierData,
+                                            UInt32 *ioDataSize,
+                                            void *outData)
+{
+    if (inObjectID == kAudioObjectSystemObject) {
+        CCCAssertTrue(outData != NULL);
+        CCCAssertTrue(*ioDataSize == sizeof(AudioDeviceID));
+        *(AudioDeviceID *)outData = 0x1234567;
+        return 0;
+    }
+
+    if (inAddress->mSelector == kAudioDevicePropertyDeviceUID) {
+        CFStringRef ret = CFSTR("PXS-04G");
+        *(CFStringRef *)outData = CFStringCreateCopy(nil, ret);
+        return 0;
+    }
+
+    return -1;
+}
+
+OSStatus FAILING_AudioObjectGetPropertyData(AudioObjectID inObjectID,
+                                            const AudioObjectPropertyAddress *inAddress,
+                                            UInt32 inQualifierDataSize,
+                                            const void *inQualifierData,
+                                            UInt32 *ioDataSize,
+                                            void *outData)
+{
+    if (inObjectID == kAudioObjectSystemObject) {
+        return -1;
+    }
+    return -1;
+}
+
+OSStatus FAILING_AudioObjectGetPropertyData2(AudioObjectID inObjectID,
+                                             const AudioObjectPropertyAddress *inAddress,
+                                             UInt32 inQualifierDataSize,
+                                             const void *inQualifierData,
+                                             UInt32 *ioDataSize,
+                                             void *outData)
+{
+    if (inObjectID == kAudioObjectSystemObject) {
+        *(AudioDeviceID *)outData = 0x1234567;
+        return 0;
+    }
+    if (inAddress->mSelector == kAudioDevicePropertyDeviceUID) {
+        return -1;
+    }
+    return -1;
+}
+#endif
+
+OSStatus FAILING_AudioQueueSetProperty(AudioQueueRef inAQ,
+                                       AudioQueuePropertyID inID,
+                                       const void *inData,
+                                       UInt32 inDataSize)
+{
+    if (inID == kAudioQueueProperty_CurrentDevice) {
+        CCCAssertNotEqual(inData, nil);
+        CCCAssertEqual(inDataSize, sizeof(CFStringRef *));
+
+        return -1;
+    }
+    return 0;
+}
+
+OSStatus PASSING_AudioQueueStart(AudioQueueRef inAQ,
+                                 const AudioTimeStamp *inStartTime)
+{
+    CCCAssert(inAQ != NULL);
+    return 0;
+}
+
+
+DECLARE_GENERIC_PASS(_AudioQueueDispose)
+DECLARE_GENERIC_PASS(_AudioQueueEnqueueBuffer)
+DECLARE_GENERIC_PASS(_AudioQueueSetProperty)
+DECLARE_GENERIC_PASS(_AudioQueueStop)
+
+DECLARE_GENERIC_FAIL(_AudioQueueDispose)
+DECLARE_GENERIC_FAIL(_AudioQueueEnqueueBuffer)
+DECLARE_GENERIC_FAIL(_AudioQueueNewInput)
+DECLARE_GENERIC_FAIL(_AudioQueueNewOutput)
+DECLARE_GENERIC_FAIL(_AudioQueueStart)
+DECLARE_GENERIC_FAIL(_AudioQueueStop)
+
+@interface OCTAudioQueueTests : XCTestCase
+
+@property (strong, nonatomic) id audioSession;
+
+@end
+
+@implementation OCTAudioQueueTests
+
+- (void)setUp
+{
+    [super setUp];
+
+    refToSelf = (__bridge void *)(self);
+
+#if TARGET_OS_IPHONE
+    OCMStub([self.audioSession sampleRate]).andReturn(44100.00);
+    // Put setup code here. This method is called before the invocation of each test method in the class.
+#endif
+
+    RESTORE_PATCHES
+
+#if ! TARGET_OS_IPHONE
+    _AudioObjectGetPropertyData = PASSING_AudioObjectGetPropertyData;
+#endif
+}
+
+- (void)tearDown
+{
+    refToSelf = NULL;
+
+    self.audioSession = nil;
+    // Put teardown code here. This method is called after the invocation of each test method in the class.
+    [super tearDown];
+}
+
+- (void)testInitOutput
+{
+    NSError *error = nil;
+    OCTAudioQueue *oq = [[OCTAudioQueue alloc] initWithOutputDeviceID:@"Crystinger" error:&error];
+
+    XCTAssertNotNil(oq);
+    XCTAssertNotEqual([oq getBufferPointer], NULL);
+}
+
+- (void)testInitInput
+{
+    NSError *error = nil;
+    OCTAudioQueue *oq = [[OCTAudioQueue alloc] initWithInputDeviceID:@"Daxx" error:&error];
+
+    XCTAssertNotNil(oq);
+    XCTAssertNotEqual([oq getBufferPointer], NULL);
+}
+
+- (void)testInitFail
+{
+    PATCH_FAILING(_AudioQueueNewOutput);
+
+    NSError *error = nil;
+    OCTAudioQueue *oq = [[OCTAudioQueue alloc] initWithOutputDeviceID:@"Vint" error:&error];
+
+    XCTAssertNil(oq);
+    XCTAssertNotNil(error);
+
+
+    PATCH_FAILING(_AudioQueueNewInput);
+
+    error = nil;
+    oq = [[OCTAudioQueue alloc] initWithInputDeviceID:@"Rita" error:&error];
+
+    XCTAssertNil(oq);
+    XCTAssertNotNil(error);
+}
+
+- (void)testInitLater
+{
+    PATCH_FAILING(_AudioQueueSetProperty);
+
+    NSError *error = nil;
+    OCTAudioQueue *oq = [[OCTAudioQueue alloc] initWithOutputDeviceID:@"Elgarde" error:&error];
+
+    XCTAssertNil(oq);
+    XCTAssertNotNil(error);
+
+    error = nil;
+    oq = [[OCTAudioQueue alloc] initWithInputDeviceID:@"Kirin" error:&error];
+
+    XCTAssertNil(oq);
+    XCTAssertNotNil(error);
+}
+
+// setting devices only available on OS X
+- (void)testSetDevice
+{
+#if ! TARGET_OS_IPHONE
+    NSError *error = nil;
+    OCTAudioQueue *oq = [[OCTAudioQueue alloc] initWithInputDeviceID:@"Undine" error:&error];
+    XCTAssertNotNil(oq);
+
+    BOOL ok = [oq setDeviceID:@"PXS-04G" error:&error];
+    XCTAssertTrue(ok);
+
+    PATCH_FAILING(_AudioQueueSetProperty);
+    ok = [oq setDeviceID:@"Nyx" error:&error];
+    XCTAssertFalse(ok);
+    XCTAssertNotNil(error);
+#endif
+}
+
+- (void)testSetDefaultDevice
+{
+    NSError *error = nil;
+    OCTAudioQueue *oq = [[OCTAudioQueue alloc] initWithInputDeviceID:@"Sayle" error:&error];
+    XCTAssertNotNil(oq);
+
+#if ! TARGET_OS_IPHONE
+    BOOL ok = [oq setDeviceID:nil error:&error];
+    XCTAssertTrue(ok);
+
+    _AudioObjectGetPropertyData = FAILING_AudioObjectGetPropertyData;
+    ok = [oq setDeviceID:nil error:&error];
+    XCTAssertFalse(ok);
+    XCTAssertNotNil(error);
+
+    _AudioObjectGetPropertyData = FAILING_AudioObjectGetPropertyData2;
+    error = nil;
+    ok = [oq setDeviceID:nil error:&error];
+    XCTAssertFalse(ok);
+    XCTAssertNotNil(error);
+#endif
+}
+
+- (void)testStartStop
+{
+    NSError *error = nil;
+    OCTAudioQueue *oq = [[OCTAudioQueue alloc] initWithOutputDeviceID:@"Naivy" error:&error];
+
+    XCTAssertNotNil(oq);
+    XCTAssertNotEqual([oq getBufferPointer], NULL);
+
+    BOOL ok = [oq begin:&error];
+    XCTAssertTrue(ok);
+
+    ok = [oq stop:&error];
+    XCTAssertTrue(ok);
+}
+
+- (void)testStartFail
+{
+    NSError *error = nil;
+    OCTAudioQueue *oq = [[OCTAudioQueue alloc] initWithOutputDeviceID:@"Vervain" error:&error];
+
+    XCTAssertNotNil(oq);
+
+    PATCH_FAILING(_AudioQueueStart);
+
+    BOOL ok = [oq begin:&error];
+    XCTAssertFalse(ok);
+    XCTAssertNotNil(error);
+
+    ok = [oq stop:&error];
+    XCTAssertTrue(ok);
+}
+
+- (void)testStopFail
+{
+    NSError *error = nil;
+    OCTAudioQueue *oq = [[OCTAudioQueue alloc] initWithOutputDeviceID:@"Raijin" error:&error];
+
+    XCTAssertNotNil(oq);
+
+    PATCH_FAILING(_AudioQueueStop);
+
+    BOOL ok = [oq begin:&error];
+    XCTAssertTrue(ok);
+
+    ok = [oq stop:&error];
+    XCTAssertFalse(ok);
+    XCTAssertNotNil(error);
+}
+
+- (void)testChangeSampleRate
+{
+    NSError *error = nil;
+    OCTAudioQueue *oq = [[OCTAudioQueue alloc] initWithOutputDeviceID:@"Minari" error:&error];
+
+    XCTAssertNotNil(oq);
+
+    BOOL ok = [oq begin:&error];
+    XCTAssertTrue(ok);
+
+    ok = [oq updateSampleRate:96000.0 numberOfChannels:2.0 error:&error];
+    XCTAssertTrue(ok);
+}
+
+- (void)testChangeSampleRateFail
+{
+    NSError *error = nil;
+    OCTAudioQueue *oq = [[OCTAudioQueue alloc] initWithOutputDeviceID:@"Medis" error:&error];
+
+    XCTAssertNotNil(oq);
+
+    BOOL ok = [oq begin:&error];
+    XCTAssertTrue(ok);
+
+    PATCH_FAILING(_AudioQueueNewOutput);
+
+    ok = [oq updateSampleRate:96000.0 numberOfChannels:2.0 error:&error];
+    XCTAssertFalse(ok);
+    XCTAssertNotNil(error);
+
+    PATCH_PASSING(_AudioQueueNewOutput);
+
+    ok = [oq begin:&error];
+    XCTAssertTrue(ok);
+}
+
+- (void)testFillOutput
+{
+    // TODO investigate failing test on travis
+
+    // NSError *error = nil;
+    // OCTAudioQueue *oq = [[OCTAudioQueue alloc] initWithOutputDeviceID:@"Shadogan" error:&error];
+
+    // XCTAssertNotNil(oq);
+
+    // BOOL ok = [oq begin:&error];
+    // XCTAssertTrue(ok);
+
+    // AudioQueueBufferRef buf;
+
+    // // Allocate some extra space because the implementation is supposed to fill
+    // // it with 0 if there's not enough data in the ring.
+
+    // PASSING_AudioQueueAllocateBuffer(nil, 32, &buf);
+    // XCTAssertNotEqual(buf, NULL);
+
+    // TPCircularBufferProduceBytes([oq getBufferPointer], pcm, 16);
+    // callForOutput((__bridge void *)(oq), (void *)0x1234567, buf);
+
+    // OCTToxAVPCMData checkPCM[16];
+    // memset((void *)checkPCM, 0, 32);
+    // memcpy((void *)checkPCM, pcm, 16);
+
+    // XCTAssertTrue(memcmp(buf->mAudioData, checkPCM, 32) == 0);
+    // PASSING_AudioQueueFreeBuffer(nil, buf);
+}
+
+- (void)testFillInput
+{
+    NSError *error = nil;
+    OCTAudioQueue *oq = [[OCTAudioQueue alloc] initWithInputDeviceID:@"Nelly" error:&error];
+
+    XCTAssertNotNil(oq);
+
+    BOOL ok = [oq begin:&error];
+    XCTAssertTrue(ok);
+
+    AudioQueueBufferRef buf;
+    PASSING_AudioQueueAllocateBuffer(nil, 4, &buf);
+    XCTAssertNotEqual(buf, NULL);
+
+    __block BOOL sbreak = NO;
+
+    oq.sendDataBlock = ^(void *data, OCTToxAVSampleCount samples, OCTToxAVSampleRate srate, OCTToxAVChannels nchan) {
+        sbreak = YES;
+    };
+
+    int times = 0;
+    while (! sbreak && times < 2000) {
+        memcpy(buf->mAudioData, pcm, 4);
+        callForInput((__bridge void *_Nullable)(oq),
+                     (void *)0x1234567,
+                     buf,
+                     (void *)0x1,
+                     0,
+                     NULL);
+    }
+
+    XCTAssertTrue(times < 2000);
+    // we just have to make sure sendDataBlock is called
+    XCTAssertTrue(sbreak);
+    PASSING_AudioQueueFreeBuffer(nil, buf);
+}
+
+@end

local_pod_repo/objcTox/Tests/OCTCAsserts.h

@@ -0,0 +1,31 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef objcTox_OCTCAsserts_h
+#define objcTox_OCTCAsserts_h
+
+#import <XCTest/XCTest.h>
+
+/**
+ * Macros for testing to use in C functions.
+ *
+ * Define `void *refToSelf` in you test file. Set it to test object in setUp, to nil in tearDown.
+ */
+
+#define CCCAssert(expression, ...) \
+    _XCTPrimitiveAssertTrue((__bridge id)refToSelf, expression, @#expression, __VA_ARGS__)
+
+#define CCCAssertFalse(expression, ...) \
+    _XCTPrimitiveAssertFalse((__bridge id)refToSelf, expression, @#expression, __VA_ARGS__)
+
+#define CCCAssertTrue(expression, ...) \
+    _XCTPrimitiveAssertTrue((__bridge id)refToSelf, expression, @#expression, __VA_ARGS__)
+
+#define CCCAssertEqual(expression1, expression2, ...) \
+    _XCTPrimitiveAssertEqual((__bridge id)refToSelf, expression1, @#expression1, expression2, @#expression2, __VA_ARGS__)
+
+#define CCCAssertNotEqual(expression1, expression2, ...) \
+    _XCTPrimitiveAssertNotEqual((__bridge id)refToSelf, expression1, @#expression1, expression2, @#expression2, __VA_ARGS__)
+
+#endif

local_pod_repo/objcTox/Tests/OCTCallTimerTests.m

@@ -0,0 +1,73 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#import <XCTest/XCTest.h>
+
+#import "OCTCallTimer.h"
+#import "OCTCall.h"
+#import "OCTRealmTests.h"
+
+@interface OCTCallTimer (Tests)
+
+@property (strong, nonatomic) dispatch_source_t timer;
+@property (weak, nonatomic) OCTRealmManager *realmManager;
+
+@end
+@interface OCTCallTimerTests : OCTRealmTests
+
+@property (strong, nonatomic) OCTCallTimer *callTimer;
+
+@end
+
+@implementation OCTCallTimerTests
+
+- (void)setUp
+{
+    [super setUp];
+
+    self.callTimer = [[OCTCallTimer alloc] initWithRealmManager:self.realmManager];
+    // Put setup code here. This method is called before the invocation of each test method in the class.
+}
+
+- (void)tearDown
+{
+    // Put teardown code here. This method is called after the invocation of each test method in the class.
+    [super tearDown];
+}
+
+- (void)testInit
+{
+    XCTAssertNil(self.callTimer.timer);
+    XCTAssertNotNil(self.callTimer.realmManager);
+}
+
+- (void)testStartTimer
+{
+    OCTFriend *friend = [self createFriendWithFriendNumber:9];
+
+    [self.realmManager.realm beginWriteTransaction];
+    [self.realmManager.realm addObject:friend];
+    [self.realmManager.realm commitWriteTransaction];
+
+    OCTChat *chat = [self.realmManager getOrCreateChatWithFriend:friend];
+    OCTCall *call = [self.realmManager createCallWithChat:chat status:OCTCallStatusActive];
+
+    XCTestExpectation *expectation = [self expectationWithDescription:@"Test Timer"];
+
+    [self.callTimer startTimerForCall:call];
+
+    dispatch_time_t delayTime =  dispatch_time(DISPATCH_TIME_NOW, 1.5 * NSEC_PER_SEC);
+
+    dispatch_after(delayTime, dispatch_get_main_queue(), ^{
+        if (call.callDuration > 1) {
+            [expectation fulfill];
+        }
+    });
+
+    [self waitForExpectationsWithTimeout:3.0 handler:^(NSError *error) {
+        [self.callTimer stopTimer];
+    }];
+}
+
+@end

local_pod_repo/objcTox/Tests/OCTChatTests.m

@@ -0,0 +1,76 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#import <XCTest/XCTest.h>
+
+#import "OCTChat.h"
+#import "OCTMessageAbstract.h"
+
+@interface OCTChatTests : XCTestCase
+
+@end
+
+@implementation OCTChatTests
+
+- (void)setUp
+{
+    [super setUp];
+    // Put setup code here. This method is called before the invocation of each test method in the class.
+}
+
+- (void)tearDown
+{
+    // Put teardown code here. This method is called after the invocation of each test method in the class.
+    [super tearDown];
+}
+
+- (void)testLastReadDate
+{
+    OCTChat *chat = [OCTChat new];
+
+    chat.lastReadDateInterval = 0;
+    XCTAssertNil([chat lastReadDate]);
+
+    chat.lastReadDateInterval = 12345;
+    XCTAssertEqual([[chat lastReadDate] timeIntervalSince1970], 12345);
+
+    chat.lastReadDateInterval = -12345;
+    XCTAssertNil([chat lastReadDate]);
+}
+
+- (void)testLastActivityDate
+{
+    OCTChat *chat = [OCTChat new];
+
+    chat.lastActivityDateInterval = 0;
+    XCTAssertNil([chat lastActivityDate]);
+
+    chat.lastActivityDateInterval = 12345;
+    XCTAssertEqual([[chat lastActivityDate] timeIntervalSince1970], 12345);
+
+    chat.lastActivityDateInterval = -12345;
+    XCTAssertNil([chat lastActivityDate]);
+}
+
+- (void)testHasUnreadMessages
+{
+    OCTChat *chat = [OCTChat new];
+    chat.lastMessage = [OCTMessageAbstract new];
+
+    XCTAssertFalse([chat hasUnreadMessages]);
+
+    chat.lastReadDateInterval = 10;
+    XCTAssertFalse([chat hasUnreadMessages]);
+
+    chat.lastMessage.dateInterval = 20;
+    XCTAssertTrue([chat hasUnreadMessages]);
+
+    chat.lastReadDateInterval = 20;
+    XCTAssertFalse([chat hasUnreadMessages]);
+
+    chat.lastReadDateInterval = 30;
+    XCTAssertFalse([chat hasUnreadMessages]);
+}
+
+@end

local_pod_repo/objcTox/Tests/OCTDefaultFileStorageTests.m

@@ -0,0 +1,49 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#import <Foundation/Foundation.h>
+#import <XCTest/XCTest.h>
+
+#import "OCTDefaultFileStorage.h"
+
+@interface OCTDefaultFileStorageTests : XCTestCase
+
+@end
+
+@implementation OCTDefaultFileStorageTests
+
+- (void)setUp
+{
+    [super setUp];
+    // Put setup code here. This method is called before the invocation of each test method in the class.
+}
+
+- (void)tearDown
+{
+    // Put teardown code here. This method is called after the invocation of each test method in the class.
+    [super tearDown];
+}
+
+- (void)testProperties
+{
+    OCTDefaultFileStorage *storage = [[OCTDefaultFileStorage alloc] initWithBaseDirectory:@"/base"
+                                                                       temporaryDirectory:@"/temp"];
+
+    XCTAssertEqualObjects(storage.pathForToxSaveFile, @"/base/save.tox");
+    XCTAssertEqualObjects(storage.pathForDatabase, @"/base/database");
+    XCTAssertEqualObjects(storage.pathForDatabaseEncryptionKey, @"/base/database.encryptionkey");
+    XCTAssertEqualObjects(storage.pathForDownloadedFilesDirectory, @"/base/files");
+    XCTAssertEqualObjects(storage.pathForTemporaryFilesDirectory, @"/temp");
+}
+
+- (void)testCustomToxSaveFileName
+{
+    OCTDefaultFileStorage *storage = [[OCTDefaultFileStorage alloc] initWithToxSaveFileName:@"filename"
+                                                                              baseDirectory:@"/base"
+                                                                         temporaryDirectory:@"/temp"];
+
+    XCTAssertEqualObjects(storage.pathForToxSaveFile, @"/base/filename.tox");
+}
+
+@end

local_pod_repo/objcTox/Tests/OCTFileToolsTests.m

@@ -0,0 +1,127 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#import <XCTest/XCTest.h>
+#import "OCTFileTools.h"
+
+@interface OCTFileToolsTests : XCTestCase
+
+@end
+
+@implementation OCTFileToolsTests
+
+- (void)setUp
+{
+    [super setUp];
+    // Put setup code here. This method is called before the invocation of each test method in the class.
+}
+
+- (void)tearDown
+{
+    // Put teardown code here. This method is called after the invocation of each test method in the class.
+    [super tearDown];
+}
+
+- (void)testCreateNewFilePath
+{
+#define COMPARE(originalName, resultName) \
+    XCTAssertEqualObjects([directory stringByAppendingPathComponent:resultName], \
+                          [OCTFileTools createNewFilePathInDirectory:directory fileName:originalName]);
+
+    NSString *directory = [NSTemporaryDirectory() stringByAppendingPathComponent:@"testCreateNewFilePath"];
+
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    [fileManager removeItemAtPath:directory error:nil];
+    [fileManager createDirectoryAtPath:directory withIntermediateDirectories:YES attributes:nil error:nil];
+
+    COMPARE(@"file.txt", @"file.txt")
+    COMPARE(@"file", @"file")
+
+    [self createFileInDirectory: directory name: @"file.txt"];
+    [self createFileInDirectory:directory name:@"file"];
+    COMPARE(@"file.txt", @"file 2.txt")
+    COMPARE(@"file", @"file 2")
+
+    [self createFileInDirectory: directory name: @"file 2.txt"];
+    [self createFileInDirectory:directory name:@"file 2"];
+    COMPARE(@"file.txt", @"file 3.txt")
+    COMPARE(@"file", @"file 3")
+
+    [self createFileInDirectory: directory name: @"file 3.txt"];
+    [self createFileInDirectory:directory name:@"file 3"];
+    COMPARE(@"file.txt", @"file 4.txt")
+    COMPARE(@"file", @"file 4")
+
+
+
+    COMPARE(@"other 1.txt", @"other 1.txt")
+    COMPARE(@"other 1", @"other 1")
+
+    [self createFileInDirectory: directory name: @"other 1.txt"];
+    [self createFileInDirectory:directory name:@"other 1"];
+    COMPARE(@"other 1.txt", @"other 2.txt")
+    COMPARE(@"other 1", @"other 2")
+
+    [self createFileInDirectory: directory name: @"other 9.txt"];
+    [self createFileInDirectory:directory name:@"other 9"];
+    COMPARE(@"other 9.txt", @"other 10.txt")
+    COMPARE(@"other 9", @"other 10")
+
+    [self createFileInDirectory: directory name: @"other 10.txt"];
+    [self createFileInDirectory:directory name:@"other 10"];
+    COMPARE(@"other 9.txt", @"other 11.txt")
+    COMPARE(@"other 9", @"other 11")
+
+
+
+    COMPARE(@"qq 1q.txt", @"qq 1q.txt")
+    COMPARE(@"qq 1q", @"qq 1q")
+
+    [self createFileInDirectory: directory name: @"qq 1q.txt"];
+    [self createFileInDirectory:directory name:@"qq 1q"];
+    COMPARE(@"qq 1q.txt", @"qq 1q 2.txt")
+    COMPARE(@"qq 1q", @"qq 1q 2")
+
+
+
+    COMPARE(@"zz 0.txt", @"zz 0.txt")
+    COMPARE(@"zz 0", @"zz 0")
+
+    [self createFileInDirectory: directory name: @"zz 0.txt"];
+    [self createFileInDirectory:directory name:@"zz 0"];
+    COMPARE(@"zz 0.txt", @"zz 1.txt")
+    COMPARE(@"zz 0", @"zz 1")
+
+    [self createFileInDirectory: directory name: @"zz 1.txt"];
+    [self createFileInDirectory:directory name:@"zz 1"];
+    COMPARE(@"zz 0.txt", @"zz 2.txt")
+    COMPARE(@"zz 0", @"zz 2")
+
+    [self createFileInDirectory: directory name: @"zz -3.txt"];
+    [self createFileInDirectory:directory name:@"zz -3"];
+    COMPARE(@"zz -3.txt", @"zz -3 2.txt")
+    COMPARE(@"zz -3", @"zz -3 2")
+
+
+
+    COMPARE(@"1.txt", @"1.txt")
+    COMPARE(@"1", @"1")
+
+    [self createFileInDirectory: directory name: @"1.txt"];
+    [self createFileInDirectory:directory name:@"1"];
+
+    COMPARE(@"1.txt", @"1 2.txt")
+    COMPARE(@"1", @"1 2")
+
+    [fileManager removeItemAtPath: directory error: nil];
+}
+
+- (void)createFileInDirectory:(NSString *)directory name:(NSString *)name
+{
+    [[NSFileManager defaultManager] createFileAtPath:[directory stringByAppendingPathComponent:name]
+                                            contents:[NSData data]
+                                          attributes:nil];
+}
+
+@end

local_pod_repo/objcTox/Tests/OCTFriendRequestTests.m

@@ -0,0 +1,37 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#import <XCTest/XCTest.h>
+
+#import "OCTFriendRequest.h"
+
+@interface OCTFriendRequestTests : XCTestCase
+
+@end
+
+@implementation OCTFriendRequestTests
+
+- (void)setUp
+{
+    [super setUp];
+    // Put setup code here. This method is called before the invocation of each test method in the class.
+}
+
+- (void)tearDown
+{
+    // Put teardown code here. This method is called after the invocation of each test method in the class.
+    [super tearDown];
+}
+
+- (void)testDate
+{
+    OCTFriendRequest *request = [OCTFriendRequest new];
+    request.dateInterval = 12345;
+
+    NSDate *date = [request date];
+
+    XCTAssertEqual([date timeIntervalSince1970], 12345);
+}
+
+@end

local_pod_repo/objcTox/Tests/OCTManagerConfigurationTests.m

@@ -0,0 +1,84 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#import <Foundation/Foundation.h>
+#import <XCTest/XCTest.h>
+
+#import "OCTManagerConfiguration.h"
+
+@interface OCTManagerConfigurationTests : XCTestCase
+
+@end
+
+@implementation OCTManagerConfigurationTests
+
+- (void)setUp
+{
+    [super setUp];
+    // Put setup code here. This method is called before the invocation of each test method in the class.
+}
+
+- (void)tearDown
+{
+    // Put teardown code here. This method is called after the invocation of each test method in the class.
+    [super tearDown];
+}
+
+- (void)testDefaultConfiguration
+{
+    OCTManagerConfiguration *configuration = [OCTManagerConfiguration defaultConfiguration];
+
+    XCTAssertNotNil(configuration.fileStorage);
+    XCTAssertNotNil(configuration.options);
+    XCTAssertTrue(configuration.useFauxOfflineMessaging);
+}
+
+- (void)testCopy
+{
+    OCTManagerConfiguration *configuration = [OCTManagerConfiguration defaultConfiguration];
+    configuration.options.ipv6Enabled = YES;
+    configuration.options.udpEnabled = YES;
+    configuration.options.localDiscoveryEnabled = YES;
+    configuration.options.proxyType = OCTToxProxyTypeHTTP;
+    configuration.options.proxyHost = @"proxy.address";
+    configuration.options.proxyPort = 999;
+    configuration.options.startPort = 123;
+    configuration.options.endPort = 321;
+    configuration.options.tcpPort = 777;
+    configuration.options.holePunchingEnabled = YES;
+    configuration.importToxSaveFromPath = @"save.tox";
+    configuration.useFauxOfflineMessaging = NO;
+
+    OCTManagerConfiguration *c2 = [configuration copy];
+
+    configuration.options.ipv6Enabled = NO;
+    configuration.options.udpEnabled = NO;
+    configuration.options.localDiscoveryEnabled = NO;
+    configuration.options.proxyType = OCTToxProxyTypeSocks5;
+    configuration.options.proxyHost = @"another.address";
+    configuration.options.proxyPort = 10;
+    configuration.options.startPort = 11;
+    configuration.options.endPort = 12;
+    configuration.options.tcpPort = 13;
+    configuration.options.holePunchingEnabled = NO;
+    configuration.importToxSaveFromPath = @"another.tox";
+    configuration.useFauxOfflineMessaging = YES;
+
+    XCTAssertEqualObjects(configuration.fileStorage, c2.fileStorage);
+
+    XCTAssertTrue(c2.options.ipv6Enabled);
+    XCTAssertTrue(c2.options.udpEnabled);
+    XCTAssertTrue(c2.options.localDiscoveryEnabled);
+    XCTAssertEqual(c2.options.proxyType, OCTToxProxyTypeHTTP);
+    XCTAssertEqualObjects(c2.options.proxyHost, @"proxy.address");
+    XCTAssertEqual(c2.options.proxyPort, 999);
+    XCTAssertEqual(c2.options.startPort, 123);
+    XCTAssertEqual(c2.options.endPort, 321);
+    XCTAssertEqual(c2.options.tcpPort, 777);
+    XCTAssertTrue(c2.options.holePunchingEnabled);
+    XCTAssertEqualObjects(c2.importToxSaveFromPath, @"save.tox");
+    XCTAssertFalse(c2.useFauxOfflineMessaging);
+}
+
+@end

local_pod_repo/objcTox/Tests/OCTManagerImplTests.m

@@ -0,0 +1,514 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#import <OCMock/OCMock.h>
+#import <XCTest/XCTest.h>
+
+#import "OCTManagerImpl.h"
+#import "OCTManagerFactory.h"
+#import "OCTManagerConstants.h"
+#import "OCTTox.h"
+#import "OCTToxAV.h"
+#import "OCTToxEncryptSave.h"
+#import "OCTSubmanagerDataSource.h"
+#import "OCTManagerConfiguration.h"
+#import "OCTSubmanagerBootstrapImpl.h"
+#import "OCTSubmanagerChatsImpl.h"
+#import "OCTSubmanagerFriendsImpl.h"
+#import "OCTSubmanagerFilesImpl.h"
+#import "OCTSubmanagerUserImpl.h"
+#import "OCTSubmanagerObjectsImpl.h"
+#import "OCTSubmanagerCallsImpl.h"
+#import "OCTRealmManager.h"
+#import "OCTDefaultFileStorage.h"
+#import "OCTMessageAbstract.h"
+#import "OCTMessageText.h"
+#import "OCTMessageFile.h"
+
+static NSString *const kTestDirectory = @"me.dvor.objcToxTests";
+
+@interface OCTManagerImpl (Tests) <OCTSubmanagerDataSource>
+
+@property (strong, nonatomic, readonly) OCTTox *tox;
+@property (strong, nonatomic, readonly) OCTToxAV *toxAV;
+@property (copy, nonatomic, readwrite) OCTManagerConfiguration *configuration;
+
+@property (strong, nonatomic, readwrite) OCTSubmanagerBootstrapImpl *bootstrap;
+@property (strong, nonatomic, readwrite) OCTSubmanagerChatsImpl *chats;
+@property (strong, nonatomic, readwrite) OCTSubmanagerFilesImpl *files;
+@property (strong, nonatomic, readwrite) OCTSubmanagerFriendsImpl *friends;
+@property (strong, nonatomic, readwrite) OCTSubmanagerObjectsImpl *objects;
+@property (strong, nonatomic, readwrite) OCTSubmanagerUserImpl *user;
+
+@property (strong, nonatomic) OCTRealmManager *realmManager;
+@property (strong, nonatomic) NSNotificationCenter *notificationCenter;
+
+- (id)forwardingTargetForSelector:(SEL)aSelector;
+
+@end
+
+
+@interface FakeSubmanager : NSObject <OCTToxDelegate>
+@property (weak, nonatomic) id dataSource;
+@end
+@implementation FakeSubmanager
+- (void)tox:(OCTTox *)tox connectionStatus:(OCTToxConnectionStatus)status
+{}
+@end
+
+@interface OCTManagerImplTests : XCTestCase
+
+@property (strong, nonatomic) OCTManagerImpl *manager;
+@property (nonatomic, assign) id mockedCallManager;
+@property (strong, nonatomic) id tox;
+@property (strong, nonatomic) id toxAV;
+
+@property (strong, nonatomic) NSString *tempDirectoryPath;
+
+@end
+
+@implementation OCTManagerImplTests
+
+- (void)setUp
+{
+    [super setUp];
+    // Put setup code here. This method is called before the invocation of each test method in the class.
+
+    self.tempDirectoryPath = [[NSTemporaryDirectory() stringByAppendingPathComponent:kTestDirectory] stringByAppendingPathComponent:[[NSUUID UUID] UUIDString]];
+
+    [[NSFileManager defaultManager] createDirectoryAtPath:self.tempDirectoryPath
+                              withIntermediateDirectories:YES
+                                               attributes:nil
+                                                    error:nil];
+
+    self.mockedCallManager = OCMClassMock([OCTSubmanagerCallsImpl class]);
+
+    self.tox = OCMClassMock([OCTTox class]);
+    OCMStub([self.tox alloc]).andReturn(self.tox);
+    OCMStub([self.tox initWithOptions:[OCMArg any] savedData:[OCMArg any] error:[OCMArg anyObjectRef]]).andReturn(self.tox);
+    OCMStub([self.tox initWithOptions:[OCMArg any] savedData:[OCMArg any] error:[OCMArg anyObjectRef]]).andReturn(self.tox);
+    OCMStub([self.tox save]).andReturn([@"save file" dataUsingEncoding:NSUTF8StringEncoding]);
+
+    self.toxAV = OCMClassMock([OCTToxAV class]);
+    OCMStub([self.toxAV alloc]).andReturn(self.toxAV);
+    OCMStub([self.toxAV initWithTox:[OCMArg any] error:[OCMArg anyObjectRef]]).andReturn(self.toxAV);
+
+    id data = OCMClassMock([NSData class]);
+
+    OCMStub([data writeToFile:[OCMArg any] options:NSDataWritingAtomic error:[OCMArg anyObjectRef]]).andReturn(YES);
+    OCMStub([self.tox save]).andReturn(data);
+}
+
+- (void)tearDown
+{
+    [self.tox stopMocking];
+    self.tox = nil;
+
+    [self.toxAV stopMocking];
+    self.toxAV = nil;
+
+    self.manager = nil;
+    [self.mockedCallManager stopMocking];
+    self.mockedCallManager = nil;
+
+    [[NSFileManager defaultManager] removeItemAtPath:self.tempDirectoryPath error:nil];
+
+    // Put teardown code here. This method is called after the invocation of each test method in the class.
+    [super tearDown];
+}
+
+- (void)testInit
+{
+    [self createManager];
+
+    XCTAssertNotNil(self.manager);
+
+    XCTAssertNotNil(self.manager.bootstrap);
+    XCTAssertEqual(self.manager.bootstrap.dataSource, self.manager);
+    XCTAssertNotNil(self.manager.chats);
+    XCTAssertEqual(self.manager.chats.dataSource, self.manager);
+    XCTAssertNotNil(self.manager.files);
+    XCTAssertEqual(self.manager.files.dataSource, self.manager);
+    XCTAssertNotNil(self.manager.friends);
+    XCTAssertEqual(self.manager.friends.dataSource, self.manager);
+    XCTAssertNotNil(self.manager.objects);
+    XCTAssertEqual(self.manager.objects.dataSource, self.manager);
+    XCTAssertNotNil(self.manager.user);
+    XCTAssertEqual(self.manager.user.dataSource, self.manager);
+
+    XCTAssertNotNil(self.manager.tox);
+    XCTAssertNotNil(self.manager.configuration);
+    XCTAssertNotNil(self.manager.realmManager);
+    XCTAssertEqualObjects(self.manager.realmManager.realmFileURL.path, self.manager.configuration.fileStorage.pathForDatabase);
+
+    XCTAssertNotNil(self.manager.notificationCenter);
+}
+
+- (void)testToxEncryption
+{
+    // We want use real data to make sure that encryption/decryption actually works. This is really crucial test.
+    [self.tox stopMocking];
+    self.tox = nil;
+
+    OCTManagerConfiguration *configuration = [OCTManagerConfiguration defaultConfiguration];
+    configuration.fileStorage = [self temporaryFileStorage];
+    __block NSString *userAddress;
+
+    {
+        // Create non-encrypted Tox to test manager encryption of first start.
+        OCTTox *tox = [[OCTTox alloc] initWithOptions:configuration.options savedData:nil error:nil];
+        XCTAssertNotNil(tox);
+
+        userAddress = tox.userAddress;
+        [tox setNickname:@"nonEncrypted" error:nil];
+
+        NSData *data = [tox save];
+        BOOL result = [data writeToFile:configuration.fileStorage.pathForToxSaveFile
+                                options:NSDataWritingAtomic
+                                  error:nil];
+        XCTAssertTrue(result);
+    }
+
+    XCTestExpectation *encryptOnFirstRunExpectation = [self expectationWithDescription:@"encryptOnFirstRunExpectation"];
+
+    [OCTManagerFactory managerWithConfiguration:configuration encryptPassword:@"password123" successBlock:^(id < OCTManager > manager) {
+        XCTAssertNotNil(manager);
+        XCTAssertEqualObjects(userAddress, manager.user.userAddress);
+        XCTAssertEqualObjects(@"nonEncrypted", manager.user.userName);
+
+        [encryptOnFirstRunExpectation fulfill];
+    } failureBlock:nil];
+
+    [self waitForExpectationsWithTimeout:2.0 handler:nil];
+
+
+    XCTestExpectation *encryptedExpectation = [self expectationWithDescription:@"encryptedExpectation"];
+
+    [OCTManagerFactory managerWithConfiguration:configuration encryptPassword:@"password123" successBlock:^(id < OCTManager > manager) {
+        XCTAssertNotNil(manager);
+        XCTAssertEqualObjects(userAddress, manager.user.userAddress);
+        XCTAssertEqualObjects(@"nonEncrypted", manager.user.userName);
+
+        // Change passphrase
+        [manager.user setUserName:@"renamed" error:nil];
+        [manager changeEncryptPassword:@"new password" oldPassword:@"password123"];
+
+        [encryptedExpectation fulfill];
+    } failureBlock:nil];
+
+    [self waitForExpectationsWithTimeout:2.0 handler:nil];
+
+
+    XCTestExpectation *renamedEncryptedExpectation = [self expectationWithDescription:@"renamedEncryptedExpectation"];
+
+    [OCTManagerFactory managerWithConfiguration:configuration encryptPassword:@"new password" successBlock:^(id < OCTManager > manager) {
+        XCTAssertNotNil(manager);
+        XCTAssertEqualObjects(userAddress, manager.user.userAddress);
+        XCTAssertEqualObjects(@"renamed", manager.user.userName);
+
+        [renamedEncryptedExpectation fulfill];
+    } failureBlock:nil];
+
+    [self waitForExpectationsWithTimeout:2.0 handler:nil];
+
+
+    XCTestExpectation *wrongPasswordExpectation = [self expectationWithDescription:@"wrongPasswordExpectation"];
+
+    [OCTManagerFactory managerWithConfiguration:configuration encryptPassword:@"new password" successBlock:^(id < OCTManager > manager) {
+        XCTAssertNotNil(manager);
+        XCTAssertFalse([manager changeEncryptPassword:@"the password" oldPassword:@"wrong password"]);
+
+        [wrongPasswordExpectation fulfill];
+    } failureBlock:nil];
+
+    [self waitForExpectationsWithTimeout:2.0 handler:nil];
+
+
+    XCTestExpectation *newPasswordExpectation = [self expectationWithDescription:@"newPasswordExpectation"];
+
+    [OCTManagerFactory managerWithConfiguration:configuration encryptPassword:@"new password" successBlock:^(id < OCTManager > manager) {
+        XCTAssertNotNil(manager);
+        XCTAssertTrue([manager changeEncryptPassword:@"another" oldPassword:@"new password"]);
+
+        [newPasswordExpectation fulfill];
+    } failureBlock:nil];
+
+    [self waitForExpectationsWithTimeout:2.0 handler:nil];
+
+
+    XCTestExpectation *anotherPasswordExpectation = [self expectationWithDescription:@"anotherPasswordExpectation"];
+
+    [OCTManagerFactory managerWithConfiguration:configuration encryptPassword:@"another" successBlock:^(id < OCTManager > manager) {
+        XCTAssertNotNil(manager);
+
+        [anotherPasswordExpectation fulfill];
+    } failureBlock:nil];
+
+    [self waitForExpectationsWithTimeout:2.0 handler:nil];
+}
+
+- (void)testIsManagerEncryptedWithPassword
+{
+    // We want use real data to make sure that encryption/decryption actually works. This is really crucial test.
+    [self.tox stopMocking];
+    self.tox = nil;
+
+    OCTManagerConfiguration *configuration = [OCTManagerConfiguration defaultConfiguration];
+    configuration.fileStorage = [self temporaryFileStorage];
+
+    XCTestExpectation *expectation = [self expectationWithDescription:@"expectation"];
+
+    [OCTManagerFactory managerWithConfiguration:configuration encryptPassword:@"password123" successBlock:^(id < OCTManager > manager) {
+        XCTAssertNotNil(manager);
+        XCTAssertTrue([manager isManagerEncryptedWithPassword:@"password123"]);
+        XCTAssertFalse([manager isManagerEncryptedWithPassword:@"wrong password"]);
+
+        [expectation fulfill];
+    } failureBlock:nil];
+
+    [self waitForExpectationsWithTimeout:2.0 handler:nil];
+}
+
+- (void)testDatabaseMigration
+{
+    NSMutableArray *friendsArray = [NSMutableArray new];
+    for (int i = 0; i < 100; i++) {
+        [friendsArray addObject:@(i)];
+
+        NSString *publicKey = [NSString stringWithFormat:@"publicKey-%d", i];
+        OCMStub([self.tox publicKeyFromFriendNumber:i error:[OCMArg anyObjectRef]]).andReturn(publicKey);
+    }
+    OCMStub([self.tox friendsArray]).andReturn(friendsArray);
+
+    OCTManagerConfiguration *configuration = [OCTManagerConfiguration defaultConfiguration];
+    configuration.fileStorage = [self temporaryFileStorage];
+
+    NSBundle *testBundle = [NSBundle bundleForClass:[self class]];
+    NSString *bundlePath = [testBundle pathForResource:@"unencrypted-database" ofType:@"realm"];
+
+    [[NSFileManager defaultManager] copyItemAtPath:bundlePath toPath:configuration.fileStorage.pathForDatabase
+                                             error:nil];
+
+    XCTestExpectation *expectation = [self expectationWithDescription:@"expectation"];
+    __block id<OCTManager> manager;
+
+    [OCTManagerFactory managerWithConfiguration:configuration encryptPassword:@"the password" successBlock:^(id < OCTManager > m) {
+        manager = m;
+        [expectation fulfill];
+    } failureBlock:nil];
+
+    [self waitForExpectationsWithTimeout:20.0 handler:nil];
+
+    XCTAssertNotNil(manager);
+
+    RLMResults *friends = [manager.objects objectsForType:OCTFetchRequestTypeFriend predicate:nil];
+    XCTAssertEqual(friends.count, 100);
+
+    for (OCTToxFriendNumber friendNumber = 0; friendNumber < 100; friendNumber++) {
+        OCTFriend *friend = friends[friendNumber];
+
+        XCTAssertEqual(friend.friendNumber, friendNumber);
+        NSString *nickname = [NSString stringWithFormat:@"friend-%d", friendNumber];
+        XCTAssertEqualObjects(friend.nickname, nickname);
+    }
+
+    RLMResults *messages = [manager.objects objectsForType:OCTFetchRequestTypeMessageAbstract predicate:nil];
+    XCTAssertEqual(messages.count, 50000);
+
+    OCTMessageAbstract *message0 = messages[0];
+    XCTAssertNotNil(message0.messageText);
+    XCTAssertNil(message0.messageFile);
+    XCTAssertNil(message0.messageCall);
+    XCTAssertEqualObjects(message0.messageText.text, @"message-0");
+
+    OCTMessageAbstract *message1 = messages[1];
+    XCTAssertNil(message1.messageText);
+    XCTAssertNotNil(message1.messageFile);
+    XCTAssertNil(message1.messageCall);
+    XCTAssertEqualObjects(message1.messageFile.fileName, @"file-1");
+
+    XCTAssertEqualObjects(message0.chatUniqueIdentifier, message1.chatUniqueIdentifier);
+}
+
+- (void)testConfiguration
+{
+    OCTToxEncryptSave *encryptSave = OCMClassMock([OCTToxEncryptSave class]);
+    OCMStub([(id)encryptSave alloc]).andReturn(encryptSave);
+    OCMStub([encryptSave initWithPassphrase:[OCMArg any]
+                                    toxData:[OCMArg any]
+                                      error:[OCMArg anyObjectRef]]).andReturn(encryptSave);
+    OCMStub([encryptSave encryptData:[OCMArg any] error:[OCMArg anyObjectRef]]).andReturn([NSData new]);
+    OCMStub([encryptSave decryptData:[OCMArg any] error:[OCMArg anyObjectRef]]).andReturn([NSData new]);
+
+    OCTManagerConfiguration *configuration = [OCTManagerConfiguration defaultConfiguration];
+    configuration.options.ipv6Enabled = YES;
+    configuration.options.udpEnabled = YES;
+    configuration.options.localDiscoveryEnabled = YES;
+    configuration.options.proxyType = OCTToxProxyTypeHTTP;
+    configuration.options.proxyHost = @"proxy.address";
+    configuration.options.proxyPort = 999;
+    configuration.options.startPort = 123;
+    configuration.options.endPort = 321;
+    configuration.options.tcpPort = 777;
+    configuration.options.holePunchingEnabled = YES;
+    configuration.importToxSaveFromPath = @"save.tox";
+    configuration.fileStorage = [self temporaryFileStorage];
+
+    XCTestExpectation *expectation = [self expectationWithDescription:@"expectation"];
+    __block id<OCTManager> manager;
+
+    [OCTManagerFactory managerWithConfiguration:configuration encryptPassword:@"p@s$" successBlock:^(id < OCTManager > m) {
+        manager = m;
+        [expectation fulfill];
+    } failureBlock:nil];
+
+    [self waitForExpectationsWithTimeout:200.0 handler:nil];
+
+    OCTManagerConfiguration *c2 = [manager configuration];
+
+    XCTAssertTrue(c2.options.ipv6Enabled);
+    XCTAssertTrue(c2.options.udpEnabled);
+    XCTAssertTrue(c2.options.localDiscoveryEnabled);
+    XCTAssertEqual(c2.options.proxyType, OCTToxProxyTypeHTTP);
+    XCTAssertEqualObjects(c2.options.proxyHost, @"proxy.address");
+    XCTAssertEqual(c2.options.proxyPort, 999);
+    XCTAssertEqual(c2.options.startPort, 123);
+    XCTAssertEqual(c2.options.endPort, 321);
+    XCTAssertEqual(c2.options.tcpPort, 777);
+    XCTAssertTrue(c2.options.holePunchingEnabled);
+    XCTAssertEqualObjects(c2.importToxSaveFromPath, @"save.tox");
+
+    [(id)encryptSave stopMocking];
+}
+
+- (void)testSubmanagerDataSource
+{
+    [self createManager];
+
+    XCTAssertEqual([self.manager managerGetTox], self.manager.tox);
+    XCTAssertEqual([self.manager managerGetRealmManager], self.manager.realmManager);
+    XCTAssertEqual([self.manager managerGetFileStorage], self.manager.configuration.fileStorage);
+    XCTAssertEqual([self.manager managerGetNotificationCenter], self.manager.notificationCenter);
+}
+
+- (void)testForwardTargetForSelector
+{
+    [self createManager];
+
+    id submanager = [FakeSubmanager new];
+    self.manager.bootstrap = submanager;
+    self.manager.chats = submanager;
+    self.manager.files = submanager;
+    self.manager.friends = submanager;
+    self.manager.objects = submanager;
+    self.manager.user = submanager;
+
+    // test non protocol selector
+    XCTAssertNil([self.manager forwardingTargetForSelector:@selector(dataSource)]);
+
+    // test for protocol non-implemented selector
+    XCTAssertNil([self.manager forwardingTargetForSelector:@selector(tox:friendRequestWithMessage:publicKey:)]);
+
+    // test for protocol implemented selector
+    XCTAssertEqual([self.manager forwardingTargetForSelector:@selector(tox:connectionStatus:)], submanager);
+}
+
+- (void)testForwardTargetForSelector2
+{
+    [self createManager];
+
+    id submanager = [FakeSubmanager new];
+    id dummy = [NSObject new];
+
+    self.manager.bootstrap = submanager;
+    self.manager.chats = dummy;
+    self.manager.files = dummy;
+    self.manager.friends = dummy;
+    self.manager.objects = dummy;
+    self.manager.user = dummy;
+
+    XCTAssertEqual([self.manager forwardingTargetForSelector:@selector(tox:connectionStatus:)], submanager);
+
+    self.manager.bootstrap = dummy;
+    self.manager.chats = submanager;
+    self.manager.files = dummy;
+    self.manager.friends = dummy;
+    self.manager.objects = dummy;
+    self.manager.user = dummy;
+
+    XCTAssertEqual([self.manager forwardingTargetForSelector:@selector(tox:connectionStatus:)], submanager);
+
+    self.manager.bootstrap = dummy;
+    self.manager.chats = dummy;
+    self.manager.files = submanager;
+    self.manager.friends = dummy;
+    self.manager.objects = dummy;
+    self.manager.user = dummy;
+
+    XCTAssertEqual([self.manager forwardingTargetForSelector:@selector(tox:connectionStatus:)], submanager);
+
+    self.manager.bootstrap = dummy;
+    self.manager.chats = dummy;
+    self.manager.files = dummy;
+    self.manager.friends = submanager;
+    self.manager.objects = dummy;
+    self.manager.user = dummy;
+
+    XCTAssertEqual([self.manager forwardingTargetForSelector:@selector(tox:connectionStatus:)], submanager);
+
+    self.manager.bootstrap = dummy;
+    self.manager.chats = dummy;
+    self.manager.files = dummy;
+    self.manager.friends = dummy;
+    self.manager.objects = submanager;
+    self.manager.user = dummy;
+
+    XCTAssertEqual([self.manager forwardingTargetForSelector:@selector(tox:connectionStatus:)], submanager);
+
+    self.manager.bootstrap = dummy;
+    self.manager.chats = dummy;
+    self.manager.files = dummy;
+    self.manager.friends = dummy;
+    self.manager.objects = dummy;
+    self.manager.user = submanager;
+
+    XCTAssertEqual([self.manager forwardingTargetForSelector:@selector(tox:connectionStatus:)], submanager);
+}
+
+- (void)testExportToxSaveFile
+{
+    [self createManager];
+
+    NSString *path = [self.manager exportToxSaveFileAndReturnError:nil];
+    NSString *result = [[self.manager configuration].fileStorage.pathForTemporaryFilesDirectory stringByAppendingPathComponent:@"save.tox"];
+    XCTAssertEqualObjects(path, result);
+}
+
+#pragma mark -  Helper methods
+
+- (void)createManager
+{
+    OCMStub([[self.mockedCallManager alloc] initWithTox:[OCMArg anyPointer]]).andReturn(nil);
+    OCTManagerConfiguration *configuration = [OCTManagerConfiguration defaultConfiguration];
+
+    configuration.fileStorage = [self temporaryFileStorage];
+
+    XCTestExpectation *expectation = [self expectationWithDescription:@"expectation"];
+    __weak OCTManagerImplTests *weakSelf = self;
+
+    [OCTManagerFactory managerWithConfiguration:configuration encryptPassword:@"123" successBlock:^(id < OCTManager > manager) {
+        weakSelf.manager = (OCTManagerImpl *)manager;
+        [expectation fulfill];
+    } failureBlock:nil];
+
+    [self waitForExpectationsWithTimeout:2.0 handler:nil];
+}
+
+- (OCTDefaultFileStorage *)temporaryFileStorage
+{
+    return [[OCTDefaultFileStorage alloc] initWithBaseDirectory:self.tempDirectoryPath
+                                             temporaryDirectory:[self.tempDirectoryPath stringByAppendingPathComponent:@"tmp"]];
+}
+
+@end

local_pod_repo/objcTox/Tests/OCTMessageAbstractTests.m

@@ -0,0 +1,52 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#import <XCTest/XCTest.h>
+
+#import "OCTMessageAbstract.h"
+#import "OCTFriend.h"
+
+@interface OCTMessageAbstractTests : XCTestCase
+
+@end
+
+@implementation OCTMessageAbstractTests
+
+- (void)setUp
+{
+    [super setUp];
+    // Put setup code here. This method is called before the invocation of each test method in the class.
+}
+
+- (void)tearDown
+{
+    // Put teardown code here. This method is called after the invocation of each test method in the class.
+    [super tearDown];
+}
+
+- (void)testDate
+{
+    OCTMessageAbstract *message = [OCTMessageAbstract new];
+
+    message.dateInterval = 0;
+    XCTAssertNil([message date]);
+
+    message.dateInterval = 12345;
+    XCTAssertEqual([[message date] timeIntervalSince1970], 12345);
+
+    message.dateInterval = -12345;
+    XCTAssertNil([message date]);
+}
+
+- (void)testIsOutgoing
+{
+    OCTMessageAbstract *message = [OCTMessageAbstract new];
+
+    XCTAssertTrue([message isOutgoing]);
+
+    message.senderUniqueIdentifier = @"Some unique id";
+    XCTAssertFalse([message isOutgoing]);
+}
+
+@end

local_pod_repo/objcTox/Tests/OCTObjectTests.m

@@ -0,0 +1,40 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#import <XCTest/XCTest.h>
+
+#import "OCTObject.h"
+
+@interface OCTObjectTests : XCTestCase
+
+@end
+
+@implementation OCTObjectTests
+
+- (void)setUp
+{
+    [super setUp];
+    // Put setup code here. This method is called before the invocation of each test method in the class.
+}
+
+- (void)tearDown
+{
+    // Put teardown code here. This method is called after the invocation of each test method in the class.
+    [super tearDown];
+}
+
+- (void)testIsEqual
+{
+    OCTObject *object = [OCTObject new];
+    OCTObject *same = [OCTObject new];
+    same.uniqueIdentifier = object.uniqueIdentifier;
+
+    OCTObject *another = [OCTObject new];
+
+    XCTAssertTrue([object isEqual:object]);
+    XCTAssertTrue([object isEqual:same]);
+    XCTAssertFalse([object isEqual:another]);
+}
+
+@end

local_pod_repo/objcTox/Tests/OCTRealmTests.h

@@ -0,0 +1,28 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#import <XCTest/XCTest.h>
+#import <Realm/Realm.h>
+
+#import "OCTRealmManager.h"
+#import "OCTFriend.h"
+#import "OCTChat.h"
+
+@interface OCTRealmManager (Tests)
+
+@property (strong, nonatomic) dispatch_queue_t queue;
+@property (strong, nonatomic) RLMRealm *realm;
+
+@end
+
+@interface OCTRealmTests : XCTestCase
+
+/**
+ * Partially mocked realm manager with in memory realm, which is reset after each test.
+ */
+@property (strong, nonatomic) OCTRealmManager *realmManager;
+
+- (OCTFriend *)createFriendWithFriendNumber:(OCTToxFriendNumber)friendNumber;
+
+@end

local_pod_repo/objcTox/Tests/OCTRealmTests.m

@@ -0,0 +1,61 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#import <OCMock/OCMock.h>
+
+#import "OCTRealmTests.h"
+
+@interface OCTRealmTests ()
+
+@property (strong, nonatomic) id realmMock;
+
+@end
+
+@implementation OCTRealmTests
+
+- (void)setUp
+{
+    [super setUp];
+    // Put setup code here. This method is called before the invocation of each test method in the class.
+
+    RLMRealmConfiguration *configuration = [RLMRealmConfiguration defaultConfiguration];
+    configuration.inMemoryIdentifier = @"OCTRealmTests";
+
+    RLMRealm *realRealm = [RLMRealm realmWithConfiguration:configuration error:nil];
+
+    self.realmMock = OCMClassMock([RLMRealm class]);
+    OCMStub([self.realmMock realmWithConfiguration:[OCMArg any] error:[OCMArg anyObjectRef]]).andReturn(realRealm);
+
+    NSURL *fileURL = [NSURL fileURLWithPath:@"/some/realm/path"];
+    self.realmManager = [[OCTRealmManager alloc] initWithDatabaseFileURL:fileURL encryptionKey:nil];
+    self.realmManager = OCMPartialMock(self.realmManager);
+}
+
+- (void)tearDown
+{
+    [self.realmManager.realm beginWriteTransaction];
+    [self.realmManager.realm deleteAllObjects];
+    [self.realmManager.realm commitWriteTransaction];
+
+    [(id)self.realmManager stopMocking];
+    self.realmManager = nil;
+
+    [self.realmMock stopMocking];
+    self.realmMock = nil;
+
+    // Put teardown code here. This method is called after the invocation of each test method in the class.
+    [super tearDown];
+}
+
+- (OCTFriend *)createFriendWithFriendNumber:(OCTToxFriendNumber)friendNumber
+{
+    OCTFriend *friend = [OCTFriend new];
+    friend.nickname = @"";
+    friend.publicKey = [[NSUUID UUID] UUIDString];
+    friend.friendNumber = friendNumber;
+
+    return friend;
+}
+
+@end

local_pod_repo/objcTox/Tests/OCTSubmanagerBootstrapImplTests.m

@@ -0,0 +1,211 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#import <XCTest/XCTest.h>
+#import <OCMock/OCMock.h>
+
+#import "OCTSubmanagerBootstrapImpl.h"
+#import "OCTSubmanagerDataSource.h"
+#import "OCTTox.h"
+#import "OCTRealmManager.h"
+#import "OCTSettingsStorageObject.h"
+#import "OCTNode.h"
+
+@interface OCTSubmanagerBootstrapImpl (Tests)
+
+@property (strong, nonatomic) NSMutableSet *addedNodes;
+
+@property (assign, nonatomic) NSTimeInterval didConnectDelay;
+@property (assign, nonatomic) NSTimeInterval iterationTime;
+
+@end
+
+@interface OCTSubmanagerBootstrapImplTests : XCTestCase
+
+@property (strong, nonatomic) id dataSource;
+@property (strong, nonatomic) id tox;
+@property (strong, nonatomic) id realmManager;
+@property (strong, nonatomic) id settingsStorage;
+@property (strong, nonatomic) OCTSubmanagerBootstrapImpl *submanager;
+
+@end
+
+@implementation OCTSubmanagerBootstrapImplTests
+
+- (void)setUp
+{
+    [super setUp];
+    // Put setup code here. This method is called before the invocation of each test method in the class.
+
+    self.dataSource = OCMProtocolMock(@protocol(OCTSubmanagerDataSource));
+    // self.tox = OCMClassMock([OCTTox class]);
+    self.tox = OCMStrictClassMock([OCTTox class]);
+    self.realmManager = OCMClassMock([OCTRealmManager class]);
+    self.settingsStorage = OCMClassMock([OCTSettingsStorageObject class]);
+
+    OCMStub([self.dataSource managerGetTox]).andReturn(self.tox);
+    OCMStub([self.dataSource managerGetRealmManager]).andReturn(self.realmManager);
+    OCMStub([self.realmManager settingsStorage]).andReturn(self.settingsStorage);
+
+    self.submanager = [OCTSubmanagerBootstrapImpl new];
+    self.submanager.dataSource = self.dataSource;
+}
+
+- (void)tearDown
+{
+    self.dataSource = nil;
+    self.tox = nil;
+    self.realmManager = nil;
+    self.settingsStorage = nil;
+    self.submanager = nil;
+    // Put teardown code here. This method is called after the invocation of each test method in the class.
+    [super tearDown];
+}
+
+- (void)testAddPredefinedNodes
+{
+    [self.submanager addPredefinedNodes];
+
+    XCTAssertTrue(self.submanager.addedNodes.count > 0);
+
+    for (OCTNode *node in self.submanager.addedNodes) {
+        XCTAssertTrue(node.ipv4Host.length > 0);
+        XCTAssertTrue(node.udpPort > 0);
+        XCTAssertNotNil(node.tcpPorts);
+        XCTAssertEqual(node.publicKey.length, kOCTToxPublicKeyLength);
+    }
+}
+
+- (void)testBootstrapCustomNodes
+{
+    XCTestExpectation *expectation = [self expectationWithDescription:@"bootstrap"];
+
+    self.submanager.didConnectDelay = 0.0;
+    self.submanager.iterationTime = 0.05;
+
+    [self.submanager addNodeWithIpv4Host:@"one" ipv6Host:@"one6" udpPort:1 tcpPorts:@[@1, @11] publicKey:@"1"];
+    [self.submanager addNodeWithIpv4Host:@"two" ipv6Host:nil udpPort:2 tcpPorts:@[@2] publicKey:@"2"];
+    [self.submanager addNodeWithIpv4Host:nil ipv6Host:@"three6" udpPort:3 tcpPorts:@[@3] publicKey:@"3"];
+    [self.submanager addNodeWithIpv4Host:@"four" ipv6Host:@"four6" udpPort:4 tcpPorts:@[] publicKey:@"4"];
+
+    OCMExpect([self.tox bootstrapFromHost:@"one" port:1 publicKey:@"1" error:[OCMArg anyObjectRef]]);
+    OCMExpect([self.tox bootstrapFromHost:@"one6" port:1 publicKey:@"1" error:[OCMArg anyObjectRef]]);
+    OCMExpect([self.tox addTCPRelayWithHost:@"one" port:1 publicKey:@"1" error:[OCMArg anyObjectRef]]);
+    OCMExpect([self.tox addTCPRelayWithHost:@"one6" port:1 publicKey:@"1" error:[OCMArg anyObjectRef]]);
+    OCMExpect([self.tox addTCPRelayWithHost:@"one" port:11 publicKey:@"1" error:[OCMArg anyObjectRef]]);
+    OCMExpect([self.tox addTCPRelayWithHost:@"one6" port:11 publicKey:@"1" error:[OCMArg anyObjectRef]]);
+
+    OCMExpect([self.tox bootstrapFromHost:@"two" port:2 publicKey:@"2" error:[OCMArg anyObjectRef]]);
+    OCMExpect([self.tox addTCPRelayWithHost:@"two" port:2 publicKey:@"2" error:[OCMArg anyObjectRef]]);
+
+    OCMExpect([self.tox bootstrapFromHost:@"three6" port:3 publicKey:@"3" error:[OCMArg anyObjectRef]]);
+    OCMExpect([self.tox addTCPRelayWithHost:@"three6" port:3 publicKey:@"3" error:[OCMArg anyObjectRef]]);
+
+    OCMExpect([self.tox bootstrapFromHost:@"four" port:4 publicKey:@"4" error:[OCMArg anyObjectRef]]);
+    OCMExpect([self.tox bootstrapFromHost:@"four6" port:4 publicKey:@"4" error:[OCMArg anyObjectRef]]);
+
+    [self.submanager bootstrap];
+
+    [self performBlock:^{
+        [expectation fulfill];
+    } afterDelay:0.1];
+    [self waitForExpectationsWithTimeout:0.5 handler:nil];
+
+    OCMVerifyAll(self.tox);
+}
+
+- (void)testBootstrapSeveralPortions
+{
+    XCTestExpectation *expectation = [self expectationWithDescription:@"bootstrap"];
+
+    self.submanager.didConnectDelay = 0.0;
+    self.submanager.iterationTime = 0.1;
+
+    [self.submanager addNodeWithIpv4Host:@"h1" ipv6Host:nil udpPort:1 tcpPorts:@[] publicKey:@"1"];
+    [self.submanager addNodeWithIpv4Host:@"h2" ipv6Host:nil udpPort:2 tcpPorts:@[] publicKey:@"2"];
+    [self.submanager addNodeWithIpv4Host:@"h3" ipv6Host:nil udpPort:3 tcpPorts:@[] publicKey:@"3"];
+    [self.submanager addNodeWithIpv4Host:@"h4" ipv6Host:nil udpPort:4 tcpPorts:@[] publicKey:@"4"];
+    [self.submanager addNodeWithIpv4Host:@"h5" ipv6Host:nil udpPort:5 tcpPorts:@[] publicKey:@"5"];
+    [self.submanager addNodeWithIpv4Host:@"h6" ipv6Host:nil udpPort:6 tcpPorts:@[] publicKey:@"6"];
+    [self.submanager addNodeWithIpv4Host:@"h7" ipv6Host:nil udpPort:7 tcpPorts:@[] publicKey:@"7"];
+    [self.submanager addNodeWithIpv4Host:@"h8" ipv6Host:nil udpPort:8 tcpPorts:@[] publicKey:@"8"];
+    [self.submanager addNodeWithIpv4Host:@"h9" ipv6Host:nil udpPort:9 tcpPorts:@[] publicKey:@"9"];
+    [self.submanager addNodeWithIpv4Host:@"h10" ipv6Host:nil udpPort:10 tcpPorts:@[] publicKey:@"10"];
+
+    OCMExpect([self.tox bootstrapFromHost:@"h1" port:1 publicKey:@"1" error:[OCMArg anyObjectRef]]);
+    OCMExpect([self.tox bootstrapFromHost:@"h2" port:2 publicKey:@"2" error:[OCMArg anyObjectRef]]);
+    OCMExpect([self.tox bootstrapFromHost:@"h3" port:3 publicKey:@"3" error:[OCMArg anyObjectRef]]);
+    OCMExpect([self.tox bootstrapFromHost:@"h4" port:4 publicKey:@"4" error:[OCMArg anyObjectRef]]);
+    OCMExpect([self.tox bootstrapFromHost:@"h5" port:5 publicKey:@"5" error:[OCMArg anyObjectRef]]);
+    OCMExpect([self.tox bootstrapFromHost:@"h6" port:6 publicKey:@"6" error:[OCMArg anyObjectRef]]);
+    OCMExpect([self.tox bootstrapFromHost:@"h7" port:7 publicKey:@"7" error:[OCMArg anyObjectRef]]);
+    OCMExpect([self.tox bootstrapFromHost:@"h8" port:8 publicKey:@"8" error:[OCMArg anyObjectRef]]);
+    OCMExpect([self.tox bootstrapFromHost:@"h9" port:9 publicKey:@"9" error:[OCMArg anyObjectRef]]);
+    OCMExpect([self.tox bootstrapFromHost:@"h10" port:10 publicKey:@"10" error:[OCMArg anyObjectRef]]);
+
+    [self.submanager bootstrap];
+
+    [self performBlock:^{
+        [expectation fulfill];
+    } afterDelay:0.6];
+    [self waitForExpectationsWithTimeout:0.8 handler:nil];
+
+    OCMVerifyAll(self.tox);
+}
+
+- (void)testBootstrapDidConnectVerify
+{
+    XCTestExpectation *expectation = [self expectationWithDescription:@"bootstrap"];
+
+    OCMStub([self.settingsStorage bootstrapDidConnect]).andReturn(YES);
+
+    self.submanager.didConnectDelay = 0.1;
+    self.submanager.iterationTime = 0.05;
+
+    [self.submanager addNodeWithIpv4Host:@"one" ipv6Host:nil udpPort:1 tcpPorts:@[] publicKey:@"1"];
+
+    OCMExpect([self.tox bootstrapFromHost:@"one" port:1 publicKey:@"1" error:[OCMArg anyObjectRef]]);
+
+    [self.submanager bootstrap];
+
+    [self performBlock:^{
+        [expectation fulfill];
+    } afterDelay:0.3];
+    [self waitForExpectationsWithTimeout:0.5 handler:nil];
+
+    OCMVerifyAll(self.tox);
+}
+
+- (void)testBootstrapDidConnectReject
+{
+    XCTestExpectation *expectation = [self expectationWithDescription:@"bootstrap"];
+
+    OCMStub([self.settingsStorage bootstrapDidConnect]).andReturn(YES);
+
+    self.submanager.didConnectDelay = 0.2;
+    self.submanager.iterationTime = 0.05;
+
+    [self.submanager addNodeWithIpv4Host:@"one" ipv6Host:nil udpPort:1 tcpPorts:@[] publicKey:@"1"];
+
+    [self.submanager bootstrap];
+
+    [self performBlock:^{
+        [expectation fulfill];
+    } afterDelay:0.1];
+    [self waitForExpectationsWithTimeout:0.15 handler:nil];
+
+    OCMVerifyAll(self.tox);
+}
+
+- (void)performBlock:(void (^)())block afterDelay:(NSTimeInterval)delay
+{
+    [self performSelector:@selector(runBlock:) withObject:block afterDelay:delay];
+}
+
+- (void)runBlock:(void (^)())block
+{
+    block();
+}
+
+@end

local_pod_repo/objcTox/Tests/OCTSubmanagerCallsImplTests.m

@@ -0,0 +1,527 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#import <XCTest/XCTest.h>
+
+#import "OCTRealmTests.h"
+
+#import "OCTSubmanagerCallsImpl.h"
+#import "OCTRealmManager.h"
+#import "OCTAudioEngine.h"
+#import "OCTMessageCall.h"
+#import "OCTMessageAbstract.h"
+#import "OCTToxAV.h"
+#import "OCTTox.h"
+#import "OCTToxOptions.h"
+#import <OCMock/OCMock.h>
+
+@import AVFoundation;
+
+@interface OCTSubmanagerCallsImpl (Tests)
+
+@property (strong, nonatomic) OCTToxAV *toxAV;
+@property (strong, nonatomic) OCTAudioEngine *audioEngine;
+@property (strong, nonatomic) OCTVideoEngine *videoEngine;
+@property (weak, nonatomic) id<OCTSubmanagerDataSource> dataSource;
+@property (strong, nonatomic) OCTCallTimer *timer;
+
+- (void)toxAV:(OCTToxAV *)toxAV receiveCallAudioEnabled:(BOOL)audio videoEnabled:(BOOL)video friendNumber:(OCTToxFriendNumber)friendNumber;
+- (void)toxAV:(OCTToxAV *)toxAV callStateChanged:(OCTToxAVCallState)state friendNumber:(OCTToxFriendNumber)friendNumber;
+- (void)toxAV:(OCTToxAV *)toxAV audioBitRateChanged:(OCTToxAVAudioBitRate)bitrate stable:(BOOL)stable friendNumber:(OCTToxFriendNumber)friendNumber;
+- (void)   toxAV:(OCTToxAV *)toxAV
+    receiveAudio:(OCTToxAVPCMData *)pcm
+     sampleCount:(OCTToxAVSampleCount)sampleCount
+        channels:(OCTToxAVChannels)channels
+      sampleRate:(OCTToxAVSampleRate)sampleRate
+    friendNumber:(OCTToxFriendNumber)friendNumber;
+
+- (void)                 toxAV:(OCTToxAV *)toxAV
+    receiveVideoFrameWithWidth:(OCTToxAVVideoWidth)width height:(OCTToxAVVideoHeight)height
+                        yPlane:(OCTToxAVPlaneData *)yPlane uPlane:(OCTToxAVPlaneData *)uPlane
+                        vPlane:(OCTToxAVPlaneData *)vPlane
+                       yStride:(OCTToxAVStrideData)yStride uStride:(OCTToxAVStrideData)uStride
+                       vStride:(OCTToxAVStrideData)vStride
+                  friendNumber:(OCTToxFriendNumber)friendNumber;
+
+- (OCTCall *)createCallWithFriend:(OCTFriend *)friend status:(OCTCallStatus)status;
+- (OCTCall *)getCurrentCallForFriendNumber:(OCTToxFriendNumber)friendNumber;
+
+@end
+
+@interface OCTSubmanagerCallsImplTests : OCTRealmTests
+
+@property (strong, nonatomic) id dataSource;
+@property (strong, nonatomic) OCTSubmanagerCallsImpl *callManager;
+@property (strong, nonatomic) OCTTox *tox;
+@property (strong, nonatomic) id mockedAudioEngine;
+@property (strong, nonatomic) id mockedVideoEngine;
+@property (strong, nonatomic) id mockedToxAV;
+
+@end
+
+@implementation OCTSubmanagerCallsImplTests
+
+- (void)setUp
+{
+    [super setUp];
+    self.tox = [[OCTTox alloc] initWithOptions:[OCTToxOptions new] savedData:nil error:nil];
+    self.tox = OCMPartialMock(self.tox);
+    self.callManager = [[OCTSubmanagerCallsImpl alloc] initWithTox:self.tox];
+
+    self.dataSource = OCMProtocolMock(@protocol(OCTSubmanagerDataSource));
+    OCMStub([self.dataSource managerGetRealmManager]).andReturn(self.realmManager);
+    OCMStub([self.dataSource managerGetTox]).andReturn(self.tox);
+
+    OCTAudioEngine *audioEngine = [OCTAudioEngine new];
+    self.mockedAudioEngine = OCMPartialMock(audioEngine);
+    self.callManager.audioEngine = self.mockedAudioEngine;
+
+    OCTVideoEngine *videoEngine = [OCTVideoEngine new];
+    self.mockedVideoEngine = OCMPartialMock(videoEngine);
+    self.callManager.videoEngine = self.mockedVideoEngine;
+
+    self.mockedToxAV = OCMClassMock([OCTToxAV class]);
+    self.callManager.toxAV = self.mockedToxAV;
+
+    self.callManager.dataSource = self.dataSource;
+    // Put setup code here. This method is called before the invocation of each test method in the class.
+}
+
+- (void)tearDown
+{
+    // Put teardown code here. This method is called after the invocation of each test method in the class.
+    [self.dataSource stopMocking];
+    [self.mockedAudioEngine stopMocking];
+    [self.mockedVideoEngine stopMocking];
+    [self.mockedToxAV stopMocking];
+    [(id)self.tox stopMocking];
+    self.dataSource = nil;
+    self.callManager = nil;
+    self.tox = nil;
+    self.mockedAudioEngine = nil;
+    self.mockedToxAV = nil;
+    self.mockedVideoEngine = nil;
+    [super tearDown];
+}
+
+- (void)testInit
+{
+    id tox = OCMClassMock([OCTTox class]);
+    OCMStub([self.mockedToxAV alloc]).andReturn(self.mockedToxAV);
+    OCMStub([self.mockedToxAV initWithTox:tox error:nil]).andReturn(self.mockedToxAV);
+
+    OCTSubmanagerCallsImpl *manager = [[OCTSubmanagerCallsImpl alloc] initWithTox:tox];
+
+    XCTAssertNotNil(manager);
+    OCMVerify([(OCTToxAV *)self.mockedToxAV start]);
+
+    [tox stopMocking];
+}
+
+- (void)testSetup
+{
+    OCMStub([self.mockedAudioEngine new]).andReturn(self.mockedAudioEngine);
+
+    OCMStub([self.mockedVideoEngine new]).andReturn(self.mockedVideoEngine);
+    OCMStub([self.mockedVideoEngine setupAndReturnError:[OCMArg anyObjectRef]]).andReturn(YES);
+
+    XCTAssertTrue([self.callManager setupAndReturnError:nil]);
+
+    OCMVerify([self.mockedVideoEngine setupAndReturnError:[OCMArg anyObjectRef]]);
+}
+
+- (void)testCallToChat
+{
+    [OCMStub([self.mockedToxAV callFriendNumber:1
+                                   audioBitRate:0
+                                   videoBitRate:0
+                                          error:[OCMArg anyObjectRef]]).andReturn(YES) ignoringNonObjectArgs];
+
+    OCTFriend *friend = [self createFriendWithFriendNumber:1];
+
+    [self.realmManager.realm beginWriteTransaction];
+    [self.realmManager.realm addObject:friend];
+    [self.realmManager.realm commitWriteTransaction];
+
+    OCTChat *chat = [self.realmManager getOrCreateChatWithFriend:friend];
+
+    OCTCall *call = [self.callManager callToChat:chat enableAudio:YES enableVideo:NO error:nil];
+
+    XCTAssertNotNil(call.chat);
+
+    XCTAssertEqualObjects(call.chat, chat);
+    XCTAssertEqual(call.status, OCTCallStatusDialing);
+    XCTAssertNil(call.caller);
+    XCTAssertTrue([call isOutgoing]);
+}
+
+- (void)testEnableVideoForCall
+{
+    id partialMockedVideoEngine = OCMPartialMock([OCTVideoEngine new]);
+    self.callManager.videoEngine = partialMockedVideoEngine;
+    [self.mockedVideoEngine setExpectationOrderMatters:YES];
+    OCMExpect([partialMockedVideoEngine startSendingVideo]);
+    OCMExpect([partialMockedVideoEngine stopSendingVideo]);
+
+    [OCMStub([self.mockedToxAV setVideoBitRate:123 force:YES forFriend:987 error:[OCMArg anyObjectRef]]).andReturn(YES) ignoringNonObjectArgs];
+    OCTFriend *friend = [self createFriendWithFriendNumber:987];
+    OCTCall *call = [self.callManager createCallWithFriend:friend status:OCTCallStatusActive];
+
+    XCTAssertTrue([self.callManager enableVideoSending:YES forCall:call error:nil]);
+    XCTAssertTrue(call.videoIsEnabled);
+    XCTAssertEqual(self.callManager.videoEngine.friendNumber, 987);
+
+    XCTAssertTrue([self.callManager enableVideoSending:NO forCall:call error:nil]);
+    XCTAssertFalse(call.videoIsEnabled);
+
+    OCMVerifyAll(partialMockedVideoEngine);
+}
+
+- (void)testEndCall
+{
+    OCMStub([self.mockedToxAV callFriendNumber:12 audioBitRate:48 videoBitRate:0 error:[OCMArg anyObjectRef]]).andReturn(YES);
+    OCMStub([self.mockedToxAV sendCallControl:OCTToxAVCallControlCancel toFriendNumber:12 error:[OCMArg anyObjectRef]]).andReturn(YES);
+    OCMStub([self.mockedAudioEngine stopAudioFlow:[OCMArg anyObjectRef]]).andReturn(YES);
+
+    OCTFriend *friend = [self createFriendWithFriendNumber:12];
+    OCTChat *chat = [self.realmManager getOrCreateChatWithFriend:friend];
+
+    OCTCall *call = [self.callManager callToChat:chat enableAudio:YES enableVideo:NO error:nil];
+
+    NSError *error;
+    XCTAssertTrue([self.callManager sendCallControl:OCTToxAVCallControlCancel toCall:call error:&error]);
+
+    OCMVerify([self.realmManager deleteObject:call]);
+
+    XCTAssertNotNil(chat.lastMessage.messageCall);
+    XCTAssertEqual(chat.lastMessage.messageCall.callEvent, OCTMessageCallEventUnanswered);
+    XCTAssertTrue(chat.lastMessage.isOutgoing);
+}
+
+- (void)testAnswerCallSuccess
+{
+    OCMStub([self.mockedAudioEngine startAudioFlow:[OCMArg anyObjectRef]]).andReturn(YES);
+
+    OCTFriend *friend = [self createFriendWithFriendNumber:1234];
+
+    OCTCall *call = [self.callManager createCallWithFriend:friend status:OCTCallStatusRinging];
+
+    OCMStub([self.mockedToxAV answerIncomingCallFromFriend:1234 audioBitRate:0 videoBitRate:0 error:[OCMArg anyObjectRef]]).andReturn(YES);
+
+    XCTAssertTrue([self.callManager answerCall:call enableAudio:NO enableVideo:NO error:nil]);
+    XCTAssertEqual(self.callManager.audioEngine.friendNumber, 1234);
+}
+
+- (void)testCallStateReceiveFinished
+{
+    OCMStub([self.mockedAudioEngine isAudioRunning:nil]).andReturn(NO);
+    OCMStub([self.mockedAudioEngine friendNumber]).andReturn(89);
+
+    OCTFriend *friend = [self createFriendWithFriendNumber:89];
+
+    OCTCall *call = [self.callManager createCallWithFriend:friend status:OCTCallStatusDialing];
+    [self.realmManager updateObject:call withBlock:^(OCTCall *callToUpdate) {
+        callToUpdate.status = OCTCallStatusRinging;
+    }];
+
+    OCTToxAVCallState state = 0;
+    state |= OCTToxAVFriendCallStateFinished;
+
+    [self.callManager toxAV:nil callStateChanged:state friendNumber:89];
+
+    OCTChat *chat = [self.realmManager getOrCreateChatWithFriend:friend];
+
+    XCTAssertNotNil(chat.lastMessage.messageCall);
+    XCTAssertEqual(chat.lastMessage.messageCall.callEvent, OCTMessageCallEventUnanswered);
+
+    call = [self.callManager createCallWithFriend:friend status:OCTCallStatusRinging];
+    [self.realmManager updateObject:call withBlock:^(OCTCall *callToUpdate) {
+        call.status = OCTCallStatusActive;
+    }];
+
+    [self.callManager toxAV:nil callStateChanged:state friendNumber:89];
+
+    XCTAssertEqual(chat.lastMessage.messageCall.callEvent, OCTMessageCallEventAnswered);
+}
+
+- (void)testFriendAnsweredCall
+{
+    id timer = OCMClassMock([OCTCallTimer class]);
+    self.callManager.timer = timer;
+
+    OCTFriend *friend = [self createFriendWithFriendNumber:92];
+
+    OCTCall *call = [self.callManager createCallWithFriend:friend status:OCTCallStatusRinging];
+    [self.realmManager updateObject:call withBlock:^(OCTCall *callToUpdate) {
+        callToUpdate.status = OCTCallStatusDialing;
+    }];
+
+    OCTToxAVCallState state = 0;
+    state |= OCTToxAVFriendCallStateAcceptingVideo;
+
+    OCMStub([self.mockedAudioEngine startAudioFlow:[OCMArg anyObjectRef]]).andReturn(YES);
+    [self.callManager toxAV:nil callStateChanged:state friendNumber:92];
+
+    OCMVerify([self.mockedAudioEngine startAudioFlow:[OCMArg anyObjectRef]]);
+    OCMVerify([self.mockedAudioEngine setFriendNumber:92]);
+    OCMVerify([timer startTimerForCall:[OCMArg isNotNil]]);
+
+    XCTAssertEqual(call.status, OCTCallStatusActive);
+    XCTAssertTrue(call.friendAcceptingVideo);
+}
+
+- (void)testEnableMicrophone
+{
+    [self.callManager setEnableMicrophone:NO];
+
+    OCMVerify([self.mockedAudioEngine setEnableMicrophone:NO]);
+
+    XCTAssertFalse(self.callManager.enableMicrophone);
+}
+
+- (void)testTogglePauseForCall
+{
+    OCMStub([self.mockedToxAV sendCallControl:OCTToxAVCallControlPause toFriendNumber:12345 error:nil]).andReturn(YES);
+    id partialMockedAudioEngine = OCMPartialMock([OCTAudioEngine new]);
+    self.callManager.audioEngine = partialMockedAudioEngine;
+    self.callManager.audioEngine.friendNumber = 12345;
+
+    OCTFriend *friend = [self createFriendWithFriendNumber:12345];
+
+    OCTCall *call = [self.callManager createCallWithFriend:friend status:OCTCallStatusActive];
+    [self.realmManager updateObject:call withBlock:^(OCTCall *callToUpdate) {
+        callToUpdate.videoIsEnabled = YES;
+    }];
+
+    OCMStub([self.mockedVideoEngine isSendingVideo]).andReturn(YES);
+    OCMStub([partialMockedAudioEngine isAudioRunning:nil]).andReturn(YES);
+    OCMStub([self.mockedVideoEngine stopSendingVideo]);
+    XCTAssertTrue([self.callManager sendCallControl:OCTToxAVCallControlPause toCall:call error:nil]);
+
+    OCMStub([self.mockedVideoEngine startSendingVideo]);
+    OCMVerify([self.mockedVideoEngine stopSendingVideo]);
+    OCMVerify([partialMockedAudioEngine stopAudioFlow:nil]);
+
+    OCMStub([partialMockedAudioEngine isAudioRunning:nil]).andReturn(NO);
+    OCMStub([self.mockedVideoEngine isSendingVideo]).andReturn(NO);
+
+    OCMStub([self.mockedToxAV sendCallControl:OCTToxAVCallControlResume toFriendNumber:12345 error:nil]).andReturn(YES);
+    OCMStub([partialMockedAudioEngine startAudioFlow:[OCMArg anyObjectRef]]).andReturn(YES);
+    XCTAssertTrue([self.callManager sendCallControl:OCTToxAVCallControlResume toCall:call error:nil]);
+
+    OCMVerify([self.mockedVideoEngine startSendingVideo]);
+    OCMVerify([partialMockedAudioEngine startAudioFlow:[OCMArg anyObjectRef]]);
+}
+
+- (void)testSetAudioBitRate
+{
+    OCTFriend *friend = [self createFriendWithFriendNumber:123456];
+
+    OCTCall *call = [self.callManager createCallWithFriend:friend status:OCTCallStatusActive];
+
+    OCMStub([self.mockedToxAV setAudioBitRate:5555 force:NO forFriend:123456 error:nil]).andReturn(YES);
+
+    XCTAssertTrue([self.callManager setAudioBitrate:5555 forCall:call error:nil]);
+    OCMVerify([self.mockedToxAV setAudioBitRate:5555 force:NO forFriend:123456 error:nil]);
+}
+
+#pragma mark - Pause Scenarios
+
+- (void)testAnsweringAnotherCallWhileActive
+{
+    [OCMStub([self.mockedToxAV sendCallControl:123 toFriendNumber:123 error:[OCMArg anyObjectRef]]).andReturn(YES) ignoringNonObjectArgs];
+    [OCMStub([self.mockedToxAV answerIncomingCallFromFriend:123 audioBitRate:48 videoBitRate:0 error:[OCMArg anyObjectRef]]).andReturn(YES) ignoringNonObjectArgs];
+    [self.mockedToxAV setExpectationOrderMatters:YES];
+    OCMExpect([self.mockedToxAV sendCallControl:OCTToxAVCallControlPause toFriendNumber:4 error:[OCMArg anyObjectRef]]);
+    OCMExpect([self.mockedToxAV answerIncomingCallFromFriend:5 audioBitRate:48 videoBitRate:0 error:[OCMArg anyObjectRef]]);
+
+    OCMStub([self.callManager.audioEngine isAudioRunning:nil]).andReturn(YES);
+    OCMStub([self.callManager.audioEngine stopAudioFlow:[OCMArg anyObjectRef]]).andReturn(YES);
+    OCMStub([self.callManager.audioEngine startAudioFlow:[OCMArg anyObjectRef]]).andReturn(YES);
+
+    OCTFriend *firstFriend = [self createFriendWithFriendNumber:4];
+    OCTFriend *secondFriend = [self createFriendWithFriendNumber:5];
+    OCTCall *firstCall = [self.callManager createCallWithFriend:firstFriend status:OCTCallStatusActive];
+    self.callManager.audioEngine.friendNumber = 4;
+
+    // create incoming call
+    OCTCall *secondCall = [self.callManager createCallWithFriend:secondFriend status:OCTCallStatusRinging];
+
+    // mock call timer
+    id mockedTimer = OCMClassMock([OCTCallTimer class]);
+    [mockedTimer setExpectationOrderMatters:YES];
+    OCMExpect([mockedTimer stopTimer]);
+    OCMExpect([mockedTimer startTimerForCall:[OCMArg isNotNil]]);
+
+    self.callManager.timer = mockedTimer;
+
+    [self.callManager answerCall:secondCall enableAudio:YES enableVideo:NO error:nil];
+
+    XCTAssertEqual(secondCall.status, OCTCallStatusActive);
+    XCTAssertEqual(secondCall.pausedStatus, OCTCallPausedStatusNone);
+    XCTAssertEqual(self.callManager.audioEngine.friendNumber, 5);
+
+    XCTAssertEqual(firstCall.status, OCTCallStatusActive);
+    XCTAssertEqual(firstCall.pausedStatus, OCTCallPausedStatusByUser);
+
+    OCMVerifyAll(mockedTimer);
+    OCMVerifyAll(self.mockedAudioEngine);
+}
+
+- (void)testPauseControlPermissions
+{
+    OCTFriend *friend = [self createFriendWithFriendNumber:11];
+
+    OCTCall *call = [self.callManager createCallWithFriend:friend status:OCTCallStatusActive];
+
+    id mockedTimer = OCMClassMock([OCTCallTimer class]);
+    [mockedTimer setExpectationOrderMatters:YES];
+    self.callManager.timer = mockedTimer;
+    OCMExpect([mockedTimer stopTimer]);
+    OCMExpect([mockedTimer startTimerForCall:[OCMArg isNotNil]]);
+
+    [self.callManager toxAV:nil callStateChanged:OCTToxAVFriendCallStatePaused friendNumber:11];
+
+    XCTAssertEqual(call.pausedStatus, OCTCallPausedStatusByFriend);
+    XCTAssertEqual(call.status, OCTCallStatusActive);
+
+    id strictMockedTimer = OCMStrictClassMock([OCTCallTimer class]);
+    self.callManager.timer = strictMockedTimer;
+
+    OCMStub([self.mockedToxAV sendCallControl:OCTToxAVCallControlResume toFriendNumber:11 error:[OCMArg anyObjectRef]]).andReturn(YES);
+    [self.callManager sendCallControl:OCTToxAVCallControlResume toCall:call error:nil];
+
+    XCTAssertEqual(call.pausedStatus, OCTCallPausedStatusByFriend);
+
+    OCMStub([self.mockedToxAV sendCallControl:OCTToxAVCallControlPause toFriendNumber:11 error:[OCMArg anyObjectRef]]).andReturn(YES);
+    [self.callManager sendCallControl:OCTToxAVCallControlPause toCall:call error:nil];
+
+    XCTAssertEqual(call.pausedStatus, OCTCallPausedStatusByFriend | OCTCallPausedStatusByUser);
+
+    [self.callManager toxAV:nil callStateChanged:OCTToxAVFriendCallStateAcceptingAudio friendNumber:11];
+    XCTAssertEqual(call.pausedStatus, OCTCallPausedStatusByUser);
+
+    self.callManager.timer = mockedTimer;
+
+    OCMStub([self.mockedAudioEngine startAudioFlow:[OCMArg anyObjectRef]]).andReturn(YES);
+    [self.callManager sendCallControl:OCTToxAVCallControlResume toCall:call error:nil];
+    XCTAssertEqual(call.pausedStatus, OCTCallPausedStatusNone);
+
+    OCMVerifyAll(mockedTimer);
+}
+
+#pragma mark - Private
+- (void)testGetOrCreateCallWithFriend
+{
+    OCTFriend *friend = [self createFriendWithFriendNumber:222];
+
+    OCTChat *chat = [self.realmManager getOrCreateChatWithFriend:friend];
+
+    OCTCall *call = [self.callManager createCallWithFriend:friend status:OCTCallStatusActive];
+    OCTCall *sameCall = [self.callManager getCurrentCallForFriendNumber:222];
+
+    XCTAssertNotNil(call.chat);
+    XCTAssertEqualObjects(call.chat, chat);
+    XCTAssertEqualObjects(sameCall, call);
+}
+
+ #pragma mark - Delegates
+
+- (void)testReceiveCalls
+{
+    id delegate = OCMProtocolMock(@protocol(OCTSubmanagerCallDelegate));
+    OCMStub([delegate respondsToSelector:[OCMArg anySelector]]).andReturn(YES);
+    self.callManager.delegate = delegate;
+
+    OCTFriend *friend = [self createFriendWithFriendNumber:221];
+
+    OCTCall *call = [self.callManager createCallWithFriend:friend status:OCTCallStatusActive];
+
+    [self.callManager toxAV:nil receiveCallAudioEnabled:YES videoEnabled:NO friendNumber:221];
+    OCMVerify([delegate callSubmanager:self.callManager receiveCall:[OCMArg isNotNil] audioEnabled:YES videoEnabled:NO]);
+    XCTAssertEqualObjects(friend, call.caller);
+    XCTAssertFalse([call isOutgoing]);
+}
+
+- (void)testCallStateChanged
+{
+    OCTFriend *friend = [self createFriendWithFriendNumber:111];
+
+    OCTCall *call = [self.callManager createCallWithFriend:friend status:OCTCallStatusActive];
+
+    OCTToxAVCallState state = 0;
+
+    state |= OCTToxAVFriendCallStateAcceptingAudio;
+    state |= OCTToxAVFriendCallStateAcceptingVideo;
+
+    [self.callManager toxAV:nil callStateChanged:state friendNumber:111];
+
+    call = [self.callManager getCurrentCallForFriendNumber:111];
+
+    XCTAssertTrue(call.friendAcceptingAudio);
+    XCTAssertTrue(call.friendAcceptingVideo);
+    XCTAssertFalse(call.friendSendingAudio);
+    XCTAssertFalse(call.friendSendingVideo);
+}
+
+- (void)testReceiveAudio
+{
+    OCTToxAVPCMData pcm[] = { 1, 2, 3, 4};
+
+    [self.callManager toxAV:nil receiveAudio:pcm sampleCount:4 channels:2 sampleRate:55 friendNumber:123];
+
+    OCMVerify([self.mockedAudioEngine provideAudioFrames:pcm sampleCount:4 channels:2 sampleRate:55 fromFriend:123]);
+}
+
+- (void)testReceiveVideo
+{
+    OCTToxAVVideoHeight height = 1920;
+    OCTToxAVVideoHeight width = 1080;
+    OCTToxAVPlaneData y[] = {5, 5, 6, 8};
+    OCTToxAVPlaneData u[] = {5, 5, 6, 8};
+    OCTToxAVPlaneData v[] = {5, 5, 6, 8};
+    OCTToxAVStrideData yStride = 44;
+    OCTToxAVStrideData uStride = 45;
+    OCTToxAVStrideData vStride = 46;
+
+    [self.callManager toxAV:nil
+ receiveVideoFrameWithWidth:width
+                     height:height
+                     yPlane:y
+                     uPlane:u
+                     vPlane:v
+                    yStride:yStride
+                    uStride:uStride
+                    vStride:vStride
+               friendNumber:444];
+
+    OCMVerify([self.mockedVideoEngine receiveVideoFrameWithWidth:width
+                                                          height:height
+                                                          yPlane:y
+                                                          uPlane:u
+                                                          vPlane:v
+                                                         yStride:yStride
+                                                         uStride:uStride
+                                                         vStride:vStride
+                                                    friendNumber:444]);
+}
+
+#pragma mark Test helper methods
+
+- (OCTFriend *)createFriendWithFriendNumber:(OCTToxFriendNumber)friendNumber
+{
+    OCTFriend *friend = [super createFriendWithFriendNumber:friendNumber];
+    friend.friendNumber = friendNumber;
+
+    [self.realmManager.realm beginWriteTransaction];
+    [self.realmManager.realm addObject:friend];
+    [self.realmManager.realm commitWriteTransaction];
+
+    NSString *publicKey = friend.publicKey;
+    OCMStub([self.tox publicKeyFromFriendNumber:friendNumber error:nil]).andReturn(publicKey);
+
+    return friend;
+}
+
+@end

local_pod_repo/objcTox/Tests/OCTSubmanagerChatsImplTests.m

@@ -0,0 +1,486 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#import <Foundation/Foundation.h>
+#import <OCMock/OCMock.h>
+
+#import "OCTRealmTests.h"
+
+#import "OCTSubmanagerChatsImpl.h"
+#import "OCTRealmManager.h"
+#import "OCTTox.h"
+#import "OCTMessageAbstract.h"
+#import "OCTMessageText.h"
+
+@interface OCTSubmanagerChatsImplTests : OCTRealmTests
+
+@property (strong, nonatomic) OCTSubmanagerChatsImpl *submanager;
+@property (strong, nonatomic) NSNotificationCenter *notificationCenter;
+@property (strong, nonatomic) id dataSource;
+@property (strong, nonatomic) id tox;
+
+@end
+
+@implementation OCTSubmanagerChatsImplTests
+
+- (void)setUp
+{
+    [super setUp];
+    self.notificationCenter = [[NSNotificationCenter alloc] init];
+
+    self.dataSource = OCMProtocolMock(@protocol(OCTSubmanagerDataSource));
+    OCMStub([self.dataSource managerGetNotificationCenter]).andReturn(self.notificationCenter);
+
+    OCMStub([self.dataSource managerGetRealmManager]).andReturn(self.realmManager);
+
+    self.tox = OCMClassMock([OCTTox class]);
+    OCMStub([self.dataSource managerGetTox]).andReturn(self.tox);
+
+    self.submanager = [OCTSubmanagerChatsImpl new];
+    self.submanager.dataSource = self.dataSource;
+    [self.submanager configure];
+}
+
+- (void)tearDown
+{
+    self.dataSource = nil;
+    self.tox = nil;
+    self.submanager = nil;
+    // Put teardown code here. This method is called after the invocation of each test method in the class.
+    [super tearDown];
+}
+
+- (void)testGetOrCreateChatWithFriend
+{
+    OCTFriend *friend = [self createFriendWithFriendNumber:5];
+
+    [self.realmManager.realm beginWriteTransaction];
+    [self.realmManager.realm addObject:friend];
+    [self.realmManager.realm commitWriteTransaction];
+
+    OCTChat *first = [self.realmManager getOrCreateChatWithFriend:friend];
+    OCTChat *second = [self.realmManager getOrCreateChatWithFriend:friend];
+
+    XCTAssertEqualObjects(first, second);
+    XCTAssertEqualObjects([first.friends firstObject], friend);
+}
+
+- (void)testRemoveMessages
+{
+    XCTestExpectation *expect = [self expectationWithDescription:@""];
+    [self.notificationCenter addObserverForName:kOCTScheduleFileTransferCleanupNotification object:nil queue:nil usingBlock:^(NSNotification *note) {
+        [expect fulfill];
+    }];
+
+    NSArray *messages = [NSArray new];
+    OCMExpect([self.realmManager removeMessages:messages]);
+
+    [self.submanager removeMessages:messages];
+
+    [self waitForExpectationsWithTimeout:0.0 handler:nil];
+    OCMVerifyAll((id)self.realmManager);
+}
+
+- (void)testRemoveMessagesWithChat
+{
+    XCTestExpectation *expect = [self expectationWithDescription:@""];
+    [self.notificationCenter addObserverForName:kOCTScheduleFileTransferCleanupNotification object:nil queue:nil usingBlock:^(NSNotification *note) {
+        [expect fulfill];
+    }];
+
+    OCTChat *chat = [OCTChat new];
+
+    OCMExpect([self.realmManager removeAllMessagesInChat:chat removeChat:YES]);
+
+    [self.submanager removeAllMessagesInChat:chat removeChat:YES];
+
+    [self waitForExpectationsWithTimeout:0.0 handler:nil];
+    OCMVerifyAll((id)self.realmManager);
+}
+
+- (void)testSendMessageToChatSuccess
+{
+    id message = OCMClassMock([OCTMessageAbstract class]);
+
+    id friend = OCMClassMock([OCTFriend class]);
+    OCMStub([friend friendNumber]).andReturn(5);
+    NSArray *friends = @[friend];
+
+    id chat = OCMClassMock([OCTChat class]);
+    OCMStub([chat friends]).andReturn(friends);
+
+    OCMStub([self.tox sendMessageWithFriendNumber:5
+                                             type:OCTToxMessageTypeAction
+                                          message:@"text"
+                                            error:[OCMArg anyObjectRef]]).andReturn(7);
+    OCMExpect([self.realmManager addMessageWithText:@"text"
+                                               type:OCTToxMessageTypeAction
+                                               chat:chat
+                                             sender:nil
+                                          messageId:7]).andReturn(message);
+
+    XCTestExpectation *expectation = [self expectationWithDescription:@""];
+
+    [self.submanager sendMessageToChat:chat text:@"text" type:OCTToxMessageTypeAction successBlock:^(OCTMessageAbstract *theMessage) {
+        OCMVerifyAll((id)self.realmManager);
+        XCTAssertEqualObjects(message, theMessage);
+        [expectation fulfill];
+
+    } failureBlock:^(NSError *error) {
+        XCTAssertTrue(false, @"This block shouldn't be called");
+    }];
+
+    [self waitForExpectationsWithTimeout:0.2 handler:nil];
+}
+
+- (void)testSendMessageToChatFailure
+{
+    id friend = OCMClassMock([OCTFriend class]);
+    OCMStub([friend friendNumber]).andReturn(5);
+    NSArray *friends = @[friend];
+
+    id chat = OCMClassMock([OCTChat class]);
+    OCMStub([chat friends]).andReturn(friends);
+
+    NSError *error2 = OCMClassMock([NSError class]);
+
+    OCMStub([self.tox sendMessageWithFriendNumber:5
+                                             type:OCTToxMessageTypeAction
+                                          message:@"text"
+                                            error:[OCMArg setTo:error2]]).andReturn(0);
+
+
+    XCTestExpectation *expectation = [self expectationWithDescription:@""];
+
+    [self.submanager sendMessageToChat:chat text:@"text" type:OCTToxMessageTypeAction successBlock:^(OCTMessageAbstract *theMessage) {
+        XCTAssertTrue(false, @"This block shouldn't be called");
+
+    } failureBlock:^(NSError *error) {
+        OCMVerifyAll((id)self.realmManager);
+        XCTAssertEqualObjects(error, error2);
+        [expectation fulfill];
+    }];
+
+    [self waitForExpectationsWithTimeout:0.2 handler:nil];
+}
+
+- (void)testSendMessageToChatFauxEnabled
+{
+    OCMStub([self.dataSource managerUseFauxOfflineMessaging]).andReturn(YES);
+
+    id message = OCMClassMock([OCTMessageAbstract class]);
+
+    id friend = OCMClassMock([OCTFriend class]);
+    OCMStub([friend friendNumber]).andReturn(5);
+    NSArray *friends = @[friend];
+
+    id chat = OCMClassMock([OCTChat class]);
+    OCMStub([chat friends]).andReturn(friends);
+
+    NSError *error2 = OCMClassMock([NSError class]);
+    OCMStub(error2.code).andReturn(OCTToxErrorFriendSendMessageFriendNotConnected);
+
+    OCMStub([self.tox sendMessageWithFriendNumber:5
+                                             type:OCTToxMessageTypeAction
+                                          message:@"text"
+                                            error:[OCMArg setTo:error2]]).andReturn(0);
+    OCMExpect([self.realmManager addMessageWithText:@"text"
+                                               type:OCTToxMessageTypeAction
+                                               chat:chat
+                                             sender:nil
+                                          messageId:-1]).andReturn(message);
+
+    XCTestExpectation *expectation = [self expectationWithDescription:@""];
+
+    [self.submanager sendMessageToChat:chat text:@"text" type:OCTToxMessageTypeAction successBlock:^(OCTMessageAbstract *theMessage) {
+        OCMVerifyAll((id)self.realmManager);
+        XCTAssertEqualObjects(message, theMessage);
+        [expectation fulfill];
+
+    } failureBlock:^(NSError *error) {
+        XCTAssertTrue(false, @"This block shouldn't be called");
+    }];
+
+    [self waitForExpectationsWithTimeout:0.2 handler:nil];
+}
+
+- (void)testSendMessageToChatFauxDisabled
+{
+    OCMStub([self.dataSource managerUseFauxOfflineMessaging]).andReturn(NO);
+
+    id friend = OCMClassMock([OCTFriend class]);
+    OCMStub([friend friendNumber]).andReturn(5);
+    NSArray *friends = @[friend];
+
+    id chat = OCMClassMock([OCTChat class]);
+    OCMStub([chat friends]).andReturn(friends);
+
+    NSError *error2 = OCMClassMock([NSError class]);
+    OCMStub(error2.code).andReturn(OCTToxErrorFriendSendMessageFriendNotConnected);
+
+    OCMStub([self.tox sendMessageWithFriendNumber:5
+                                             type:OCTToxMessageTypeAction
+                                          message:@"text"
+                                            error:[OCMArg setTo:error2]]).andReturn(0);
+
+    XCTestExpectation *expectation = [self expectationWithDescription:@""];
+
+    [self.submanager sendMessageToChat:chat text:@"text" type:OCTToxMessageTypeAction successBlock:^(OCTMessageAbstract *theMessage) {
+        XCTAssertTrue(false, @"This block shouldn't be called");
+
+    } failureBlock:^(NSError *error) {
+        OCMVerifyAll((id)self.realmManager);
+        XCTAssertEqualObjects(error, error2);
+        [expectation fulfill];
+    }];
+
+    [self waitForExpectationsWithTimeout:0.2 handler:nil];
+}
+
+- (void)testSetIsTyping
+{
+    id friend = OCMClassMock([OCTFriend class]);
+    OCMStub([friend friendNumber]).andReturn(5);
+    NSArray *friends = @[friend];
+
+    id chat = OCMClassMock([OCTChat class]);
+    OCMStub([chat friends]).andReturn(friends);
+
+    NSError *error;
+    NSError *error2 = OCMClassMock([NSError class]);
+
+    OCMExpect([self.tox setUserIsTyping:YES forFriendNumber:5 error:[OCMArg setTo:error2]]).andReturn(NO);
+
+    XCTAssertFalse([self.submanager setIsTyping:YES inChat:chat error:&error]);
+
+    XCTAssertEqual(error, error2);
+    OCMVerifyAll(self.tox);
+}
+
+- (void)testResendUndeliveredMessages
+{
+    NSArray * (^createMessages)(OCTChat *, OCTToxMessageId) = ^(OCTChat *chat, OCTToxMessageId number) {
+        NSMutableArray *array = [NSMutableArray new];
+
+        for (OCTToxMessageId index = 0; index < number; index++) {
+            BOOL outgoing = index % 2;
+            OCTMessageAbstract *message = [self createTextMessageInChat:chat outgoing:outgoing messageId:index];
+            [array addObject:message];
+        }
+
+        return [array copy];
+    };
+
+    OCTToxFriendNumber friendNumber = 1;
+
+    OCTFriend *friend1 = [self createFriendWithFriendNumber:friendNumber++];
+    OCTFriend *friend2 = [self createFriendWithFriendNumber:friendNumber++];
+
+    NSString *publicKey1 = friend1.publicKey;
+    NSString *publicKey2 = friend2.publicKey;
+
+    OCMStub([self.tox publicKeyFromFriendNumber:friend1.friendNumber error:nil]).andReturn(publicKey1);
+    OCMStub([self.tox publicKeyFromFriendNumber:friend2.friendNumber error:nil]).andReturn(publicKey2);
+
+    OCTChat *chat1 = [self createChatWithFriend:friend1];
+    OCTChat *chat2 = [self createChatWithFriend:friend2];
+
+    NSArray *messages1 = createMessages(chat1, 10);
+    NSArray *messages2 = createMessages(chat2, 2);
+
+    [self.realmManager.realm beginWriteTransaction];
+    [self.realmManager.realm addObject:chat1];
+    [self.realmManager.realm addObject:chat2];
+    [self.realmManager.realm addObjects:messages1];
+    [self.realmManager.realm addObjects:messages2];
+    [self.realmManager.realm commitWriteTransaction];
+
+    OCMStub([self.tox sendMessageWithFriendNumber:1 type:OCTToxMessageTypeNormal message:@"1" error:[OCMArg anyObjectRef]]).andReturn(101);
+    OCMStub([self.tox sendMessageWithFriendNumber:1 type:OCTToxMessageTypeNormal message:@"3" error:[OCMArg anyObjectRef]]).andReturn(103);
+    OCMStub([self.tox sendMessageWithFriendNumber:1 type:OCTToxMessageTypeNormal message:@"5" error:[OCMArg anyObjectRef]]).andReturn(105);
+    OCMStub([self.tox sendMessageWithFriendNumber:1 type:OCTToxMessageTypeNormal message:@"7" error:[OCMArg anyObjectRef]]).andReturn(107);
+    OCMStub([self.tox sendMessageWithFriendNumber:1 type:OCTToxMessageTypeNormal message:@"9" error:[OCMArg anyObjectRef]]).andReturn(109);
+
+    [self.realmManager.realm beginWriteTransaction];
+    friend1.connectionStatus = OCTToxConnectionStatusUDP;
+    friend1.isConnected = YES;
+    [self.realmManager.realm commitWriteTransaction];
+
+    [self.notificationCenter postNotificationName:kOCTFriendConnectionStatusChangeNotification object:friend1];
+
+#define VERIFY_MESSAGE(__array, __index, __messageId, __delivered) \
+    { \
+        NSString *identifier = [__array[__index] uniqueIdentifier]; \
+        OCTMessageAbstract *message = [self.realmManager objectWithUniqueIdentifier:identifier class:[OCTMessageAbstract class]]; \
+        XCTAssertEqual(message.messageText.messageId, __messageId); \
+        XCTAssertEqual(message.messageText.isDelivered, __delivered); \
+    }
+
+    XCTestExpectation *expectation = [self expectationWithDescription:@""];
+
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 0.1 * NSEC_PER_SEC), dispatch_get_main_queue(), ^{
+        VERIFY_MESSAGE(messages1, 0, 0, NO);
+        VERIFY_MESSAGE(messages1, 1, 101, NO);
+        VERIFY_MESSAGE(messages1, 2, 2, NO);
+        VERIFY_MESSAGE(messages1, 3, 103, NO);
+        VERIFY_MESSAGE(messages1, 4, 4, NO);
+        VERIFY_MESSAGE(messages1, 5, 105, NO);
+        VERIFY_MESSAGE(messages1, 6, 6, NO);
+        VERIFY_MESSAGE(messages1, 7, 107, NO);
+        VERIFY_MESSAGE(messages1, 8, 8, NO);
+        VERIFY_MESSAGE(messages1, 9, 109, NO);
+
+        VERIFY_MESSAGE(messages2, 0, 0, NO);
+        VERIFY_MESSAGE(messages2, 1, 1, NO);
+
+        [expectation fulfill];
+    });
+
+    [self waitForExpectationsWithTimeout:0.3 handler:nil];
+
+
+    // Deliver some messages, then resend all left again.
+
+    [self.submanager tox:self.tox messageDelivered:101 friendNumber:1];
+    [self.submanager tox:self.tox messageDelivered:103 friendNumber:1];
+    [self.submanager tox:self.tox messageDelivered:105 friendNumber:1];
+
+    {
+        OCTMessageAbstract *message;
+
+        [self.realmManager.realm beginWriteTransaction];
+
+        message = messages1[7];
+        message.messageText.text = @"107";
+        message = messages1[9];
+        message.messageText.text = @"109";
+
+        [self.realmManager.realm commitWriteTransaction];
+    }
+
+    OCMStub([self.tox sendMessageWithFriendNumber:1 type:OCTToxMessageTypeNormal message:@"107" error:[OCMArg anyObjectRef]]).andReturn(207);
+    OCMStub([self.tox sendMessageWithFriendNumber:1 type:OCTToxMessageTypeNormal message:@"109" error:[OCMArg anyObjectRef]]).andReturn(209);
+
+    [self.notificationCenter postNotificationName:kOCTFriendConnectionStatusChangeNotification object:friend1];
+
+    XCTestExpectation *expectation2 = [self expectationWithDescription:@""];
+
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 0.1 * NSEC_PER_SEC), dispatch_get_main_queue(), ^{
+        VERIFY_MESSAGE(messages1, 0, 0, NO);
+        VERIFY_MESSAGE(messages1, 1, 101, YES);
+        VERIFY_MESSAGE(messages1, 2, 2, NO);
+        VERIFY_MESSAGE(messages1, 3, 103, YES);
+        VERIFY_MESSAGE(messages1, 4, 4, NO);
+        VERIFY_MESSAGE(messages1, 5, 105, YES);
+        VERIFY_MESSAGE(messages1, 6, 6, NO);
+        VERIFY_MESSAGE(messages1, 7, 207, NO);
+        VERIFY_MESSAGE(messages1, 8, 8, NO);
+        VERIFY_MESSAGE(messages1, 9, 209, NO);
+
+        VERIFY_MESSAGE(messages2, 0, 0, NO);
+        VERIFY_MESSAGE(messages2, 1, 1, NO);
+
+        [expectation2 fulfill];
+    });
+
+    [self waitForExpectationsWithTimeout:0.3 handler:nil];
+}
+
+#pragma mark -  OCTToxDelegate
+
+- (void)testFriendMessage
+{
+    OCTFriend *friend = [self createFriendWithFriendNumber:5];
+    NSString *publicKey = friend.publicKey;
+    OCMStub([self.tox publicKeyFromFriendNumber:friend.friendNumber error:nil]).andReturn(publicKey);
+
+    OCTChat *chat = [OCTChat new];
+    [chat.friends addObject:friend];
+
+    [self.realmManager.realm beginWriteTransaction];
+    [self.realmManager.realm addObject:chat];
+    [self.realmManager.realm commitWriteTransaction];
+
+    [self.submanager tox:nil friendMessage:@"message" type:OCTToxMessageTypeAction friendNumber:5];
+
+    RLMResults *results = [OCTMessageAbstract allObjectsInRealm:self.realmManager.realm];
+    XCTAssertEqual(results.count, 1);
+
+    OCTMessageAbstract *message = [results firstObject];
+    XCTAssertEqualObjects(message.senderUniqueIdentifier, friend.uniqueIdentifier);
+    XCTAssertEqualObjects(message.chatUniqueIdentifier, chat.uniqueIdentifier);
+    XCTAssertNotNil(message.messageText);
+    XCTAssertEqualObjects(message.messageText.text, @"message");
+    XCTAssertEqual(message.messageText.type, OCTToxMessageTypeAction);
+}
+
+- (void)testMessageDelivered
+{
+    OCTFriend *friend = [self createFriendWithFriendNumber:5];
+    NSString *publicKey = friend.publicKey;
+    OCMStub([self.tox publicKeyFromFriendNumber:friend.friendNumber error:nil]).andReturn(publicKey);
+
+    OCTChat *chat = [OCTChat new];
+    [chat.friends addObject:friend];
+
+    OCTMessageAbstract *message = [OCTMessageAbstract new];
+    message.chatUniqueIdentifier = chat.uniqueIdentifier;
+    message.dateInterval = [[NSDate date] timeIntervalSince1970];
+    message.messageText = [OCTMessageText new];
+    message.messageText.text = @"";
+    message.messageText.messageId = 10;
+    message.messageText.isDelivered = NO;
+
+    [self.realmManager.realm beginWriteTransaction];
+    [self.realmManager.realm addObject:friend];
+    [self.realmManager.realm addObject:chat];
+    [self.realmManager.realm addObject:message];
+    [self.realmManager.realm commitWriteTransaction];
+
+    [self.submanager tox:self.tox messageDelivered:10 friendNumber:5];
+
+    XCTAssertTrue(message.messageText.isDelivered);
+
+    OCTMessageAbstract *anotherMessageSameId = [OCTMessageAbstract new];
+    anotherMessageSameId.chatUniqueIdentifier = chat.uniqueIdentifier;
+    anotherMessageSameId.dateInterval = [[NSDate date] timeIntervalSince1970];
+    anotherMessageSameId.messageText = [OCTMessageText new];
+    anotherMessageSameId.messageText.text = @"";
+    anotherMessageSameId.messageText.messageId = 10;
+    anotherMessageSameId.messageText.isDelivered = NO;
+
+    [self.realmManager.realm beginWriteTransaction];
+    [self.realmManager.realm addObject:anotherMessageSameId];
+    [self.realmManager.realm commitWriteTransaction];
+
+    [self.submanager tox:self.tox messageDelivered:10 friendNumber:5];
+
+    XCTAssertTrue(anotherMessageSameId.messageText.isDelivered);
+}
+
+- (OCTChat *)createChatWithFriend:(OCTFriend *)friend
+{
+    OCTChat *chat = [OCTChat new];
+    [chat.friends addObject:friend];
+
+    return chat;
+}
+
+- (OCTMessageAbstract *)createTextMessageInChat:(OCTChat *)chat outgoing:(BOOL)outgoing messageId:(OCTToxMessageId)messageId
+{
+    OCTMessageAbstract *message = [OCTMessageAbstract new];
+    message.chatUniqueIdentifier = chat.uniqueIdentifier;
+    message.messageText = [OCTMessageText new];
+    message.messageText.text = [NSString stringWithFormat:@"%d", messageId];
+    message.messageText.messageId = messageId;
+
+    if (! outgoing) {
+        OCTFriend *friend = chat.friends.lastObject;
+        message.senderUniqueIdentifier = friend.uniqueIdentifier;
+    }
+
+    return message;
+}
+
+@end

local_pod_repo/objcTox/Tests/OCTSubmanagerFilesImplTests.m

@@ -0,0 +1,26 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#import <Foundation/Foundation.h>
+#import <XCTest/XCTest.h>
+
+@interface OCTSubmanagerFilesImplTests : XCTestCase
+
+@end
+
+@implementation OCTSubmanagerFilesImplTests
+
+- (void)setUp
+{
+    [super setUp];
+    // Put setup code here. This method is called before the invocation of each test method in the class.
+}
+
+- (void)tearDown
+{
+    // Put teardown code here. This method is called after the invocation of each test method in the class.
+    [super tearDown];
+}
+
+@end

local_pod_repo/objcTox/Tests/OCTSubmanagerFriendsImplTests.m

@@ -0,0 +1,481 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#import <Foundation/Foundation.h>
+#import <OCMock/OCMock.h>
+
+#import "OCTRealmTests.h"
+#import "OCTSubmanagerFriendsImpl.h"
+#import "OCTSubmanagerDataSource.h"
+#import "OCTTox.h"
+#import "OCTFriendRequest.h"
+
+static const OCTToxFriendNumber kFriendNumber = 5;
+static NSString *const kPublicKey = @"kPublicKey";
+static NSString *const kName = @"kName";
+static NSString *const kStatusMessage = @"kStatusMessage";
+static const OCTToxUserStatus kStatus = OCTToxUserStatusAway;
+static const OCTToxConnectionStatus kConnectionStatus = OCTToxConnectionStatusUDP;
+static const BOOL kIsTyping = YES;
+static NSDate *sLastSeenOnline;
+static NSString *const kMessage = @"kMessage";
+
+@interface OCTSubmanagerFriendsImplTests : OCTRealmTests
+
+@property (strong, nonatomic) OCTSubmanagerFriendsImpl *submanager;
+@property (strong, nonatomic) id dataSource;
+@property (strong, nonatomic) id tox;
+
+@end
+
+@implementation OCTSubmanagerFriendsImplTests
+
+- (void)setUp
+{
+    [super setUp];
+
+    sLastSeenOnline = [NSDate date];
+
+    self.dataSource = OCMProtocolMock(@protocol(OCTSubmanagerDataSource));
+
+    OCMStub([self.dataSource managerGetRealmManager]).andReturn(self.realmManager);
+
+    self.tox = OCMClassMock([OCTTox class]);
+    OCMStub([self.dataSource managerGetTox]).andReturn(self.tox);
+
+    self.submanager = [OCTSubmanagerFriendsImpl new];
+    self.submanager.dataSource = self.dataSource;
+}
+
+- (void)tearDown
+{
+    self.dataSource = nil;
+    self.tox = nil;
+    self.submanager = nil;
+
+    [super tearDown];
+}
+
+- (void)testConfigure
+{
+    OCTFriend *friend = [self createFriendWithFriendNumber:5];
+    friend.status = OCTToxUserStatusBusy;
+    friend.isConnected = YES;
+    friend.connectionStatus = OCTToxConnectionStatusUDP;
+    friend.isTyping = YES;
+
+    NSString *publicKey = friend.publicKey;
+    OCMStub([self.tox publicKeyFromFriendNumber:5 error:[OCMArg anyObjectRef]]).andReturn(publicKey);
+
+    NSArray *array = @[@(5)];
+    OCMStub([self.tox friendsArray]).andReturn(array);
+
+    [self.realmManager.realm beginWriteTransaction];
+    [self.realmManager.realm addObject:friend];
+    [self.realmManager.realm commitWriteTransaction];
+
+    [self.submanager configure];
+
+    XCTAssertEqual(friend.status, OCTToxUserStatusNone);
+    XCTAssertFalse(friend.isConnected);
+    XCTAssertEqual(friend.connectionStatus, OCTToxConnectionStatusNone);
+    XCTAssertFalse(friend.isTyping);
+}
+
+- (void)testConfigure2
+{
+    OCTFriend *friend = [self createFriendWithFriendNumber:99];
+    // This one should be removed.
+    OCTFriend *unboundedFriend = [self createFriendWithFriendNumber:33];
+
+    [self.realmManager.realm beginWriteTransaction];
+    [self.realmManager.realm addObject:friend];
+    [self.realmManager.realm addObject:unboundedFriend];
+    [self.realmManager.realm commitWriteTransaction];
+
+    NSString *publicKey = friend.publicKey;
+    OCMStub([self.tox publicKeyFromFriendNumber:99 error:[OCMArg anyObjectRef]]).andReturn(publicKey);
+
+    NSArray *array = @[@(99), @(kFriendNumber)];
+    OCMStub([self.tox friendsArray]).andReturn(array);
+    [self stubFriendMethodsInTox];
+
+    [self.submanager configure];
+
+    RLMResults *objects = [OCTFriend allObjectsInRealm:self.realmManager.realm];
+    XCTAssertEqual(objects.count, 2);
+
+    OCTFriend *first = objects[0];
+    OCTFriend *second = objects[1];
+
+    XCTAssertEqualObjects(friend, first);
+    [self verifyFriend:second];
+}
+
+#pragma mark -  Public
+
+- (void)testSendFriendRequestSuccess
+{
+    [self stubFriendMethodsInTox];
+
+    OCMExpect([self.tox addFriendWithAddress:kPublicKey message:@"message" error:nil]).andReturn(kFriendNumber);
+
+    BOOL result = [self.submanager sendFriendRequestToAddress:kPublicKey message:@"message" error:nil];
+
+    XCTAssertTrue(result);
+    OCMVerify([self.dataSource managerSaveTox]);
+    OCMVerifyAll(self.tox);
+
+    RLMResults *objects = [OCTFriend allObjectsInRealm:self.realmManager.realm];
+    XCTAssertEqual(objects.count, 1);
+
+    OCTFriend *friend = [objects firstObject];
+
+    [self verifyFriend:friend];
+}
+
+- (void)testSendFriendRequestFailure
+{
+    NSError *error;
+    NSError *error2 = [NSError new];
+
+    [[self.dataSource reject] managerSaveTox];
+    OCMExpect([self.tox addFriendWithAddress:kPublicKey message:@"message" error:[OCMArg setTo:error2]]).andReturn(kOCTToxFriendNumberFailure);
+
+    BOOL result = [self.submanager sendFriendRequestToAddress:kPublicKey message:@"message" error:&error];
+
+    XCTAssertFalse(result);
+    XCTAssertEqualObjects(error, error2);
+}
+
+- (void)testApproveFriendRequestSuccess
+{
+    [self stubFriendMethodsInTox];
+
+    OCTFriendRequest *friendRequest = [OCTFriendRequest new];
+    friendRequest.publicKey = kPublicKey;
+    friendRequest.message = @"message";
+
+    [self.realmManager.realm beginWriteTransaction];
+    [self.realmManager.realm addObject:friendRequest];
+    [self.realmManager.realm commitWriteTransaction];
+
+    OCMExpect([self.tox addFriendWithNoRequestWithPublicKey:kPublicKey error:nil]).andReturn(kFriendNumber);
+
+    BOOL result = [self.submanager approveFriendRequest:friendRequest error:nil];
+
+    XCTAssertTrue(result);
+    OCMVerify([self.dataSource managerSaveTox]);
+    OCMVerifyAll(self.tox);
+
+    RLMResults *objects = [OCTFriendRequest allObjectsInRealm:self.realmManager.realm];
+    XCTAssertEqual(objects.count, 0);
+
+    objects = [OCTFriend allObjectsInRealm:self.realmManager.realm];
+    XCTAssertEqual(objects.count, 1);
+
+    OCTFriend *friend = [objects firstObject];
+
+    [self verifyFriend:friend];
+}
+
+- (void)testApproveFriendRequestFailure
+{
+    OCTFriendRequest *friendRequest = [OCTFriendRequest new];
+    friendRequest.publicKey = kPublicKey;
+    friendRequest.message = @"message";
+
+    [self.realmManager.realm beginWriteTransaction];
+    [self.realmManager.realm addObject:friendRequest];
+    [self.realmManager.realm commitWriteTransaction];
+
+    NSError *error;
+    NSError *error2 = [NSError new];
+
+    [[self.dataSource reject] managerSaveTox];
+    OCMExpect([self.tox addFriendWithNoRequestWithPublicKey:kPublicKey error:[OCMArg setTo:error2]]).andReturn(kOCTToxFriendNumberFailure);
+
+    BOOL result = [self.submanager approveFriendRequest:friendRequest error:&error];
+
+    XCTAssertFalse(result);
+    XCTAssertEqualObjects(error, error2);
+
+    RLMResults *objects = [OCTFriendRequest allObjectsInRealm:self.realmManager.realm];
+    XCTAssertEqual(objects.count, 1);
+
+    XCTAssertEqualObjects(friendRequest, [objects firstObject]);
+}
+
+- (void)testRemoveFriendRequest
+{
+    OCTFriendRequest *friendRequest = [OCTFriendRequest new];
+    friendRequest.publicKey = kPublicKey;
+    friendRequest.message = @"message";
+
+    [self.realmManager.realm beginWriteTransaction];
+    [self.realmManager.realm addObject:friendRequest];
+    [self.realmManager.realm commitWriteTransaction];
+
+    [self.submanager removeFriendRequest:friendRequest];
+
+    RLMResults *objects = [OCTFriendRequest allObjectsInRealm:self.realmManager.realm];
+    XCTAssertEqual(objects.count, 0);
+}
+
+- (void)testRemoveFriendSuccess
+{
+    OCTFriend *friend = [self createFriendWithFriendNumber:kFriendNumber];
+
+    NSString *publicKey = friend.publicKey;
+    OCMStub([self.tox publicKeyFromFriendNumber:kFriendNumber error:[OCMArg anyObjectRef]]).andReturn(publicKey);
+
+    [self.realmManager.realm beginWriteTransaction];
+    [self.realmManager.realm addObject:friend];
+    [self.realmManager.realm commitWriteTransaction];
+
+    OCMExpect([self.tox deleteFriendWithFriendNumber:kFriendNumber error:nil]).andReturn(YES);
+
+    BOOL result = [self.submanager removeFriend:friend error:nil];
+
+    XCTAssertTrue(result);
+    OCMVerify([self.dataSource managerSaveTox]);
+
+    RLMResults *objects = [OCTFriend allObjectsInRealm:self.realmManager.realm];
+    XCTAssertEqual(objects.count, 0);
+}
+
+- (void)testRemoveFriendFailure
+{
+    OCTFriend *friend = [self createFriendWithFriendNumber:kFriendNumber];
+
+    NSString *publicKey = friend.publicKey;
+    OCMStub([self.tox publicKeyFromFriendNumber:kFriendNumber error:[OCMArg anyObjectRef]]).andReturn(publicKey);
+
+    [self.realmManager.realm beginWriteTransaction];
+    [self.realmManager.realm addObject:friend];
+    [self.realmManager.realm commitWriteTransaction];
+
+    NSError *error;
+    NSError *error2 = [NSError new];
+
+    [[self.dataSource reject] managerSaveTox];
+    OCMExpect([self.tox deleteFriendWithFriendNumber:kFriendNumber error:[OCMArg setTo:error2]]).andReturn(NO);
+
+    BOOL result = [self.submanager removeFriend:friend error:&error];
+
+    XCTAssertFalse(result);
+
+    RLMResults *objects = [OCTFriend allObjectsInRealm:self.realmManager.realm];
+    XCTAssertEqual(objects.count, 1);
+    XCTAssertEqualObjects([objects firstObject], friend);
+}
+
+#pragma mark -  OCTToxDelegate
+
+- (void)testFriendRequestWithMessage
+{
+    [self.submanager tox:self.tox friendRequestWithMessage:kMessage publicKey:kPublicKey];
+
+    RLMResults *objects = [OCTFriendRequest allObjectsInRealm:self.realmManager.realm];
+    XCTAssertEqual(objects.count, 1);
+
+    OCTFriendRequest *request = [objects firstObject];
+    XCTAssertEqualObjects(request.publicKey, kPublicKey);
+    XCTAssertEqualObjects(request.message, kMessage);
+    XCTAssertTrue(([[NSDate date] timeIntervalSince1970] - request.dateInterval) < 0.1);
+}
+
+- (void)testFriendRequestWithMessageDuplicate
+{
+    // trying to add same friend request twice
+    [self.submanager tox:self.tox friendRequestWithMessage:kMessage publicKey:kPublicKey];
+    [self.submanager tox:self.tox friendRequestWithMessage:kMessage publicKey:kPublicKey];
+
+    RLMResults *objects = [OCTFriendRequest allObjectsInRealm:self.realmManager.realm];
+    XCTAssertEqual(objects.count, 1);
+
+    OCTFriendRequest *request = [objects firstObject];
+    XCTAssertEqualObjects(request.publicKey, kPublicKey);
+    XCTAssertEqualObjects(request.message, kMessage);
+    XCTAssertTrue(([[NSDate date] timeIntervalSince1970] - request.dateInterval) < 0.1);
+}
+
+- (void)testFriendRequestWithMessageFriendExists
+{
+    OCTFriend *friend = [self createFriendWithFriendNumber:kFriendNumber];
+    friend.publicKey = kPublicKey;
+    friend.status = OCTToxUserStatusBusy;
+    friend.isConnected = YES;
+    friend.connectionStatus = OCTToxConnectionStatusUDP;
+    friend.isTyping = YES;
+
+    NSString *publicKey = friend.publicKey;
+    OCMStub([self.tox publicKeyFromFriendNumber:kFriendNumber error:[OCMArg anyObjectRef]]).andReturn(publicKey);
+
+    [self.realmManager.realm beginWriteTransaction];
+    [self.realmManager.realm addObject:friend];
+    [self.realmManager.realm commitWriteTransaction];
+
+    [self.submanager tox:self.tox friendRequestWithMessage:kMessage publicKey:kPublicKey];
+
+    RLMResults *objects = [OCTFriendRequest allObjectsInRealm:self.realmManager.realm];
+    XCTAssertEqual(objects.count, 0);
+}
+
+- (void)testFriendNameUpdate
+{
+    OCTFriend *friend = [self createFriendWithFriendNumber:kFriendNumber];
+    friend.publicKey = kPublicKey;
+    friend.nickname = kPublicKey;
+
+    NSString *publicKey = friend.publicKey;
+    OCMStub([self.tox publicKeyFromFriendNumber:kFriendNumber error:[OCMArg anyObjectRef]]).andReturn(publicKey);
+
+    [self.realmManager.realm beginWriteTransaction];
+    [self.realmManager.realm addObject:friend];
+    [self.realmManager.realm commitWriteTransaction];
+
+    [self.submanager tox:self.tox friendNameUpdate:@"" friendNumber:kFriendNumber];
+    XCTAssertEqualObjects(friend.name, @"");
+    XCTAssertEqualObjects(friend.nickname, kPublicKey);
+
+    [self.submanager tox:self.tox friendNameUpdate:kName friendNumber:kFriendNumber];
+    XCTAssertEqualObjects(friend.name, kName);
+    XCTAssertEqualObjects(friend.nickname, kName);
+}
+
+- (void)testStatusMessageUpdate
+{
+    OCTFriend *friend = [self createFriendWithFriendNumber:kFriendNumber];
+
+    NSString *publicKey = friend.publicKey;
+    OCMStub([self.tox publicKeyFromFriendNumber:kFriendNumber error:[OCMArg anyObjectRef]]).andReturn(publicKey);
+
+    [self.realmManager.realm beginWriteTransaction];
+    [self.realmManager.realm addObject:friend];
+    [self.realmManager.realm commitWriteTransaction];
+
+    [self.submanager tox:self.tox friendStatusMessageUpdate:kStatusMessage friendNumber:kFriendNumber];
+    XCTAssertEqualObjects(friend.statusMessage, kStatusMessage);
+}
+
+- (void)testStatusUpdate
+{
+    OCTFriend *friend = [self createFriendWithFriendNumber:kFriendNumber];
+
+    NSString *publicKey = friend.publicKey;
+    OCMStub([self.tox publicKeyFromFriendNumber:kFriendNumber error:[OCMArg anyObjectRef]]).andReturn(publicKey);
+
+    [self.realmManager.realm beginWriteTransaction];
+    [self.realmManager.realm addObject:friend];
+    [self.realmManager.realm commitWriteTransaction];
+
+    [self.submanager tox:self.tox friendStatusUpdate:kStatus friendNumber:kFriendNumber];
+    XCTAssertEqual(friend.status, kStatus);
+}
+
+- (void)testLastSeenDate
+{
+    OCTFriend *friend = [self createFriendWithFriendNumber:kFriendNumber];
+    friend.lastSeenOnlineInterval = 0;
+
+    NSString *publicKey = friend.publicKey;
+    OCMStub([self.tox publicKeyFromFriendNumber:kFriendNumber error:[OCMArg anyObjectRef]]).andReturn(publicKey);
+
+    [self.realmManager.realm beginWriteTransaction];
+    [self.realmManager.realm addObject:friend];
+    [self.realmManager.realm commitWriteTransaction];
+
+    XCTAssertNil([friend lastSeenOnline]);
+
+    [self.submanager tox:self.tox friendConnectionStatusChanged:OCTToxConnectionStatusTCP friendNumber:kFriendNumber];
+
+    XCTAssertNil([friend lastSeenOnline]);
+    XCTAssertEqual(friend.lastSeenOnlineInterval, 0);
+
+    [self stubFriendMethodsInTox];
+    [self.submanager tox:self.tox friendConnectionStatusChanged:OCTToxConnectionStatusNone friendNumber:kFriendNumber];
+    XCTAssertEqual(friend.lastSeenOnlineInterval, [sLastSeenOnline timeIntervalSince1970]);
+}
+
+- (void)testIsTypingUpdate
+{
+    OCTFriend *friend = [self createFriendWithFriendNumber:kFriendNumber];
+
+    NSString *publicKey = friend.publicKey;
+    OCMStub([self.tox publicKeyFromFriendNumber:kFriendNumber error:[OCMArg anyObjectRef]]).andReturn(publicKey);
+
+    [self.realmManager.realm beginWriteTransaction];
+    [self.realmManager.realm addObject:friend];
+    [self.realmManager.realm commitWriteTransaction];
+
+    [self.submanager tox:self.tox friendIsTypingUpdate:kIsTyping friendNumber:kFriendNumber];
+    XCTAssertEqual(friend.isTyping, kIsTyping);
+}
+
+- (void)testFriendConnectionStatusChanged
+{
+    OCTFriend *friend = [self createFriendWithFriendNumber:kFriendNumber];
+
+    NSString *publicKey = friend.publicKey;
+    OCMStub([self.tox publicKeyFromFriendNumber:kFriendNumber error:[OCMArg anyObjectRef]]).andReturn(publicKey);
+
+    [self.realmManager.realm beginWriteTransaction];
+    [self.realmManager.realm addObject:friend];
+    [self.realmManager.realm commitWriteTransaction];
+
+    [self.submanager tox:self.tox friendConnectionStatusChanged:OCTToxConnectionStatusUDP friendNumber:kFriendNumber];
+    XCTAssertEqual(friend.connectionStatus, OCTToxConnectionStatusUDP);
+    XCTAssertTrue(friend.isConnected);
+
+    [self.submanager tox:self.tox friendConnectionStatusChanged:OCTToxConnectionStatusNone friendNumber:kFriendNumber];
+    XCTAssertEqual(friend.connectionStatus, OCTToxConnectionStatusNone);
+    XCTAssertFalse(friend.isConnected);
+
+    [self.submanager tox:self.tox friendConnectionStatusChanged:OCTToxConnectionStatusTCP friendNumber:kFriendNumber];
+    XCTAssertEqual(friend.connectionStatus, OCTToxConnectionStatusTCP);
+    XCTAssertTrue(friend.isConnected);
+
+    NSNotificationCenter *center = [[NSNotificationCenter alloc] init];
+    OCMStub([self.dataSource managerGetNotificationCenter]).andReturn(center);
+
+    XCTestExpectation *expect = [self expectationWithDescription:@""];
+    [center addObserverForName:kOCTFriendConnectionStatusChangeNotification object:nil queue:nil usingBlock:^(NSNotification *note) {
+        if ([note.object friendNumber] == kFriendNumber) {
+            [expect fulfill];
+        }
+    }];
+
+    [self.submanager tox:self.tox friendConnectionStatusChanged:OCTToxConnectionStatusUDP friendNumber:kFriendNumber];
+    [self waitForExpectationsWithTimeout:0.0 handler:nil];
+}
+
+#pragma mark -  Helper methods
+
+- (void)stubFriendMethodsInTox
+{
+    OCMStub([self.tox publicKeyFromFriendNumber:kFriendNumber error:[OCMArg anyObjectRef]]).andReturn(kPublicKey);
+    OCMStub([self.tox friendNameWithFriendNumber:kFriendNumber error:[OCMArg anyObjectRef]]).andReturn(kName);
+    OCMStub([self.tox friendStatusMessageWithFriendNumber:kFriendNumber error:[OCMArg anyObjectRef]]).andReturn(kStatusMessage);
+    OCMStub([self.tox friendStatusWithFriendNumber:kFriendNumber error:[OCMArg anyObjectRef]]).andReturn(kStatus);
+    OCMStub([self.tox friendConnectionStatusWithFriendNumber:kFriendNumber error:[OCMArg anyObjectRef]]).andReturn(kConnectionStatus);
+    OCMStub([self.tox friendGetLastOnlineWithFriendNumber:kFriendNumber error:[OCMArg anyObjectRef]]).andReturn(sLastSeenOnline);
+    OCMStub([self.tox isFriendTypingWithFriendNumber:kFriendNumber error:[OCMArg anyObjectRef]]).andReturn(kIsTyping);
+}
+
+- (void)verifyFriend:(OCTFriend *)friend
+{
+    XCTAssertEqual(friend.friendNumber, kFriendNumber);
+    XCTAssertEqualObjects(friend.nickname, kName);
+    XCTAssertEqualObjects(friend.publicKey, kPublicKey);
+    XCTAssertEqualObjects(friend.name, kName);
+    XCTAssertEqualObjects(friend.statusMessage, kStatusMessage);
+    XCTAssertEqual(friend.status, kStatus);
+    XCTAssertEqual(friend.isConnected, YES);
+    XCTAssertEqual(friend.connectionStatus, kConnectionStatus);
+    XCTAssertEqual(friend.lastSeenOnlineInterval, [sLastSeenOnline timeIntervalSince1970]);
+    XCTAssertEqual(friend.isTyping, kIsTyping);
+}
+
+@end

local_pod_repo/objcTox/Tests/OCTSubmanagerObjectsImplTests.m

@@ -0,0 +1,195 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#import <OCMock/OCMock.h>
+#import <XCTest/XCTest.h>
+
+#import "OCTSubmanagerObjectsImpl.h"
+#import "OCTRealmManager.h"
+#import "OCTFriend.h"
+#import "OCTFriendRequest.h"
+#import "OCTChat.h"
+#import "OCTMessageAbstract.h"
+#import "OCTSettingsStorageObject.h"
+
+@interface OCTSubmanagerObjectsImplTests : XCTestCase
+
+@property (strong, nonatomic) OCTSubmanagerObjectsImpl *submanager;
+@property (strong, nonatomic) id dataSource;
+@property (strong, nonatomic) id realmManager;
+
+@end
+
+@implementation OCTSubmanagerObjectsImplTests
+
+- (void)setUp
+{
+    [super setUp];
+    // Put setup code here. This method is called before the invocation of each test method in the class.
+
+    self.dataSource = OCMProtocolMock(@protocol(OCTSubmanagerDataSource));
+
+    self.realmManager = OCMClassMock([OCTRealmManager class]);
+    OCMStub([self.dataSource managerGetRealmManager]).andReturn(self.realmManager);
+
+    self.submanager = [OCTSubmanagerObjectsImpl new];
+    self.submanager.dataSource = self.dataSource;
+}
+
+- (void)tearDown
+{
+    self.dataSource = nil;
+    self.realmManager = nil;
+    self.submanager = nil;
+
+    // Put teardown code here. This method is called after the invocation of each test method in the class.
+    [super tearDown];
+}
+
+- (void)testFetchRequestByType
+{
+    id predicate = OCMClassMock([NSPredicate class]);
+
+    id results1 = OCMClassMock([RLMResults class]);
+    id results2 = OCMClassMock([RLMResults class]);
+    id results3 = OCMClassMock([RLMResults class]);
+    id results4 = OCMClassMock([RLMResults class]);
+
+    OCMStub([self.realmManager objectsWithClass:[OCTFriend class]
+                                      predicate:predicate]).andReturn(results1);
+    OCMStub([self.realmManager objectsWithClass:[OCTFriendRequest class]
+                                      predicate:predicate]).andReturn(results2);
+    OCMStub([self.realmManager objectsWithClass:[OCTChat class]
+                                      predicate:predicate]).andReturn(results3);
+    OCMStub([self.realmManager objectsWithClass:[OCTMessageAbstract class]
+                                      predicate:predicate]).andReturn(results4);
+
+    XCTAssertEqual(results1, [self.submanager objectsForType:OCTFetchRequestTypeFriend
+                                                   predicate:predicate]);
+    XCTAssertEqual(results2, [self.submanager objectsForType:OCTFetchRequestTypeFriendRequest
+                                                   predicate:predicate]);
+    XCTAssertEqual(results3, [self.submanager objectsForType:OCTFetchRequestTypeChat
+                                                   predicate:predicate]);
+    XCTAssertEqual(results4, [self.submanager objectsForType:OCTFetchRequestTypeMessageAbstract
+                                                   predicate:predicate]);
+}
+
+- (void)testGenericSettingsData
+{
+    NSData *data = [@"some string" dataUsingEncoding:NSUTF8StringEncoding];
+
+    id settingsStorage = OCMClassMock([OCTSettingsStorageObject class]);
+    OCMStub([settingsStorage genericSettingsData]).andReturn(data);
+    OCMExpect([settingsStorage setGenericSettingsData:data]);
+
+    OCMStub([self.realmManager settingsStorage]).andReturn(settingsStorage);
+
+    XCTAssertEqual(self.submanager.genericSettingsData, data);
+    self.submanager.genericSettingsData = data;
+
+    OCMVerify(settingsStorage);
+}
+
+- (void)testObjectWithUniqueIdentifier
+{
+    NSString *identifier = @"identifier";
+
+    id object1 = OCMClassMock([OCTObject class]);
+    id object2 = OCMClassMock([OCTObject class]);
+    id object3 = OCMClassMock([OCTObject class]);
+    id object4 = OCMClassMock([OCTObject class]);
+
+    OCMStub([self.realmManager objectWithUniqueIdentifier:identifier class:[OCTFriend class]]).andReturn(object1);
+    OCMStub([self.realmManager objectWithUniqueIdentifier:identifier class:[OCTFriendRequest class]]).andReturn(object2);
+    OCMStub([self.realmManager objectWithUniqueIdentifier:identifier class:[OCTChat class]]).andReturn(object3);
+    OCMStub([self.realmManager objectWithUniqueIdentifier:identifier class:[OCTMessageAbstract class]]).andReturn(object4);
+
+    XCTAssertEqual(object1, [self.submanager objectWithUniqueIdentifier:identifier forType:OCTFetchRequestTypeFriend]);
+    XCTAssertEqual(object2, [self.submanager objectWithUniqueIdentifier:identifier forType:OCTFetchRequestTypeFriendRequest]);
+    XCTAssertEqual(object3, [self.submanager objectWithUniqueIdentifier:identifier forType:OCTFetchRequestTypeChat]);
+    XCTAssertEqual(object4, [self.submanager objectWithUniqueIdentifier:identifier forType:OCTFetchRequestTypeMessageAbstract]);
+}
+
+- (void)testChangeFriendNickname
+{
+    OCTFriend *friend = [OCTFriend new];
+
+    OCMStub([self.realmManager updateObject:friend withBlock:[OCMArg checkWithBlock:^BOOL (id obj) {
+        void (^block)(id) = obj;
+        block(friend);
+        return YES;
+    }]]);
+
+    [self.submanager changeFriend:friend nickname:@"new"];
+
+    XCTAssertEqualObjects(friend.nickname, @"new");
+}
+
+- (void)testChangeFriendNicknameEmpty1
+{
+    OCTFriend *friend = [OCTFriend new];
+    friend.nickname = @"nickname";
+    friend.name = @"name";
+    friend.publicKey = @"public";
+
+    OCMStub([self.realmManager updateObject:friend withBlock:[OCMArg checkWithBlock:^BOOL (id obj) {
+        void (^block)(id) = obj;
+        block(friend);
+        return YES;
+    }]]);
+
+    [self.submanager changeFriend:friend nickname:@""];
+
+    XCTAssertEqualObjects(friend.nickname, @"name");
+}
+
+- (void)testChangeFriendNicknameEmpty2
+{
+    OCTFriend *friend = [OCTFriend new];
+    friend.nickname = @"nickname";
+    friend.name = @"";
+    friend.publicKey = @"public";
+
+    OCMStub([self.realmManager updateObject:friend withBlock:[OCMArg checkWithBlock:^BOOL (id obj) {
+        void (^block)(id) = obj;
+        block(friend);
+        return YES;
+    }]]);
+
+    [self.submanager changeFriend:friend nickname:@""];
+
+    XCTAssertEqualObjects(friend.nickname, @"public");
+}
+
+- (void)testChangeChatEnteredText
+{
+    OCTChat *chat = [OCTChat new];
+
+    OCMStub([self.realmManager updateObject:chat withBlock:[OCMArg checkWithBlock:^BOOL (id obj) {
+        void (^block)(id) = obj;
+        block(chat);
+        return YES;
+    }]]);
+
+    [self.submanager changeChat:chat enteredText:@"text"];
+
+    XCTAssertEqualObjects(chat.enteredText, @"text");
+}
+
+- (void)testChangeChatEnteredLastReadDateInterval
+{
+    OCTChat *chat = [OCTChat new];
+
+    OCMStub([self.realmManager updateObject:chat withBlock:[OCMArg checkWithBlock:^BOOL (id obj) {
+        void (^block)(id) = obj;
+        block(chat);
+        return YES;
+    }]]);
+
+    [self.submanager changeChat:chat lastReadDateInterval:17];
+
+    XCTAssertEqual(chat.lastReadDateInterval, 17);
+}
+
+@end

local_pod_repo/objcTox/Tests/OCTSubmanagerUserImplTests.m

@@ -0,0 +1,130 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#import <OCMock/OCMock.h>
+#import <XCTest/XCTest.h>
+
+#import "OCTRealmTests.h"
+#import "OCTSubmanagerUserImpl.h"
+#import "OCTSubmanagerDataSource.h"
+#import "OCTTox.h"
+
+@interface OCTSubmanagerUserImplTests : OCTRealmTests
+
+@property (strong, nonatomic) OCTSubmanagerUserImpl *submanager;
+@property (strong, nonatomic) id dataSource;
+@property (strong, nonatomic) id tox;
+
+@end
+
+@implementation OCTSubmanagerUserImplTests
+
+- (void)setUp
+{
+    [super setUp];
+    // Put setup code here. This method is called before the invocation of each test method in the class.
+    self.tox = OCMClassMock([OCTTox class]);
+
+    self.dataSource = OCMProtocolMock(@protocol(OCTSubmanagerDataSource));
+    OCMStub([self.dataSource managerGetTox]).andReturn(self.tox);
+    OCMStub([self.dataSource managerGetRealmManager]).andReturn(self.realmManager);
+
+    self.submanager = [OCTSubmanagerUserImpl new];
+    self.submanager.dataSource = self.dataSource;
+}
+
+- (void)tearDown
+{
+    self.tox = nil;
+    self.dataSource = nil;
+    self.submanager = nil;
+    // Put teardown code here. This method is called after the invocation of each test method in the class.
+    [super tearDown];
+}
+
+- (void)testConnectionStatus
+{
+    OCMStub([self.tox connectionStatus]).andReturn(OCTToxConnectionStatusTCP);
+    XCTAssertEqual([self.submanager connectionStatus], OCTToxConnectionStatusTCP);
+}
+
+- (void)testUserAddress
+{
+    OCMStub([self.tox userAddress]).andReturn(@"address");
+    XCTAssertEqualObjects([self.submanager userAddress], @"address");
+}
+
+- (void)testPublicKey
+{
+    OCMStub([self.tox publicKey]).andReturn(@"publicKey");
+    XCTAssertEqualObjects([self.submanager publicKey], @"publicKey");
+}
+
+- (void)testNospam
+{
+    OCMStub([self.tox nospam]).andReturn(5);
+    XCTAssertEqual([self.submanager nospam], 5);
+
+    self.submanager.nospam = 7;
+    OCMVerify([self.tox setNospam:7]);
+    OCMVerify([self.dataSource managerSaveTox]);
+}
+
+- (void)testUserStatus
+{
+    OCMStub([self.tox userStatus]).andReturn(5);
+    XCTAssertEqual([self.submanager userStatus], 5);
+
+    self.submanager.userStatus = 7;
+    OCMVerify([self.tox setUserStatus:7]);
+    OCMVerify([self.dataSource managerSaveTox]);
+}
+
+- (void)testUserName
+{
+    OCMStub([self.tox userName]).andReturn(@"userName");
+    XCTAssertEqualObjects([self.submanager userName], @"userName");
+
+    NSError *error, *error2;
+    OCMExpect([self.tox setNickname:@"name" error:[OCMArg setTo:error2]]).andReturn(YES);
+
+    [self.submanager setUserName:@"name" error:&error];
+
+    XCTAssertEqual(error, error2);
+    OCMVerifyAll(self.tox);
+    OCMVerify([self.dataSource managerSaveTox]);
+}
+
+- (void)testUserStatusMessage
+{
+    OCMStub([self.tox userStatusMessage]).andReturn(@"userStatusMessage");
+    XCTAssertEqualObjects([self.submanager userStatusMessage], @"userStatusMessage");
+
+    NSError *error, *error2;
+    OCMExpect([self.tox setUserStatusMessage:@"message" error:[OCMArg setTo:error2]]).andReturn(YES);
+
+    [self.submanager setUserStatusMessage:@"message" error:&error];
+
+    XCTAssertEqual(error, error2);
+    OCMVerifyAll(self.tox);
+    OCMVerify([self.dataSource managerSaveTox]);
+}
+
+- (void)testSetUserAvatar
+{
+    char databytes[65536];
+    NSData *data = [[NSData alloc] initWithBytes:databytes length:65536];
+    XCTAssertTrue([self.submanager setUserAvatar:data error:nil]);
+
+    XCTAssertEqualObjects([self.submanager userAvatar], data);
+
+    char toomanybytes[85536];
+    data = [[NSData alloc] initWithBytes:toomanybytes length:85536];
+    XCTAssertFalse([self.submanager setUserAvatar:data error:nil]);
+
+    XCTAssertTrue([self.submanager setUserAvatar:nil error:nil]);
+    XCTAssertNil([self.submanager userAvatar]);
+}
+
+@end

local_pod_repo/objcTox/Tests/OCTToxAVTests.m

@@ -0,0 +1,583 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#import <Foundation/Foundation.h>
+
+#import <OCMock/OCMock.h>
+#import "OCTToxAV+Private.h"
+#import "OCTTox+Private.h"
+#import "OCTToxOptions.h"
+#import "OCTCAsserts.h"
+
+static void *refToSelf;
+
+void mocked_toxav_iterate(ToxAV *toxAV);
+uint32_t mocked_toxav_iteration_interval(const ToxAV *toxAV);
+void mocked_toxav_kill(ToxAV *toxAV);
+
+bool mocked_tox_av_call_success(ToxAV *toxAV, uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate, TOXAV_ERR_CALL *error);
+bool mocked_tox_av_answer_success(ToxAV *cToxAV, uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate, TOXAV_ERR_ANSWER *error);
+bool mocked_tox_av_answer_fail(ToxAV *cToxAV, uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate, TOXAV_ERR_ANSWER *error);
+bool mocked_tox_av_call_fail(ToxAV *toxAV, uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate, TOXAV_ERR_CALL *error);
+
+bool mocked_toxav_call_control_resume(ToxAV *toxAV, uint32_t friend_number, TOXAV_CALL_CONTROL control, TOXAV_ERR_CALL_CONTROL *error);
+bool mocked_toxav_call_control_cancel(ToxAV *toxAV, uint32_t friend_number, TOXAV_CALL_CONTROL control, TOXAV_ERR_CALL_CONTROL *error);
+
+bool mocked_toxav_audio_set_bit_rate(ToxAV *av, uint32_t friend_number, uint32_t bit_rate, TOXAV_ERR_BIT_RATE_SET *error);
+bool mocked_toxav_video_set_bit_rate(ToxAV *av, uint32_t friend_number, uint32_t bit_rate, TOXAV_ERR_BIT_RATE_SET *error);
+
+bool mocked_toxav_audio_send_frame(ToxAV *toxAV, uint32_t friend_number, const int16_t *pcm, size_t sample_count, uint8_t channels, uint32_t sampling_rate, TOXAV_ERR_SEND_FRAME *error);
+bool mocked_toxav_video_send_frame(ToxAV *toxAV, uint32_t friend_number, uint16_t width, uint16_t height, const uint8_t *y, const uint8_t *u, const uint8_t *v, TOXAV_ERR_SEND_FRAME *error);
+
+OCTToxAVPCMData pcmTestData [] = { 5, 6, 7, 8};
+OCTToxAVPCMData *pcmPointer = pcmTestData;
+
+OCTToxAVPlaneData yPlaneTestData [] = {2, 3, 4, 5};
+OCTToxAVPlaneData *yPlanePointer = yPlaneTestData;
+OCTToxAVPlaneData uPlaneTestData [] = {6, 7, 8, 9};
+OCTToxAVPlaneData *uPlanePointer = uPlaneTestData;
+OCTToxAVPlaneData vPlaneTestData [] = {10, 11, 12, 13};
+OCTToxAVPlaneData *vPlanePointer = vPlaneTestData;
+OCTToxAVPlaneData aPlaneTestData [] = {14, 15, 16, 17};
+OCTToxAVPlaneData *aPlanePointer = aPlaneTestData;
+
+@interface OCTToxAVTests : XCTestCase
+
+@property (strong, nonatomic) OCTToxAV *toxAV;
+@property (strong, nonatomic) OCTTox *tox;
+
+@end
+
+@implementation OCTToxAVTests
+
+- (void)setUp
+{
+    [super setUp];
+    // Put setup code here. This method is called before the invocation of each test method in the class.
+
+    refToSelf = (__bridge void *)(self);
+
+    self.tox = [[OCTTox alloc] initWithOptions:[OCTToxOptions new] savedData:nil error:nil];
+    self.toxAV = [[OCTToxAV alloc] initWithTox:self.tox error:nil];
+}
+
+- (void)tearDown
+{
+    // Put teardown code here. This method is called after the invocation of each test method in the class.
+
+    self.tox = nil;
+    self.toxAV = nil;
+
+    refToSelf = NULL;
+
+    [super tearDown];
+}
+
+- (void)testInit
+{
+    XCTAssertNotNil(self.toxAV);
+}
+
+- (void)testCallFriend
+{
+    _toxav_call = mocked_tox_av_call_success;
+    XCTAssertTrue([self.toxAV callFriendNumber:1234 audioBitRate:5678 videoBitRate:9101112 error:nil]);
+
+    _toxav_call = mocked_tox_av_call_fail;
+    XCTAssertFalse([self.toxAV callFriendNumber:1234 audioBitRate:5678 videoBitRate:9101112 error:nil]);
+}
+
+- (void)testAnswerCall
+{
+    _toxav_answer = mocked_tox_av_answer_success;
+    XCTAssertTrue([self.toxAV answerIncomingCallFromFriend:9876 audioBitRate:555 videoBitRate:666 error:nil]);
+
+    _toxav_answer = mocked_tox_av_answer_fail;
+    XCTAssertFalse([self.toxAV answerIncomingCallFromFriend:999 audioBitRate:888 videoBitRate:777 error:nil]);
+}
+
+- (void)testSendCallControl
+{
+    _toxav_call_control = mocked_toxav_call_control_resume;
+    XCTAssertTrue([self.toxAV sendCallControl:OCTToxAVCallControlResume toFriendNumber:12345 error:nil]);
+
+    _toxav_call_control = mocked_toxav_call_control_cancel;
+    XCTAssertTrue([self.toxAV sendCallControl:OCTToxAVCallControlCancel toFriendNumber:12345 error:nil]);
+}
+
+- (void)testStartandStop
+{
+    _toxav_iterate = mocked_toxav_iterate;
+    _toxav_iteration_interval = mocked_toxav_iteration_interval;
+
+    [self.toxAV start];
+    [self.toxAV stop];
+
+    _toxav_iterate = nil;
+    _toxav_iteration_interval = nil;
+}
+
+- (void)testSendAudioFrame
+{
+    _toxav_audio_send_frame = mocked_toxav_audio_send_frame;
+    XCTAssertTrue([self.toxAV sendAudioFrame:pcmPointer sampleCount:6 channels:7 sampleRate:8 toFriend:5 error:nil]);
+}
+
+- (void)testSendVideoFrame
+{
+    _toxav_video_send_frame = mocked_toxav_video_send_frame;
+    XCTAssertFalse([self.toxAV sendVideoFrametoFriend:7 width:50 height:70
+                                               yPlane:yPlanePointer
+                                               uPlane:uPlanePointer
+                                               vPlane:vPlanePointer
+                                                error:nil]);
+}
+
+#pragma mark Private methods
+
+- (void)testFillErrorInit
+{
+    [self.toxAV fillError:nil withCErrorInit:TOXAV_ERR_NEW_NULL];
+
+    NSError *error;
+    [self.toxAV fillError:&error withCErrorInit:TOXAV_ERR_NEW_NULL];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxAVErrorInitNULL);
+
+    error = nil;
+    [self.toxAV fillError:&error withCErrorInit:TOXAV_ERR_NEW_MALLOC];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxAVErrorInitCodeMemoryError);
+
+    error = nil;
+    [self.toxAV fillError:&error withCErrorInit:TOXAV_ERR_NEW_MULTIPLE];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxAVErrorInitMultiple);
+}
+
+- (void)testFillErrorCall
+{
+    [self.toxAV fillError:nil withCErrorCall:TOXAV_ERR_CALL_MALLOC];
+
+    NSError *error;
+    [self.toxAV fillError:&error withCErrorCall:TOXAV_ERR_CALL_MALLOC];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxAVErrorCallMalloc);
+
+    error = nil;
+    [self.toxAV fillError:&error withCErrorCall:TOXAV_ERR_CALL_FRIEND_NOT_FOUND];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxAVErrorCallFriendNotFound);
+
+    error = nil;
+    [self.toxAV fillError:&error withCErrorCall:TOXAV_ERR_CALL_FRIEND_NOT_CONNECTED];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxAVErrorCallFriendNotConnected);
+
+    error = nil;
+    [self.toxAV fillError:&error withCErrorCall:TOXAV_ERR_CALL_FRIEND_ALREADY_IN_CALL];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxAVErrorCallAlreadyInCall);
+
+    error = nil;
+    [self.toxAV fillError:&error withCErrorCall:TOXAV_ERR_CALL_INVALID_BIT_RATE];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxAVErrorCallInvalidBitRate);
+}
+
+- (void)testFillErrorAnswer
+{
+    [self.toxAV fillError:nil withCErrorAnswer:TOXAV_ERR_ANSWER_OK];
+
+    NSError *error;
+    [self.toxAV fillError:&error withCErrorAnswer:TOXAV_ERR_ANSWER_CODEC_INITIALIZATION];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxAVErrorAnswerCodecInitialization);
+
+    error = nil;
+    [self.toxAV fillError:&error withCErrorAnswer:TOXAV_ERR_ANSWER_FRIEND_NOT_CALLING];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxAVErrorAnswerFriendNotCalling);
+
+    error = nil;
+    [self.toxAV fillError:&error withCErrorAnswer:TOXAV_ERR_ANSWER_FRIEND_NOT_FOUND];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxAVErrorAnswerFriendNotFound);
+
+    error = nil;
+    [self.toxAV fillError:&error withCErrorAnswer:TOXAV_ERR_ANSWER_INVALID_BIT_RATE];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxAVErrorAnswerInvalidBitRate);
+}
+
+- (void)testFillErrorControl
+{
+    [self.toxAV fillError:nil withCErrorControl:TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION];
+
+    NSError *error;
+    [self.toxAV fillError:&error withCErrorControl:TOXAV_ERR_CALL_CONTROL_FRIEND_NOT_FOUND];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxAVErrorControlFriendNotFound);
+
+    error = nil;
+    [self.toxAV fillError:&error withCErrorControl:TOXAV_ERR_CALL_CONTROL_FRIEND_NOT_IN_CALL];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxAVErrorControlFriendNotInCall);
+
+    error = nil;
+    [self.toxAV fillError:&error withCErrorControl:TOXAV_ERR_CALL_CONTROL_INVALID_TRANSITION];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxAVErrorControlInvaldTransition);
+}
+- (void)testFillErrorSetBitRate
+{
+    [self.toxAV fillError:nil withCErrorSetBitRate:TOXAV_ERR_BIT_RATE_SET_FRIEND_NOT_IN_CALL];
+
+    NSError *error;
+    [self.toxAV fillError:&error withCErrorSetBitRate:TOXAV_ERR_BIT_RATE_SET_INVALID_BIT_RATE];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxAVErrorSetBitRateInvalidBitRate);
+
+    error = nil;
+    [self.toxAV fillError:&error withCErrorSetBitRate:TOXAV_ERR_BIT_RATE_SET_SYNC];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxAVErrorSetBitRateSync);
+
+    error = nil;
+    [self.toxAV fillError:&error withCErrorSetBitRate:TOXAV_ERR_BIT_RATE_SET_FRIEND_NOT_FOUND];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxAVErrorSetBitRateFriendNotFound);
+
+    error = nil;
+    [self.toxAV fillError:&error withCErrorSetBitRate:TOXAV_ERR_BIT_RATE_SET_FRIEND_NOT_IN_CALL];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxAVErrorSetBitRateFriendNotInCall);
+}
+
+- (void)testFillErrorSendFrame
+{
+    [self.toxAV fillError:nil withCErrorSendFrame:TOXAV_ERR_SEND_FRAME_NULL];
+
+    NSError *error;
+    [self.toxAV fillError:&error withCErrorSendFrame:TOXAV_ERR_SEND_FRAME_NULL];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxAVErrorSendFrameNull);
+
+    error = nil;
+    [self.toxAV fillError:&error withCErrorSendFrame:TOXAV_ERR_SEND_FRAME_FRIEND_NOT_FOUND];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxAVErrorSendFrameFriendNotFound);
+
+    error = nil;
+    [self.toxAV fillError:&error withCErrorSendFrame:TOXAV_ERR_SEND_FRAME_FRIEND_NOT_IN_CALL];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxAVErrorSendFrameFriendNotInCall);
+
+    error = nil;
+    [self.toxAV fillError:&error withCErrorSendFrame:TOXAV_ERR_SEND_FRAME_INVALID];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxAVErrorSendFrameInvalid);
+
+    error = nil;
+    [self.toxAV fillError:&error withCErrorSendFrame:TOXAV_ERR_SEND_FRAME_RTP_FAILED];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxAVErrorSendFrameRTPFailed);
+}
+
+#pragma mark Callbacks
+
+- (void)testReceiveCallback
+{
+    [self makeTestCallbackWithCallBlock:^{
+        callIncomingCallback(NULL, 1, true, false, (__bridge void *)self.toxAV);
+    } expectBlock:^(id<OCTToxAVDelegate> delegate) {
+        OCMExpect([self.toxAV.delegate toxAV:self.toxAV
+                     receiveCallAudioEnabled:YES
+                                videoEnabled:NO
+                                friendNumber:1]);
+    }];
+}
+
+- (void)testCallStateCallback
+{
+    [self makeTestCallbackWithCallBlock:^{
+        callStateCallback(NULL, 1, TOXAV_FRIEND_CALL_STATE_ACCEPTING_A | TOXAV_FRIEND_CALL_STATE_SENDING_A, (__bridge void *)self.toxAV);
+    } expectBlock:^(id<OCTToxAVDelegate> delegate) {
+        OCTToxFriendNumber friendNumber = 1;
+        OCMExpect([self.toxAV.delegate toxAV:self.toxAV
+                            callStateChanged:OCTToxAVFriendCallStateAcceptingAudio | OCTToxAVFriendCallStateSendingAudio
+                                friendNumber:friendNumber]);
+    }];
+
+    [self makeTestCallbackWithCallBlock:^{
+        callStateCallback(NULL, 1, TOXAV_FRIEND_CALL_STATE_SENDING_A, (__bridge void *)self.toxAV);
+    } expectBlock:^(id<OCTToxAVDelegate> delegate) {
+        OCTToxFriendNumber friendNumber = 1;
+        OCMExpect([self.toxAV.delegate toxAV:self.toxAV
+                            callStateChanged:OCTToxAVFriendCallStateSendingAudio
+                                friendNumber:friendNumber]);
+    }];
+
+    [self makeTestCallbackWithCallBlock:^{
+        callStateCallback(NULL, 1, TOXAV_FRIEND_CALL_STATE_ERROR, (__bridge void *)self.toxAV);
+    } expectBlock:^(id<OCTToxAVDelegate> delegate) {
+        OCTToxFriendNumber friendNumber = 1;
+        OCMExpect([self.toxAV.delegate toxAV:self.toxAV
+                            callStateChanged:OCTToxAVFriendCallStateError
+                                friendNumber:friendNumber]);
+    }];
+
+    [self makeTestCallbackWithCallBlock:^{
+        callStateCallback(NULL, 1, TOXAV_FRIEND_CALL_STATE_ACCEPTING_A | TOXAV_FRIEND_CALL_STATE_SENDING_A | TOXAV_FRIEND_CALL_STATE_SENDING_V, (__bridge void *)self.toxAV);
+    } expectBlock:^(id<OCTToxAVDelegate> delegate) {
+        OCTToxFriendNumber friendNumber = 1;
+        OCMExpect([self.toxAV.delegate toxAV:self.toxAV
+                            callStateChanged:OCTToxAVFriendCallStateAcceptingAudio | OCTToxAVFriendCallStateSendingAudio | OCTToxAVFriendCallStateSendingVideo
+                                friendNumber:friendNumber]);
+    }];
+}
+
+- (void)testAudioBitRateCallback
+{
+    [self makeTestCallbackWithCallBlock:^{
+        audioBitRateStatusCallback(NULL, 1234, 567, (__bridge void *)self.toxAV);
+    } expectBlock:^(id<OCTToxAVDelegate> delegate) {
+        OCMExpect([self.toxAV.delegate toxAV:self.toxAV audioBitRateStatus:567 forFriendNumber:1234]);
+    }];
+}
+
+- (void)testVideoBitRateCallback
+{
+    [self makeTestCallbackWithCallBlock:^{
+        videoBitRateStatusCallback(NULL, 1234, 890, (__bridge void *)self.toxAV);
+    } expectBlock:^(id<OCTToxAVDelegate> delegate) {
+        OCMExpect([self.toxAV.delegate toxAV:self.toxAV videoBitRateStatus:890 forFriendNumber:1234]);
+    }];
+}
+
+- (void)testReceiveAudioCallback
+{
+    const int16_t pcm[] = {5, 9, 5};
+    const int16_t *pointerToData = pcm;
+
+    [self makeTestCallbackWithCallBlock:^{
+        receiveAudioFrameCallback(NULL, 20, pointerToData, 4, 0, 6, (__bridge void *)self.toxAV);
+    } expectBlock:^(id<OCTToxAVDelegate> delegate) {
+        OCMExpect([self.toxAV.delegate toxAV:self.toxAV
+                                receiveAudio:pointerToData
+                                 sampleCount:4
+                                    channels:0
+                                  sampleRate:6
+                                friendNumber:20]);
+    }];
+}
+
+- (void)testReceiveVideoFrameCallback
+{
+    const OCTToxAVPlaneData yPlane[] = {1, 2, 3, 4, 5};
+    const OCTToxAVPlaneData *yPointer = yPlane;
+    const OCTToxAVPlaneData uPlane[] = {4, 3, 3, 4, 5};
+    const OCTToxAVPlaneData *uPointer = uPlane;
+    const OCTToxAVPlaneData vPlane[] = {1, 2, 5, 4, 5};
+    const OCTToxAVPlaneData *vPointer = vPlane;
+
+    [self makeTestCallbackWithCallBlock:^{
+        receiveVideoFrameCallback(NULL, 123,
+                                  999, 888,
+                                  yPointer, uPointer, vPointer,
+                                  1, 2, 3,
+                                  (__bridge void *)self.toxAV);
+    } expectBlock:^(id<OCTToxAVDelegate> delegate) {
+        OCMExpect([self.toxAV.delegate toxAV:self.toxAV
+                   receiveVideoFrameWithWidth:999 height:888
+                                       yPlane:yPointer uPlane:uPointer vPlane:vPointer
+                                      yStride:1 uStride:2 vStride:3 friendNumber:123]);
+    }];
+}
+
+- (void)makeTestCallbackWithCallBlock:(void (^)())callBlock expectBlock:(void (^)(id<OCTToxAVDelegate> delegate))expectBlock
+{
+    NSParameterAssert(callBlock);
+    NSParameterAssert(expectBlock);
+
+    self.toxAV.delegate = OCMProtocolMock(@protocol(OCTToxAVDelegate));
+    expectBlock(self.toxAV.delegate);
+
+    callBlock();
+
+    XCTestExpectation *expectation = [self expectationWithDescription:@"callback"];
+
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 0.1 * NSEC_PER_SEC), dispatch_get_main_queue(), ^{
+        [expectation fulfill];
+    });
+
+    [self waitForExpectationsWithTimeout:1.0 handler:nil];
+    OCMVerifyAll((id)self.toxAV.delegate);
+
+}
+
+@end
+
+#pragma mark - Mocked toxav methods
+
+void mocked_toxav_iterate(ToxAV *cToxAV)
+{
+    OCTToxAV *toxAV = [(__bridge OCTToxAVTests *)refToSelf toxAV];
+
+    CCCAssertTrue(toxAV.toxAV == cToxAV);
+}
+
+uint32_t mocked_toxav_iteration_interval(const ToxAV *cToxAV)
+{
+    OCTToxAV *toxAV = [(__bridge OCTToxAVTests *)refToSelf toxAV];
+
+    CCCAssertTrue(toxAV.toxAV == cToxAV);
+
+    return 200;
+}
+
+void mocked_toxav_kill(ToxAV *cToxAV)
+{
+    OCTToxAV *toxAV = [(__bridge OCTToxAVTests *)refToSelf toxAV];
+
+    CCCAssertTrue(toxAV.toxAV == cToxAV);
+}
+
+bool mocked_tox_av_call_success(ToxAV *cToxAV, uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate, TOXAV_ERR_CALL *error)
+{
+    OCTToxAV *toxAV = [(__bridge OCTToxAVTests *)refToSelf toxAV];
+
+    CCCAssertTrue(toxAV.toxAV == cToxAV);
+
+    CCCAssertEqual(1234, friend_number);
+    CCCAssertEqual(5678, audio_bit_rate);
+    CCCAssertEqual(9101112, video_bit_rate);
+
+    return true;
+}
+
+bool mocked_tox_av_call_fail(ToxAV *cToxAV, uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate, TOXAV_ERR_CALL *error)
+{
+    OCTToxAV *toxAV = [(__bridge OCTToxAVTests *)refToSelf toxAV];
+
+    CCCAssertTrue(toxAV.toxAV == cToxAV);
+
+    CCCAssertEqual(1234, friend_number);
+    CCCAssertEqual(5678, audio_bit_rate);
+    CCCAssertEqual(9101112, video_bit_rate);
+
+    return false;
+}
+
+bool mocked_tox_av_answer_success(ToxAV *cToxAV, uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate, TOXAV_ERR_ANSWER *error)
+{
+    OCTToxAV *toxAV = [(__bridge OCTToxAVTests *)refToSelf toxAV];
+    CCCAssertTrue(toxAV.toxAV == cToxAV);
+
+    CCCAssertEqual(9876, friend_number);
+    CCCAssertEqual(555, audio_bit_rate);
+    CCCAssertEqual(666, video_bit_rate);
+
+    return true;
+}
+
+bool mocked_tox_av_answer_fail(ToxAV *cToxAV, uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate, TOXAV_ERR_ANSWER *error)
+{
+    OCTToxAV *toxAV = [(__bridge OCTToxAVTests *)refToSelf toxAV];
+    CCCAssertTrue(toxAV.toxAV == cToxAV);
+
+    CCCAssertEqual(999, friend_number);
+    CCCAssertEqual(888, audio_bit_rate);
+    CCCAssertEqual(777, video_bit_rate);
+
+    return false;
+}
+
+
+bool mocked_toxav_call_control_resume(ToxAV *cToxAV, uint32_t friend_number, TOXAV_CALL_CONTROL control, TOXAV_ERR_CALL_CONTROL *error)
+{
+    OCTToxAV *toxAV = [(__bridge OCTToxAVTests *)refToSelf toxAV];
+
+    CCCAssertTrue(toxAV.toxAV == cToxAV);
+
+    CCCAssertEqual(friend_number, 12345);
+    CCCAssertEqual(control, TOXAV_CALL_CONTROL_RESUME);
+
+    return true;
+}
+
+bool mocked_toxav_call_control_cancel(ToxAV *cToxAV, uint32_t friend_number, TOXAV_CALL_CONTROL control, TOXAV_ERR_CALL_CONTROL *error)
+{
+    OCTToxAV *toxAV = [(__bridge OCTToxAVTests *)refToSelf toxAV];
+
+    CCCAssertTrue(toxAV.toxAV == cToxAV);
+
+    CCCAssertEqual(friend_number, 12345);
+    CCCAssertEqual(control, TOXAV_CALL_CONTROL_CANCEL);
+
+    return true;
+}
+
+bool mocked_toxav_audio_set_bit_rate(ToxAV *av, uint32_t friend_number, uint32_t bit_rate, TOXAV_ERR_BIT_RATE_SET *error)
+{
+    OCTToxAV *toxAV = [(__bridge OCTToxAVTests *)refToSelf toxAV];
+
+    CCCAssertTrue(toxAV.toxAV == av);
+
+    CCCAssertEqual(5, friend_number);
+    CCCAssertEqual(10, bit_rate);
+
+    return false;
+}
+
+bool mocked_toxav_video_set_bit_rate(ToxAV *av, uint32_t friend_number, uint32_t bit_rate, TOXAV_ERR_BIT_RATE_SET *error)
+{
+    OCTToxAV *toxAV = [(__bridge OCTToxAVTests *)refToSelf toxAV];
+
+    CCCAssertTrue(toxAV.toxAV == av);
+
+    CCCAssertEqual(5, friend_number);
+    CCCAssertEqual(11, bit_rate);
+
+    return false;
+}
+
+bool mocked_toxav_audio_send_frame(ToxAV *cToxAV, uint32_t friend_number, const int16_t *pcm, size_t sample_count, uint8_t channels, uint32_t sampling_rate, TOXAV_ERR_SEND_FRAME *error)
+{
+    OCTToxAV *toxAV = [(__bridge OCTToxAVTests *)refToSelf toxAV];
+
+    CCCAssertTrue(toxAV.toxAV == cToxAV);
+
+    CCCAssertEqual(pcmPointer, pcm);
+    CCCAssertEqual(5, friend_number);
+    CCCAssertEqual(6, sample_count);
+    CCCAssertEqual(7, channels);
+    CCCAssertEqual(8, sampling_rate);
+
+    return true;
+}
+
+bool mocked_toxav_video_send_frame(ToxAV *cToxAV, uint32_t friend_number, uint16_t width, uint16_t height, const uint8_t *y, const uint8_t *u, const uint8_t *v, TOXAV_ERR_SEND_FRAME *error)
+{
+    OCTToxAV *toxAV = [(__bridge OCTToxAVTests *)refToSelf toxAV];
+
+    CCCAssertTrue(toxAV.toxAV == cToxAV);
+
+    CCCAssertEqual(50, width);
+    CCCAssertEqual(70, height);
+    CCCAssertEqual(yPlanePointer, y);
+    CCCAssertEqual(uPlanePointer, u);
+    CCCAssertEqual(vPlanePointer, v);
+    CCCAssertEqual(7, friend_number);
+
+    return false;
+}
+
+bool mocked_toxav_version_is_compatible(uint32_t major, uint32_t minor, uint32_t patch)
+{
+    CCCAssertEqual(999, major);
+    CCCAssertEqual(888, minor);
+    CCCAssertEqual(777, patch);
+    return false;
+}

local_pod_repo/objcTox/Tests/OCTToxEncryptSaveTests.m

@@ -0,0 +1,77 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#import <XCTest/XCTest.h>
+
+#import "OCTToxEncryptSave.h"
+
+@interface OCTToxEncryptSaveTests : XCTestCase
+
+@end
+
+@implementation OCTToxEncryptSaveTests
+
+- (void)setUp
+{
+    [super setUp];
+    // Put setup code here. This method is called before the invocation of each test method in the class.
+}
+
+- (void)tearDown
+{
+    // Put teardown code here. This method is called after the invocation of each test method in the class.
+    [super tearDown];
+}
+
+- (void)testClassMethods
+{
+    NSData *data = [@"data" dataUsingEncoding:NSUTF8StringEncoding];
+
+    XCTAssertFalse([OCTToxEncryptSave isDataEncrypted:data]);
+
+    NSData *encrypted = [OCTToxEncryptSave encryptData:data withPassphrase:@"password123" error:nil];
+
+    XCTAssertTrue([OCTToxEncryptSave isDataEncrypted:encrypted]);
+    XCTAssertFalse([data isEqualToData:encrypted]);
+
+    NSData *decrypted = [OCTToxEncryptSave decryptData:encrypted withPassphrase:@"password123" error:nil];
+
+    XCTAssertFalse([OCTToxEncryptSave isDataEncrypted:decrypted]);
+    XCTAssertTrue([data isEqualToData:decrypted]);
+    XCTAssertFalse([encrypted isEqualToData:decrypted]);
+}
+
+- (void)testInstanceMethods
+{
+    OCTToxEncryptSave *save = [[OCTToxEncryptSave alloc] initWithPassphrase:@"p@s$" toxData:nil error:nil];
+
+    XCTAssertNotNil(save);
+
+    NSData *data = [@"data" dataUsingEncoding:NSUTF8StringEncoding];
+
+    XCTAssertFalse([OCTToxEncryptSave isDataEncrypted:data]);
+
+    NSData *encrypted = [save encryptData:data error:nil];
+
+    XCTAssertTrue([OCTToxEncryptSave isDataEncrypted:encrypted]);
+    XCTAssertFalse([data isEqualToData:encrypted]);
+
+    NSData *decrypted = [save decryptData:encrypted error:nil];
+
+    XCTAssertFalse([OCTToxEncryptSave isDataEncrypted:decrypted]);
+    XCTAssertTrue([data isEqualToData:decrypted]);
+    XCTAssertFalse([encrypted isEqualToData:decrypted]);
+
+    save = nil;
+
+    OCTToxEncryptSave *anotherSave = [[OCTToxEncryptSave alloc] initWithPassphrase:@"p@s$" toxData:encrypted error:nil];
+
+    NSData *anotherDecrypted = [anotherSave decryptData:encrypted error:nil];
+
+    XCTAssertFalse([OCTToxEncryptSave isDataEncrypted:anotherDecrypted]);
+    XCTAssertTrue([data isEqualToData:anotherDecrypted]);
+    XCTAssertFalse([encrypted isEqualToData:anotherDecrypted]);
+}
+
+@end

local_pod_repo/objcTox/Tests/OCTToxTests.m

@@ -0,0 +1,784 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#import <Foundation/Foundation.h>
+#import <OCMock/OCMock.h>
+
+#import "OCTTox+Private.h"
+#import "OCTToxOptions.h"
+#import "OCTCAsserts.h"
+
+static void *refToSelf;
+
+void mocked_tox_self_get_public_key(const Tox *tox, uint8_t *public_key);
+
+@interface OCTToxTests : XCTestCase
+
+@property (strong, nonatomic) OCTTox *tox;
+
+@end
+
+@implementation OCTToxTests
+
+- (void)setUp
+{
+    [super setUp];
+    // Put setup code here. This method is called before the invocation of each test method in the class.
+
+    refToSelf = (__bridge void *)(self);
+
+    self.tox = [[OCTTox alloc] initWithOptions:[OCTToxOptions new] savedData:nil error:nil];
+}
+
+- (void)tearDown
+{
+    // Put teardown code here. This method is called after the invocation of each test method in the class.
+    refToSelf = NULL;
+
+    self.tox = nil;
+
+    [super tearDown];
+}
+
+- (void)testInit
+{
+    XCTAssertNotNil(self.tox);
+}
+
+- (void)testSavingAndLoading
+{
+    NSData *data = [self.tox save];
+    XCTAssertNotNil(data);
+
+    OCTTox *tox = [[OCTTox alloc] initWithOptions:[OCTToxOptions new] savedData:data error:nil];
+    XCTAssertNotNil(tox);
+
+    NSData *data2 = [tox save];
+
+    XCTAssertTrue(data.length == data2.length);
+}
+
+- (void)testPublicKey
+{
+    _tox_self_get_public_key = mocked_tox_self_get_public_key;
+
+    NSString *publicKey = [self.tox publicKey];
+
+    XCTAssertEqualObjects(publicKey, @"000102030405060708090A0B0C0D0E0F" @"000102030405060708090A0B0C0D0E0F");
+}
+
+#pragma mark -  Private methods
+
+- (void)testUserStatusFromCUserStatus
+{
+    XCTAssertTrue(OCTToxUserStatusNone == [self.tox userStatusFromCUserStatus:TOX_USER_STATUS_NONE]);
+    XCTAssertTrue(OCTToxUserStatusAway == [self.tox userStatusFromCUserStatus:TOX_USER_STATUS_AWAY]);
+    XCTAssertTrue(OCTToxUserStatusBusy == [self.tox userStatusFromCUserStatus:TOX_USER_STATUS_BUSY]);
+}
+
+- (void)testUserConnectionStatusFromCUserStatus
+{
+    XCTAssertTrue(OCTToxConnectionStatusNone == [self.tox userConnectionStatusFromCUserStatus:TOX_CONNECTION_NONE]);
+    XCTAssertTrue(OCTToxConnectionStatusTCP  == [self.tox userConnectionStatusFromCUserStatus:TOX_CONNECTION_TCP]);
+    XCTAssertTrue(OCTToxConnectionStatusUDP  == [self.tox userConnectionStatusFromCUserStatus:TOX_CONNECTION_UDP]);
+}
+
+- (void)testMessageTypeFromCMessageType
+{
+    XCTAssertTrue(OCTToxMessageTypeNormal == [self.tox messageTypeFromCMessageType:TOX_MESSAGE_TYPE_NORMAL]);
+    XCTAssertTrue(OCTToxMessageTypeAction == [self.tox messageTypeFromCMessageType:TOX_MESSAGE_TYPE_ACTION]);
+}
+
+- (void)testFileControlFromCFileControl
+{
+    XCTAssertTrue(OCTToxFileControlResume == [self.tox fileControlFromCFileControl:TOX_FILE_CONTROL_RESUME]);
+    XCTAssertTrue(OCTToxFileControlPause  == [self.tox fileControlFromCFileControl:TOX_FILE_CONTROL_PAUSE]);
+    XCTAssertTrue(OCTToxFileControlCancel == [self.tox fileControlFromCFileControl:TOX_FILE_CONTROL_CANCEL]);
+}
+
+- (void)testFillErrorInit
+{
+    // test nil error
+    [self.tox fillError:nil withCErrorInit:TOX_ERR_NEW_NULL];
+
+    NSError *error;
+    [self.tox fillError:&error withCErrorInit:TOX_ERR_NEW_OK];
+    XCTAssertNil(error);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorInit:TOX_ERR_NEW_NULL];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorInitCodeUnknown);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorInit:TOX_ERR_NEW_MALLOC];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorInitCodeMemoryError);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorInit:TOX_ERR_NEW_PORT_ALLOC];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorInitCodePortAlloc);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorInit:TOX_ERR_NEW_PROXY_BAD_TYPE];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorInitCodeProxyBadType);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorInit:TOX_ERR_NEW_PROXY_BAD_HOST];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorInitCodeProxyBadHost);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorInit:TOX_ERR_NEW_PROXY_BAD_PORT];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorInitCodeProxyBadPort);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorInit:TOX_ERR_NEW_PROXY_NOT_FOUND];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorInitCodeProxyNotFound);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorInit:TOX_ERR_NEW_LOAD_ENCRYPTED];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorInitCodeEncrypted);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorInit:TOX_ERR_NEW_LOAD_BAD_FORMAT];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorInitCodeLoadBadFormat);
+}
+
+- (void)testFillErrorBootstrap
+{
+    // test nil error
+    [self.tox fillError:nil withCErrorBootstrap:TOX_ERR_BOOTSTRAP_NULL];
+
+    NSError *error;
+    [self.tox fillError:&error withCErrorBootstrap:TOX_ERR_BOOTSTRAP_OK];
+    XCTAssertNil(error);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorBootstrap:TOX_ERR_BOOTSTRAP_NULL];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorBootstrapCodeUnknown);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorBootstrap:TOX_ERR_BOOTSTRAP_BAD_HOST];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorBootstrapCodeBadHost);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorBootstrap:TOX_ERR_BOOTSTRAP_BAD_PORT];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorBootstrapCodeBadPort);
+}
+
+- (void)testFillErrorFriendAdd
+{
+    // test nil error
+    [self.tox fillError:nil withCErrorFriendAdd:TOX_ERR_FRIEND_ADD_NULL];
+
+    NSError *error;
+    [self.tox fillError:&error withCErrorFriendAdd:TOX_ERR_FRIEND_ADD_OK];
+    XCTAssertNil(error);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFriendAdd:TOX_ERR_FRIEND_ADD_NULL];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFriendAddUnknown);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFriendAdd:TOX_ERR_FRIEND_ADD_TOO_LONG];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFriendAddTooLong);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFriendAdd:TOX_ERR_FRIEND_ADD_NO_MESSAGE];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFriendAddNoMessage);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFriendAdd:TOX_ERR_FRIEND_ADD_OWN_KEY];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFriendAddOwnKey);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFriendAdd:TOX_ERR_FRIEND_ADD_ALREADY_SENT];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFriendAddAlreadySent);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFriendAdd:TOX_ERR_FRIEND_ADD_BAD_CHECKSUM];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFriendAddBadChecksum);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFriendAdd:TOX_ERR_FRIEND_ADD_SET_NEW_NOSPAM];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFriendAddSetNewNospam);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFriendAdd:TOX_ERR_FRIEND_ADD_MALLOC];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFriendAddMalloc);
+}
+
+- (void)testFillErrorFriendDelete
+{
+    // test nil error
+    [self.tox fillError:nil withCErrorFriendDelete:TOX_ERR_FRIEND_DELETE_FRIEND_NOT_FOUND];
+
+    NSError *error;
+    [self.tox fillError:&error withCErrorFriendDelete:TOX_ERR_FRIEND_DELETE_OK];
+    XCTAssertNil(error);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFriendDelete:TOX_ERR_FRIEND_DELETE_FRIEND_NOT_FOUND];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFriendDeleteNotFound);
+}
+
+- (void)testFillErrorFriendByPublicKey
+{
+    // test nil error
+    [self.tox fillError:nil withCErrorFriendByPublicKey:TOX_ERR_FRIEND_BY_PUBLIC_KEY_NULL];
+
+    NSError *error;
+    [self.tox fillError:&error withCErrorFriendByPublicKey:TOX_ERR_FRIEND_BY_PUBLIC_KEY_OK];
+    XCTAssertNil(error);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFriendByPublicKey:TOX_ERR_FRIEND_BY_PUBLIC_KEY_NULL];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFriendByPublicKeyUnknown);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFriendByPublicKey:TOX_ERR_FRIEND_BY_PUBLIC_KEY_NOT_FOUND];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFriendByPublicKeyNotFound);
+}
+
+- (void)testFillErrorFriendGetPublicKey
+{
+    // test nil error
+    [self.tox fillError:nil withCErrorFriendGetPublicKey:TOX_ERR_FRIEND_GET_PUBLIC_KEY_FRIEND_NOT_FOUND];
+
+    NSError *error;
+    [self.tox fillError:&error withCErrorFriendGetPublicKey:TOX_ERR_FRIEND_GET_PUBLIC_KEY_OK];
+    XCTAssertNil(error);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFriendGetPublicKey:TOX_ERR_FRIEND_GET_PUBLIC_KEY_FRIEND_NOT_FOUND];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFriendGetPublicKeyFriendNotFound);
+}
+
+- (void)testFillErrorSetInfo
+{
+    // test nil error
+    [self.tox fillError:nil withCErrorSetInfo:TOX_ERR_SET_INFO_NULL];
+
+    NSError *error;
+    [self.tox fillError:&error withCErrorSetInfo:TOX_ERR_SET_INFO_OK];
+    XCTAssertNil(error);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorSetInfo:TOX_ERR_SET_INFO_NULL];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorSetInfoCodeUnknow);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorSetInfo:TOX_ERR_SET_INFO_TOO_LONG];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorSetInfoCodeTooLong);
+}
+
+- (void)testFillErrorFriendGetLastOnline
+{
+    // test nil error
+    [self.tox fillError:nil withCErrorFriendGetLastOnline:TOX_ERR_FRIEND_GET_LAST_ONLINE_FRIEND_NOT_FOUND];
+
+    NSError *error;
+    [self.tox fillError:&error withCErrorFriendGetLastOnline:TOX_ERR_FRIEND_GET_LAST_ONLINE_OK];
+    XCTAssertNil(error);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFriendGetLastOnline:TOX_ERR_FRIEND_GET_LAST_ONLINE_FRIEND_NOT_FOUND];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFriendGetLastOnlineFriendNotFound);
+}
+
+- (void)testFillErrorFriendQuery
+{
+    // test nil error
+    [self.tox fillError:nil withCErrorFriendQuery:TOX_ERR_FRIEND_QUERY_NULL];
+
+    NSError *error;
+    [self.tox fillError:&error withCErrorFriendQuery:TOX_ERR_FRIEND_QUERY_OK];
+    XCTAssertNil(error);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFriendQuery:TOX_ERR_FRIEND_QUERY_NULL];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFriendQueryUnknown);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFriendQuery:TOX_ERR_FRIEND_QUERY_FRIEND_NOT_FOUND];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFriendQueryFriendNotFound);
+}
+
+- (void)testFillErrorSetTyping
+{
+    // test nil error
+    [self.tox fillError:nil withCErrorSetTyping:TOX_ERR_SET_TYPING_FRIEND_NOT_FOUND];
+
+    NSError *error;
+    [self.tox fillError:&error withCErrorSetTyping:TOX_ERR_SET_TYPING_OK];
+    XCTAssertNil(error);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorSetTyping:TOX_ERR_SET_TYPING_FRIEND_NOT_FOUND];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorSetTypingFriendNotFound);
+}
+
+- (void)testFillErrorFriendSendMessage
+{
+    // test nil error
+    [self.tox fillError:nil withCErrorFriendSendMessage:TOX_ERR_FRIEND_SEND_MESSAGE_NULL];
+
+    NSError *error;
+    [self.tox fillError:&error withCErrorFriendSendMessage:TOX_ERR_FRIEND_SEND_MESSAGE_OK];
+    XCTAssertNil(error);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFriendSendMessage:TOX_ERR_FRIEND_SEND_MESSAGE_NULL];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFriendSendMessageUnknown);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFriendSendMessage:TOX_ERR_FRIEND_SEND_MESSAGE_FRIEND_NOT_FOUND];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFriendSendMessageFriendNotFound);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFriendSendMessage:TOX_ERR_FRIEND_SEND_MESSAGE_FRIEND_NOT_CONNECTED];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFriendSendMessageFriendNotConnected);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFriendSendMessage:TOX_ERR_FRIEND_SEND_MESSAGE_SENDQ];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFriendSendMessageAlloc);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFriendSendMessage:TOX_ERR_FRIEND_SEND_MESSAGE_TOO_LONG];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFriendSendMessageTooLong);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFriendSendMessage:TOX_ERR_FRIEND_SEND_MESSAGE_EMPTY];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFriendSendMessageEmpty);
+}
+
+- (void)testFillErrorFileControl
+{
+    // test nil error
+    [self.tox fillError:nil withCErrorFileControl:TOX_ERR_FILE_CONTROL_FRIEND_NOT_FOUND];
+
+    NSError *error;
+    [self.tox fillError:&error withCErrorFileControl:TOX_ERR_FILE_CONTROL_OK];
+    XCTAssertNil(error);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileControl:TOX_ERR_FILE_CONTROL_FRIEND_NOT_FOUND];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileControlFriendNotFound);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileControl:TOX_ERR_FILE_CONTROL_FRIEND_NOT_CONNECTED];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileControlFriendNotConnected);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileControl:TOX_ERR_FILE_CONTROL_NOT_FOUND];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileControlNotFound);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileControl:TOX_ERR_FILE_CONTROL_NOT_PAUSED];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileControlNotPaused);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileControl:TOX_ERR_FILE_CONTROL_DENIED];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileControlDenied);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileControl:TOX_ERR_FILE_CONTROL_ALREADY_PAUSED];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileControlAlreadyPaused);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileControl:TOX_ERR_FILE_CONTROL_SENDQ];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileControlSendq);
+}
+
+- (void)testFillErrorFileSeek
+{
+    // test nil error
+    [self.tox fillError:nil withCErrorFileSeek:TOX_ERR_FILE_SEEK_FRIEND_NOT_FOUND];
+
+    NSError *error;
+    [self.tox fillError:&error withCErrorFileSeek:TOX_ERR_FILE_SEEK_OK];
+    XCTAssertNil(error);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileSeek:TOX_ERR_FILE_SEEK_FRIEND_NOT_FOUND];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileSeekFriendNotFound);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileSeek:TOX_ERR_FILE_SEEK_FRIEND_NOT_CONNECTED];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileSeekFriendNotConnected);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileSeek:TOX_ERR_FILE_SEEK_NOT_FOUND];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileSeekNotFound);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileSeek:TOX_ERR_FILE_SEEK_DENIED];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileSeekDenied);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileSeek:TOX_ERR_FILE_SEEK_INVALID_POSITION];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileSeekInvalidPosition);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileSeek:TOX_ERR_FILE_SEEK_SENDQ];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileSeekSendq);
+}
+
+- (void)testFillErrorFileGet
+{
+    // test nil error
+    [self.tox fillError:nil withCErrorFileGet:TOX_ERR_FILE_GET_FRIEND_NOT_FOUND];
+
+    NSError *error;
+    [self.tox fillError:&error withCErrorFileGet:TOX_ERR_FILE_GET_OK];
+    XCTAssertNil(error);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileGet:TOX_ERR_FILE_GET_NULL];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileGetInternal);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileGet:TOX_ERR_FILE_GET_FRIEND_NOT_FOUND];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileGetFriendNotFound);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileGet:TOX_ERR_FILE_GET_NOT_FOUND];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileGetNotFound);
+}
+
+- (void)testFillErrorFileSend
+{
+    // test nil error
+    [self.tox fillError:nil withCErrorFileSend:TOX_ERR_FILE_SEND_NULL];
+
+    NSError *error;
+    [self.tox fillError:&error withCErrorFileSend:TOX_ERR_FILE_SEND_OK];
+    XCTAssertNil(error);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileSend:TOX_ERR_FILE_SEND_NULL];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileSendUnknown);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileSend:TOX_ERR_FILE_SEND_FRIEND_NOT_FOUND];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileSendFriendNotFound);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileSend:TOX_ERR_FILE_SEND_FRIEND_NOT_CONNECTED];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileSendFriendNotConnected);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileSend:TOX_ERR_FILE_SEND_NAME_TOO_LONG];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileSendNameTooLong);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileSend:TOX_ERR_FILE_SEND_TOO_MANY];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileSendTooMany);
+}
+
+- (void)testFillErrorFileSendChunk
+{
+    // test nil error
+    [self.tox fillError:nil withCErrorFileSendChunk:TOX_ERR_FILE_SEND_CHUNK_NULL];
+
+    NSError *error;
+    [self.tox fillError:&error withCErrorFileSendChunk:TOX_ERR_FILE_SEND_CHUNK_OK];
+    XCTAssertNil(error);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileSendChunk:TOX_ERR_FILE_SEND_CHUNK_NULL];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileSendChunkUnknown);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileSendChunk:TOX_ERR_FILE_SEND_CHUNK_FRIEND_NOT_FOUND];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileSendChunkFriendNotFound);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileSendChunk:TOX_ERR_FILE_SEND_CHUNK_FRIEND_NOT_CONNECTED];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileSendChunkFriendNotConnected);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileSendChunk:TOX_ERR_FILE_SEND_CHUNK_NOT_FOUND];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileSendChunkNotFound);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileSendChunk:TOX_ERR_FILE_SEND_CHUNK_NOT_TRANSFERRING];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileSendChunkNotTransferring);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileSendChunk:TOX_ERR_FILE_SEND_CHUNK_INVALID_LENGTH];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileSendChunkInvalidLength);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileSendChunk:TOX_ERR_FILE_SEND_CHUNK_SENDQ];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileSendChunkSendq);
+
+    error = nil;
+    [self.tox fillError:&error withCErrorFileSendChunk:TOX_ERR_FILE_SEND_CHUNK_WRONG_POSITION];
+    XCTAssertNotNil(error);
+    XCTAssertTrue(error.code == OCTToxErrorFileSendChunkWrongPosition);
+}
+
+- (void)testBinToHexString
+{
+    uint8_t bin[16] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
+    NSString *string = [OCTTox binToHexString:bin length:16];
+
+    XCTAssertTrue([@"000102030405060708090A0B0C0D0E0F" isEqualToString:string]);
+}
+
+- (void)testHexStringToBin
+{
+    uint8_t *bin = [OCTTox hexStringToBin:@"000102030405060708090A0B0C0D0E0F"];
+
+    for (NSUInteger i = 0; i < 16; i++) {
+        XCTAssertTrue(bin[i] == i);
+    }
+}
+
+#pragma mark -  Callbacks
+
+- (void)testConnectionStatusCallback
+{
+    [self makeTestCallbackWithCallBlock:^{
+        connectionStatusCallback(NULL, TOX_CONNECTION_UDP, (__bridge void *)self.tox);
+    } expectBlock:^(id<OCTToxDelegate> delegate) {
+        OCMExpect([self.tox.delegate tox:self.tox connectionStatus:OCTToxConnectionStatusUDP]);
+    }];
+}
+
+- (void)testFriendNameCallback
+{
+    [self makeTestCallbackWithCallBlock:^{
+        friendNameCallback(NULL, 5, (const uint8_t *)"name", 4, (__bridge void *)self.tox);
+    } expectBlock:^(id<OCTToxDelegate> delegate) {
+        OCMExpect([self.tox.delegate tox:self.tox friendNameUpdate:[OCMArg isEqual:@"name"] friendNumber:5]);
+    }];
+}
+
+- (void)testFriendStatusMessageCallback
+{
+    [self makeTestCallbackWithCallBlock:^{
+        friendStatusMessageCallback(NULL, 5, (const uint8_t *)"message", 7, (__bridge void *)self.tox);
+    } expectBlock:^(id<OCTToxDelegate> delegate) {
+        OCMExpect([self.tox.delegate tox:self.tox friendStatusMessageUpdate:[OCMArg isEqual:@"message"] friendNumber:5]);
+    }];
+}
+
+- (void)testFriendStatusCallback
+{
+    [self makeTestCallbackWithCallBlock:^{
+        friendStatusCallback(NULL, 5, TOX_USER_STATUS_BUSY, (__bridge void *)self.tox);
+    } expectBlock:^(id<OCTToxDelegate> delegate) {
+        OCMExpect([self.tox.delegate tox:self.tox friendStatusUpdate:OCTToxUserStatusBusy friendNumber:5]);
+    }];
+}
+
+- (void)testFriendConnectionStatusCallback
+{
+    [self makeTestCallbackWithCallBlock:^{
+        friendConnectionStatusCallback(NULL, 5, TOX_CONNECTION_UDP, (__bridge void *)self.tox);
+    } expectBlock:^(id<OCTToxDelegate> delegate) {
+        OCMExpect([self.tox.delegate tox:self.tox friendConnectionStatusChanged:OCTToxConnectionStatusUDP friendNumber:5]);
+    }];
+}
+
+- (void)testFriendTypingCallback
+{
+    [self makeTestCallbackWithCallBlock:^{
+        friendTypingCallback(NULL, 5, true, (__bridge void *)self.tox);
+    } expectBlock:^(id<OCTToxDelegate> delegate) {
+        OCMExpect([self.tox.delegate tox:self.tox friendIsTypingUpdate:YES friendNumber:5]);
+    }];
+}
+
+- (void)testFriendReadReceiptCallback
+{
+    [self makeTestCallbackWithCallBlock:^{
+        friendReadReceiptCallback(NULL, 5, 7, (__bridge void *)self.tox);
+    } expectBlock:^(id<OCTToxDelegate> delegate) {
+        OCMExpect([self.tox.delegate tox:self.tox messageDelivered:7 friendNumber:5]);
+    }];
+}
+
+- (void)testFriendRequestCallback
+{
+    [self makeTestCallbackWithCallBlock:^{
+        uint8_t bin[32] = {
+            0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+            0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
+        };
+
+        friendRequestCallback(NULL, bin, (const uint8_t *)"message", 7, (__bridge void *)self.tox);
+
+    } expectBlock:^(id<OCTToxDelegate> delegate) {
+        NSString *publicKey =
+            @"000102030405060708090A0B0C0D0E0F"
+            @"000102030405060708090A0B0C0D0E0F";
+
+        OCMExpect([self.tox.delegate tox:self.tox friendRequestWithMessage:[OCMArg isEqual:@"message"] publicKey:publicKey]);
+    }];
+}
+
+- (void)testFriendMessageCallback
+{
+    [self makeTestCallbackWithCallBlock:^{
+        friendMessageCallback(NULL, 5, TOX_MESSAGE_TYPE_ACTION, (const uint8_t *)"message", 7, (__bridge void *)self.tox);
+
+    } expectBlock:^(id<OCTToxDelegate> delegate) {
+        OCMExpect([self.tox.delegate tox:self.tox
+                           friendMessage:[OCMArg isEqual:@"message"]
+                                    type:OCTToxMessageTypeAction
+                            friendNumber:5]);
+    }];
+}
+
+- (void)testFileReceiveControlCallback
+{
+    [self makeTestCallbackWithCallBlock:^{
+        fileReceiveControlCallback(NULL, 5, 4, TOX_FILE_CONTROL_PAUSE, (__bridge void *)self.tox);
+
+    } expectBlock:^(id<OCTToxDelegate> delegate) {
+        OCMExpect([self.tox.delegate tox:self.tox fileReceiveControl:OCTToxFileControlPause friendNumber:5 fileNumber:4]);
+    }];
+}
+
+- (void)testFileChunkRequestCallback
+{
+    [self makeTestCallbackWithCallBlock:^{
+        fileChunkRequestCallback(NULL, 5, 4, 300, 150, (__bridge void *)self.tox);
+
+    } expectBlock:^(id<OCTToxDelegate> delegate) {
+        OCMExpect([self.tox.delegate tox:self.tox fileChunkRequestForFileNumber:4 friendNumber:5 position:300 length:150]);
+    }];
+}
+
+- (void)testFileReceiveCallback
+{
+    [self makeTestCallbackWithCallBlock:^{
+        fileReceiveCallback(NULL, 5, 4, TOX_FILE_KIND_DATA, 500, (const uint8_t *)"filename", 8, (__bridge void *)self.tox);
+
+    } expectBlock:^(id<OCTToxDelegate> delegate) {
+        OCMExpect([self.tox.delegate tox:self.tox
+                   fileReceiveForFileNumber:4
+                               friendNumber:5
+                                       kind:OCTToxFileKindData
+                                   fileSize:500
+                                   fileName:[OCMArg isEqual:@"filename"]]);
+    }];
+}
+
+- (void)testFileReceiveChunkCallback
+{
+    [self makeTestCallbackWithCallBlock:^{
+        fileReceiveChunkCallback(NULL, 5, 4, 250, (const uint8_t *)"data", 4, (__bridge void *)self.tox);
+
+    } expectBlock:^(id<OCTToxDelegate> delegate) {
+        NSData *data = [NSData dataWithBytes:"data" length:4];
+
+        OCMExpect([self.tox.delegate tox:self.tox
+                        fileReceiveChunk:[OCMArg isEqual:data]
+                              fileNumber:4
+                            friendNumber:5
+                                position:250]);
+    }];
+}
+
+- (void)makeTestCallbackWithCallBlock:(void (^)())callBlock expectBlock:(void (^)(id<OCTToxDelegate> delegate))expectBlock
+{
+    NSParameterAssert(callBlock);
+    NSParameterAssert(expectBlock);
+
+    self.tox.delegate = OCMProtocolMock(@protocol(OCTToxDelegate));
+    expectBlock(self.tox.delegate);
+
+    callBlock();
+
+    XCTestExpectation *expectation = [self expectationWithDescription:@"callback"];
+
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 0.1 * NSEC_PER_SEC), dispatch_get_main_queue(), ^{
+        [expectation fulfill];
+    });
+
+    [self waitForExpectationsWithTimeout:1.0 handler:nil];
+    OCMVerifyAll((id)self.tox.delegate);
+}
+
+void mocked_tox_self_get_public_key(const Tox *cTox, uint8_t *public_key)
+{
+    OCTTox *tox = [(__bridge OCTToxTests *)refToSelf tox];
+
+    CCCAssertTrue(cTox == tox.tox);
+
+    uint8_t bin[32] = {
+        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
+    };
+
+    memcpy(public_key, bin, TOX_PUBLIC_KEY_SIZE);
+}
+
+@end

local_pod_repo/objcTox/Tests/OCTVideoEngineTests.m

@@ -0,0 +1,235 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#import <XCTest/XCTest.h>
+#import <OCMock/OCMock.h>
+#import "OCTVideoEngine.h"
+#import "OCTPixelBufferPool.h"
+#import "OCTVideoView.h"
+#import "OCTToxAV.h"
+
+#include "test_straight3p.h"
+#include "test_stride13p.h"
+#include "test_backwards_3p.h"
+#include "test_backwards_stride13p.h"
+#include "test_good.h"
+
+@import AVFoundation;
+
+@interface OCTVideoEngine (Testing)
+
+@property (nonatomic, strong) AVCaptureSession *captureSession;
+@property (nonatomic, strong) dispatch_queue_t processingQueue;
+@property (nonatomic, weak) OCTVideoView *videoView;
+@property (strong, nonatomic) OCTPixelBufferPool *pixelPool;
+
+- (void)captureOutput:(AVCaptureOutput *)captureOutput didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer fromConnection:(AVCaptureConnection *)connection;
+
+@end
+
+@interface OCTVideoEngineTests : XCTestCase
+
+@property (strong, nonatomic) OCTVideoEngine *videoEngine;
+@property (strong, nonatomic) id mockedToxAV;
+@property (strong, nonatomic) id mockedCaptureSession;
+
+@end
+
+@implementation OCTVideoEngineTests
+
+- (void)setUp
+{
+    [super setUp];
+    self.videoEngine = [OCTVideoEngine new];
+    self.mockedToxAV = OCMClassMock([OCTToxAV class]);
+    self.videoEngine.toxav = self.mockedToxAV;
+    self.mockedCaptureSession = OCMClassMock([AVCaptureSession class]);
+    self.videoEngine.captureSession = self.mockedCaptureSession;
+
+    // Put setup code here. This method is called before the invocation of each test method in the class.
+}
+
+- (void)tearDown
+{
+    // Put teardown code here. This method is called after the invocation of each test method in the class.
+    [self.mockedToxAV stopMocking];
+    self.mockedToxAV = nil;
+    [self.mockedCaptureSession stopMocking];
+    self.mockedCaptureSession = nil;
+    self.videoEngine = nil;
+    [super tearDown];
+}
+
+- (void)testInit
+{
+    XCTAssertNotNil(self.videoEngine);
+}
+
+- (void)testStartSendingVideo
+{
+    OCMStub([self.mockedCaptureSession isRunning]).andReturn(NO);
+
+    [self.videoEngine startSendingVideo];
+
+    dispatch_sync(self.videoEngine.processingQueue, ^{
+        OCMVerify([self.mockedCaptureSession startRunning]);
+    });
+}
+
+- (void)testStopSendingVideo
+{
+    OCMStub([self.mockedCaptureSession isRunning]).andReturn(YES);
+
+    [self.videoEngine stopSendingVideo];
+
+    dispatch_sync(self.videoEngine.processingQueue, ^{
+        OCMVerify([self.mockedCaptureSession stopRunning]);
+    });
+}
+
+- (void)testIsSendingVideo
+{
+    OCMStub([self.mockedCaptureSession isRunning]).andReturn(YES);
+
+    XCTAssertTrue([self.videoEngine isSendingVideo]);
+}
+
+- (void)testGetVideoCallPreview
+{
+    id mockedCapturePreviewLayer = OCMClassMock([AVCaptureVideoPreviewLayer class]);
+    OCMStub([mockedCapturePreviewLayer layerWithSession:self.mockedCaptureSession]).andReturn(mockedCapturePreviewLayer);
+
+    dispatch_sync(self.videoEngine.processingQueue, ^{
+        [self.videoEngine getVideoCallPreview:^(CALayer *layer) {
+            XCTAssertEqualObjects(layer, mockedCapturePreviewLayer);
+        }];
+    });
+}
+
+- (void)testVideoFeed
+{
+    id mockedVideoView = OCMClassMock([OCTVideoView class]);
+    OCMStub([mockedVideoView view]).andReturn(mockedVideoView);
+
+    OCTView *view = [self.videoEngine videoFeed];
+
+    XCTAssertEqualObjects(view, mockedVideoView);
+}
+
+- (void)testReceiveVideoFrame
+{
+    OCTToxAVVideoWidth width = 10;
+    OCTToxAVVideoHeight height = 10;
+
+    id mockedPixelPool = OCMClassMock([OCTPixelBufferPool class]);
+    self.videoEngine.pixelPool = mockedPixelPool;
+
+    OCMStub([mockedPixelPool createPixelBuffer:[OCMArg anyPointer] width:10 height:10]).andReturn(NO);
+
+    self.videoEngine.videoView = OCMClassMock([OCTVideoView class]);
+
+    [self.videoEngine receiveVideoFrameWithWidth:width
+                                          height:height
+                                          yPlane:nil
+                                          uPlane:nil
+                                          vPlane:nil
+                                         yStride:10
+                                         uStride:10
+                                         vStride:10
+                                    friendNumber:10];
+
+    dispatch_sync(self.videoEngine.processingQueue, ^{
+        OCMVerify([mockedPixelPool createPixelBuffer:[OCMArg anyPointer]
+                                               width:width
+                                              height:height]);
+    });
+}
+
+- (void)performYUVCheckWithPlanes:(uint8_t * [3])planes strides:(OCTToxAVStrideData[3])strides
+{
+    OCTToxAVVideoWidth width = 30;
+    OCTToxAVVideoHeight height = 30;
+    self.videoEngine.videoView = OCMClassMock([OCTVideoView class]);
+    id ciMock = OCMClassMock([CIImage class]);
+
+    OCMStub([ciMock imageWithCVPixelBuffer:[OCMArg anyPointer]]).andDo(^(NSInvocation *invocation) {
+        CVPixelBufferRef pb = NULL;
+        [invocation getArgument:&pb atIndex:2];
+
+        XCTAssertNotNil((__bridge id)pb);
+        XCTAssertEqual(CVPixelBufferGetPixelFormatType(pb), kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange);
+
+        // now we compare the buffer contents with the known good result
+        CVPixelBufferLockBaseAddress(pb, kCVPixelBufferLock_ReadOnly);
+        uint8_t *y = CVPixelBufferGetBaseAddressOfPlane(pb, 0);
+        uint8_t *uv = CVPixelBufferGetBaseAddressOfPlane(pb, 1);
+
+        uint8_t *testyrow = y;
+        uint8_t *goodyrow = test_good_y;
+        for (int i = 0; i < 30; ++i) {
+            XCTAssertEqual(memcmp(testyrow, goodyrow, 30), 0);
+            testyrow += CVPixelBufferGetBytesPerRowOfPlane(pb, 0);
+            goodyrow += 30;
+        }
+
+        uint8_t *testuvrow = uv;
+        uint8_t *gooduvrow = test_good_uv;
+        for (int i = 0; i < 15; ++i) {
+            XCTAssertEqual(memcmp(testuvrow, gooduvrow, 30), 0);
+            testuvrow += CVPixelBufferGetBytesPerRowOfPlane(pb, 1);
+            gooduvrow += 30;
+        }
+
+        void *ret = nil;
+        [invocation setReturnValue:&ret];
+    });
+
+    [self.videoEngine receiveVideoFrameWithWidth:width
+                                          height:height
+                                          yPlane:planes[0]
+                                          uPlane:planes[1]
+                                          vPlane:planes[2]
+                                         yStride:strides[0]
+                                         uStride:strides[1]
+                                         vStride:strides[2]
+                                    friendNumber:10];
+
+    dispatch_sync(self.videoEngine.processingQueue, ^{
+        OCMVerify([ciMock imageWithCVPixelBuffer:[OCMArg anyPointer]]);
+    });
+}
+
+- (void)testReceivePackedVideoFrame
+{
+    uint8_t *planes[3] = {test_str83p_y, test_str83p_u, test_str83p_v};
+    OCTToxAVStrideData strides[3] = {30, 15, 15};
+
+    [self performYUVCheckWithPlanes:planes strides:strides];
+}
+
+- (void)testReceiveStridedVideoFrame
+{
+    uint8_t *planes[3] = {test_stride13p_y, test_stride13p_u, test_stride13p_v};
+    OCTToxAVStrideData strides[3] = {31, 16, 16};
+
+    [self performYUVCheckWithPlanes:planes strides:strides];
+}
+
+- (void)testReceiveUpsideDownStridedVideoFrame
+{
+    uint8_t *planes[3] = {test_backwards_stride13p_y, test_backwards_stride13p_u, test_backwards_stride13p_v};
+    OCTToxAVStrideData strides[3] = {-31, -16, -16};
+
+    [self performYUVCheckWithPlanes:planes strides:strides];
+}
+
+- (void)testReceiveUpsideDownVideoFrame
+{
+    uint8_t *planes[3] = {test_backwards_3p_y, test_backwards_3p_u, test_backwards_3p_v};
+    OCTToxAVStrideData strides[3] = {-30, -15, -15};
+
+    [self performYUVCheckWithPlanes:planes strides:strides];
+}
+
+@end

local_pod_repo/objcTox/Tests/YUVPlanes/test_backwards_3p.h

@@ -0,0 +1,77 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/*
+ * Tri-planar 30x30 YUV stream but backwards
+ * (negative strides)
+ */
+
+uint8_t test_backwards_3p_y[] = {
+    186, 173, 174, 174, 203, 211, 196, 188, 188, 182, 168, 203, 171, 180, 210, 194, 190, 173, 179, 194, 191, 160, 125, 129, 171, 146,  76,  61, 128, 205,
+    214, 188, 184, 204, 211, 182, 208, 208, 181, 180, 176, 200, 168, 181, 188, 211, 194, 181, 168, 145, 154, 181, 195, 208, 207, 206, 198, 148,  86, 112,
+    213, 211, 211, 209, 184, 181, 195, 196, 194, 179, 176, 196, 172, 155, 187, 211, 201, 167, 163, 176, 204, 206, 206, 206, 206, 205, 204, 203, 203, 147,
+    202, 209, 208, 203, 190, 190, 180, 182, 199, 174, 176, 197, 160, 146, 193, 200, 167, 185, 204, 204, 204, 204, 205, 205, 205, 203, 203, 202, 201, 201,
+    207, 208, 207, 206, 194, 182, 185, 186, 194, 171, 175, 203, 161, 148, 208, 171, 166, 203, 203, 203, 203, 197, 184, 186, 189, 189, 186, 188, 197, 201,
+    209, 201, 200, 205, 203, 189, 187, 193, 201, 174, 171, 202, 157, 160, 208, 176, 199, 202, 202, 202, 202, 195, 183, 194, 198, 196, 189, 182, 178, 192,
+    195, 191, 193, 195, 204, 203, 196, 197, 201, 183, 171, 200, 153, 165, 207, 183, 196, 196, 195, 201, 202, 202, 202, 202, 201, 201, 200, 199, 198, 199,
+    194, 195, 196, 196, 198, 203, 202, 200, 201, 180, 168, 200, 153, 177, 198, 175, 170, 167, 168, 179, 200, 201, 202, 202, 201, 200, 199, 198, 181, 176,
+    202, 201, 201, 202, 201, 200, 201, 201, 201, 178, 165, 200, 160, 168, 199, 188, 167, 173, 173, 186, 198, 201, 198, 183, 197, 200, 199, 198, 172, 157,
+    207, 204,  59, 203,  58, 201, 201, 201, 200, 187, 173, 200, 146, 153, 207, 160, 172, 199, 179, 198, 200, 201, 197, 184, 198, 200, 199, 198, 198, 188,
+    208, 205, 204, 203, 203, 202, 201, 200, 200, 189, 188, 174, 125, 138, 187, 156, 170, 192, 166, 191, 200, 201, 201, 201, 200, 199, 199, 198, 198, 196,
+    208, 205,  59, 203,  57, 202, 201, 201, 195, 161, 178, 181, 150, 131, 190, 171, 168, 178, 145, 179, 195, 199, 200, 199, 199, 199, 197, 196, 193, 169,
+    207, 204,  58, 203,  56, 201, 200, 200, 185, 146, 182, 193, 132, 185, 206, 146, 174, 178,  85,  75, 147, 203, 204, 204, 203, 201, 201, 202, 186, 130,
+    209, 206,  60, 204,  58, 203, 202, 201, 176, 157, 200, 181, 137, 198, 200, 154, 160, 106,  61,  60, 136, 206, 206, 207, 207, 204, 205, 198, 199,  94,
+    216, 212, 213, 212, 210, 211, 210, 208, 182, 168, 208, 179, 158, 206, 181, 148, 179,  66,  69, 129, 200, 208, 207, 209, 208, 202, 167, 170, 148,  62,
+    209, 205,  60, 203, 203,  57, 201, 200, 174, 166, 200, 177, 177, 202, 196, 113, 180, 120,  56, 109, 201, 201, 201, 202, 193, 166, 133, 184, 160,  65,
+    207, 204,  58, 202,  57, 200, 195, 191, 182, 189, 198, 188, 194, 201, 207, 137, 117, 159, 122,  91, 165, 200, 198, 165, 171, 182, 158, 162, 215, 116,
+    208, 204,  58,  57, 202, 201, 188, 177, 179, 198, 199, 198, 200, 200, 196, 196, 165, 126, 147, 140, 171, 200, 169, 139, 197, 200, 151, 164, 151, 132,
+    208, 204,  58, 203,  57, 201, 194, 184, 169, 185, 199, 192, 197, 202, 207, 200, 185, 190, 187, 200, 200, 200, 147, 168, 200, 187, 154, 180, 162, 107,
+    208, 204,  59, 203, 202,  56, 196, 179, 172, 186, 199, 187, 191, 201, 207, 206, 178, 180, 200, 200, 200, 182, 148, 190, 200, 173, 154, 194, 168, 159,
+    208, 204, 203, 203, 202, 201, 197, 184, 177, 190, 199, 192, 192, 201, 207, 199, 189, 174, 196, 200, 194, 161, 177, 201, 199, 178, 181, 192, 158, 180,
+    207, 204, 203,  57,  56, 201, 200, 192, 178, 169, 199, 198, 201, 203, 207, 201, 184, 165, 172, 194, 179, 170, 196, 201, 198, 192, 200, 171, 178, 199,
+    207, 204,  58, 203, 202,  56, 200, 185, 193, 176, 185, 198, 200, 200, 206, 205, 198, 181, 163, 184, 175, 193, 200, 201, 198, 196, 198, 159, 184, 183,
+    208, 204,  59, 203, 202,  56, 201, 194, 185, 199, 190, 199, 201, 202, 207, 206, 197, 200, 179, 174, 180, 201, 201, 201, 200, 201, 193, 167, 188, 171,
+    208, 205,  58, 203, 202,  56, 200, 200, 181, 186, 199, 199, 202, 203, 208, 207, 197, 200, 189, 155, 187, 201, 201, 202, 201, 201, 187, 171, 199, 188,
+    208, 204,  59, 202, 202,  56, 200, 200, 195, 169, 193, 199, 200, 199, 206, 206, 198, 200, 201, 154, 174, 201, 202, 202, 202, 201, 192, 184, 200, 196,
+    207, 203, 202,  56,  56, 200, 199, 199, 199, 181, 184, 197, 199, 202, 206, 205, 196, 199, 199, 183, 182, 200, 201, 202, 201, 200, 195, 195, 199, 200,
+    205, 201, 200, 199, 199, 198, 198, 197, 196, 192, 178, 195, 198, 201, 205, 204, 191, 195, 198, 198, 199, 199, 199, 200, 200, 200, 190, 191, 198, 200,
+    200, 199, 199, 198, 198, 196, 196, 195, 195, 195, 180, 179, 196, 198, 204, 201, 209, 210, 194, 197, 197, 198, 199, 199, 199, 199, 181, 187, 198, 197,
+    204, 201, 199, 198, 197, 197, 196, 196, 195, 195, 194, 176, 189, 191, 206, 206, 204, 206, 195, 197, 198, 199, 199, 200, 200, 200, 187, 193, 199, 199,
+};
+
+uint8_t test_backwards_3p_u[] = {
+    99,  99,  99, 101, 105, 110, 117, 124, 130, 137, 144, 151, 153, 154, 155,
+    100, 101, 101, 102, 107, 112, 118, 125, 131, 139, 146, 152, 155, 156, 156,
+    101, 101, 102, 103, 107, 112, 120, 127, 134, 140, 147, 154, 156, 157, 157,
+    101, 102, 102, 103, 108, 113, 120, 127, 134, 141, 148, 155, 157, 158, 158,
+    101, 102, 102, 103, 108, 114, 120, 127, 134, 141, 148, 155, 158, 158, 158,
+    101, 101, 102, 103, 108, 113, 120, 127, 134, 142, 148, 156, 158, 159, 159,
+    101, 102, 102, 103, 107, 114, 120, 127, 134, 140, 146, 153, 155, 155, 157,
+    103, 104, 104, 105, 109, 114, 121, 127, 134, 141, 147, 153, 155, 156, 151,
+    101, 100, 101, 103, 107, 113, 120, 127, 134, 141, 148, 155, 158, 158, 156,
+    101, 101, 102, 102, 107, 114, 120, 128, 135, 141, 148, 155, 157, 158, 159,
+    101, 101, 101, 103, 108, 114, 121, 127, 134, 141, 148, 155, 157, 158, 158,
+    101, 101, 101, 103, 108, 114, 121, 127, 134, 141, 148, 155, 157, 158, 158,
+    102, 102, 102, 103, 108, 113, 121, 127, 134, 141, 148, 155, 157, 157, 158,
+    103, 103, 103, 104, 109, 115, 122, 128, 136, 142, 149, 156, 157, 158, 158,
+    104, 105, 105, 106, 111, 117, 124, 130, 135, 143, 150, 156, 158, 158, 158,
+};
+
+uint8_t test_backwards_3p_v[] = {
+    90,  91,  91,  92,  92,  93,  92,  97,  93,  94,  95,  95,  96,  97,  98,
+    92,  92,  94,  94,  94,  95,  94,  99,  94,  95,  96,  96,  97,  98,  99,
+    95,  95,  96,  97,  98,  97,  97, 102,  98,  98,  99,  99, 100, 101, 103,
+    100, 101, 101, 103, 103, 103, 103, 106, 103, 104, 103, 104, 105, 105, 107,
+    105, 106, 108, 108, 109, 109, 109, 111, 109, 109, 110, 110, 110, 112, 112,
+    112, 113, 114, 115, 116, 116, 115, 117, 115, 116, 116, 116, 117, 118, 118,
+    119, 120, 121, 122, 122, 122, 123, 123, 123, 123, 123, 122, 124, 124, 125,
+    126, 127, 128, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 131, 131,
+    132, 133, 135, 135, 136, 136, 136, 135, 136, 136, 136, 136, 137, 137, 137,
+    139, 140, 141, 142, 143, 143, 142, 141, 143, 143, 143, 142, 143, 144, 145,
+    145, 147, 148, 149, 150, 150, 149, 147, 150, 150, 150, 149, 150, 151, 151,
+    152, 154, 155, 156, 157, 157, 156, 153, 157, 156, 156, 155, 157, 157, 158,
+    159, 161, 162, 163, 164, 164, 162, 159, 165, 163, 163, 163, 163, 164, 164,
+    163, 164, 165, 167, 167, 167, 166, 162, 169, 167, 166, 165, 166, 166, 166,
+    164, 166, 167, 168, 168, 169, 169, 162, 160, 168, 167, 166, 166, 166, 167,
+};

local_pod_repo/objcTox/Tests/YUVPlanes/test_backwards_stride13p.h

@@ -0,0 +1,77 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/*
+ * Tri-planar 30x30 YUV stream with 1 extra padding per row, but backwards
+ * (negative strides)
+ */
+
+uint8_t test_backwards_stride13p_y[] = {
+    186, 173, 174, 174, 203, 211, 196, 188, 188, 182, 168, 203, 171, 180, 210, 194, 190, 173, 179, 194, 191, 160, 125, 129, 171, 146,  76,  61, 128, 205, 126,
+    214, 188, 184, 204, 211, 182, 208, 208, 181, 180, 176, 200, 168, 181, 188, 211, 194, 181, 168, 145, 154, 181, 195, 208, 207, 206, 198, 148,  86, 112, 117,
+    213, 211, 211, 209, 184, 181, 195, 196, 194, 179, 176, 196, 172, 155, 187, 211, 201, 167, 163, 176, 204, 206, 206, 206, 206, 205, 204, 203, 203, 147, 102,
+    202, 209, 208, 203, 190, 190, 180, 182, 199, 174, 176, 197, 160, 146, 193, 200, 167, 185, 204, 204, 204, 204, 205, 205, 205, 203, 203, 202, 201, 201,  97,
+    207, 208, 207, 206, 194, 182, 185, 186, 194, 171, 175, 203, 161, 148, 208, 171, 166, 203, 203, 203, 203, 197, 184, 186, 189, 189, 186, 188, 197, 201, 119,
+    209, 201, 200, 205, 203, 189, 187, 193, 201, 174, 171, 202, 157, 160, 208, 176, 199, 202, 202, 202, 202, 195, 183, 194, 198, 196, 189, 182, 178, 192, 126,
+    195, 191, 193, 195, 204, 203, 196, 197, 201, 183, 171, 200, 153, 165, 207, 183, 196, 196, 195, 201, 202, 202, 202, 202, 201, 201, 200, 199, 198, 199, 117,
+    194, 195, 196, 196, 198, 203, 202, 200, 201, 180, 168, 200, 153, 177, 198, 175, 170, 167, 168, 179, 200, 201, 202, 202, 201, 200, 199, 198, 181, 176, 102,
+    202, 201, 201, 202, 201, 200, 201, 201, 201, 178, 165, 200, 160, 168, 199, 188, 167, 173, 173, 186, 198, 201, 198, 183, 197, 200, 199, 198, 172, 157,  97,
+    207, 204,  59, 203,  58, 201, 201, 201, 200, 187, 173, 200, 146, 153, 207, 160, 172, 199, 179, 198, 200, 201, 197, 184, 198, 200, 199, 198, 198, 188, 119,
+    208, 205, 204, 203, 203, 202, 201, 200, 200, 189, 188, 174, 125, 138, 187, 156, 170, 192, 166, 191, 200, 201, 201, 201, 200, 199, 199, 198, 198, 196, 126,
+    208, 205,  59, 203,  57, 202, 201, 201, 195, 161, 178, 181, 150, 131, 190, 171, 168, 178, 145, 179, 195, 199, 200, 199, 199, 199, 197, 196, 193, 169, 117,
+    207, 204,  58, 203,  56, 201, 200, 200, 185, 146, 182, 193, 132, 185, 206, 146, 174, 178,  85,  75, 147, 203, 204, 204, 203, 201, 201, 202, 186, 130, 102,
+    209, 206,  60, 204,  58, 203, 202, 201, 176, 157, 200, 181, 137, 198, 200, 154, 160, 106,  61,  60, 136, 206, 206, 207, 207, 204, 205, 198, 199,  94,  97,
+    216, 212, 213, 212, 210, 211, 210, 208, 182, 168, 208, 179, 158, 206, 181, 148, 179,  66,  69, 129, 200, 208, 207, 209, 208, 202, 167, 170, 148,  62, 119,
+    209, 205,  60, 203, 203,  57, 201, 200, 174, 166, 200, 177, 177, 202, 196, 113, 180, 120,  56, 109, 201, 201, 201, 202, 193, 166, 133, 184, 160,  65, 126,
+    207, 204,  58, 202,  57, 200, 195, 191, 182, 189, 198, 188, 194, 201, 207, 137, 117, 159, 122,  91, 165, 200, 198, 165, 171, 182, 158, 162, 215, 116, 117,
+    208, 204,  58,  57, 202, 201, 188, 177, 179, 198, 199, 198, 200, 200, 196, 196, 165, 126, 147, 140, 171, 200, 169, 139, 197, 200, 151, 164, 151, 132, 102,
+    208, 204,  58, 203,  57, 201, 194, 184, 169, 185, 199, 192, 197, 202, 207, 200, 185, 190, 187, 200, 200, 200, 147, 168, 200, 187, 154, 180, 162, 107,  97,
+    208, 204,  59, 203, 202,  56, 196, 179, 172, 186, 199, 187, 191, 201, 207, 206, 178, 180, 200, 200, 200, 182, 148, 190, 200, 173, 154, 194, 168, 159, 119,
+    208, 204, 203, 203, 202, 201, 197, 184, 177, 190, 199, 192, 192, 201, 207, 199, 189, 174, 196, 200, 194, 161, 177, 201, 199, 178, 181, 192, 158, 180, 126,
+    207, 204, 203,  57,  56, 201, 200, 192, 178, 169, 199, 198, 201, 203, 207, 201, 184, 165, 172, 194, 179, 170, 196, 201, 198, 192, 200, 171, 178, 199, 117,
+    207, 204,  58, 203, 202,  56, 200, 185, 193, 176, 185, 198, 200, 200, 206, 205, 198, 181, 163, 184, 175, 193, 200, 201, 198, 196, 198, 159, 184, 183, 102,
+    208, 204,  59, 203, 202,  56, 201, 194, 185, 199, 190, 199, 201, 202, 207, 206, 197, 200, 179, 174, 180, 201, 201, 201, 200, 201, 193, 167, 188, 171,  97,
+    208, 205,  58, 203, 202,  56, 200, 200, 181, 186, 199, 199, 202, 203, 208, 207, 197, 200, 189, 155, 187, 201, 201, 202, 201, 201, 187, 171, 199, 188, 119,
+    208, 204,  59, 202, 202,  56, 200, 200, 195, 169, 193, 199, 200, 199, 206, 206, 198, 200, 201, 154, 174, 201, 202, 202, 202, 201, 192, 184, 200, 196, 126,
+    207, 203, 202,  56,  56, 200, 199, 199, 199, 181, 184, 197, 199, 202, 206, 205, 196, 199, 199, 183, 182, 200, 201, 202, 201, 200, 195, 195, 199, 200, 117,
+    205, 201, 200, 199, 199, 198, 198, 197, 196, 192, 178, 195, 198, 201, 205, 204, 191, 195, 198, 198, 199, 199, 199, 200, 200, 200, 190, 191, 198, 200, 102,
+    200, 199, 199, 198, 198, 196, 196, 195, 195, 195, 180, 179, 196, 198, 204, 201, 209, 210, 194, 197, 197, 198, 199, 199, 199, 199, 181, 187, 198, 197,  97,
+    204, 201, 199, 198, 197, 197, 196, 196, 195, 195, 194, 176, 189, 191, 206, 206, 204, 206, 195, 197, 198, 199, 199, 200, 200, 200, 187, 193, 199, 199, 119,
+};
+
+uint8_t test_backwards_stride13p_u[] = {
+    99,  99,  99, 101, 105, 110, 117, 124, 130, 137, 144, 151, 153, 154, 155, 126,
+    100, 101, 101, 102, 107, 112, 118, 125, 131, 139, 146, 152, 155, 156, 156, 117,
+    101, 101, 102, 103, 107, 112, 120, 127, 134, 140, 147, 154, 156, 157, 157, 102,
+    101, 102, 102, 103, 108, 113, 120, 127, 134, 141, 148, 155, 157, 158, 158,  97,
+    101, 102, 102, 103, 108, 114, 120, 127, 134, 141, 148, 155, 158, 158, 158, 119,
+    101, 101, 102, 103, 108, 113, 120, 127, 134, 142, 148, 156, 158, 159, 159, 126,
+    101, 102, 102, 103, 107, 114, 120, 127, 134, 140, 146, 153, 155, 155, 157, 117,
+    103, 104, 104, 105, 109, 114, 121, 127, 134, 141, 147, 153, 155, 156, 151, 102,
+    101, 100, 101, 103, 107, 113, 120, 127, 134, 141, 148, 155, 158, 158, 156,  97,
+    101, 101, 102, 102, 107, 114, 120, 128, 135, 141, 148, 155, 157, 158, 159, 119,
+    101, 101, 101, 103, 108, 114, 121, 127, 134, 141, 148, 155, 157, 158, 158, 126,
+    101, 101, 101, 103, 108, 114, 121, 127, 134, 141, 148, 155, 157, 158, 158, 117,
+    102, 102, 102, 103, 108, 113, 121, 127, 134, 141, 148, 155, 157, 157, 158, 102,
+    103, 103, 103, 104, 109, 115, 122, 128, 136, 142, 149, 156, 157, 158, 158,  97,
+    104, 105, 105, 106, 111, 117, 124, 130, 135, 143, 150, 156, 158, 158, 158, 119,
+};
+
+uint8_t test_backwards_stride13p_v[] = {
+    90,  91,  91,  92,  92,  93,  92,  97,  93,  94,  95,  95,  96,  97,  98, 126,
+    92,  92,  94,  94,  94,  95,  94,  99,  94,  95,  96,  96,  97,  98,  99, 117,
+    95,  95,  96,  97,  98,  97,  97, 102,  98,  98,  99,  99, 100, 101, 103, 102,
+    100, 101, 101, 103, 103, 103, 103, 106, 103, 104, 103, 104, 105, 105, 107,  97,
+    105, 106, 108, 108, 109, 109, 109, 111, 109, 109, 110, 110, 110, 112, 112, 119,
+    112, 113, 114, 115, 116, 116, 115, 117, 115, 116, 116, 116, 117, 118, 118, 126,
+    119, 120, 121, 122, 122, 122, 123, 123, 123, 123, 123, 122, 124, 124, 125, 117,
+    126, 127, 128, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 131, 131, 102,
+    132, 133, 135, 135, 136, 136, 136, 135, 136, 136, 136, 136, 137, 137, 137,  97,
+    139, 140, 141, 142, 143, 143, 142, 141, 143, 143, 143, 142, 143, 144, 145, 119,
+    145, 147, 148, 149, 150, 150, 149, 147, 150, 150, 150, 149, 150, 151, 151, 126,
+    152, 154, 155, 156, 157, 157, 156, 153, 157, 156, 156, 155, 157, 157, 158, 117,
+    159, 161, 162, 163, 164, 164, 162, 159, 165, 163, 163, 163, 163, 164, 164, 102,
+    163, 164, 165, 167, 167, 167, 166, 162, 169, 167, 166, 165, 166, 166, 166,  97,
+    164, 166, 167, 168, 168, 169, 169, 162, 160, 168, 167, 166, 166, 166, 167, 119,
+};

local_pod_repo/objcTox/Tests/YUVPlanes/test_good.h

@@ -0,0 +1,54 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+uint8_t test_good_y[] = {
+    204, 201, 199, 198, 197, 197, 196, 196, 195, 195, 194, 176, 189, 191, 206, 206, 204, 206, 195, 197, 198, 199, 199, 200, 200, 200, 187, 193, 199, 199,
+    200, 199, 199, 198, 198, 196, 196, 195, 195, 195, 180, 179, 196, 198, 204, 201, 209, 210, 194, 197, 197, 198, 199, 199, 199, 199, 181, 187, 198, 197,
+    205, 201, 200, 199, 199, 198, 198, 197, 196, 192, 178, 195, 198, 201, 205, 204, 191, 195, 198, 198, 199, 199, 199, 200, 200, 200, 190, 191, 198, 200,
+    207, 203, 202,  56,  56, 200, 199, 199, 199, 181, 184, 197, 199, 202, 206, 205, 196, 199, 199, 183, 182, 200, 201, 202, 201, 200, 195, 195, 199, 200,
+    208, 204,  59, 202, 202,  56, 200, 200, 195, 169, 193, 199, 200, 199, 206, 206, 198, 200, 201, 154, 174, 201, 202, 202, 202, 201, 192, 184, 200, 196,
+    208, 205,  58, 203, 202,  56, 200, 200, 181, 186, 199, 199, 202, 203, 208, 207, 197, 200, 189, 155, 187, 201, 201, 202, 201, 201, 187, 171, 199, 188,
+    208, 204,  59, 203, 202,  56, 201, 194, 185, 199, 190, 199, 201, 202, 207, 206, 197, 200, 179, 174, 180, 201, 201, 201, 200, 201, 193, 167, 188, 171,
+    207, 204,  58, 203, 202,  56, 200, 185, 193, 176, 185, 198, 200, 200, 206, 205, 198, 181, 163, 184, 175, 193, 200, 201, 198, 196, 198, 159, 184, 183,
+    207, 204, 203,  57,  56, 201, 200, 192, 178, 169, 199, 198, 201, 203, 207, 201, 184, 165, 172, 194, 179, 170, 196, 201, 198, 192, 200, 171, 178, 199,
+    208, 204, 203, 203, 202, 201, 197, 184, 177, 190, 199, 192, 192, 201, 207, 199, 189, 174, 196, 200, 194, 161, 177, 201, 199, 178, 181, 192, 158, 180,
+    208, 204,  59, 203, 202,  56, 196, 179, 172, 186, 199, 187, 191, 201, 207, 206, 178, 180, 200, 200, 200, 182, 148, 190, 200, 173, 154, 194, 168, 159,
+    208, 204,  58, 203,  57, 201, 194, 184, 169, 185, 199, 192, 197, 202, 207, 200, 185, 190, 187, 200, 200, 200, 147, 168, 200, 187, 154, 180, 162, 107,
+    208, 204,  58,  57, 202, 201, 188, 177, 179, 198, 199, 198, 200, 200, 196, 196, 165, 126, 147, 140, 171, 200, 169, 139, 197, 200, 151, 164, 151, 132,
+    207, 204,  58, 202,  57, 200, 195, 191, 182, 189, 198, 188, 194, 201, 207, 137, 117, 159, 122,  91, 165, 200, 198, 165, 171, 182, 158, 162, 215, 116,
+    209, 205,  60, 203, 203,  57, 201, 200, 174, 166, 200, 177, 177, 202, 196, 113, 180, 120,  56, 109, 201, 201, 201, 202, 193, 166, 133, 184, 160,  65,
+    216, 212, 213, 212, 210, 211, 210, 208, 182, 168, 208, 179, 158, 206, 181, 148, 179,  66,  69, 129, 200, 208, 207, 209, 208, 202, 167, 170, 148,  62,
+    209, 206,  60, 204,  58, 203, 202, 201, 176, 157, 200, 181, 137, 198, 200, 154, 160, 106,  61,  60, 136, 206, 206, 207, 207, 204, 205, 198, 199,  94,
+    207, 204,  58, 203,  56, 201, 200, 200, 185, 146, 182, 193, 132, 185, 206, 146, 174, 178,  85,  75, 147, 203, 204, 204, 203, 201, 201, 202, 186, 130,
+    208, 205,  59, 203,  57, 202, 201, 201, 195, 161, 178, 181, 150, 131, 190, 171, 168, 178, 145, 179, 195, 199, 200, 199, 199, 199, 197, 196, 193, 169,
+    208, 205, 204, 203, 203, 202, 201, 200, 200, 189, 188, 174, 125, 138, 187, 156, 170, 192, 166, 191, 200, 201, 201, 201, 200, 199, 199, 198, 198, 196,
+    207, 204,  59, 203,  58, 201, 201, 201, 200, 187, 173, 200, 146, 153, 207, 160, 172, 199, 179, 198, 200, 201, 197, 184, 198, 200, 199, 198, 198, 188,
+    202, 201, 201, 202, 201, 200, 201, 201, 201, 178, 165, 200, 160, 168, 199, 188, 167, 173, 173, 186, 198, 201, 198, 183, 197, 200, 199, 198, 172, 157,
+    194, 195, 196, 196, 198, 203, 202, 200, 201, 180, 168, 200, 153, 177, 198, 175, 170, 167, 168, 179, 200, 201, 202, 202, 201, 200, 199, 198, 181, 176,
+    195, 191, 193, 195, 204, 203, 196, 197, 201, 183, 171, 200, 153, 165, 207, 183, 196, 196, 195, 201, 202, 202, 202, 202, 201, 201, 200, 199, 198, 199,
+    209, 201, 200, 205, 203, 189, 187, 193, 201, 174, 171, 202, 157, 160, 208, 176, 199, 202, 202, 202, 202, 195, 183, 194, 198, 196, 189, 182, 178, 192,
+    207, 208, 207, 206, 194, 182, 185, 186, 194, 171, 175, 203, 161, 148, 208, 171, 166, 203, 203, 203, 203, 197, 184, 186, 189, 189, 186, 188, 197, 201,
+    202, 209, 208, 203, 190, 190, 180, 182, 199, 174, 176, 197, 160, 146, 193, 200, 167, 185, 204, 204, 204, 204, 205, 205, 205, 203, 203, 202, 201, 201,
+    213, 211, 211, 209, 184, 181, 195, 196, 194, 179, 176, 196, 172, 155, 187, 211, 201, 167, 163, 176, 204, 206, 206, 206, 206, 205, 204, 203, 203, 147,
+    214, 188, 184, 204, 211, 182, 208, 208, 181, 180, 176, 200, 168, 181, 188, 211, 194, 181, 168, 145, 154, 181, 195, 208, 207, 206, 198, 148,  86, 112,
+    186, 173, 174, 174, 203, 211, 196, 188, 188, 182, 168, 203, 171, 180, 210, 194, 190, 173, 179, 194, 191, 160, 125, 129, 171, 146,  76,  61, 128, 205,
+};
+
+uint8_t test_good_uv[] = {
+    104, 164, 105, 166, 105, 167, 106, 168, 111, 168, 117, 169, 124, 169, 130, 162, 135, 160, 143, 168, 150, 167, 156, 166, 158, 166, 158, 166, 158, 167,
+    103, 163, 103, 164, 103, 165, 104, 167, 109, 167, 115, 167, 122, 166, 128, 162, 136, 169, 142, 167, 149, 166, 156, 165, 157, 166, 158, 166, 158, 166,
+    102, 159, 102, 161, 102, 162, 103, 163, 108, 164, 113, 164, 121, 162, 127, 159, 134, 165, 141, 163, 148, 163, 155, 163, 157, 163, 157, 164, 158, 164,
+    101, 152, 101, 154, 101, 155, 103, 156, 108, 157, 114, 157, 121, 156, 127, 153, 134, 157, 141, 156, 148, 156, 155, 155, 157, 157, 158, 157, 158, 158,
+    101, 145, 101, 147, 101, 148, 103, 149, 108, 150, 114, 150, 121, 149, 127, 147, 134, 150, 141, 150, 148, 150, 155, 149, 157, 150, 158, 151, 158, 151,
+    101, 139, 101, 140, 102, 141, 102, 142, 107, 143, 114, 143, 120, 142, 128, 141, 135, 143, 141, 143, 148, 143, 155, 142, 157, 143, 158, 144, 159, 145,
+    101, 132, 100, 133, 101, 135, 103, 135, 107, 136, 113, 136, 120, 136, 127, 135, 134, 136, 141, 136, 148, 136, 155, 136, 158, 137, 158, 137, 156, 137,
+    103, 126, 104, 127, 104, 128, 105, 129, 109, 129, 114, 129, 121, 129, 127, 129, 134, 129, 141, 129, 147, 129, 153, 129, 155, 129, 156, 131, 151, 131,
+    101, 119, 102, 120, 102, 121, 103, 122, 107, 122, 114, 122, 120, 123, 127, 123, 134, 123, 140, 123, 146, 123, 153, 122, 155, 124, 155, 124, 157, 125,
+    101, 112, 101, 113, 102, 114, 103, 115, 108, 116, 113, 116, 120, 115, 127, 117, 134, 115, 142, 116, 148, 116, 156, 116, 158, 117, 159, 118, 159, 118,
+    101, 105, 102, 106, 102, 108, 103, 108, 108, 109, 114, 109, 120, 109, 127, 111, 134, 109, 141, 109, 148, 110, 155, 110, 158, 110, 158, 112, 158, 112,
+    101, 100, 102, 101, 102, 101, 103, 103, 108, 103, 113, 103, 120, 103, 127, 106, 134, 103, 141, 104, 148, 103, 155, 104, 157, 105, 158, 105, 158, 107,
+    101,  95, 101,  95, 102,  96, 103,  97, 107,  98, 112,  97, 120,  97, 127, 102, 134,  98, 140,  98, 147,  99, 154,  99, 156, 100, 157, 101, 157, 103,
+    100,  92, 101,  92, 101,  94, 102,  94, 107,  94, 112,  95, 118,  94, 125,  99, 131,  94, 139,  95, 146,  96, 152,  96, 155,  97, 156,  98, 156,  99,
+    99,  90,  99,  91,  99,  91, 101,  92, 105,  92, 110,  93, 117,  92, 124,  97, 130,  93, 137,  94, 144,  95, 151,  95, 153,  96, 154,  97, 155,  98,
+};

local_pod_repo/objcTox/Tests/YUVPlanes/test_straight3p.h

@@ -0,0 +1,75 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/*
+ * Tightly packed (i.e. stride == width) tri-planar
+ * 30x30 YUV stream.
+ */
+
+uint8_t test_str83p_y[] = {
+    204, 201, 199, 198, 197, 197, 196, 196, 195, 195, 194, 176, 189, 191, 206, 206, 204, 206, 195, 197, 198, 199, 199, 200, 200, 200, 187, 193, 199, 199,
+    200, 199, 199, 198, 198, 196, 196, 195, 195, 195, 180, 179, 196, 198, 204, 201, 209, 210, 194, 197, 197, 198, 199, 199, 199, 199, 181, 187, 198, 197,
+    205, 201, 200, 199, 199, 198, 198, 197, 196, 192, 178, 195, 198, 201, 205, 204, 191, 195, 198, 198, 199, 199, 199, 200, 200, 200, 190, 191, 198, 200,
+    207, 203, 202,  56,  56, 200, 199, 199, 199, 181, 184, 197, 199, 202, 206, 205, 196, 199, 199, 183, 182, 200, 201, 202, 201, 200, 195, 195, 199, 200,
+    208, 204,  59, 202, 202,  56, 200, 200, 195, 169, 193, 199, 200, 199, 206, 206, 198, 200, 201, 154, 174, 201, 202, 202, 202, 201, 192, 184, 200, 196,
+    208, 205,  58, 203, 202,  56, 200, 200, 181, 186, 199, 199, 202, 203, 208, 207, 197, 200, 189, 155, 187, 201, 201, 202, 201, 201, 187, 171, 199, 188,
+    208, 204,  59, 203, 202,  56, 201, 194, 185, 199, 190, 199, 201, 202, 207, 206, 197, 200, 179, 174, 180, 201, 201, 201, 200, 201, 193, 167, 188, 171,
+    207, 204,  58, 203, 202,  56, 200, 185, 193, 176, 185, 198, 200, 200, 206, 205, 198, 181, 163, 184, 175, 193, 200, 201, 198, 196, 198, 159, 184, 183,
+    207, 204, 203,  57,  56, 201, 200, 192, 178, 169, 199, 198, 201, 203, 207, 201, 184, 165, 172, 194, 179, 170, 196, 201, 198, 192, 200, 171, 178, 199,
+    208, 204, 203, 203, 202, 201, 197, 184, 177, 190, 199, 192, 192, 201, 207, 199, 189, 174, 196, 200, 194, 161, 177, 201, 199, 178, 181, 192, 158, 180,
+    208, 204,  59, 203, 202,  56, 196, 179, 172, 186, 199, 187, 191, 201, 207, 206, 178, 180, 200, 200, 200, 182, 148, 190, 200, 173, 154, 194, 168, 159,
+    208, 204,  58, 203,  57, 201, 194, 184, 169, 185, 199, 192, 197, 202, 207, 200, 185, 190, 187, 200, 200, 200, 147, 168, 200, 187, 154, 180, 162, 107,
+    208, 204,  58,  57, 202, 201, 188, 177, 179, 198, 199, 198, 200, 200, 196, 196, 165, 126, 147, 140, 171, 200, 169, 139, 197, 200, 151, 164, 151, 132,
+    207, 204,  58, 202,  57, 200, 195, 191, 182, 189, 198, 188, 194, 201, 207, 137, 117, 159, 122,  91, 165, 200, 198, 165, 171, 182, 158, 162, 215, 116,
+    209, 205,  60, 203, 203,  57, 201, 200, 174, 166, 200, 177, 177, 202, 196, 113, 180, 120,  56, 109, 201, 201, 201, 202, 193, 166, 133, 184, 160,  65,
+    216, 212, 213, 212, 210, 211, 210, 208, 182, 168, 208, 179, 158, 206, 181, 148, 179,  66,  69, 129, 200, 208, 207, 209, 208, 202, 167, 170, 148,  62,
+    209, 206,  60, 204,  58, 203, 202, 201, 176, 157, 200, 181, 137, 198, 200, 154, 160, 106,  61,  60, 136, 206, 206, 207, 207, 204, 205, 198, 199,  94,
+    207, 204,  58, 203,  56, 201, 200, 200, 185, 146, 182, 193, 132, 185, 206, 146, 174, 178,  85,  75, 147, 203, 204, 204, 203, 201, 201, 202, 186, 130,
+    208, 205,  59, 203,  57, 202, 201, 201, 195, 161, 178, 181, 150, 131, 190, 171, 168, 178, 145, 179, 195, 199, 200, 199, 199, 199, 197, 196, 193, 169,
+    208, 205, 204, 203, 203, 202, 201, 200, 200, 189, 188, 174, 125, 138, 187, 156, 170, 192, 166, 191, 200, 201, 201, 201, 200, 199, 199, 198, 198, 196,
+    207, 204,  59, 203,  58, 201, 201, 201, 200, 187, 173, 200, 146, 153, 207, 160, 172, 199, 179, 198, 200, 201, 197, 184, 198, 200, 199, 198, 198, 188,
+    202, 201, 201, 202, 201, 200, 201, 201, 201, 178, 165, 200, 160, 168, 199, 188, 167, 173, 173, 186, 198, 201, 198, 183, 197, 200, 199, 198, 172, 157,
+    194, 195, 196, 196, 198, 203, 202, 200, 201, 180, 168, 200, 153, 177, 198, 175, 170, 167, 168, 179, 200, 201, 202, 202, 201, 200, 199, 198, 181, 176,
+    195, 191, 193, 195, 204, 203, 196, 197, 201, 183, 171, 200, 153, 165, 207, 183, 196, 196, 195, 201, 202, 202, 202, 202, 201, 201, 200, 199, 198, 199,
+    209, 201, 200, 205, 203, 189, 187, 193, 201, 174, 171, 202, 157, 160, 208, 176, 199, 202, 202, 202, 202, 195, 183, 194, 198, 196, 189, 182, 178, 192,
+    207, 208, 207, 206, 194, 182, 185, 186, 194, 171, 175, 203, 161, 148, 208, 171, 166, 203, 203, 203, 203, 197, 184, 186, 189, 189, 186, 188, 197, 201,
+    202, 209, 208, 203, 190, 190, 180, 182, 199, 174, 176, 197, 160, 146, 193, 200, 167, 185, 204, 204, 204, 204, 205, 205, 205, 203, 203, 202, 201, 201,
+    213, 211, 211, 209, 184, 181, 195, 196, 194, 179, 176, 196, 172, 155, 187, 211, 201, 167, 163, 176, 204, 206, 206, 206, 206, 205, 204, 203, 203, 147,
+    214, 188, 184, 204, 211, 182, 208, 208, 181, 180, 176, 200, 168, 181, 188, 211, 194, 181, 168, 145, 154, 181, 195, 208, 207, 206, 198, 148,  86, 112,
+    186, 173, 174, 174, 203, 211, 196, 188, 188, 182, 168, 203, 171, 180, 210, 194, 190, 173, 179, 194, 191, 160, 125, 129, 171, 146,  76,  61, 128, 205,
+};
+uint8_t test_str83p_u[] = {
+    104, 105, 105, 106, 111, 117, 124, 130, 135, 143, 150, 156, 158, 158, 158,
+    103, 103, 103, 104, 109, 115, 122, 128, 136, 142, 149, 156, 157, 158, 158,
+    102, 102, 102, 103, 108, 113, 121, 127, 134, 141, 148, 155, 157, 157, 158,
+    101, 101, 101, 103, 108, 114, 121, 127, 134, 141, 148, 155, 157, 158, 158,
+    101, 101, 101, 103, 108, 114, 121, 127, 134, 141, 148, 155, 157, 158, 158,
+    101, 101, 102, 102, 107, 114, 120, 128, 135, 141, 148, 155, 157, 158, 159,
+    101, 100, 101, 103, 107, 113, 120, 127, 134, 141, 148, 155, 158, 158, 156,
+    103, 104, 104, 105, 109, 114, 121, 127, 134, 141, 147, 153, 155, 156, 151,
+    101, 102, 102, 103, 107, 114, 120, 127, 134, 140, 146, 153, 155, 155, 157,
+    101, 101, 102, 103, 108, 113, 120, 127, 134, 142, 148, 156, 158, 159, 159,
+    101, 102, 102, 103, 108, 114, 120, 127, 134, 141, 148, 155, 158, 158, 158,
+    101, 102, 102, 103, 108, 113, 120, 127, 134, 141, 148, 155, 157, 158, 158,
+    101, 101, 102, 103, 107, 112, 120, 127, 134, 140, 147, 154, 156, 157, 157,
+    100, 101, 101, 102, 107, 112, 118, 125, 131, 139, 146, 152, 155, 156, 156,
+    99,  99,  99, 101, 105, 110, 117, 124, 130, 137, 144, 151, 153, 154, 155,
+};
+uint8_t test_str83p_v[] = {
+    164, 166, 167, 168, 168, 169, 169, 162, 160, 168, 167, 166, 166, 166, 167,
+    163, 164, 165, 167, 167, 167, 166, 162, 169, 167, 166, 165, 166, 166, 166,
+    159, 161, 162, 163, 164, 164, 162, 159, 165, 163, 163, 163, 163, 164, 164,
+    152, 154, 155, 156, 157, 157, 156, 153, 157, 156, 156, 155, 157, 157, 158,
+    145, 147, 148, 149, 150, 150, 149, 147, 150, 150, 150, 149, 150, 151, 151,
+    139, 140, 141, 142, 143, 143, 142, 141, 143, 143, 143, 142, 143, 144, 145,
+    132, 133, 135, 135, 136, 136, 136, 135, 136, 136, 136, 136, 137, 137, 137,
+    126, 127, 128, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 131, 131,
+    119, 120, 121, 122, 122, 122, 123, 123, 123, 123, 123, 122, 124, 124, 125,
+    112, 113, 114, 115, 116, 116, 115, 117, 115, 116, 116, 116, 117, 118, 118,
+    105, 106, 108, 108, 109, 109, 109, 111, 109, 109, 110, 110, 110, 112, 112,
+    100, 101, 101, 103, 103, 103, 103, 106, 103, 104, 103, 104, 105, 105, 107,
+    95,  95,  96,  97,  98,  97,  97, 102,  98,  98,  99,  99, 100, 101, 103,
+    92,  92,  94,  94,  94,  95,  94,  99,  94,  95,  96,  96,  97,  98,  99,
+    90,  91,  91,  92,  92,  93,  92,  97,  93,  94,  95,  95,  96,  97,  98,
+};

local_pod_repo/objcTox/Tests/YUVPlanes/test_stride13p.h

@@ -0,0 +1,74 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+/*
+ * Tri-planar 30x30 YUV stream with 1 extra padding per row.
+ */
+
+uint8_t test_stride13p_y[] = {
+    204, 201, 199, 198, 197, 197, 196, 196, 195, 195, 194, 176, 189, 191, 206, 206, 204, 206, 195, 197, 198, 199, 199, 200, 200, 200, 187, 193, 199, 199, 119,
+    200, 199, 199, 198, 198, 196, 196, 195, 195, 195, 180, 179, 196, 198, 204, 201, 209, 210, 194, 197, 197, 198, 199, 199, 199, 199, 181, 187, 198, 197,  97,
+    205, 201, 200, 199, 199, 198, 198, 197, 196, 192, 178, 195, 198, 201, 205, 204, 191, 195, 198, 198, 199, 199, 199, 200, 200, 200, 190, 191, 198, 200, 102,
+    207, 203, 202,  56,  56, 200, 199, 199, 199, 181, 184, 197, 199, 202, 206, 205, 196, 199, 199, 183, 182, 200, 201, 202, 201, 200, 195, 195, 199, 200, 117,
+    208, 204,  59, 202, 202,  56, 200, 200, 195, 169, 193, 199, 200, 199, 206, 206, 198, 200, 201, 154, 174, 201, 202, 202, 202, 201, 192, 184, 200, 196, 126,
+    208, 205,  58, 203, 202,  56, 200, 200, 181, 186, 199, 199, 202, 203, 208, 207, 197, 200, 189, 155, 187, 201, 201, 202, 201, 201, 187, 171, 199, 188, 119,
+    208, 204,  59, 203, 202,  56, 201, 194, 185, 199, 190, 199, 201, 202, 207, 206, 197, 200, 179, 174, 180, 201, 201, 201, 200, 201, 193, 167, 188, 171,  97,
+    207, 204,  58, 203, 202,  56, 200, 185, 193, 176, 185, 198, 200, 200, 206, 205, 198, 181, 163, 184, 175, 193, 200, 201, 198, 196, 198, 159, 184, 183, 102,
+    207, 204, 203,  57,  56, 201, 200, 192, 178, 169, 199, 198, 201, 203, 207, 201, 184, 165, 172, 194, 179, 170, 196, 201, 198, 192, 200, 171, 178, 199, 117,
+    208, 204, 203, 203, 202, 201, 197, 184, 177, 190, 199, 192, 192, 201, 207, 199, 189, 174, 196, 200, 194, 161, 177, 201, 199, 178, 181, 192, 158, 180, 126,
+    208, 204,  59, 203, 202,  56, 196, 179, 172, 186, 199, 187, 191, 201, 207, 206, 178, 180, 200, 200, 200, 182, 148, 190, 200, 173, 154, 194, 168, 159, 119,
+    208, 204,  58, 203,  57, 201, 194, 184, 169, 185, 199, 192, 197, 202, 207, 200, 185, 190, 187, 200, 200, 200, 147, 168, 200, 187, 154, 180, 162, 107,  97,
+    208, 204,  58,  57, 202, 201, 188, 177, 179, 198, 199, 198, 200, 200, 196, 196, 165, 126, 147, 140, 171, 200, 169, 139, 197, 200, 151, 164, 151, 132, 102,
+    207, 204,  58, 202,  57, 200, 195, 191, 182, 189, 198, 188, 194, 201, 207, 137, 117, 159, 122,  91, 165, 200, 198, 165, 171, 182, 158, 162, 215, 116, 117,
+    209, 205,  60, 203, 203,  57, 201, 200, 174, 166, 200, 177, 177, 202, 196, 113, 180, 120,  56, 109, 201, 201, 201, 202, 193, 166, 133, 184, 160,  65, 126,
+    216, 212, 213, 212, 210, 211, 210, 208, 182, 168, 208, 179, 158, 206, 181, 148, 179,  66,  69, 129, 200, 208, 207, 209, 208, 202, 167, 170, 148,  62, 119,
+    209, 206,  60, 204,  58, 203, 202, 201, 176, 157, 200, 181, 137, 198, 200, 154, 160, 106,  61,  60, 136, 206, 206, 207, 207, 204, 205, 198, 199,  94,  97,
+    207, 204,  58, 203,  56, 201, 200, 200, 185, 146, 182, 193, 132, 185, 206, 146, 174, 178,  85,  75, 147, 203, 204, 204, 203, 201, 201, 202, 186, 130, 102,
+    208, 205,  59, 203,  57, 202, 201, 201, 195, 161, 178, 181, 150, 131, 190, 171, 168, 178, 145, 179, 195, 199, 200, 199, 199, 199, 197, 196, 193, 169, 117,
+    208, 205, 204, 203, 203, 202, 201, 200, 200, 189, 188, 174, 125, 138, 187, 156, 170, 192, 166, 191, 200, 201, 201, 201, 200, 199, 199, 198, 198, 196, 126,
+    207, 204,  59, 203,  58, 201, 201, 201, 200, 187, 173, 200, 146, 153, 207, 160, 172, 199, 179, 198, 200, 201, 197, 184, 198, 200, 199, 198, 198, 188, 119,
+    202, 201, 201, 202, 201, 200, 201, 201, 201, 178, 165, 200, 160, 168, 199, 188, 167, 173, 173, 186, 198, 201, 198, 183, 197, 200, 199, 198, 172, 157,  97,
+    194, 195, 196, 196, 198, 203, 202, 200, 201, 180, 168, 200, 153, 177, 198, 175, 170, 167, 168, 179, 200, 201, 202, 202, 201, 200, 199, 198, 181, 176, 102,
+    195, 191, 193, 195, 204, 203, 196, 197, 201, 183, 171, 200, 153, 165, 207, 183, 196, 196, 195, 201, 202, 202, 202, 202, 201, 201, 200, 199, 198, 199, 117,
+    209, 201, 200, 205, 203, 189, 187, 193, 201, 174, 171, 202, 157, 160, 208, 176, 199, 202, 202, 202, 202, 195, 183, 194, 198, 196, 189, 182, 178, 192, 126,
+    207, 208, 207, 206, 194, 182, 185, 186, 194, 171, 175, 203, 161, 148, 208, 171, 166, 203, 203, 203, 203, 197, 184, 186, 189, 189, 186, 188, 197, 201, 119,
+    202, 209, 208, 203, 190, 190, 180, 182, 199, 174, 176, 197, 160, 146, 193, 200, 167, 185, 204, 204, 204, 204, 205, 205, 205, 203, 203, 202, 201, 201,  97,
+    213, 211, 211, 209, 184, 181, 195, 196, 194, 179, 176, 196, 172, 155, 187, 211, 201, 167, 163, 176, 204, 206, 206, 206, 206, 205, 204, 203, 203, 147, 102,
+    214, 188, 184, 204, 211, 182, 208, 208, 181, 180, 176, 200, 168, 181, 188, 211, 194, 181, 168, 145, 154, 181, 195, 208, 207, 206, 198, 148,  86, 112, 117,
+    186, 173, 174, 174, 203, 211, 196, 188, 188, 182, 168, 203, 171, 180, 210, 194, 190, 173, 179, 194, 191, 160, 125, 129, 171, 146,  76,  61, 128, 205, 126,
+};
+uint8_t test_stride13p_u[] = {
+    104, 105, 105, 106, 111, 117, 124, 130, 135, 143, 150, 156, 158, 158, 158, 119,
+    103, 103, 103, 104, 109, 115, 122, 128, 136, 142, 149, 156, 157, 158, 158,  97,
+    102, 102, 102, 103, 108, 113, 121, 127, 134, 141, 148, 155, 157, 157, 158, 102,
+    101, 101, 101, 103, 108, 114, 121, 127, 134, 141, 148, 155, 157, 158, 158, 117,
+    101, 101, 101, 103, 108, 114, 121, 127, 134, 141, 148, 155, 157, 158, 158, 126,
+    101, 101, 102, 102, 107, 114, 120, 128, 135, 141, 148, 155, 157, 158, 159, 119,
+    101, 100, 101, 103, 107, 113, 120, 127, 134, 141, 148, 155, 158, 158, 156,  97,
+    103, 104, 104, 105, 109, 114, 121, 127, 134, 141, 147, 153, 155, 156, 151, 102,
+    101, 102, 102, 103, 107, 114, 120, 127, 134, 140, 146, 153, 155, 155, 157, 117,
+    101, 101, 102, 103, 108, 113, 120, 127, 134, 142, 148, 156, 158, 159, 159, 126,
+    101, 102, 102, 103, 108, 114, 120, 127, 134, 141, 148, 155, 158, 158, 158, 119,
+    101, 102, 102, 103, 108, 113, 120, 127, 134, 141, 148, 155, 157, 158, 158,  97,
+    101, 101, 102, 103, 107, 112, 120, 127, 134, 140, 147, 154, 156, 157, 157, 102,
+    100, 101, 101, 102, 107, 112, 118, 125, 131, 139, 146, 152, 155, 156, 156, 117,
+    99,  99,  99, 101, 105, 110, 117, 124, 130, 137, 144, 151, 153, 154, 155, 126,
+};
+uint8_t test_stride13p_v[] = {
+    164, 166, 167, 168, 168, 169, 169, 162, 160, 168, 167, 166, 166, 166, 167, 119,
+    163, 164, 165, 167, 167, 167, 166, 162, 169, 167, 166, 165, 166, 166, 166,  97,
+    159, 161, 162, 163, 164, 164, 162, 159, 165, 163, 163, 163, 163, 164, 164, 102,
+    152, 154, 155, 156, 157, 157, 156, 153, 157, 156, 156, 155, 157, 157, 158, 117,
+    145, 147, 148, 149, 150, 150, 149, 147, 150, 150, 150, 149, 150, 151, 151, 126,
+    139, 140, 141, 142, 143, 143, 142, 141, 143, 143, 143, 142, 143, 144, 145, 119,
+    132, 133, 135, 135, 136, 136, 136, 135, 136, 136, 136, 136, 137, 137, 137,  97,
+    126, 127, 128, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 131, 131, 102,
+    119, 120, 121, 122, 122, 122, 123, 123, 123, 123, 123, 122, 124, 124, 125, 117,
+    112, 113, 114, 115, 116, 116, 115, 117, 115, 116, 116, 116, 117, 118, 118, 126,
+    105, 106, 108, 108, 109, 109, 109, 111, 109, 109, 110, 110, 110, 112, 112, 119,
+    100, 101, 101, 103, 103, 103, 103, 106, 103, 104, 103, 104, 105, 105, 107,  97,
+    95,  95,  96,  97,  98,  97,  97, 102,  98,  98,  99,  99, 100, 101, 103, 102,
+    92,  92,  94,  94,  94,  95,  94,  99,  94,  95,  96,  96,  97,  98,  99, 117,
+    90,  91,  91,  92,  92,  93,  92,  97,  93,  94,  95,  95,  96,  97,  98, 126,
+};