Corrected the behavior of various functions when passed null. Instead of

asserting (c++) or throwing exceptions (c#), they log a warning and return an
invalid value, which matches the behavior we have on mobile platforms. The
tests and testapps have been updated to reflect this.

PiperOrigin-RevId: 276144627

Author: amablue

database/src/common/data_snapshot.cc

@@ -98,9 +98,8 @@ DataSnapshot::~DataSnapshot() {
 bool DataSnapshot::exists() const { return internal_ && internal_->Exists(); }
 
 DataSnapshot DataSnapshot::Child(const char* path) const {
-  FIREBASE_ASSERT_RETURN(DataSnapshot(), path != nullptr);
-  return internal_ ? DataSnapshot(internal_->Child(path))
-                   : DataSnapshot(nullptr);
+  return internal_ && path ? DataSnapshot(internal_->Child(path))
+                           : DataSnapshot(nullptr);
 }
 
 DataSnapshot DataSnapshot::Child(const std::string& path) const {
@@ -141,8 +140,7 @@ DatabaseReference DataSnapshot::GetReference() const {
 }
 
 bool DataSnapshot::HasChild(const char* path) const {
-  FIREBASE_ASSERT_RETURN(false, path != nullptr);
-  return internal_ && internal_->HasChild(path);
+  return internal_ && path && internal_->HasChild(path);
 }
 
 bool DataSnapshot::HasChild(const std::string& path) const {

database/src/common/database.cc

@@ -175,13 +175,13 @@ DatabaseReference Database::GetReference() const {
 }
 
 DatabaseReference Database::GetReference(const char* path) const {
-  FIREBASE_ASSERT_RETURN(DatabaseReference(), path != nullptr);
-  return internal_ ? internal_->GetReference(path) : DatabaseReference();
+  return internal_ && path ? internal_->GetReference(path)
+                           : DatabaseReference();
 }
 
 DatabaseReference Database::GetReferenceFromUrl(const char* url) const {
-  FIREBASE_ASSERT_RETURN(DatabaseReference(), url != nullptr);
-  return internal_ ? internal_->GetReferenceFromUrl(url) : DatabaseReference();
+  return internal_ && url ? internal_->GetReferenceFromUrl(url)
+                          : DatabaseReference();
 }
 
 void Database::GoOffline() {

database/src/common/database_reference.cc

@@ -167,9 +167,8 @@ DatabaseReference DatabaseReference::GetRoot() const {
 }
 
 DatabaseReference DatabaseReference::Child(const char* path) const {
-  FIREBASE_ASSERT_RETURN(DatabaseReference(), path != nullptr);
-  return internal_ ? DatabaseReference(internal_->Child(path))
-                   : DatabaseReference(nullptr);
+  return internal_ && path ? DatabaseReference(internal_->Child(path))
+                           : DatabaseReference(nullptr);
 }
 
 DatabaseReference DatabaseReference::Child(const std::string& path) const {

database/src/common/mutable_data.cc

@@ -89,8 +89,8 @@ MutableData::~MutableData() {
 }
 
 MutableData MutableData::Child(const char* path) {
-  FIREBASE_ASSERT_RETURN(GetInvalidMutableData(), path != nullptr);
-  return internal_ ? MutableData(internal_->Child(path)) : MutableData(nullptr);
+  return internal_ && path ? MutableData(internal_->Child(path))
+                           : GetInvalidMutableData();
 }
 
 MutableData MutableData::Child(const std::string& path) {
@@ -122,8 +122,7 @@ Variant MutableData::priority() {
 }
 
 bool MutableData::HasChild(const char* path) const {
-  FIREBASE_ASSERT_RETURN(false, path != nullptr);
-  return internal_ ? internal_->HasChild(path) : false;
+  return internal_ && path ? internal_->HasChild(path) : false;
 }
 
 bool MutableData::HasChild(const std::string& path) const {

database/src/common/query.cc

@@ -121,8 +121,7 @@ Future<DataSnapshot> Query::GetValueLastResult() {
 }
 
 void Query::AddValueListener(ValueListener* listener) {
-  FIREBASE_ASSERT_RETURN_VOID(listener != nullptr);
-  if (internal_) internal_->AddValueListener(listener);
+  if (internal_ && listener) internal_->AddValueListener(listener);
 }
 
 void Query::RemoveValueListener(ValueListener* listener) {
@@ -136,8 +135,7 @@ void Query::RemoveAllValueListeners() {
 }
 
 void Query::AddChildListener(ChildListener* listener) {
-  FIREBASE_ASSERT_RETURN_VOID(listener != nullptr);
-  if (internal_) internal_->AddChildListener(listener);
+  if (internal_ && listener) internal_->AddChildListener(listener);
 }
 
 void Query::RemoveChildListener(ChildListener* listener) {
@@ -160,8 +158,8 @@ void Query::SetKeepSynchronized(bool keep_sync) {
 }
 
 Query Query::OrderByChild(const char* path) {
-  FIREBASE_ASSERT_RETURN(Query(), path != nullptr);
-  return internal_ ? Query(internal_->OrderByChild(path)) : Query(nullptr);
+  return internal_ && path ? Query(internal_->OrderByChild(path))
+                           : Query(nullptr);
 }
 
 Query Query::OrderByChild(const std::string& path) {
@@ -185,29 +183,29 @@ Query Query::StartAt(Variant order_value) {
 }
 
 Query Query::StartAt(Variant order_value, const char* child_key) {
-  FIREBASE_ASSERT_RETURN(Query(), child_key != nullptr);
-  return internal_ ? Query(internal_->StartAt(order_value, child_key))
-                   : Query(nullptr);
+  return internal_ && child_key
+             ? Query(internal_->StartAt(order_value, child_key))
+             : Query(nullptr);
 }
 
 Query Query::EndAt(Variant order_value) {
   return internal_ ? Query(internal_->EndAt(order_value)) : Query(nullptr);
 }
 
 Query Query::EndAt(Variant order_value, const char* child_key) {
-  FIREBASE_ASSERT_RETURN(Query(), child_key != nullptr);
-  return internal_ ? Query(internal_->EndAt(order_value, child_key))
-                   : Query(nullptr);
+  return internal_ && child_key
+             ? Query(internal_->EndAt(order_value, child_key))
+             : Query(nullptr);
 }
 
 Query Query::EqualTo(Variant order_value) {
   return internal_ ? Query(internal_->EqualTo(order_value)) : Query(nullptr);
 }
 
 Query Query::EqualTo(Variant order_value, const char* child_key) {
-  FIREBASE_ASSERT_RETURN(Query(), child_key != nullptr);
-  return internal_ ? Query(internal_->EqualTo(order_value, child_key))
-                   : Query(nullptr);
+  return internal_ && child_key
+             ? Query(internal_->EqualTo(order_value, child_key))
+             : Query(nullptr);
 }
 
 Query Query::LimitToFirst(size_t limit) {