@react-native-firebase/app 26.4.0 → 27.1.0

package/ios/RNFBAppUnitTests/RNFBJSONTests.m

@@ -0,0 +1,172 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library 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 <XCTest/XCTest.h>
+
+#import "RNFBHandleMapStorage-Swift.inc"
+#import "RNFBJSON.h"
+
+@interface RNFBJSONTests : XCTestCase
+@end
+
+@implementation RNFBJSONTests
+
+- (RNFBJSON *)jsonWithObject:(NSObject *)object {
+  RNFBJSON *json = [[RNFBJSON alloc] init];
+  RNFBJSONImplementation *implementation =
+      [[RNFBJSONImplementation alloc] initWithJSONObject:object];
+  [json setValue:implementation forKey:@"implementation"];
+  return json;
+}
+
+- (void)testSharedUsesStableDispatchOnceIdentity {
+  RNFBJSON *first = RNFBJSON.shared;
+  XCTAssertNotNil(first);
+  XCTAssertIdentical(first, RNFBJSON.shared);
+}
+
+- (void)testPublicSelectorsAndReturnEncodingsAreUnchanged {
+  NSArray<NSString *> *selectorNames = @[
+    @"contains:",
+    @"getBooleanValue:defaultValue:",
+    @"getStringValue:defaultValue:",
+    @"getArrayValue:defaultValue:",
+    @"getAll",
+    @"getRawJSON",
+  ];
+  for (NSString *selectorName in selectorNames) {
+    XCTAssertTrue([[RNFBJSON shared] respondsToSelector:NSSelectorFromString(selectorName)]);
+  }
+  XCTAssertTrue([RNFBJSON respondsToSelector:@selector(shared)]);
+
+  NSMethodSignature *contains = [RNFBJSON instanceMethodSignatureForSelector:@selector(contains:)];
+  XCTAssertEqual(strcmp(contains.methodReturnType, @encode(BOOL)), 0);
+  NSMethodSignature *boolean =
+      [RNFBJSON instanceMethodSignatureForSelector:@selector(getBooleanValue:defaultValue:)];
+  XCTAssertEqual(strcmp(boolean.methodReturnType, @encode(BOOL)), 0);
+  XCTAssertEqual(strcmp([boolean getArgumentTypeAtIndex:3], @encode(BOOL)), 0);
+
+  NSArray<NSString *> *objectReturnSelectors = @[
+    @"getStringValue:defaultValue:", @"getArrayValue:defaultValue:", @"getAll", @"getRawJSON"
+  ];
+  for (NSString *selectorName in objectReturnSelectors) {
+    NSMethodSignature *signature =
+        [RNFBJSON instanceMethodSignatureForSelector:NSSelectorFromString(selectorName)];
+    XCTAssertEqual(strcmp(signature.methodReturnType, @encode(id)), 0);
+  }
+  NSMethodSignature *shared = [RNFBJSON methodSignatureForSelector:@selector(shared)];
+  XCTAssertEqual(strcmp(shared.methodReturnType, @encode(id)), 0);
+}
+
+- (void)testFacadePreservesKVCContainsDefaultsAndUncheckedObjectReturns {
+  NSDictionary *dictionary = @{
+    @"boolean" : @YES,
+    @"booleanFalse" : @NO,
+    @"numericZero" : @0,
+    @"booleanString" : @"YES",
+    @"string" : @"value",
+    @"array" : @[ @"one" ],
+    @"numberAsString" : @42,
+    @"stringAsArray" : @"unchecked",
+    @"null" : NSNull.null,
+    @"count" : @"count value",
+    @"@count" : @"at-count value",
+  };
+  RNFBJSON *json = [self jsonWithObject:dictionary];
+
+  XCTAssertTrue([json contains:@"boolean"]);
+  XCTAssertTrue([json contains:@"booleanFalse"]);
+  XCTAssertTrue([json contains:@"numericZero"]);
+  XCTAssertTrue([json contains:@"null"]);
+  XCTAssertFalse([json contains:@"missing"]);
+  XCTAssertTrue([json getBooleanValue:@"boolean" defaultValue:NO]);
+  XCTAssertFalse([json getBooleanValue:@"booleanFalse" defaultValue:YES]);
+  XCTAssertFalse([json getBooleanValue:@"numericZero" defaultValue:YES]);
+  XCTAssertTrue([json getBooleanValue:@"booleanString" defaultValue:NO]);
+  XCTAssertTrue([json getBooleanValue:@"missing" defaultValue:YES]);
+  XCTAssertEqualObjects([json getStringValue:@"missing" defaultValue:@"fallback"], @"fallback");
+  XCTAssertEqualObjects([json getArrayValue:@"missing" defaultValue:@[ @"fallback" ]],
+                        (@[ @"fallback" ]));
+  XCTAssertEqualObjects([json getStringValue:@"string" defaultValue:@"fallback"], @"value");
+  XCTAssertEqualObjects([json getArrayValue:@"array" defaultValue:@[]], (@[ @"one" ]));
+
+  id uncheckedString = [json getStringValue:@"numberAsString" defaultValue:@"fallback"];
+  id uncheckedArray = [json getArrayValue:@"stringAsArray" defaultValue:@[]];
+  XCTAssertEqualObjects(uncheckedString, @42);
+  XCTAssertEqualObjects(uncheckedArray, @"unchecked");
+  XCTAssertIdentical([json getStringValue:@"null" defaultValue:@"fallback"], NSNull.null);
+
+  for (NSString *key in @[ @"count", @"@count" ]) {
+    XCTAssertEqualObjects([json getStringValue:key defaultValue:@"fallback"],
+                          [dictionary valueForKey:key]);
+    XCTAssertEqual([json contains:key], [dictionary valueForKey:key] != nil);
+  }
+}
+
+- (void)testGetBooleanValueThrowsForNSNullArrayAndDictionaryReceivers {
+  NSDictionary *dictionary = @{
+    @"null" : NSNull.null,
+    @"array" : @[ @"one" ],
+    @"object" : @{@"nested" : @"value"},
+  };
+  RNFBJSON *json = [self jsonWithObject:dictionary];
+
+  XCTAssertThrowsSpecificNamed([json getBooleanValue:@"null" defaultValue:YES], NSException,
+                               NSInvalidArgumentException);
+  XCTAssertThrowsSpecificNamed([json getBooleanValue:@"array" defaultValue:YES], NSException,
+                               NSInvalidArgumentException);
+  XCTAssertThrowsSpecificNamed([json getBooleanValue:@"object" defaultValue:YES], NSException,
+                               NSInvalidArgumentException);
+
+  @try {
+    [json getBooleanValue:@"null" defaultValue:YES];
+    XCTFail(@"expected NSNull boolValue to throw");
+  } @catch (NSException *exception) {
+    XCTAssertEqualObjects(exception.name, NSInvalidArgumentException);
+    XCTAssertTrue([exception.reason containsString:@"boolValue"]);
+  }
+}
+
+- (void)testGetAllCopiesItemsAndReturnsIndependentImmutableSnapshot {
+  NSMutableString *mutableString = [NSMutableString stringWithString:@"before"];
+  NSMutableArray *mutableArray = [NSMutableArray arrayWithObject:@"first"];
+  NSDictionary *source = @{@"string" : mutableString, @"array" : mutableArray};
+  RNFBJSON *json = [self jsonWithObject:source];
+
+  NSDictionary *snapshot = [json getAll];
+
+  XCTAssertNotIdentical(snapshot, source);
+  XCTAssertNotIdentical(snapshot[@"string"], mutableString);
+  XCTAssertNotIdentical(snapshot[@"array"], mutableArray);
+  [mutableString appendString:@"-after"];
+  [mutableArray addObject:@"second"];
+  XCTAssertEqualObjects(snapshot[@"string"], @"before");
+  XCTAssertEqualObjects(snapshot[@"array"], (@[ @"first" ]));
+}
+
+- (void)testGetAllPreservesNonDictionaryExceptionBehavior {
+  RNFBJSON *json = [self jsonWithObject:@[ @"valid", @"JSON", @"array" ]];
+
+  XCTAssertThrowsSpecificNamed([json getAll], NSException, NSInvalidArgumentException);
+}
+
+- (void)testRawFacadeUsesCurrentBundleValueAndSwiftDecoder {
+  NSString *raw = [[NSBundle mainBundle].infoDictionary valueForKey:@"firebase_json_raw"];
+  XCTAssertEqualObjects([RNFBJSON.shared getRawJSON],
+                        [RNFBJSONImplementation rawJSONFromRawValue:raw]);
+}
+
+@end

package/ios/RNFBAppUnitTests/RNFBMetaStorageTests.swift

@@ -0,0 +1,106 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library 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 Foundation
+import XCTest
+
+final class RNFBMetaStorageTests: XCTestCase {
+  private func storage(_ plist: [String: Any]) -> RNFBMetaStorage {
+    RNFBMetaStorage(infoDictionary: plist)
+  }
+
+  func testMissingKeysUseDefaultsAndAreNotContained() {
+    let meta = storage([:])
+
+    XCTAssertFalse(meta.contains("missing"))
+    XCTAssertTrue(meta.getBooleanValue("missing", defaultValue: true))
+    XCTAssertFalse(meta.getBooleanValue("missing", defaultValue: false))
+    XCTAssertEqual(meta.getStringValue("missing", defaultValue: "fallback"), "fallback")
+    XCTAssertEqual(meta.getAll() as NSDictionary, NSDictionary())
+  }
+
+  func testPrefixIsAppliedAndUnprefixedKeysAreIgnored() {
+    let meta = storage([
+      "rnfirebase_present": "value",
+      "other_key": "ignored",
+      "rnfirebase": "not-prefixed-enough",
+    ])
+
+    XCTAssertTrue(meta.contains("present"))
+    XCTAssertFalse(meta.contains("other_key"))
+    XCTAssertEqual(meta.getStringValue("present", defaultValue: "fallback"), "value")
+    XCTAssertEqual(meta.getStringValue("other_key", defaultValue: "fallback"), "fallback")
+
+    let all = meta.getAll()
+    XCTAssertEqual(all as NSDictionary, ["rnfirebase_present": "value"] as NSDictionary)
+    XCTAssertNil(all["other_key"])
+    XCTAssertNil(all["rnfirebase"])
+  }
+
+  func testGetAllReturnsPrefixedKeysUnstripped() {
+    let meta = storage([
+      "rnfirebase_string": "abc",
+      "rnfirebase_boolean_true": true,
+      "rnfirebase_boolean_false": false,
+      "unrelated": 1,
+    ])
+
+    let all = meta.getAll()
+    XCTAssertEqual(Set(all.keys), Set([
+      "rnfirebase_string",
+      "rnfirebase_boolean_true",
+      "rnfirebase_boolean_false",
+    ]))
+    XCTAssertEqual(all["rnfirebase_string"] as? String, "abc")
+    XCTAssertEqual(all["rnfirebase_boolean_true"] as? Bool, true)
+    XCTAssertEqual(all["rnfirebase_boolean_false"] as? Bool, false)
+  }
+
+  func testPresentBooleanFalseAndNumericZeroOverrideDefaultYes() {
+    let meta = storage([
+      "rnfirebase_boolFalse": false,
+      "rnfirebase_numericZero": 0,
+      "rnfirebase_boolTrue": true,
+      "rnfirebase_numericOne": 1,
+      "rnfirebase_boolStringYes": "YES",
+      "rnfirebase_boolStringNo": "0",
+    ])
+
+    XCTAssertTrue(meta.contains("boolFalse"))
+    XCTAssertTrue(meta.contains("numericZero"))
+    XCTAssertFalse(meta.getBooleanValue("boolFalse", defaultValue: true))
+    XCTAssertFalse(meta.getBooleanValue("numericZero", defaultValue: true))
+    XCTAssertTrue(meta.getBooleanValue("boolTrue", defaultValue: false))
+    XCTAssertTrue(meta.getBooleanValue("numericOne", defaultValue: false))
+    XCTAssertTrue(meta.getBooleanValue("boolStringYes", defaultValue: false))
+    XCTAssertFalse(meta.getBooleanValue("boolStringNo", defaultValue: true))
+  }
+
+  func testStringLookupPreservesPresentValues() {
+    let meta = storage([
+      "rnfirebase_string": "abc",
+    ])
+
+    XCTAssertEqual(meta.getStringValue("string", defaultValue: "fallback"), "abc")
+  }
+
+  func testDefaultInitializerUsesMainBundleInfoDictionary() {
+    let production = RNFBMetaStorage()
+    let fromBundle = RNFBMetaStorage(infoDictionary: Bundle.main.infoDictionary ?? [:])
+
+    XCTAssertEqual(production.getAll() as NSDictionary, fromBundle.getAll() as NSDictionary)
+  }
+}

package/ios/RNFBAppUnitTests/RNFBMetaTests.m

@@ -0,0 +1,65 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library 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 <XCTest/XCTest.h>
+
+#import "RNFBHandleMapStorage-Swift.inc"
+#import "RNFBMeta.h"
+
+@interface RNFBMetaTests : XCTestCase
+@end
+
+@implementation RNFBMetaTests
+
+- (void)testPublicClassSelectorsAndReturnEncodingsAreUnchanged {
+  NSArray<NSString *> *selectorNames = @[
+    @"contains:",
+    @"getBooleanValue:defaultValue:",
+    @"getStringValue:defaultValue:",
+    @"getAll",
+  ];
+  for (NSString *selectorName in selectorNames) {
+    XCTAssertTrue([RNFBMeta respondsToSelector:NSSelectorFromString(selectorName)]);
+  }
+
+  NSMethodSignature *contains = [RNFBMeta methodSignatureForSelector:@selector(contains:)];
+  XCTAssertEqual(strcmp(contains.methodReturnType, @encode(BOOL)), 0);
+
+  NSMethodSignature *boolean = [RNFBMeta methodSignatureForSelector:@selector(getBooleanValue:
+                                                                                 defaultValue:)];
+  XCTAssertEqual(strcmp(boolean.methodReturnType, @encode(BOOL)), 0);
+  XCTAssertEqual(strcmp([boolean getArgumentTypeAtIndex:3], @encode(BOOL)), 0);
+
+  NSMethodSignature *string = [RNFBMeta methodSignatureForSelector:@selector(getStringValue:
+                                                                               defaultValue:)];
+  XCTAssertEqual(strcmp(string.methodReturnType, @encode(id)), 0);
+
+  NSMethodSignature *getAll = [RNFBMeta methodSignatureForSelector:@selector(getAll)];
+  XCTAssertEqual(strcmp(getAll.methodReturnType, @encode(id)), 0);
+}
+
+- (void)testFacadeForwardsToSharedMainBundleStorage {
+  // Smoke: class methods are callable and getAll returns a dictionary (may be empty).
+  XCTAssertNotNil([RNFBMeta getAll]);
+  XCTAssertTrue([[RNFBMeta getAll] isKindOfClass:[NSDictionary class]]);
+  XCTAssertFalse([RNFBMeta contains:@"__rnfb_meta_unit_test_missing_key__"]);
+  XCTAssertTrue([RNFBMeta getBooleanValue:@"__rnfb_meta_unit_test_missing_key__" defaultValue:YES]);
+  XCTAssertEqualObjects([RNFBMeta getStringValue:@"__rnfb_meta_unit_test_missing_key__"
+                                    defaultValue:@"fallback"],
+                        @"fallback");
+}
+
+@end

package/ios/RNFBAppUnitTests/RNFBNullSentinelDecodingTests.swift

@@ -0,0 +1,286 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library 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 Foundation
+import XCTest
+
+final class RNFBNullSentinelDecodingTests: XCTestCase {
+  private func decode(_ value: Any?) -> Any? {
+    RNFBNullSentinelDecoder.decodeNullSentinels(value)
+  }
+
+  private func sentinel(_ flag: Any = true) -> NSDictionary {
+    ["__rnfbNull": flag] as NSDictionary
+  }
+
+  private func serverTimestamp() -> NSDictionary {
+    [".sv": "timestamp"] as NSDictionary
+  }
+
+  func testNilAndNonContainersPreserveIdentity() {
+    XCTAssertNil(decode(nil))
+
+    let number = NSNumber(value: 42)
+    let string = "hello" as NSString
+    let date = NSDate()
+    let data = NSData()
+    let null = NSNull()
+
+    XCTAssertTrue(decode(number) as AnyObject === number)
+    XCTAssertTrue(decode(string) as AnyObject === string)
+    XCTAssertTrue(decode(date) as AnyObject === date)
+    XCTAssertTrue(decode(data) as AnyObject === data)
+    XCTAssertTrue(decode(null) as AnyObject === null)
+  }
+
+  func testDecodeAndDecodeNullSentinelsSelectorsAreEquivalent() {
+    let input: NSDictionary = ["a": sentinel(), "b": "keep"]
+    let viaCanonical = RNFBNullSentinelDecoder.decodeNullSentinels(input) as! NSDictionary
+    let viaAlias = RNFBNullSentinelDecoder.decode(input) as! NSDictionary
+    XCTAssertEqual(viaCanonical, viaAlias)
+    XCTAssertTrue(viaCanonical["a"] is NSNull)
+    XCTAssertEqual(viaCanonical["b"] as? String, "keep")
+  }
+
+  func testRootSentinelBecomesNSNull() {
+    XCTAssertTrue(decode(sentinel()) is NSNull)
+    XCTAssertTrue(decode(sentinel(NSNumber(value: 1))) is NSNull)
+  }
+
+  func testRootSentinelRequiresExactlyOneKeyAndTruthyFlag() {
+    XCTAssertFalse(decode(sentinel(false)) is NSNull)
+    XCTAssertEqual(decode(sentinel(false)) as? NSDictionary, ["__rnfbNull": false] as NSDictionary)
+
+    let extraKey = ["__rnfbNull": true, "other": 1] as NSDictionary
+    XCTAssertEqual(decode(extraKey) as? NSDictionary, extraKey)
+
+    let empty = decode(NSDictionary()) as! NSDictionary
+    XCTAssertEqual(empty.count, 0)
+    XCTAssertTrue(empty is NSMutableDictionary)
+  }
+
+  func testStringFlagIsNotASentinel() {
+    for flag in ["true", "YES", "yes", "1"] as [NSString] {
+      let input = sentinel(flag)
+      XCTAssertEqual(decode(input) as? NSDictionary, input)
+    }
+  }
+
+  func testNonBoolRespondingFlagIsNotASentinel() {
+    let exotic = sentinel(NSDate())
+    let decoded = decode(exotic) as! NSDictionary
+    XCTAssertEqual(decoded.count, 1)
+    XCTAssertTrue(decoded["__rnfbNull"] is NSDate)
+  }
+
+  func testRootSentinelFlagNonNumberUnchangedWithoutCrash() {
+    let nullFlag = ["__rnfbNull": NSNull()] as NSDictionary
+    let dictFlag = ["__rnfbNull": ["a": 1] as NSDictionary] as NSDictionary
+    let arrayFlag = ["__rnfbNull": [1] as NSArray] as NSDictionary
+
+    XCTAssertEqual(decode(nullFlag) as? NSDictionary, nullFlag)
+    XCTAssertEqual(decode(dictFlag) as? NSDictionary, dictFlag)
+    XCTAssertEqual(decode(arrayFlag) as? NSDictionary, arrayFlag)
+  }
+
+  func testRootServerValueUnchanged() {
+    let input = serverTimestamp()
+    XCTAssertEqual(decode(input) as? NSDictionary, input)
+  }
+
+  func testNestedDictionarySentinelsBecomeNSNull() {
+    let input: NSDictionary = [
+      "a": sentinel(),
+      "b": "keep",
+      "nested": [
+        "inner": sentinel(),
+        "n": 1,
+        "falseFlag": sentinel(false),
+        "empty": NSDictionary(),
+      ] as NSDictionary,
+    ]
+
+    let result = decode(input) as! NSDictionary
+    XCTAssertTrue(result["a"] is NSNull)
+    XCTAssertEqual(result["b"] as? String, "keep")
+    let nested = result["nested"] as! NSDictionary
+    XCTAssertTrue(nested["inner"] is NSNull)
+    XCTAssertEqual(nested["n"] as? Int, 1)
+    XCTAssertEqual(nested["falseFlag"] as? NSDictionary, ["__rnfbNull": false] as NSDictionary)
+    XCTAssertEqual((nested["empty"] as? NSDictionary)?.count, 0)
+  }
+
+  func testNestedSentinelWithExtraKeysUnchanged() {
+    let input: NSDictionary = ["child": ["__rnfbNull": true, "other": "x"] as NSDictionary]
+    XCTAssertEqual(decode(input) as? NSDictionary, input)
+  }
+
+  func testNestedSentinelFlagNonNumberUnchanged() {
+    let input: NSDictionary = [
+      "nullFlag": ["__rnfbNull": NSNull()] as NSDictionary,
+      "dictFlag": ["__rnfbNull": ["a": 1] as NSDictionary] as NSDictionary,
+      "arrayFlag": ["__rnfbNull": [1] as NSArray] as NSDictionary,
+      "stringFlag": ["__rnfbNull": "true"] as NSDictionary,
+    ]
+    XCTAssertEqual(decode(input) as? NSDictionary, input)
+
+    let arrayInput: NSArray = [
+      ["__rnfbNull": NSNull()] as NSDictionary,
+      ["__rnfbNull": ["a": 1] as NSDictionary] as NSDictionary,
+      ["__rnfbNull": [1] as NSArray] as NSDictionary,
+      ["__rnfbNull": "true"] as NSDictionary,
+    ]
+    XCTAssertEqual(decode(arrayInput) as? NSArray, arrayInput)
+  }
+
+  func testValidSentinelSiblingDecodedWhileNonNumberFlagPassesThrough() {
+    let input: NSDictionary = [
+      "valid": sentinel(),
+      "guarded": ["__rnfbNull": NSNull()] as NSDictionary,
+      "list": [sentinel(), ["__rnfbNull": [1] as NSArray] as NSDictionary] as NSArray,
+    ]
+    let result = decode(input) as! NSDictionary
+    XCTAssertTrue(result["valid"] is NSNull)
+    XCTAssertEqual(result["guarded"] as? NSDictionary, ["__rnfbNull": NSNull()] as NSDictionary)
+    let list = result["list"] as! NSArray
+    XCTAssertTrue(list[0] is NSNull)
+    XCTAssertEqual(list[1] as? NSDictionary, ["__rnfbNull": [1] as NSArray] as NSDictionary)
+  }
+
+  func testArrayWalkPreservesNSNullAndReplacesSentinels() {
+    let input: NSArray = [
+      sentinel(),
+      NSNull(),
+      "x",
+      3,
+      serverTimestamp(),
+      [sentinel(), 2] as NSArray,
+    ]
+
+    let result = decode(input) as! NSArray
+    XCTAssertEqual(result.count, 6)
+    XCTAssertTrue(result[0] is NSNull)
+    XCTAssertTrue(result[1] is NSNull)
+    XCTAssertEqual(result[2] as? String, "x")
+    XCTAssertEqual(result[3] as? Int, 3)
+    XCTAssertEqual(result[4] as? NSDictionary, serverTimestamp())
+    let nested = result[5] as! NSArray
+    XCTAssertTrue(nested[0] is NSNull)
+    XCTAssertEqual(nested[1] as? Int, 2)
+    XCTAssertTrue(result is NSMutableArray)
+  }
+
+  func testRootEmptyArrayReturnsEmptyMutableArray() {
+    let decoded = decode([] as NSArray) as! NSArray
+    XCTAssertEqual(decoded.count, 0)
+    XCTAssertTrue(decoded is NSMutableArray)
+  }
+
+  func testNestedArraysSentinelsDecodedAtEveryLevel() {
+    let input: NSArray = [[sentinel(), [sentinel(), "leaf"] as NSArray] as NSArray, [] as NSArray]
+    let result = decode(input) as! NSArray
+    let first = result[0] as! NSArray
+    XCTAssertTrue(first[0] is NSNull)
+    XCTAssertTrue((first[1] as! NSArray)[0] is NSNull)
+    XCTAssertEqual((first[1] as! NSArray)[1] as? String, "leaf")
+    XCTAssertEqual((result[1] as! NSArray).count, 0)
+  }
+
+  func testArrayInsideDictionaryAndMixedMatrixDecoded() {
+    let input: NSDictionary = [
+      "list": [sentinel(), "x", [sentinel()] as NSArray] as NSArray,
+      "items": [
+        ["id": 1, "note": sentinel()] as NSDictionary,
+        ["id": 2, "tags": [sentinel()] as NSArray] as NSDictionary,
+      ] as NSArray,
+    ]
+    let result = decode(input) as! NSDictionary
+    let list = result["list"] as! NSArray
+    XCTAssertTrue(list[0] is NSNull)
+    XCTAssertEqual(list[1] as? String, "x")
+    XCTAssertTrue((list[2] as! NSArray)[0] is NSNull)
+
+    let items = result["items"] as! NSArray
+    XCTAssertTrue((items[0] as! NSDictionary)["note"] is NSNull)
+    XCTAssertTrue(((items[1] as! NSDictionary)["tags"] as! NSArray)[0] is NSNull)
+  }
+
+  func testChildAndParentTypeMatrix() {
+    let dictInput: NSDictionary = [
+      "dictChild": ["k": 1] as NSDictionary,
+      "arrayChild": ["leaf", [2] as NSArray, sentinel(), NSNull()] as NSArray,
+      "primitiveChild": "text",
+      "nullChild": NSNull(),
+    ]
+    let arrayRoot: NSArray = [
+      ["inner": sentinel()] as NSDictionary,
+      ["nested"] as NSArray,
+      3,
+      sentinel(),
+      NSNull(),
+    ]
+
+    let decodedDict = decode(dictInput) as! NSDictionary
+    XCTAssertEqual(decodedDict["dictChild"] as? NSDictionary, ["k": 1] as NSDictionary)
+    let arrayChild = decodedDict["arrayChild"] as! NSArray
+    XCTAssertEqual(arrayChild[0] as? String, "leaf")
+    XCTAssertTrue(arrayChild[2] is NSNull)
+    XCTAssertTrue(decodedDict["nullChild"] is NSNull)
+
+    let decodedArray = decode(arrayRoot) as! NSArray
+    XCTAssertTrue((decodedArray[0] as! NSDictionary)["inner"] is NSNull)
+    XCTAssertTrue(decodedArray[3] is NSNull)
+    XCTAssertTrue(decodedArray[4] is NSNull)
+  }
+
+  func testContainersReturnNewMutableCopiesEvenWithoutSentinels() {
+    let dict = ["k": "v"] as NSDictionary
+    let array = ["a", 1] as NSArray
+
+    let decodedDict = decode(dict)
+    let decodedArray = decode(array)
+
+    XCTAssertFalse(decodedDict as AnyObject === dict)
+    XCTAssertFalse(decodedArray as AnyObject === array)
+    XCTAssertTrue(decodedDict is NSMutableDictionary)
+    XCTAssertTrue(decodedArray is NSMutableArray)
+    XCTAssertEqual(decodedDict as? NSDictionary, dict)
+    XCTAssertEqual(decodedArray as? NSArray, array)
+  }
+
+  func testCountOneNumberFalseIsNotSentinel() {
+    let input: NSDictionary = [
+      "a": ["__rnfbNull": false] as NSDictionary,
+      "b": ["__rnfbNull": NSNumber(value: 0)] as NSDictionary,
+    ]
+    XCTAssertEqual(decode(input) as? NSDictionary, input)
+  }
+
+  func testDeepNestingDoesNotOverflow() {
+    let depth = 1000
+    var leaf: Any = ["value": sentinel()] as NSDictionary
+    for _ in 0..<depth {
+      leaf = ["child": leaf] as NSDictionary
+    }
+
+    var cursor = decode(leaf) as! NSDictionary
+    for _ in 0..<depth {
+      XCTAssertTrue(cursor is NSMutableDictionary)
+      cursor = cursor["child"] as! NSDictionary
+    }
+    XCTAssertTrue(cursor["value"] is NSNull)
+  }
+}