firebase-ios-sdk/Example/Database/Tests/Integration/FData.m

/*
 * Copyright 2017 Google
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#import "FData.h"
#import "FTestHelpers.h"
#import "FEventTester.h"
#import "FTupleEventTypeString.h"
#import <FirebaseCore/FIRApp.h>
#import "FIRDatabaseQuery_Private.h"
#import "FIRDatabaseConfig_Private.h"
#import <FirebaseCore/FIROptions.h>
#import "FRepo_Private.h"
#import <limits.h>

@implementation FData

- (void) testGetNode {
    __unused FIRDatabaseReference * node = [FTestHelpers getRandomNode];
    XCTAssertTrue(YES, @"Properly created node without throwing error");
}

- (void) testWriteData {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];
    [node setValue:@42];
    XCTAssertTrue(YES, @"Properly write to node without throwing error");
}

- (void) testWriteDataWithDebugLogging {
    [FIRDatabase setLoggingEnabled:YES];
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];
    [node setValue:@42];
    [FIRDatabase setLoggingEnabled:NO];
    XCTAssertTrue(YES, @"Properly write to node without throwing error");
}

- (void) testWriteAndReadData {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];
    [node setValue:@42];

    [self snapWaiter:node withBlock:^(FIRDataSnapshot *snapshot) {
        XCTAssertEqualObjects(@42, [snapshot value], @"Properly saw correct value");
    }];
}

- (void) testProperParamChecking {
    // ios doesn't have an equivalent of this test
}

- (void) testNamespaceCaseInsensitivityWithinARepo {
    FIRDatabaseReference * ref1 = [[FIRDatabase database] referenceFromURL:[self.databaseURL uppercaseString]];
    FIRDatabaseReference * ref2 = [[FIRDatabase database] referenceFromURL:[self.databaseURL lowercaseString]];

    XCTAssertTrue([ref1.description isEqualToString:ref2.description], @"Descriptions should match");
}

- (void) testRootProperty {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];
    FIRDatabaseReference * root = node.root;
    XCTAssertTrue(root != nil, @"Should get a root");
    XCTAssertTrue([[root description] isEqualToString:self.databaseURL], @"Root is actually the root");
}

- (void) testValReturnsCompoundObjectWithChildren {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];

    [node setValue:@{@"foo": @{@"bar": @5}}];

    [self snapWaiter:node withBlock:^(FIRDataSnapshot *snapshot) {
        XCTAssertEqualObjects([[[snapshot value] objectForKey:@"foo"] objectForKey:@"bar"], @5, @"Properly saw compound object");
    }];
}

- (void) testWriteDataAndWaitForServerConfirmation {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];

    [self waitForCompletionOf:node setValue:@42];
}

- (void) testWriteAValueAndRead {
    // dupe of FEvent testWriteLeafExpectValueChanged
}

- (void) testWriteABunchOfDataAndRead {
    FTupleFirebase* tuple = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * writeNode = tuple.one;
    FIRDatabaseReference * readNode = tuple.two;


    __block BOOL done = NO;

    [[[[writeNode child:@"a"] child:@"b"] child:@"c"] setValue:@1];
    [[[[writeNode child:@"a"] child:@"d"] child:@"e"] setValue:@2];
    [[[[writeNode child:@"a"] child:@"d"] child:@"f"] setValue:@3];
    [[writeNode child:@"g"] setValue:@4 withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) { done = YES; }];

    [self waitUntil:^BOOL{ return done; }];

    [super snapWaiter:readNode withBlock:^(FIRDataSnapshot *s) {
        XCTAssertEqualObjects([[[[s childSnapshotForPath:@"a"] childSnapshotForPath:@"b"] childSnapshotForPath:@"c"] value], @1, @"Proper child value");
        XCTAssertEqualObjects([[[[s childSnapshotForPath:@"a"] childSnapshotForPath:@"d"] childSnapshotForPath:@"e"] value], @2, @"Proper child value");
        XCTAssertEqualObjects([[[[s childSnapshotForPath:@"a"] childSnapshotForPath:@"d"] childSnapshotForPath:@"f"] value], @3, @"Proper child value");
        XCTAssertEqualObjects([[s childSnapshotForPath:@"g"] value], @4, @"Proper child value");
    }];
}

- (void) testWriteABunchOfDataWithLeadingZeroesAndRead {
    FTupleFirebase* tuple = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * writeNode = tuple.one;
    FIRDatabaseReference * readNode = tuple.two;

    [self waitForCompletionOf:[writeNode child:@"1"] setValue:@1];
    [self waitForCompletionOf:[writeNode child:@"01"] setValue:@2];
    [self waitForCompletionOf:[writeNode child:@"001"] setValue:@3];
    [self waitForCompletionOf:[writeNode child:@"0001"] setValue:@4];

    [super snapWaiter:readNode withBlock:^(FIRDataSnapshot *s) {
        XCTAssertEqualObjects([[s childSnapshotForPath:@"1"] value], @1, @"Proper child value");
        XCTAssertEqualObjects([[s childSnapshotForPath:@"01"] value], @2, @"Proper child value");
        XCTAssertEqualObjects([[s childSnapshotForPath:@"001"] value], @3, @"Proper child value");
        XCTAssertEqualObjects([[s childSnapshotForPath:@"0001"] value], @4, @"Proper child value");
    }];
}

- (void) testLeadingZeroesTurnIntoDictionary {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
    [self waitForCompletionOf:[ref child:@"1"] setValue:@1];
    [self waitForCompletionOf:[ref child:@"01"] setValue:@2];

    __block BOOL done = NO;
    __block FIRDataSnapshot * snap = nil;

    [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        snap = snapshot;
        done = YES;
    }];

    WAIT_FOR(done);

    XCTAssertTrue([snap.value isKindOfClass:[NSDictionary class]], @"Should be dictionary");
    XCTAssertEqualObjects([snap.value objectForKey:@"1"], @1, @"Proper child value");
    XCTAssertEqualObjects([snap.value objectForKey:@"01"], @2, @"Proper child value");
}

- (void) testLeadingZerosDontCollapseLocally {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];

    __block BOOL done = NO;
    __block FIRDataSnapshot * snap = nil;
    [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        snap = snapshot;
        done = (snapshot.childrenCount == 2);
    }];

    [[ref child:@"3"] setValue:@YES];
    [[ref child:@"03"] setValue:@NO];

    WAIT_FOR(done);

    XCTAssertEqualObjects([[snap childSnapshotForPath:@"3"] value], @YES, @"Proper child value");
    XCTAssertEqualObjects([[snap childSnapshotForPath:@"03"] value], @NO, @"Proper child value");
}

- (void) testSnapshotRef {
    FIRDatabaseReference *ref = [FTestHelpers getRandomNode];

    __block BOOL done = NO;
    [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        [snapshot.ref observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
            done = YES;
        }];
    }];
    WAIT_FOR(done);
}

- (void) testWriteLeafNodeOverwriteAtParentVerifyExpectedEvents {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];

    FIRDatabaseReference * connected = [[[FIRDatabase database] reference] child:@".info/connected"];
    __block BOOL ready = NO;
    [connected observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        NSNumber *val = [snapshot value];
        ready = [val boolValue];
    }];

    WAIT_FOR(ready);

    NSArray* lookingFor = @[
            [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil],     // 4
            [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeChildAdded withString:@"aa"], // 0
            [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil],     // 4
            [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeChildChanged withString:@"aa"], // 2
            [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeValue withString:nil],        // 4
    ];

    [[node repo] interrupt]; // Going offline ensures that local events get queued up before server events
    FEventTester* et = [[FEventTester alloc] initFrom:self];
    [et addLookingFor:lookingFor];

    [[node child:@"a/aa"] setValue:@1];
    [[node child:@"a"] setValue:@{@"aa": @2}];

    [[node repo] resume];
    [et wait];
}

- (void) testWriteLeafNodeOverwriteAtParentMultipleTimesVerifyExpectedEvents {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];

    NSArray* lookingFor = @[
            [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeChildAdded withString:@"aa"],
            [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a/bb"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeChildChanged withString:@"aa"],
            [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeChildChanged withString:@"aa"],
            [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeValue withString:nil],
    ];

    [[node repo] interrupt]; // Going offline ensures that local events get queued up before server events
    FEventTester* et = [[FEventTester alloc] initFrom:self];
    [et addLookingFor:lookingFor];

    [[node child:@"a/aa"] setValue:@1];
    [[node child:@"a"] setValue:@{@"aa": @2}];
    [[node child:@"a"] setValue:@{@"aa": @3}];
    [[node child:@"a"] setValue:@{@"aa": @3}];

    [[node repo] resume];
    [et wait];
}

- (void) testWriteParentNodeOverwriteAtLeafVerifyExpectedEvents {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];

    NSArray* lookingFor = @[
            [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeChildAdded withString:@"aa"],
            [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeChildChanged withString:@"aa"],
            [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeValue withString:nil],
    ];

    [[node repo] interrupt]; // Going offline ensures that local events get queued up before server events
    FEventTester* et = [[FEventTester alloc] initFrom:self];
    [et addLookingFor:lookingFor];

    [[node child:@"a"] setValue:@{@"aa": @2}];
    [[node child:@"a/aa"] setValue:@1];

    [[node repo] resume];
    [et wait];
}

- (void) testWriteLeafNodeRemoveParentNodeVerifyExpectedEvents {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * writer = refs.one;
    FIRDatabaseReference * reader = refs.two;

    NSArray* lookingFor = @[
            [[FTupleEventTypeString alloc] initWithFirebase:[writer child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:[writer child:@"a"] withEvent:FIRDataEventTypeChildAdded withString:@"aa"],
            [[FTupleEventTypeString alloc] initWithFirebase:[writer child:@"a"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:writer withEvent:FIRDataEventTypeChildAdded withString:@"a"],
            [[FTupleEventTypeString alloc] initWithFirebase:writer withEvent:FIRDataEventTypeValue withString:nil],
    ];
    FEventTester* et = [[FEventTester alloc] initFrom:self];
    [et addLookingFor:lookingFor];

    [[writer child:@"a/aa"] setValue:@42];
    // the local events
    [et wait];

    // the reader should get all of the events intermingled
    FEventTester* readerEvents = [[FEventTester alloc] initFrom:self];
    lookingFor = @[
            [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"a"] withEvent:FIRDataEventTypeChildAdded withString:@"aa"],
            [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"a"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:reader withEvent:FIRDataEventTypeChildAdded withString:@"a"],
            [[FTupleEventTypeString alloc] initWithFirebase:reader withEvent:FIRDataEventTypeValue withString:nil]
    ];

    [readerEvents addLookingFor:lookingFor];

    [readerEvents wait];

    lookingFor = @[
            [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"a"] withEvent:FIRDataEventTypeChildRemoved withString:@"aa"],
            [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"a"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:reader withEvent:FIRDataEventTypeChildRemoved withString:@"a"],
            [[FTupleEventTypeString alloc] initWithFirebase:reader withEvent:FIRDataEventTypeValue withString:nil]
    ];
    [readerEvents addLookingFor:lookingFor];

    lookingFor = @[
            [[FTupleEventTypeString alloc] initWithFirebase:[writer child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:[writer child:@"a"] withEvent:FIRDataEventTypeChildRemoved withString:@"aa"],
            [[FTupleEventTypeString alloc] initWithFirebase:[writer child:@"a"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:writer withEvent:FIRDataEventTypeChildRemoved withString:@"a"],
            [[FTupleEventTypeString alloc] initWithFirebase:writer withEvent:FIRDataEventTypeValue withString:nil]
    ];

    [et addLookingFor:lookingFor];

    [[writer child:@"a"] removeValue];

    [et wait];
    [readerEvents wait];

    [et unregister];
    [readerEvents unregister];

    // Ensure we can write a new value
    __block NSNumber* readVal = @0.0;
    __block NSNumber* writeVal = @0.0;

    [[reader child:@"a/aa"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        id val = [snapshot value];
        if (val != [NSNull null]) {
            readVal = val;
        }
    }];

    [[writer child:@"a/aa"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        id val = [snapshot value];
        if (val != [NSNull null]) {
            writeVal = val;
        }
    }];

    [[writer child:@"a/aa"] setValue:@3.1415];

    [self waitUntil:^BOOL{
        return fabs([readVal doubleValue] - 3.1415) < 0.001 && fabs([writeVal doubleValue] - 3.1415) < 0.001;
        //return [readVal isEqualToNumber:@3.1415] && [writeVal isEqualToNumber:@3.1415];
    }];
}

- (void) testWriteLeafNodeRemoveLeafVerifyExpectedEvents {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * writer = refs.one;
    FIRDatabaseReference * reader = refs.two;

    NSArray* lookingFor = @[
            [[FTupleEventTypeString alloc] initWithFirebase:[writer child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:[writer child:@"a"] withEvent:FIRDataEventTypeChildAdded withString:@"aa"],
            [[FTupleEventTypeString alloc] initWithFirebase:[writer child:@"a"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:writer withEvent:FIRDataEventTypeChildAdded withString:@"a"],
            [[FTupleEventTypeString alloc] initWithFirebase:writer withEvent:FIRDataEventTypeValue withString:nil],
    ];
    FEventTester* et = [[FEventTester alloc] initFrom:self];
    [et addLookingFor:lookingFor];
    [[writer child:@"a/aa"] setValue:@42];

    // the local events
    [et wait];

    // the reader should get all of the events intermingled
    FEventTester* readerEvents = [[FEventTester alloc] initFrom:self];
    lookingFor = @[
            [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"a"] withEvent:FIRDataEventTypeChildAdded withString:@"aa"],
            [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"a"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:reader withEvent:FIRDataEventTypeChildAdded withString:@"a"],
            [[FTupleEventTypeString alloc] initWithFirebase:reader withEvent:FIRDataEventTypeValue withString:nil]
    ];

    [readerEvents addLookingFor:lookingFor];

    [readerEvents wait];

    lookingFor = @[
            [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"a"] withEvent:FIRDataEventTypeChildRemoved withString:@"aa"],
            [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"a"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:reader withEvent:FIRDataEventTypeChildRemoved withString:@"a"],
            [[FTupleEventTypeString alloc] initWithFirebase:reader withEvent:FIRDataEventTypeValue withString:nil]
    ];
    [readerEvents addLookingFor:lookingFor];

    lookingFor = @[
            [[FTupleEventTypeString alloc] initWithFirebase:[writer child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:[writer child:@"a"] withEvent:FIRDataEventTypeChildRemoved withString:@"aa"],
            [[FTupleEventTypeString alloc] initWithFirebase:[writer child:@"a"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:writer withEvent:FIRDataEventTypeChildRemoved withString:@"a"],
            [[FTupleEventTypeString alloc] initWithFirebase:writer withEvent:FIRDataEventTypeValue withString:nil]
    ];

    [et addLookingFor:lookingFor];

    // remove just the leaf
    [[writer child:@"a/aa"] removeValue];

    [et wait];
    [readerEvents wait];

    [et unregister];
    [readerEvents unregister];

    // Ensure we can write a new value
    __block NSNumber* readVal = @0.0;
    __block NSNumber* writeVal = @0.0;

    [[reader child:@"a/aa"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        id val = [snapshot value];
        if (val != [NSNull null]) {
            readVal = val;
        }
    }];

    [[writer child:@"a/aa"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        id val = [snapshot value];
        if (val != [NSNull null]) {
            writeVal = val;
        }
    }];

    [[writer child:@"a/aa"] setValue:@3.1415];

    [self waitUntil:^BOOL{
        //NSLog(@"readVal: %@, writeVal: %@, vs %@", readVal, writeVal, @3.1415);
        //return [readVal isEqualToNumber:@3.1415] && [writeVal isEqualToNumber:@3.1415];
        return fabs([readVal doubleValue] - 3.1415) < 0.001 && fabs([writeVal doubleValue] - 3.1415) < 0.001;
    }];
}

- (void) testWriteMultipleLeafNodesRemoveOnlyOneVerifyExpectedEvents {
    // XXX impl
}

- (void) testVerifyNodeNamesCantStartWithADot {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];

    XCTAssertThrows([ref child:@".foo"], @"not a valid .prefix");
    XCTAssertThrows([ref child:@"foo/.foo"], @"not a valid path");
    // Should not throw
    [[ref parent] child:@".info"];
}

- (void) testVerifyWritingToDotLengthAndDotKeysThrows {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];

    XCTAssertThrows([[ref child:@".keys"] setValue:@42], @"not a valid .prefix");
    XCTAssertThrows([[ref child:@".length"] setValue:@42], @"not a valid path");
}

- (void) testNumericKeysGetTurnedIntoArrays {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
    [[ref child:@"0"] setValue:@"alpha"];
    [[ref child:@"1"] setValue:@"bravo"];
    [[ref child:@"2"] setValue:@"charlie"];
    [[ref child:@"3"] setValue:@"delta"];
    [[ref child:@"4"] setValue:@"echo"];

    __block BOOL ready = NO;
    [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        id val = [snapshot value];
        XCTAssertTrue([val isKindOfClass:[NSArray class]], @"Expected an array");
        NSArray *expected = @[@"alpha", @"bravo", @"charlie", @"delta", @"echo"];
        XCTAssertTrue([expected isEqualToArray:val], @"Did not get the correct array");
        ready = YES;
    }];

    [self waitUntil:^{ return ready; }];
}

// This was an issue on 64-bit.
- (void) testLargeNumericKeysDontGetTurnedIntoArrays {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
    [[ref child:@"100003354884401"] setValue:@"alpha"];

    __block BOOL ready = NO;
    [ref observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        id val = [snapshot value];
        XCTAssertTrue([val isKindOfClass:[NSDictionary class]], @"Expected a dictionary.");
        ready = YES;
    }];

    [self waitUntil:^{ return ready; }];
}

- (void) testWriteCompoundObjectAndGetItBack {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];

    NSDictionary* data = @{
        @"a": @{@"aa": @5,
                @"ab": @3},
        @"b": @{@"ba": @"hey there!",
                @"bb": @{@"bba": @NO}},
        @"c": @[@0,
                @{@"c_1": @4},
                @"hey",
                @YES,
                @NO,
                @"dude"]
    };

    __block FIRDataSnapshot *snap = nil;
    [node observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        snap = snapshot;
    }];

    __block BOOL done = NO;
    [node setValue:data withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) { done = YES; }];

    [self waitUntil:^BOOL{
        return done;
    }];

    [self snapWaiter:node withBlock:^(FIRDataSnapshot *snapshot) {
        XCTAssertTrue([[[[snapshot value] objectForKey:@"c"] objectAtIndex:3] boolValue], @"Got proper boolean");
    }];
}

- (void) testCanPassValueToPush {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];

    FIRDatabaseReference * pushA = [node childByAutoId];
    [pushA setValue:@5];

    [self snapWaiter:pushA withBlock:^(FIRDataSnapshot *snapshot) {
        XCTAssertEqualObjects(@5, [snapshot value], @"Got proper value");
    }];

    FIRDatabaseReference * pushB = [node childByAutoId];
    [pushB setValue:@{@"a": @5, @"b": @6}];

    [self snapWaiter:pushB withBlock:^(FIRDataSnapshot *snapshot) {
        XCTAssertEqualObjects(@5, [[snapshot value] objectForKey:@"a"], @"Got proper value");
        XCTAssertEqualObjects(@6, [[snapshot value] objectForKey:@"b"], @"Got proper value");
    }];
}

// Dropped test that tested callbacks to push. Support was removed.

- (void) testRemoveCallbackHit {

    FIRDatabaseReference * node = [FTestHelpers getRandomNode];
    __block BOOL setDone = NO;
    __block BOOL removeDone = NO;
    __block BOOL readDone = NO;

    [node setValue:@42 withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        setDone = YES;
    }];

    [self waitUntil:^BOOL{
        return setDone;
    }];

    [node observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        id val = [snapshot value];
        if (val == [NSNull null]) {
            readDone = YES;
        }
    }];

    [node removeValueWithCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        XCTAssertTrue(error == nil, @"Should not be an error removing");
        removeDone = YES;
    }];

    [self waitUntil:^BOOL{
        return readDone && removeDone;
    }];
}

- (void) testRemoveCallbackIsHitForNodesThatAreAlreadyRemoved {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];

    __block int removes = 0;

    [node removeValueWithCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
        removes = removes + 1;
    }];

    [node removeValueWithCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
        removes = removes + 1;
    }];

    [self waitUntil:^BOOL{
        return removes == 2;
    }];
}

- (void) testUsingNumbersAsKeysDoesntCreateHugeSparseArrays {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];

    [[ref child:@"3024"] setValue:@5];

    __block BOOL ready = NO;
    [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        id val = [snapshot value];
        XCTAssertTrue(![val isKindOfClass:[NSArray class]], @"Should not be an array");
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];
}

- (void) testOnceWithACallbackHitsServer {
    FTupleFirebase* tuple = [FTestHelpers getRandomNodeTriple];
    FIRDatabaseReference * writeNode = tuple.one;
    FIRDatabaseReference * readNode = tuple.two;
    FIRDatabaseReference * readNodeB = tuple.three;

    __block BOOL initialReadDone = NO;

    [readNode observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        XCTAssertTrue([[snapshot value] isEqual:[NSNull null]], @"First callback is null");
        initialReadDone = YES;
    }];

    [self waitUntil:^BOOL{
        return initialReadDone;
    }];

    __block BOOL writeDone = NO;

    [writeNode setValue:@42 withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
        writeDone = YES;
    }];

    [self waitUntil:^BOOL{
        return writeDone;
    }];

    __block BOOL readDone = NO;

    [readNodeB observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        XCTAssertEqualObjects(@42, [snapshot value], @"Proper second read");
        readDone = YES;
    }];

    [self waitUntil:^BOOL{
        return readDone;
    }];
}

// Removed test of forEach aborting iteration. Support dropped, use for .. in syntax

- (void) testSetAndThenListenForValueEventsAreCorrect {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];

    __block BOOL setDone = NO;

    [node setValue:@"moo" withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
        setDone = YES;
    }];

    __block int calls = 0;

    [node observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        calls = calls + 1;
        XCTAssertTrue(calls == 1, @"Only called once");
        XCTAssertEqualObjects([snapshot value], @"moo", @"Proper snapshot value");
    }];

    [self waitUntil:^BOOL{
        return setDone && calls == 1;
    }];

    [node removeAllObservers];
}

- (void) testHasChildrenWorksCorrectly {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];

    [node setValue:@{@"one" : @42, @"two": @{@"a": @5}, @"three": @{@"a": @5, @"b": @6}}];

    __block BOOL removedTwo = NO;
    __block BOOL done = NO;

    [node observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        if (!removedTwo) {
            XCTAssertFalse([[snapshot childSnapshotForPath:@"one"] hasChildren], @"nope");
            XCTAssertTrue([[snapshot childSnapshotForPath:@"two"] hasChildren], @"nope");
            XCTAssertTrue([[snapshot childSnapshotForPath:@"three"] hasChildren], @"nope");
            XCTAssertFalse([[snapshot childSnapshotForPath:@"four"] hasChildren], @"nope");

            removedTwo = YES;
            [[node child:@"two"] removeValue];
        }
        else {
            XCTAssertFalse([[snapshot childSnapshotForPath:@"two"] hasChildren], @"Second time around");
            done = YES;
        }
    }];

    [self waitUntil:^BOOL{
        return done;
    }];
}

- (void) testNumChildrenWorksCorrectly {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];

    [node setValue:@{@"one" : @42, @"two": @{@"a": @5}, @"three": @{@"a": @5, @"b": @6}}];

    __block BOOL removedTwo = NO;
    __block BOOL done = NO;

    [node observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        if (!removedTwo) {
            XCTAssertTrue([snapshot childrenCount] == 3, @"Total children");
            XCTAssertTrue([[snapshot childSnapshotForPath:@"one"] childrenCount] == 0, @"Two's children");
            XCTAssertTrue([[snapshot childSnapshotForPath:@"two"] childrenCount] == 1, @"Two's children");
            XCTAssertTrue([[snapshot childSnapshotForPath:@"three"] childrenCount] == 2, @"Two's children");
            XCTAssertTrue([[snapshot childSnapshotForPath:@"four"] childrenCount] == 0, @"Two's children");

            removedTwo = YES;
            [[node child:@"two"] removeValue];
        }
        else {
            XCTAssertTrue([snapshot childrenCount] == 2, @"Total children");
            XCTAssertTrue([[snapshot childSnapshotForPath:@"two"] childrenCount] == 0, @"Two's children");
            done = YES;
        }
    }];

    [self waitUntil:^BOOL{
        return done;
    }];
}

#ifdef FLAKY_TEST
- (void) testSettingANodeWithChildrenToAPrimitiveAndBack {
    // Can't tolerate stale data; so disable persistence.
    FTupleFirebase* tuple = [FTestHelpers getRandomNodePairWithoutPersistence];
    FIRDatabaseReference * writeNode = tuple.one;
    FIRDatabaseReference * readNode = tuple.two;

    __block BOOL done = NO;

    NSDictionary* compound = @{@"a": @5, @"b": @6};
    NSNumber* number = @76;

    [writeNode setValue:compound];

    [self snapWaiter:writeNode withBlock:^(FIRDataSnapshot *snapshot) {
        XCTAssertTrue([snapshot hasChildren], @"Has children");
        XCTAssertEqualObjects(@5, [[snapshot childSnapshotForPath:@"a"] value], @"First child");
        XCTAssertEqualObjects(@6, [[snapshot childSnapshotForPath:@"b"] value], @"First child");
        done = YES;
    }];

    [self waitUntil:^BOOL{
        return done;
    }];

    done = NO;

    [self snapWaiter:readNode withBlock:^(FIRDataSnapshot *snapshot) {
        XCTAssertTrue([snapshot hasChildren], @"has children");
        XCTAssertEqualObjects(@5, [[snapshot childSnapshotForPath:@"a"] value], @"First child");
        XCTAssertEqualObjects(@6, [[snapshot childSnapshotForPath:@"b"] value], @"First child");
        done = YES;
    }];

    [self waitUntil:^BOOL{
        return done;
    }];

    done = NO;


    [writeNode setValue:number withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
        done = YES;
    }];

    [self waitUntil:^BOOL{
        return done;
    }];

    done = NO;

    [self snapWaiter:readNode withBlock:^(FIRDataSnapshot *snapshot) {
        XCTAssertFalse([snapshot hasChildren], @"No more children");
        XCTAssertEqualObjects(number, [snapshot value], @"Proper non compound value");
        done = YES;
    }];

    [self waitUntil:^BOOL{
        return done;
    }];

    done = NO;

    [writeNode setValue:compound withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
        done = YES;
    }];

    [self waitUntil:^BOOL{
        return done;
    }];

    done = NO;

    [self snapWaiter:readNode withBlock:^(FIRDataSnapshot *snapshot) {
        XCTAssertTrue([snapshot hasChildren], @"Has children");
        XCTAssertEqualObjects(@5, [[snapshot childSnapshotForPath:@"a"] value], @"First child");
        XCTAssertEqualObjects(@6, [[snapshot childSnapshotForPath:@"b"] value], @"First child");
        done = YES;
    }];

    [self waitUntil:^BOOL{
        return done;
    }];

    XCTAssertTrue(done, @"Properly finished");
}
#endif

- (void) testWriteLeafRemoveLeafAddChildToRemovedNode {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * writer = refs.one;
    FIRDatabaseReference * reader = refs.two;

    __block BOOL ready = NO;
    [writer setValue:@5];
    [writer removeValue];
    [[writer child:@"abc"] setValue:@5 withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];

    __block NSDictionary* readVal = nil;
    [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        readVal = [snapshot value];
    }];

    [self waitUntil:^BOOL{
        return readVal != nil;
    }];

    NSNumber* five = [readVal objectForKey:@"abc"];
    XCTAssertTrue([five isEqualToNumber:@5], @"Should get 5");
}

- (void) testListenForValueAndThenWriteOnANodeWithExistingData {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * writer = refs.one;
    FIRDatabaseReference * reader = refs.two;

    [self waitForCompletionOf:writer setValue:@{@"a": @5, @"b": @2}];

    __block int calls = 0;
    [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        calls++;
        if (calls == 1) {
            NSDictionary *val = [snapshot value];
            NSDictionary *expected = @{@"a" : @10, @"b" : @2};
            XCTAssertTrue([val isEqualToDictionary:expected], @"Got the correct value");
        } else {
            XCTFail(@"Should only be called once");
        }
    }];

    [[reader child:@"a"] setValue:@10];
    [self waitUntil:^BOOL{
        return calls == 1;
    }];
    [reader removeAllObservers];
}

- (void) testSetPriorityOnNonexistentNodeFails {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];

    __block BOOL ready = NO;
    [ref setPriority:@5 withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        XCTAssertTrue(error != nil, @"This should not succeed");
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];
}

- (void) testSetPriorityOnExistentNodeSucceeds {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];

    __block BOOL ready = NO;
    [ref setValue:@"hello!"];
    [ref setPriority:@5 withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        XCTAssertTrue(error == nil, @"This should succeed");
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];
}

- (void) testSetWithPrioritySetsValueAndPriority {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * writer = refs.one;
    FIRDatabaseReference * reader = refs.two;

    [self waitForCompletionOf:writer setValue:@"hello" andPriority:@5];

    __block FIRDataSnapshot * writeSnap = nil;
    __block FIRDataSnapshot * readSnap = nil;
    [writer observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        writeSnap = snapshot;
    }];
    [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        readSnap = snapshot;
    }];

    [self waitUntil:^BOOL{
        return readSnap != nil && writeSnap != nil;
    }];

    XCTAssertTrue([@"hello" isEqualToString:[readSnap value]], @"Got the value on the reader");
    XCTAssertTrue([@"hello" isEqualToString:[writeSnap value]], @"Got the value on the writer");
    XCTAssertTrue([@5 isEqualToNumber:[readSnap priority]], @"Got the priority on the reader");
    XCTAssertTrue([@5 isEqualToNumber:[writeSnap priority]], @"Got the priority on the writer");
}

- (void) testEffectsOfSetPriorityIsImmediatelyEvident {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];

    NSMutableArray* values = [[NSMutableArray alloc] init];
    NSMutableArray* priorities = [[NSMutableArray alloc] init];

    [ref observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        [values addObject:[snapshot value]];
        [priorities addObject:[snapshot priority]];
    }];
    [ref setValue:@5];
    [ref setPriority:@10];
    __block BOOL ready = NO;
    [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        [values addObject:[snapshot value]];
        [priorities addObject:[snapshot priority]];
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];

    NSArray* expectedValues = @[@5, @5];
    NSArray* expectedPriorites = @[[NSNull null], @10];
    XCTAssertTrue([values isEqualToArray:expectedValues], @"Expected both listeners to get 5, got %@ instead", values);
    XCTAssertTrue([priorities isEqualToArray:expectedPriorites], @"The first listener should have missed the priority, got %@ instead", priorities);
}

- (void) testSetOverwritesPriorityOfTopLevelNodeAndSubnodes {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * writer = refs.one;
    FIRDatabaseReference * reader = refs.two;

    __block BOOL ready = NO;
    [writer setValue:@{@"a": @5}];
    [writer setPriority:@10];
    [[writer child:@"a"] setPriority:@18];
    [writer setValue:@{@"a": @7} withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];

    ready = NO;
    [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        id pri = [snapshot priority];
        XCTAssertTrue([NSNull null] == pri, @"Expected null priority");
        FIRDataSnapshot *child = [snapshot childSnapshotForPath:@"a"];
        XCTAssertTrue([NSNull null] == [child priority], @"Child priority should be null too");
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];
}

- (void) testSetPriorityOfLeafSavesCorrectly {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * writer = refs.one;
    FIRDatabaseReference * reader = refs.two;

    __block BOOL ready = NO;
    [writer setValue:@"testleaf" andPriority:@992 withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];

    ready = NO;
    [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        id pri = [snapshot priority];
        XCTAssertTrue([@992 isEqualToNumber:pri], @"Expected non-null priority");
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];
}

- (void) testSetPriorityOfObjectSavesCorrectly {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * writer = refs.one;
    FIRDatabaseReference * reader = refs.two;

    __block BOOL ready = NO;
    [writer setValue:@{@"a": @5} andPriority:@991 withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];

    ready = NO;
    [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        id pri = [snapshot priority];
        XCTAssertTrue([@991 isEqualToNumber:pri], @"Expected non-null priority");
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];
}


- (void) testSetWithPriorityFollowedBySetClearsPriority {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * writer = refs.one;
    FIRDatabaseReference * reader = refs.two;

    __block BOOL ready = NO;
    [writer setValue:@{@"a": @5} andPriority:@991 withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];

    ready = NO;
    [reader setValue:@{@"a": @19} withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];

    ready = NO;
    [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        id pri = [snapshot priority];
        XCTAssertTrue([NSNull null] == pri, @"Expected null priority");
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];
}

- (void) testGetPriorityReturnsCorrectType {
    FIRDatabaseReference *ref = [FTestHelpers getRandomNode];
    __block FIRDataSnapshot * snap = nil;

    [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        snap = snapshot;
    }];

    [ref setValue:@"a"];
    [self waitUntil:^BOOL{
        return snap != nil;
    }];

    XCTAssertTrue([snap priority] == [NSNull null], @"Expect null priority");
    snap = nil;

    [ref setValue:@"b" andPriority:@5];
    [self waitUntil:^BOOL{
        return snap != nil;
    }];

    XCTAssertTrue([[snap priority] isEqualToNumber:@5], @"Expect priority");
    snap = nil;

    [ref setValue:@"c" andPriority:@"6"];
    [self waitUntil:^BOOL{
        return snap != nil;
    }];

    XCTAssertTrue([[snap priority] isEqualToString:@"6"], @"Expect priority");
    snap = nil;

    [ref setValue:@"d" andPriority:@7];
    [self waitUntil:^BOOL{
        return snap != nil;
    }];

    XCTAssertTrue([[snap priority] isEqualToNumber:@7], @"Expect priority");
    snap = nil;

    [ref setValue:@{@".value": @"e", @".priority": @8}];
    [self waitUntil:^BOOL{
        return snap != nil;
    }];

    XCTAssertTrue([[snap priority] isEqualToNumber:@8], @"Expect priority");
    snap = nil;

    [ref setValue:@{@".value": @"f", @".priority": @"8"}];
    [self waitUntil:^BOOL{
        return snap != nil;
    }];

    XCTAssertTrue([[snap priority] isEqualToString:@"8"], @"Expect priority");
    snap = nil;

    [ref setValue:@{@".value": @"e", @".priority": [NSNull null]}];
    [self waitUntil:^BOOL{
        return snap != nil;
    }];

    XCTAssertTrue([snap priority] == [NSNull null], @"Expect priority");
    snap = nil;

}

- (void) testExportValIncludesPriorities {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
    NSDictionary* contents = @{@"foo": @{@"bar": @{@".value": @5, @".priority": @7}, @".priority": @"hi"}};
    __block FIRDataSnapshot * snap = nil;
    [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        snap = snapshot;
    }];
    [ref setValue:contents];

    [self waitUntil:^BOOL{
        return snap != nil;
    }];

    XCTAssertTrue([contents isEqualToDictionary:[snap valueInExportFormat]], @"Expected priorities in snapshot");
}

- (void) testPriorityIsOverwrittenByServer {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * reader = refs.one;
    FIRDatabaseReference * writer = refs.two;

    __block int event = 0;
    __block BOOL done = NO;
    [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        NSLog(@"%@ Snapshot", snapshot);
        id pri = [snapshot priority];
        if (event == 0) {
            XCTAssertTrue([@100 isEqualToNumber:pri], @"Expect local priority. Got %@ instead.", pri);
        } else if (event == 1) {
            XCTAssertTrue(pri == [NSNull null], @"Expect remote priority. Got %@ instead.", pri);
        } else {
            XCTFail(@"Extra event");
        }
        event++;
        if (event == 2) {
            done = YES;
        }
    }];

    [writer observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        id pri = [snapshot priority];
        if ([[pri class] isSubclassOfClass:[NSNumber class]] && [@100 isEqualToNumber:pri]) {
            [writer setValue:@"whatever"];
        }
    }];

    [reader setValue:@"hi" andPriority:@100];
    [self waitUntil:^BOOL{
        return done;
    }];
}

- (void) testLargeNumericPrioritiesWork {
    NSNumber* bigPriority = @1356721306842;
    __block BOOL ready = NO;
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * reader = refs.one;
    FIRDatabaseReference * writer = refs.two;

    [self waitForCompletionOf:writer setValue:@5 andPriority:bigPriority];

    __block NSNumber* serverPriority = @0;
    [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        serverPriority = [snapshot priority];
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];

    XCTAssertTrue([bigPriority isEqualToNumber:serverPriority], @"Expect big priority back");
}

- (void) testToString {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
    FIRDatabaseReference * parent = [ref parent];

    XCTAssertTrue([[parent description] isEqualToString:self.databaseURL], @"Expect domain");
    FIRDatabaseReference * child = [parent child:@"a/b/c"];
    NSString* expected = [NSString stringWithFormat:@"%@/a/b/c", self.databaseURL];
    XCTAssertTrue([[child description] isEqualToString:expected], @"Expected path");
}

- (void) testURLEncodingOfDescriptionAndURLDecodingOfNewFirebase {
    __block BOOL ready = NO;
    NSString* test1 = [NSString stringWithFormat:@"%@/a%%b&c@d/space: /non-ascii_character:ø", self.databaseURL];
    NSString* expected1 = [NSString stringWithFormat:@"%@/a%%25b%%26c%%40d/space%%3A%%20/non-ascii_character%%3A%%C3%%B8", self.databaseURL];
    FIRDatabaseReference * ref = [[FIRDatabase database] referenceFromURL:test1];
    NSString* result = [ref description];
    XCTAssertTrue([result isEqualToString:expected1], @"Encodes properly");

    int rnd = arc4random_uniform(100000000);
    NSString* path = [NSString stringWithFormat:@"%i", rnd];
    [[ref child:path] setValue:@"testdata" withCompletionBlock:^(NSError* error, FIRDatabaseReference * childRef) {
        FIRDatabaseReference * other = [[FIRDatabase database] referenceFromURL:[ref description]];
        [[other child:path] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
            NSString *val = snapshot.value;
            XCTAssertTrue([val isEqualToString:@"testdata"], @"Expected to get testdata back");
            ready = YES;
        }];
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];
}

- (void) testNameAtRootAndNonRootLocations {
    FIRDatabaseReference * ref = [[FIRDatabase database] referenceFromURL:self.databaseURL];
    XCTAssertTrue(ref.key == nil, @"Root key should be nil");
    FIRDatabaseReference * child = [ref child:@"a"];
    XCTAssertTrue([child.key isEqualToString:@"a"], @"Should be 'a'");
    FIRDatabaseReference * deeperChild = [child child:@"b/c"];
    XCTAssertTrue([deeperChild.key isEqualToString:@"c"], @"Should be 'c'");
}

- (void) testNameAndRefOnSnapshotsForRootAndNonRootLocations {
    FIRDatabaseReference * ref = [[FIRDatabase database] reference];

    __block BOOL ready = NO;
    [ref removeValueWithCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];

    ready = NO;
    [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        XCTAssertTrue(snapshot.key == nil, @"Root snap should not have a key");
        NSString *snapString = [snapshot.ref description];
        XCTAssertTrue([snapString isEqualToString:snapString], @"Refs should be equivalent");
        FIRDataSnapshot *childSnap = [snapshot childSnapshotForPath:@"a"];
        XCTAssertTrue([childSnap.key isEqualToString:@"a"], @"Properly keys children");
        FIRDatabaseReference *childRef = [ref child:@"a"];
        NSString *refString = [childRef description];
        snapString = [childSnap.ref description];
        XCTAssertTrue([refString isEqualToString:snapString], @"Refs should be equivalent");
        childSnap = [childSnap childSnapshotForPath:@"b/c"];
        childRef = [childRef child:@"b/c"];
        XCTAssertTrue([childSnap.key isEqualToString:@"c"], @"properly keys children");
        refString = [childRef description];
        snapString = [childSnap.ref description];
        XCTAssertTrue([refString isEqualToString:snapString], @"Refs should be equivalent");
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];

    ready = NO;
    // generate value event at root
    [ref setValue:@"foo"];

    [self waitUntil:^BOOL{
        return ready;
    }];
}

- (void) testParentForRootAndNonRootLocations {
    FIRDatabaseReference * ref = [[FIRDatabase database] reference];

    XCTAssertTrue(ref.parent == nil, @"Parent of root should be nil");

    FIRDatabaseReference * child = [ref child:@"a"];
    XCTAssertTrue([[child.parent description] isEqualToString:[ref description]], @"Should be equivalent locations");
    child = [ref child:@"a/b/c"];
    XCTAssertTrue([[child.parent.parent.parent description] isEqualToString:[ref description]], @"Should be equivalent locations");
}

- (void) testSettingNumericKeysConvertsToStrings {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];

    NSDictionary* toSet = @{@4: @"hi", @5: @"test"};

    XCTAssertThrows([ref setValue:toSet], @"Keys must be strings");
}

- (void) testSetChildAndListenAtRootRegressionTest {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * writer = refs.one;
    FIRDatabaseReference * reader = refs.two;

    __block BOOL ready = NO;
    [writer removeValue];
    [[writer child:@"foo"] setValue:@"hi" withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
            NSDictionary *val = [snapshot value];
            NSDictionary *expected = @{@"foo" : @"hi"};
            XCTAssertTrue([val isEqualToDictionary:expected], @"Got child");
            ready = YES;
        }];
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];
}


- (void) testAccessingInvalidPathsThrows {
    NSArray* badPaths = @[
        @".test",
        @"test.",
        @"fo$o",
        @"[what",
        @"ever]",
        @"ha#sh"
    ];

    for (NSString* key in badPaths) {
        NSString* url = [NSString stringWithFormat:@"%@/%@", self.databaseURL, key];
        XCTAssertThrows(^{
            FIRDatabaseReference * ref = [[FIRDatabase database] referenceFromURL:url];
            XCTFail(@"Should not get here with ref: %@", ref);
        }(), @"should throw");
        url = [NSString stringWithFormat:@"%@/TESTS/%@", self.databaseURL, key];
        XCTAssertThrows(^{
            FIRDatabaseReference * ref = [[FIRDatabase database] referenceFromURL:url];
            XCTFail(@"Should not get here with ref: %@", ref);
        }(), @"should throw");
    }

    __block BOOL ready = NO;
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
    [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        for (NSString *key in badPaths) {
            XCTAssertThrows([snapshot childSnapshotForPath:key], @"should throw");
            XCTAssertThrows([snapshot hasChild:key], @"should throw");
        }
        ready = YES;
    }];
    [ref setValue:nil];

    [self waitUntil:^BOOL{
        return ready;
    }];
}

- (void) testSettingObjectsAtInvalidKeysThrow {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
    NSArray* badPaths = @[
        @".test",
        @"test.",
        @"fo$o",
        @"[what",
        @"ever]",
        @"ha#sh",
        @"/thing",
        @"th/ing",
        @"thing/"
    ];
    NSMutableArray* badObjs = [[NSMutableArray alloc] init];
    for (NSString* key in badPaths) {
        [badObjs addObject:@{key: @"test"}];
        [badObjs addObject:@{@"deeper": @{key: @"test"}}];
    }

    for (NSDictionary* badObj in badObjs) {
        XCTAssertThrows([ref setValue:badObj], @"Should throw");
        XCTAssertThrows([ref setValue:badObj andPriority:@5], @"Should throw");
        XCTAssertThrows([ref onDisconnectSetValue:badObj], @"Should throw");
        XCTAssertThrows([ref onDisconnectSetValue:badObj andPriority:@5], @"Should throw");
        // XXX transaction
    }
}

- (void) testSettingInvalidObjectsThrow {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];

    XCTAssertThrows([ref setValue:[NSDate date]], @"Should throw");

    NSDictionary *data = @{@"invalid":@"data", @".sv":@"timestamp"};
    XCTAssertThrows([ref setValue:data], @"Should throw");

    data = @{@".value": @{}};
    XCTAssertThrows([ref setValue:data], @"Should throw");
}

- (void) testInvalidUpdateThrow {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
    NSArray *badUpdates = @[
                            @{@"/":@"t", @"a":@"t"},
                            @{@"a":@"t", @"a/b":@"t"},
                            @{@"/a":@"t", @"a/b":@"t"},
                            @{@"/a/b":@"t", @"a":@"t"},
                            @{@"/a/b/.priority":@"t", @"/a/b":@"t"},
                            @{@"/a/b/.sv":@"timestamp"},
                            @{@"/a/b/.value":@"t"},
                            @{@"/a/b/.priority":@{@"x": @"y"}}];

    for (NSDictionary* update in badUpdates) {
       XCTAssertThrows([ref updateChildValues:update], @"Should throw");
       XCTAssertThrows([ref onDisconnectUpdateChildValues:update], @"Should throw");
    }
}

- (void) testSettingNull {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];

    XCTAssertNoThrow([ref setValue:nil], @"Should not throw");
    XCTAssertNoThrow([ref setValue:[NSNull null]], @"Should not throw");
}

- (void) testSettingNaN {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
    XCTAssertThrows([ref setValue:[NSDecimalNumber notANumber]], @"Should throw");
}

- (void) testSettingInvalidPriority {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
    XCTAssertThrows([ref setValue:@"3" andPriority:[NSDecimalNumber notANumber]], @"Should throw");
    XCTAssertThrows([ref setValue:@"4" andPriority:@{}], @"Should throw");
    XCTAssertThrows([ref setValue:@"5" andPriority:@[]], @"Should throw");
}

- (void) testRemoveFromOnMobileGraffitiBugAtAngelHack {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];

    __block BOOL done = NO;

    [node observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
        [[node child:[snapshot key]] removeValueWithCompletionBlock:^(NSError *err, FIRDatabaseReference *ref) {
            done = YES;
        }];
    }];

    [[node childByAutoId] setValue:@"moo"];

    [self waitUntil:^BOOL{
        return done;
    }];

    XCTAssertTrue(done, @"Properly finished");
}

- (void) testSetANodeWithAQuotedKey {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];

    __block BOOL done = NO;
    __block FIRDataSnapshot * snap;

    [node observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        snap = snapshot;
    }];

    [node setValue:@{@"\"herp\"": @1234} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
        done = YES;
        XCTAssertEqualObjects(@1234, [[snap childSnapshotForPath:@"\"herp\""] value], @"Got it back");
    }];

    [self waitUntil:^BOOL{
        return done;
    }];

    XCTAssertTrue(done, @"Properly finished");
}

- (void) testSetANodeWithASingleQuoteKey {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];

    __block BOOL done = NO;
    __block FIRDataSnapshot * snap;

    [node observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        snap = snapshot;
    }];

    [node setValue:@{@"\"": @1234} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
        done = YES;
        XCTAssertEqualObjects(@1234, [[snap childSnapshotForPath:@"\""] value], @"Got it back");
    }];

    [self waitUntil:^BOOL{
        return done;
    }];

    XCTAssertTrue(done, @"Properly finished");
}

- (void) testEmptyChildGetValueEventBeforeParent {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];

    NSArray* lookingFor = @[
            [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a/aa/aaa"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeValue withString:nil],
    ];

    FEventTester* et = [[FEventTester alloc] initFrom:self];
    [et addLookingFor:lookingFor];

    [node setValue:@{@"b": @5}];

    [et wait];

}

// iOS behavior is different from what the recursive set test looks for. We don't raise events synchronously

- (void) testOnAfterSetWaitsForLatestData {
    // We test here that we don't cache sets, but they would be persisted so make sure we are running without
    // persistence
    FTupleFirebase* refs = [FTestHelpers getRandomNodePairWithoutPersistence];
    FIRDatabaseReference * node1 = refs.one;
    FIRDatabaseReference * node2 = refs.two;

    __block BOOL ready = NO;
    [node1 setValue:@5 withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        [node2 setValue:@42 withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
            ready = YES;
        }];
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];

    ready = NO;

    [node1 observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        NSNumber *val = [snapshot value];
        XCTAssertTrue([val isEqualToNumber:@42], @"Should not have cached earlier set");
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];
}

- (void) testOnceWaitsForLatestData {
    // Can't tolerate stale data; so disable persistence.
    FTupleFirebase* refs = [FTestHelpers getRandomNodePairWithoutPersistence];
    FIRDatabaseReference * node1 = refs.one;
    FIRDatabaseReference * node2 = refs.two;

    __block BOOL ready = NO;

    [node1 observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        id val = [snapshot value];
        XCTAssertTrue([NSNull null] == val, @"First value should be null");

        [node2 setValue:@5 withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) {
            [node1 observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
                NSNumber *val = [snapshot value];
                XCTAssertTrue([val isKindOfClass:[NSNumber class]] && [val isEqualToNumber:@5], @"Should get first value");
                ready = YES;
            }];
        }];
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];

    ready = NO;
    [node2 setValue:@42 withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        [node1 observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
            NSNumber *val = [snapshot value];
            XCTAssertTrue([val isEqualToNumber:@42], @"Got second number");
            ready = YES;
        }];
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];
}

- (void) testMemoryFreeingOnUnlistenDoesNotCorruptData {
    // Can't tolerate stale data; so disable persistence.
    FTupleFirebase* refs = [FTestHelpers getRandomNodePairWithoutPersistence];
    FIRDatabaseReference * node2 = [[refs.one root] childByAutoId];

    __block BOOL hasRun = NO;
    __block BOOL ready = NO;
    FIRDatabaseHandle handle1 = [refs.one observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        if (!hasRun) {
            hasRun = YES;
            id val = [snapshot value];
            XCTAssertTrue([NSNull null] == val, @"First time should be null");
            [refs.one setValue:@"test" withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) {
                ready = YES;
            }];
        }
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];

    [refs.one removeObserverWithHandle:handle1];

    ready = NO;
    [node2 setValue:@"hello" withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        [refs.one observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
            NSString *val = [snapshot value];
            XCTAssertTrue([val isEqualToString:@"test"], @"Get back the value we set above");
            [refs.two observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
                NSString *val = [snapshot value];
                XCTAssertTrue([val isEqualToString:@"test"], @"Get back the value we set above");
                ready = YES;
            }];
        }];
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];

    //write {x: 1, y : {t: 2, u: 3}}
    //Listen at /. Then listen at /x/t
    //unlisten at /y/t. Off at /. Once at /. Ensure data is still all there.
    //Once at /y. Ensure data is still all there.
    refs = [FTestHelpers getRandomNodePairWithoutPersistence];

    ready = NO;
    __block FIRDatabaseHandle deeplisten = NSNotFound;
    __block FIRDatabaseHandle slashlisten = NSNotFound;
    __weak FIRDatabaseReference * refOne = refs.one;
    [refs.one setValue:@{@"x": @1, @"y": @{@"t": @2, @"u": @3}} withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        slashlisten = [refOne observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
            deeplisten = [[refOne child:@"y/t"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
                [[refOne child:@"y/t"] removeObserverWithHandle:deeplisten];
                [refOne removeObserverWithHandle:slashlisten];
                ready = YES;
            }];
        }];
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];

    ready = NO;
    [[refs.one child:@"x"] setValue:@"test" withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        [refs.one observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
            NSDictionary *val = [snapshot value];
            NSDictionary *expected = @{@"x" : @"test", @"y" : @{@"t" : @2, @"u" : @3}};
            XCTAssertTrue([val isEqualToDictionary:expected], @"Got the final value");
            ready = YES;
        }];
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];
}

- (void) testUpdateRaisesCorrectLocalEvents {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];

    __block FIRDataSnapshot * snap = nil;
    [node observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        snap = snapshot;
    }];

    __block BOOL ready = NO;
    [node setValue:@{@"a": @1, @"b": @2, @"c": @3, @"d": @4} withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];

    FEventTester* et = [[FEventTester alloc] initFrom:self];
    NSArray* expectations = @[
            [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"d"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:node withEvent:FIRDataEventTypeChildChanged withString:@"a"],
            [[FTupleEventTypeString alloc] initWithFirebase:node withEvent:FIRDataEventTypeChildChanged withString:@"d"],
            [[FTupleEventTypeString alloc] initWithFirebase:node withEvent:FIRDataEventTypeValue withString:nil]
    ];

    [et addLookingFor:expectations];

    [et waitForInitialization];

    [node updateChildValues:@{@"a": @4, @"d": @1}];

    [et wait];
}

- (void) testUpdateRaisesCorrectRemoteEvents {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * reader = refs.one;
    FIRDatabaseReference * writer = refs.two;

    __block BOOL ready = NO;
    [writer setValue:@{@"a": @1, @"b": @2, @"c": @3, @"d": @4} withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];

    FEventTester* et = [[FEventTester alloc] initFrom:self];
    NSArray* expectations = @[
            [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"a"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"d"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:reader withEvent:FIRDataEventTypeChildChanged withString:@"a"],
            [[FTupleEventTypeString alloc] initWithFirebase:reader withEvent:FIRDataEventTypeChildChanged withString:@"d"],
            [[FTupleEventTypeString alloc] initWithFirebase:reader withEvent:FIRDataEventTypeValue withString:nil]
    ];

    [et addLookingFor:expectations];

    [et waitForInitialization];

    [writer updateChildValues:@{@"a": @4, @"d": @1}];

    [et wait];

    ready = NO;
    [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        NSDictionary *result = [snapshot value];
        NSDictionary *expected = @{@"a" : @4, @"b" : @2, @"c" : @3, @"d" : @1};
        XCTAssertTrue([result isEqualToDictionary:expected], @"Got expected results");
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];
}

- (void) testUpdateChangesAreStoredCorrectlyByTheServer {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * reader = refs.one;
    FIRDatabaseReference * writer = refs.two;

    [self waitForCompletionOf:writer setValue:@{@"a": @1, @"b": @2, @"c": @3, @"d": @4}];

    [self waitForCompletionOf:writer updateChildValues:@{@"a": @42}];

    [self snapWaiter:reader withBlock:^(FIRDataSnapshot *snapshot) {
        NSDictionary* result = [snapshot value];
        NSDictionary* expected = @{@"a": @42, @"b": @2, @"c": @3, @"d": @4};
        XCTAssertTrue([result isEqualToDictionary:expected], @"Expected updated value");
    }];
}

- (void) testUpdateDoesntAffectPriorityLocally {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];

    __block FIRDataSnapshot * snap = nil;
    [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        snap = snapshot;
    }];

    [ref setValue:@{@"a": @1, @"b": @2, @"c": @3} andPriority:@"testpri"];

    [self waitUntil:^BOOL{
        return snap != nil;
    }];

    XCTAssertTrue([[snap priority] isEqualToString:@"testpri"], @"Got initial priority");
    snap = nil;

    [ref updateChildValues:@{@"a": @4}];
    [self waitUntil:^BOOL{
        return snap != nil;
    }];

    XCTAssertTrue([[snap priority] isEqualToString:@"testpri"], @"Got initial priority");
}

- (void) testUpdateDoesntAffectPriorityRemotely {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * reader = refs.one;
    FIRDatabaseReference * writer = refs.two;

    __block BOOL ready = NO;
    [writer setValue:@{@"a": @1, @"b": @2, @"c": @3} andPriority:@"testpri" withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];

    ready = NO;
    [reader observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        NSString *result = [snapshot priority];
        XCTAssertTrue([result isEqualToString:@"testpri"], @"Expected initial priority");
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];

    ready = NO;
    [writer updateChildValues:@{@"a": @4} withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];

    ready = NO;
    [reader observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        NSString *result = [snapshot priority];
        XCTAssertTrue([result isEqualToString:@"testpri"], @"Expected initial priority");
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];
}

- (void) testUpdateReplacesChildrenAndIsNotRecursive {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * reader = refs.one;
    FIRDatabaseReference * writer = refs.two;

    __block FIRDataSnapshot * localSnap = nil;
    __block BOOL ready = NO;

    [writer observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        localSnap = snapshot;
    }];

    [writer setValue:@{@"a": @{@"aa": @1, @"ab": @2}}];
    [writer updateChildValues:@{@"a": @{@"aa": @1}} withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];

    ready = NO;

    [reader observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        NSDictionary *result = [snapshot value];
        NSDictionary *expected = @{@"a" : @{@"aa" : @1}};
        XCTAssertTrue([result isEqualToDictionary:expected], @"Should get new value");
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        NSDictionary* result = [localSnap value];
        NSDictionary* expected = @{@"a": @{@"aa": @1}};
        return ready && [result isEqualToDictionary:expected];
    }];
}

- (void) testDeepUpdatesWork {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * reader = refs.one;
    FIRDatabaseReference * writer = refs.two;

    __block FIRDataSnapshot * localSnap = nil;
    __block BOOL ready = NO;

    [writer observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        localSnap = snapshot;
    }];

    [writer setValue:@{@"a": @{@"aa": @1, @"ab": @2}}];
    [writer updateChildValues:@{@"a/aa": @10,
                                @".priority": @3.0,
                                @"a/ab": @{@".priority": @2.0,
                                           @".value": @20}}
          withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];
    ready = NO;

    [reader observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        NSDictionary *result = [snapshot value];
        NSDictionary *expected = @{@"a" : @{@"aa" : @10, @"ab" : @20}};
        XCTAssertTrue([result isEqualToDictionary:expected], @"Should get new value");
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        NSDictionary* result = [localSnap value];
        NSDictionary* expected = @{@"a": @{@"aa": @10, @"ab": @20}};
        return ready && [result isEqualToDictionary:expected];
    }];
}

// Type signature means we don't need a test for updating scalars. They wouldn't compile

- (void) testEmptyUpdateWorks {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];

    __block BOOL ready = NO;
    [ref updateChildValues:@{} withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        XCTAssertTrue(error == nil, @"Should not be an error");
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];
}

// XXX update stress test

- (void) testUpdateFiresCorrectEventWhenAChildIsDeleted {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * reader = refs.one;
    FIRDatabaseReference * writer = refs.two;

    __block FIRDataSnapshot * localSnap = nil;
    __block FIRDataSnapshot * remoteSnap = nil;

    [self waitForCompletionOf:writer setValue:@{@"a": @12, @"b": @6}];
    [writer observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        localSnap = snapshot;
    }];

    [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        remoteSnap = snapshot;
    }];

    [self waitUntil:^BOOL{
        return localSnap != nil && remoteSnap != nil;
    }];

    localSnap = nil;
    remoteSnap = nil;

    [writer updateChildValues:@{@"a": [NSNull null]}];

    [self waitUntil:^BOOL{
        return localSnap != nil && remoteSnap != nil;
    }];

    NSDictionary* expected = @{@"b": @6};
    XCTAssertTrue([[remoteSnap value] isEqualToDictionary:expected], @"Removed child");
    XCTAssertTrue([[localSnap value] isEqualToDictionary:expected], @"Removed child");
}

- (void) testUpdateFiresCorrectEventOnNewChildren {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * reader = refs.one;
    FIRDatabaseReference * writer = refs.two;

    __block FIRDataSnapshot * localSnap = nil;
    __block FIRDataSnapshot * remoteSnap = nil;

    [[writer child:@"a"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        localSnap = snapshot;
    }];

    [[reader child:@"a"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        remoteSnap = snapshot;
    }];

    [self waitUntil:^BOOL{
        return localSnap != nil && remoteSnap != nil;
    }];

    localSnap = nil;
    remoteSnap = nil;

    [writer updateChildValues:@{@"a": @42}];

    [self waitUntil:^BOOL{
        return localSnap != nil && remoteSnap != nil;
    }];

    XCTAssertTrue([[remoteSnap value] isEqualToNumber:@42], @"Added child");
    XCTAssertTrue([[localSnap value] isEqualToNumber:@42], @"Added child");
}

- (void) testUpdateFiresCorrectEventOnDeletedChildren {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * reader = refs.one;
    FIRDatabaseReference * writer = refs.two;

    __block FIRDataSnapshot * localSnap = nil;
    __block FIRDataSnapshot * remoteSnap = nil;
    [self waitForCompletionOf:writer setValue:@{@"a": @12}];
    [[writer child:@"a"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        localSnap = snapshot;
    }];

    [[reader child:@"a"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        remoteSnap = snapshot;
    }];

    [self waitUntil:^BOOL{
        return localSnap != nil && remoteSnap != nil;
    }];

    localSnap = nil;
    remoteSnap = nil;

    [writer updateChildValues:@{@"a": [NSNull null]}];

    [self waitUntil:^BOOL{
        return localSnap != nil && remoteSnap != nil;
    }];

    XCTAssertTrue([remoteSnap value] == [NSNull null], @"Removed child");
    XCTAssertTrue([localSnap value]  == [NSNull null], @"Removed child");
}

- (void) testUpdateFiresCorrectEventOnChangedChildren {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * reader = refs.one;
    FIRDatabaseReference * writer = refs.two;

    [self waitForCompletionOf:writer setValue:@{@"a": @12}];

    __block FIRDataSnapshot * localSnap = nil;
    __block FIRDataSnapshot * remoteSnap = nil;

    [[writer child:@"a"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        localSnap = snapshot;
    }];

    [[reader child:@"a"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        remoteSnap = snapshot;
    }];

    [self waitUntil:^BOOL{
        return localSnap != nil && remoteSnap != nil;
    }];

    localSnap = nil;
    remoteSnap = nil;

    [self waitForCompletionOf:writer updateChildValues:@{@"a": @11}];

    [self waitUntil:^BOOL{
        return localSnap != nil && remoteSnap != nil;
    }];

    XCTAssertTrue([[remoteSnap value] isEqualToNumber:@11], @"Changed child");
    XCTAssertTrue([[localSnap value] isEqualToNumber:@11], @"Changed child");
}


- (void) testUpdateOfPriorityWorks {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * reader = refs.one;
    FIRDatabaseReference * writer = refs.two;

    __block BOOL ready = NO;
    [writer setValue:@{@"a": @5, @".priority": @"pri1"}];
    [writer updateChildValues:@{@"a": @6, @".priority": @"pri2", @"b": @{ @".priority": @"pri3", @"c": @10 } } withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        NSLog(@"error? %@", error);
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];

    ready = NO;

    [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        XCTAssertEqualObjects([[snapshot childSnapshotForPath:@"a"] value], @6, @"Should match write values");
        XCTAssertTrue([[snapshot priority] isEqualToString:@"pri2"], @"Should get updated priority");
        XCTAssertTrue([[[snapshot childSnapshotForPath:@"b"] priority] isEqualToString:@"pri3"], @"Should get updated priority");
        XCTAssertEqualObjects([[snapshot childSnapshotForPath:@"b/c"] value], @10, @"Should match write values");
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];
}

- (void) testSetWithCircularReferenceFails {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];

    NSMutableDictionary* toSet = [[NSMutableDictionary alloc] init];
    NSDictionary* lol = @{@"foo": @"bar", @"circular": toSet};
    [toSet setObject:lol forKey:@"lol"];

    XCTAssertThrows([ref setValue:toSet], @"Should not be able to set circular dictionary");
}

- (void) testLargeNumbers {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];

    long long jsMaxInt = 9007199254740992;
    long jsMaxIntPlusOne = (long)jsMaxInt + 1;
    NSNumber* toSet = [NSNumber numberWithLong:jsMaxIntPlusOne];
    [ref setValue:toSet];

    __block FIRDataSnapshot * snap = nil;
    [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        snap = snapshot;
    }];

    [self waitUntil:^BOOL{
        return snap != nil;
    }];

    NSNumber* result = [snap value];
    XCTAssertTrue([result isEqualToNumber:toSet], @"Should get back same number");

    toSet = [NSNumber numberWithLong:LONG_MAX];
    snap = nil;

    [ref setValue:toSet];

    [self waitUntil:^BOOL{
        return snap != nil;
    }];

    result = [snap value];
    XCTAssertTrue([result isEqualToNumber:toSet], @"Should get back same number");

    snap = nil;
    toSet = [NSNumber numberWithDouble:DBL_MAX];
    [ref setValue:toSet];

    [self waitUntil:^BOOL{
        return snap != nil;
    }];

    result = [snap value];
    XCTAssertTrue([result isEqualToNumber:toSet], @"Should get back same number");
}

#ifdef FLAKY_TEST
- (void) testParentDeleteShadowsChildListeners {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * writer = refs.one;
    FIRDatabaseReference * deleter = refs.two;

    NSString* childName = [writer childByAutoId].key;

    __block BOOL called = NO;
    [[deleter child:childName] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        XCTAssertFalse(called, @"Should only be hit once");
        called = YES;
        XCTAssertTrue(snapshot.value == [NSNull null], @"Value should be null");
    }];

    WAIT_FOR(called);

   __block BOOL done = NO;
    [[writer child:childName] setValue:@"foo"];
    [deleter removeValueWithCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        done = YES;
    }];

    WAIT_FOR(done);
    [deleter removeAllObservers];
}
#endif

- (void) testParentDeleteShadowsChildListenersWithNonDefaultQuery {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * writer = refs.one;
    FIRDatabaseReference * deleter = refs.two;

    NSString* childName = [writer childByAutoId].key;

    __block BOOL queryCalled = NO;
    __block BOOL deepChildCalled = NO;
    [[[[deleter child:childName] queryOrderedByPriority] queryStartingAtValue:nil childKey:@"b"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        XCTAssertFalse(queryCalled, @"Should only be hit once");
        queryCalled = YES;
        XCTAssertTrue(snapshot.value == [NSNull null], @"Value should be null");
    }];

    [[[deleter child:childName] child:@"a"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        XCTAssertFalse(deepChildCalled, @"Should only be hit once");
        deepChildCalled = YES;
        XCTAssertTrue(snapshot.value == [NSNull null], @"Value should be null");
    }];

    WAIT_FOR(deepChildCalled && queryCalled);

    __block BOOL done = NO;
    [[writer child:childName] setValue:@"foo"];
    [deleter removeValueWithCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        done = YES;
    }];

    WAIT_FOR(done);
}

- (void) testLocalServerValuesEventuallyButNotImmediatelyMatchServer {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference* writer = refs.one;
    FIRDatabaseReference* reader = refs.two;
    __block int done = 0;

    NSMutableArray* readSnaps = [[NSMutableArray alloc] init];
    NSMutableArray* writeSnaps = [[NSMutableArray alloc] init];

    [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        if ([snapshot value] != [NSNull null]) {
            [readSnaps addObject:snapshot];
            if (readSnaps.count == 1) {
                done += 1;
            }
        }
    }];

    [writer observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        if ([snapshot value] != [NSNull null]) {
            [writeSnaps addObject:snapshot];
            if (writeSnaps.count == 2) {
                done += 1;
            }
        }
    }];

    [writer setValue:[FIRServerValue timestamp] andPriority:[FIRServerValue timestamp]];

    [self waitUntil:^BOOL{
        return done == 2;
    }];

    XCTAssertEqual((unsigned long)[readSnaps count], (unsigned long)1, @"Should have received one snapshot on reader");
    XCTAssertEqual((unsigned long)[writeSnaps count], (unsigned long)2, @"Should have received two snapshots on writer");

    FIRDataSnapshot * firstReadSnap = [readSnaps objectAtIndex:0];
    FIRDataSnapshot * firstWriteSnap = [writeSnaps objectAtIndex:0];
    FIRDataSnapshot * secondWriteSnap = [writeSnaps objectAtIndex:1];

    NSNumber* now = [NSNumber numberWithDouble:round([[NSDate date] timeIntervalSince1970]*1000)];
    XCTAssertTrue([now doubleValue] - [firstWriteSnap.value doubleValue] < 3000, @"Should have received a local event with a value close to timestamp");
    XCTAssertTrue([now doubleValue] - [firstWriteSnap.priority doubleValue] < 3000, @"Should have received a local event with a priority close to timestamp");
    XCTAssertTrue([now doubleValue] - [secondWriteSnap.value doubleValue] < 3000, @"Should have received a server event with a value close to timestamp");
    XCTAssertTrue([now doubleValue] - [secondWriteSnap.priority doubleValue] < 3000, @"Should have received a server event with a priority close to timestamp");

    XCTAssertFalse([firstWriteSnap value] == [secondWriteSnap value], @"Initial and future writer values should be different");
    XCTAssertFalse([firstWriteSnap priority] == [secondWriteSnap priority], @"Initial and future writer priorities should be different");
    XCTAssertEqualObjects(firstReadSnap.value, secondWriteSnap.value, @"Eventual reader and writer values should be equal");
    XCTAssertEqualObjects(firstReadSnap.priority, secondWriteSnap.priority, @"Eventual reader and writer priorities should be equal");
}

- (void) testServerValuesSetWithPriorityRemoteEvents {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * writer = refs.one;
    FIRDatabaseReference * reader = refs.two;

    NSDictionary* data = @{
      @"a": [FIRServerValue timestamp],
      @"b": @{
        @".value": [FIRServerValue timestamp],
        @".priority": [FIRServerValue timestamp]
      }
    };

    __block BOOL done = NO;
    [writer setValue:data andPriority:[FIRServerValue timestamp] withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) { done = YES; }];

    [self waitUntil:^BOOL{
        return done;
    }];

    [self snapWaiter:reader withBlock:^(FIRDataSnapshot *snapshot) {
        NSDictionary* value = [snapshot value];
        NSNumber* now = [NSNumber numberWithDouble:round([[NSDate date] timeIntervalSince1970]*1000)];
        NSNumber* timestamp = [snapshot priority];
        XCTAssertTrue([[snapshot priority] isKindOfClass:[NSNumber class]], @"Should get back number");
        XCTAssertTrue([now doubleValue] - [timestamp doubleValue] < 2000, @"Number should be no more than 2 seconds ago");
        XCTAssertEqualObjects([snapshot priority], [value objectForKey:@"a"], @"Should get back matching ServerValue.TIMESTAMP");
        XCTAssertEqualObjects([snapshot priority], [value objectForKey:@"b"], @"Should get back matching ServerValue.TIMESTAMP");
        XCTAssertEqualObjects([snapshot priority], [[snapshot childSnapshotForPath:@"b"] priority], @"Should get back matching ServerValue.TIMESTAMP");
    }];
}

- (void) testServerValuesSetPriorityRemoteEvents {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * writer = refs.one;
    FIRDatabaseReference * reader = refs.two;

    __block FIRDataSnapshot *snap = nil;
    [reader observeEventType:FIRDataEventTypeChildMoved withBlock:^(FIRDataSnapshot *snapshot) {
        snap = snapshot;
    }];

    [self waitForCompletionOf:[writer child:@"a"] setValue:@1 andPriority:nil];
    [self waitForCompletionOf:[writer child:@"b"] setValue:@1 andPriority:@1];
    [self waitForValueOf:[reader child:@"a"] toBe:@1];

    __block BOOL done = NO;
    [[writer child:@"a"] setPriority:[FIRServerValue timestamp] withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
        done = YES;
    }];

    [self waitUntil:^BOOL{
        return done && snap != nil;
    }];

    NSNumber* now = [NSNumber numberWithDouble:round([[NSDate date] timeIntervalSince1970]*1000)];
    NSNumber* timestamp = [snap priority];
    XCTAssertTrue([[snap priority] isKindOfClass:[NSNumber class]], @"Should get back number");
    XCTAssertTrue([now doubleValue] - [timestamp doubleValue] < 2000, @"Number should be no more than 2 seconds ago");
}

- (void) testServerValuesUpdateRemoteEvents {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * writer = refs.one;
    FIRDatabaseReference * reader = refs.two;

    __block FIRDataSnapshot *snap = nil;
    __block BOOL done = NO;
    [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        snap = snapshot;
        if (snap && [[snap childSnapshotForPath:@"a/b/d"] value] != [NSNull null]) {
            done = YES;
        }
    }];

    [[writer child:@"a/b/c"] setValue:@1];
    [[writer child:@"a"] updateChildValues:@{ @"b": @{ @"c": [FIRServerValue timestamp], @"d":@1 } }];

    [self waitUntil:^BOOL{
        return done;
    }];

    NSNumber* now = [NSNumber numberWithDouble:round([[NSDate date] timeIntervalSince1970]*1000)];
    NSNumber* timestamp = [[snap childSnapshotForPath:@"a/b/c"] value];
    XCTAssertTrue([[[snap childSnapshotForPath:@"a/b/c"] value] isKindOfClass:[NSNumber class]], @"Should get back number");
    XCTAssertTrue([now doubleValue] - [timestamp doubleValue] < 2000, @"Number should be no more than 2 seconds ago");
}

- (void) testServerValuesSetWithPriorityLocalEvents {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];

    NSDictionary* data = @{
      @"a": [FIRServerValue timestamp],
      @"b": @{
        @".value": [FIRServerValue timestamp],
        @".priority": [FIRServerValue timestamp]
      }
    };

    __block FIRDataSnapshot *snap = nil;
    [node observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        snap = snapshot;
    }];

    __block BOOL done = NO;
    [node setValue:data andPriority:[FIRServerValue timestamp] withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) { done = YES; }];

    [self waitUntil:^BOOL{
        return done;
    }];

    [self snapWaiter:node withBlock:^(FIRDataSnapshot *snapshot) {
        NSDictionary* value = [snapshot value];
        NSNumber* now = [NSNumber numberWithDouble:round([[NSDate date] timeIntervalSince1970]*1000)];
        NSNumber* timestamp = [snapshot priority];
        XCTAssertTrue([[snapshot priority] isKindOfClass:[NSNumber class]], @"Should get back number");
        XCTAssertTrue([now doubleValue] - [timestamp doubleValue] < 2000, @"Number should be no more than 2 seconds ago");
        XCTAssertEqualObjects([snapshot priority], [value objectForKey:@"a"], @"Should get back matching ServerValue.TIMESTAMP");
        XCTAssertEqualObjects([snapshot priority], [value objectForKey:@"b"], @"Should get back matching ServerValue.TIMESTAMP");
        XCTAssertEqualObjects([snapshot priority], [[snapshot childSnapshotForPath:@"b"] priority], @"Should get back matching ServerValue.TIMESTAMP");
    }];
}

- (void) testServerValuesSetPriorityLocalEvents {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];

    __block FIRDataSnapshot *snap = nil;
    [node observeEventType:FIRDataEventTypeChildMoved withBlock:^(FIRDataSnapshot *snapshot) {
        snap = snapshot;
    }];

    __block BOOL done = NO;

    [[node child:@"a"] setValue:@1 andPriority:nil];
    [[node child:@"b"] setValue:@1 andPriority:@1];
    [[node child:@"a"] setPriority:[FIRServerValue timestamp] withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
      done = YES;
    }];

    [self waitUntil:^BOOL{
        return done;
    }];

    NSNumber* now = [NSNumber numberWithDouble:round([[NSDate date] timeIntervalSince1970]*1000)];
    NSNumber* timestamp = [snap priority];
    XCTAssertTrue([[snap priority] isKindOfClass:[NSNumber class]], @"Should get back number");
    XCTAssertTrue([now doubleValue] - [timestamp doubleValue] < 2000, @"Number should be no more than 2 seconds ago");
}

- (void) testServerValuesUpdateLocalEvents {
    FIRDatabaseReference * node1 = [FTestHelpers getRandomNode];

    __block FIRDataSnapshot *snap1 = nil;
    [node1 observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        snap1 = snapshot;
    }];

    __block FIRDataSnapshot *snap2 = nil;
    [node1 observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        snap2 = snapshot;
    }];

    [node1 runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        [currentData setValue:[FIRServerValue timestamp]];
        return [FIRTransactionResult successWithValue:currentData];
    }];

    [self waitUntil:^BOOL{
        return snap1 != nil && snap2 != nil && [snap1 value] != nil  && [snap2 value] != nil;
    }];

    NSNumber* now = [NSNumber numberWithDouble:round([[NSDate date] timeIntervalSince1970]*1000)];

    NSNumber* timestamp1 = [snap1 value];
    XCTAssertTrue([[snap1 value] isKindOfClass:[NSNumber class]], @"Should get back number");
    XCTAssertTrue([now doubleValue] - [timestamp1 doubleValue] < 2000, @"Number should be no more than 2 seconds ago");

    NSNumber* timestamp2 = [snap2 value];
    XCTAssertTrue([[snap2 value] isKindOfClass:[NSNumber class]], @"Should get back number");
    XCTAssertTrue([now doubleValue] - [timestamp2 doubleValue] < 2000, @"Number should be no more than 2 seconds ago");
}

- (void) testServerValuesTransactionLocalEvents {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];

    __block FIRDataSnapshot *snap = nil;
    [node observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        snap = snapshot;
    }];

    [[node child:@"a/b/c"] setValue:@1];
    [[node child:@"a"] updateChildValues:@{ @"b": @{ @"c": [FIRServerValue timestamp], @"d":@1 } }];

    [self waitUntil:^BOOL{
        return snap != nil && [[snap childSnapshotForPath:@"a/b/d"] value] != nil;
    }];

    NSNumber* now = [NSNumber numberWithDouble:round([[NSDate date] timeIntervalSince1970]*1000)];
    NSNumber* timestamp = [[snap childSnapshotForPath:@"a/b/c"] value];
    XCTAssertTrue([[[snap childSnapshotForPath:@"a/b/c"] value] isKindOfClass:[NSNumber class]], @"Should get back number");
    XCTAssertTrue([now doubleValue] - [timestamp doubleValue] < 2000, @"Number should be no more than 2 seconds ago");
}

- (void) testUpdateAfterChildSet {
    FIRDatabaseReference *node = [FTestHelpers getRandomNode];

    __block BOOL done = NO;
    __weak FIRDatabaseReference *weakRef = node;
    [node setValue:@{@"a": @"a"} withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) {
        [weakRef observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
            if (snapshot.childrenCount == 3 && [snapshot hasChild:@"a"] && [snapshot hasChild:@"b"] && [snapshot hasChild:@"c"]) {
                done = YES;
            }
        }];

        [[weakRef child:@"b"] setValue:@"b"];

        [weakRef updateChildValues:@{@"c" : @"c"}];
    }];

    [self waitUntil:^BOOL{
        return done;
    }];
}

- (void) testDeltaSyncNoDataUpdatesAfterReconnect {
    FIRDatabaseReference *ref = [FTestHelpers getRandomNode];
    FIRDatabaseConfig *cfg = [FTestHelpers configForName:@"test-config"];
    FIRDatabaseReference * ref2 = [[[FIRDatabaseReference alloc] initWithConfig:cfg] child:ref.key];
    __block id data = @{ @"a": @1, @"b": @2, @"c": @{ @".priority": @3, @".value": @3}, @"d": @4 };
    [self waitForCompletionOf:ref setValue:data];

    __block BOOL gotData = NO;
    [ref2 observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        XCTAssertFalse(gotData, @"event triggered twice.");
        gotData = YES;
        XCTAssertEqualObjects(snapshot.valueInExportFormat, data, @"Got wrong data.");
    }];

    [self waitUntil:^BOOL{ return gotData; }];

    __block BOOL done = NO;
    XCTAssertEqual(ref2.repo.dataUpdateCount, 1L, @"Should have gotten one update.");

    // Bounce connection
    [FRepoManager interrupt:cfg];
    [FRepoManager resume:cfg];

    [[[ref2 root] child:@".info/connected"] observeEventType:FIRDataEventTypeValue
        withBlock:^(FIRDataSnapshot *snapshot) {
            if ([snapshot.value boolValue]) {
                // We're connected.  Do one more round-trip to make sure all state restoration is done
                [[[ref2 root] child:@"foobar/empty/blah"] setValue:nil withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) {
                    XCTAssertEqual(ref2.repo.dataUpdateCount, 1L, @"Should have gotten one update.");
                    done = YES;
                }];
            }
        }
    ];

    [self waitUntil:^BOOL{ return done; }];

    // cleanup
    [FRepoManager interrupt:cfg];
    [FRepoManager disposeRepos:cfg];
}

- (void) testServerValuesEventualConsistencyBetweenLocalAndRemote {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * writer = refs.one;
    FIRDatabaseReference * reader = refs.two;

    __block FIRDataSnapshot *writerSnap = nil;
    __block FIRDataSnapshot *readerSnap = nil;

    [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        readerSnap = snapshot;
    }];

    [writer observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        writerSnap = snapshot;
    }];

    [writer setValue:[FIRServerValue timestamp] andPriority:[FIRServerValue timestamp]];

    [self waitUntil:^BOOL{
      if (readerSnap && writerSnap && [[readerSnap value] isKindOfClass:[NSNumber class]] && [[writerSnap value] isKindOfClass:[NSNumber class]]) {
        if ([[readerSnap value] doubleValue] == [[writerSnap value] doubleValue]) {
          return YES;
        }
      }
      return NO;
    }];
}

// Listens at a location and then creates a bunch of children, waiting for them all to complete.
- (void) testChildAddedPerf1 {
    if (!runPerfTests) return;

    FIRDatabaseReference *ref = [FTestHelpers getRandomNode];
    [ref observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {

    }];

    NSDate *start = [NSDate date];
    int COUNT = 1000;
    __block BOOL done = NO;
    __block NSDate *finished = nil;
    for(int i = 0; i < COUNT; i++) {
        [[ref childByAutoId] setValue:@"01234567890123456789012345678901234567890123456789" withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) {
            if (i == (COUNT - 1)) {
                finished = [NSDate date];
                done = YES;
            }
        }];
    }
    [self waitUntil:^BOOL {
        return done;
    } timeout:300];
    NSTimeInterval elapsed = [finished timeIntervalSinceDate:start];
    NSLog(@"Elapsed: %f", elapsed);
}

// Listens at a location, then adds a bunch of grandchildren under a single child.
- (void) testDeepChildAddedPerf1 {
    if (!runPerfTests) return;

    FIRDatabaseReference *ref = [FTestHelpers getRandomNode],
            *childRef = [ref child:@"child"];

    [ref observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {

    }];

    NSDate *start = [NSDate date];
    int COUNT = 1000;
    __block BOOL done = NO;
    __block NSDate *finished = nil;
    for(int i = 0; i < COUNT; i++) {
        [[childRef childByAutoId] setValue:@"01234567890123456789012345678901234567890123456789" withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) {
            if (i == (COUNT - 1)) {
                finished = [NSDate date];
                done = YES;
            }
        }];
    }
    [self waitUntil:^BOOL {
        return done;
    } timeout:300];

    NSTimeInterval elapsed = [finished timeIntervalSinceDate:start];
    NSLog(@"Elapsed: %f", elapsed);
}

// Listens at a location, then adds a bunch of grandchildren under a single child, but does it with merges.
// NOTE[2015-07-14]: This test is still pretty slow, because [FWriteTree removeWriteId] ends up rebuilding the tree after
// every ack.
- (void) testDeepChildAddedPerfViaMerge1 {
    if (!runPerfTests) return;

    FIRDatabaseReference *ref = [FTestHelpers getRandomNode],
            *childRef = [ref child:@"child"];

    [ref observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {

    }];

    NSDate *start = [NSDate date];
    int COUNT = 250;
    __block BOOL done = NO;
    __block NSDate *finished = nil;
    for(int i = 0; i < COUNT; i++) {
        NSString *childName = [childRef childByAutoId].key;
        [childRef updateChildValues:@{
                childName: @"01234567890123456789012345678901234567890123456789"
        } withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) {
            if (i == (COUNT - 1)) {
                finished = [NSDate date];
                done = YES;
            }
        }];
    }
    [self waitUntil:^BOOL {
        return done;
    } timeout:300];

    NSTimeInterval elapsed = [finished timeIntervalSinceDate:start];
    NSLog(@"Elapsed: %f", elapsed);
}

@end