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

amablue · a-maurice · commit 897300c80b55 · 2019-11-15T17:44:59.000-08:00
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
diff --git a/database/src/common/data_snapshot.cc b/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 {
diff --git a/database/src/common/database.cc b/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() {
diff --git a/database/src/common/database_reference.cc b/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 {
diff --git a/database/src/common/mutable_data.cc b/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 {
diff --git a/database/src/common/query.cc b/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) {

Original file line number	Diff line number	Diff line change
`@@ -98,9 +98,8 @@ DataSnapshot::~DataSnapshot() {`
`98`	`98`	`bool DataSnapshot::exists() const { return internal_ && internal_->Exists(); }`
`99`	`99`
`100`	`100`	`DataSnapshot DataSnapshot::Child(const char* path) const {`
`101`		`- FIREBASE_ASSERT_RETURN(DataSnapshot(), path != nullptr);`
`102`		`- return internal_ ? DataSnapshot(internal_->Child(path))`
`103`		`- : DataSnapshot(nullptr);`
	`101`	`+ return internal_ && path ? DataSnapshot(internal_->Child(path))`
	`102`	`+ : DataSnapshot(nullptr);`
`104`	`103`	`}`
`105`	`104`
`106`	`105`	`DataSnapshot DataSnapshot::Child(const std::string& path) const {`
`@@ -141,8 +140,7 @@ DatabaseReference DataSnapshot::GetReference() const {`
`141`	`140`	`}`
`142`	`141`
`143`	`142`	`bool DataSnapshot::HasChild(const char* path) const {`
`144`		`- FIREBASE_ASSERT_RETURN(false, path != nullptr);`
`145`		`- return internal_ && internal_->HasChild(path);`
	`143`	`+ return internal_ && path && internal_->HasChild(path);`
`146`	`144`	`}`
`147`	`145`
`148`	`146`	`bool DataSnapshot::HasChild(const std::string& path) const {`
Original file line number	Diff line number	Diff line change
`@@ -175,13 +175,13 @@ DatabaseReference Database::GetReference() const {`
`175`	`175`	`}`
`176`	`176`
`177`	`177`	`DatabaseReference Database::GetReference(const char* path) const {`
`178`		`- FIREBASE_ASSERT_RETURN(DatabaseReference(), path != nullptr);`
`179`		`- return internal_ ? internal_->GetReference(path) : DatabaseReference();`
	`178`	`+ return internal_ && path ? internal_->GetReference(path)`
	`179`	`+ : DatabaseReference();`
`180`	`180`	`}`
`181`	`181`
`182`	`182`	`DatabaseReference Database::GetReferenceFromUrl(const char* url) const {`
`183`		`- FIREBASE_ASSERT_RETURN(DatabaseReference(), url != nullptr);`
`184`		`- return internal_ ? internal_->GetReferenceFromUrl(url) : DatabaseReference();`
	`183`	`+ return internal_ && url ? internal_->GetReferenceFromUrl(url)`
	`184`	`+ : DatabaseReference();`
`185`	`185`	`}`
`186`	`186`
`187`	`187`	`void Database::GoOffline() {`
Original file line number	Diff line number	Diff line change
`@@ -167,9 +167,8 @@ DatabaseReference DatabaseReference::GetRoot() const {`
`167`	`167`	`}`
`168`	`168`
`169`	`169`	`DatabaseReference DatabaseReference::Child(const char* path) const {`
`170`		`- FIREBASE_ASSERT_RETURN(DatabaseReference(), path != nullptr);`
`171`		`- return internal_ ? DatabaseReference(internal_->Child(path))`
`172`		`- : DatabaseReference(nullptr);`
	`170`	`+ return internal_ && path ? DatabaseReference(internal_->Child(path))`
	`171`	`+ : DatabaseReference(nullptr);`
`173`	`172`	`}`
`174`	`173`
`175`	`174`	`DatabaseReference DatabaseReference::Child(const std::string& path) const {`
Original file line number	Diff line number	Diff line change
`@@ -89,8 +89,8 @@ MutableData::~MutableData() {`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`MutableData MutableData::Child(const char* path) {`
`92`		`- FIREBASE_ASSERT_RETURN(GetInvalidMutableData(), path != nullptr);`
`93`		`- return internal_ ? MutableData(internal_->Child(path)) : MutableData(nullptr);`
	`92`	`+ return internal_ && path ? MutableData(internal_->Child(path))`
	`93`	`+ : GetInvalidMutableData();`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`MutableData MutableData::Child(const std::string& path) {`
`@@ -122,8 +122,7 @@ Variant MutableData::priority() {`
`122`	`122`	`}`
`123`	`123`
`124`	`124`	`bool MutableData::HasChild(const char* path) const {`
`125`		`- FIREBASE_ASSERT_RETURN(false, path != nullptr);`
`126`		`- return internal_ ? internal_->HasChild(path) : false;`
	`125`	`+ return internal_ && path ? internal_->HasChild(path) : false;`
`127`	`126`	`}`
`128`	`127`
`129`	`128`	`bool MutableData::HasChild(const std::string& path) const {`
Original file line number	Diff line number	Diff line change
`@@ -121,8 +121,7 @@ Future<DataSnapshot> Query::GetValueLastResult() {`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`void Query::AddValueListener(ValueListener* listener) {`
`124`		`- FIREBASE_ASSERT_RETURN_VOID(listener != nullptr);`
`125`		`- if (internal_) internal_->AddValueListener(listener);`
	`124`	`+ if (internal_ && listener) internal_->AddValueListener(listener);`
`126`	`125`	`}`
`127`	`126`
`128`	`127`	`void Query::RemoveValueListener(ValueListener* listener) {`
`@@ -136,8 +135,7 @@ void Query::RemoveAllValueListeners() {`
`136`	`135`	`}`
`137`	`136`
`138`	`137`	`void Query::AddChildListener(ChildListener* listener) {`
`139`		`- FIREBASE_ASSERT_RETURN_VOID(listener != nullptr);`
`140`		`- if (internal_) internal_->AddChildListener(listener);`
	`138`	`+ if (internal_ && listener) internal_->AddChildListener(listener);`
`141`	`139`	`}`
`142`	`140`
`143`	`141`	`void Query::RemoveChildListener(ChildListener* listener) {`
`@@ -160,8 +158,8 @@ void Query::SetKeepSynchronized(bool keep_sync) {`
`160`	`158`	`}`
`161`	`159`
`162`	`160`	`Query Query::OrderByChild(const char* path) {`
`163`		`- FIREBASE_ASSERT_RETURN(Query(), path != nullptr);`
`164`		`- return internal_ ? Query(internal_->OrderByChild(path)) : Query(nullptr);`
	`161`	`+ return internal_ && path ? Query(internal_->OrderByChild(path))`
	`162`	`+ : Query(nullptr);`
`165`	`163`	`}`
`166`	`164`
`167`	`165`	`Query Query::OrderByChild(const std::string& path) {`
`@@ -185,29 +183,29 @@ Query Query::StartAt(Variant order_value) {`
`185`	`183`	`}`
`186`	`184`
`187`	`185`	`Query Query::StartAt(Variant order_value, const char* child_key) {`
`188`		`- FIREBASE_ASSERT_RETURN(Query(), child_key != nullptr);`
`189`		`- return internal_ ? Query(internal_->StartAt(order_value, child_key))`
`190`		`- : Query(nullptr);`
	`186`	`+ return internal_ && child_key`
	`187`	`+ ? Query(internal_->StartAt(order_value, child_key))`
	`188`	`+ : Query(nullptr);`
`191`	`189`	`}`
`192`	`190`
`193`	`191`	`Query Query::EndAt(Variant order_value) {`
`194`	`192`	`return internal_ ? Query(internal_->EndAt(order_value)) : Query(nullptr);`
`195`	`193`	`}`
`196`	`194`
`197`	`195`	`Query Query::EndAt(Variant order_value, const char* child_key) {`
`198`		`- FIREBASE_ASSERT_RETURN(Query(), child_key != nullptr);`
`199`		`- return internal_ ? Query(internal_->EndAt(order_value, child_key))`
`200`		`- : Query(nullptr);`
	`196`	`+ return internal_ && child_key`
	`197`	`+ ? Query(internal_->EndAt(order_value, child_key))`
	`198`	`+ : Query(nullptr);`
`201`	`199`	`}`
`202`	`200`
`203`	`201`	`Query Query::EqualTo(Variant order_value) {`
`204`	`202`	`return internal_ ? Query(internal_->EqualTo(order_value)) : Query(nullptr);`
`205`	`203`	`}`
`206`	`204`
`207`	`205`	`Query Query::EqualTo(Variant order_value, const char* child_key) {`
`208`		`- FIREBASE_ASSERT_RETURN(Query(), child_key != nullptr);`
`209`		`- return internal_ ? Query(internal_->EqualTo(order_value, child_key))`
`210`		`- : Query(nullptr);`
	`206`	`+ return internal_ && child_key`
	`207`	`+ ? Query(internal_->EqualTo(order_value, child_key))`
	`208`	`+ : Query(nullptr);`
`211`	`209`	`}`
`212`	`210`
`213`	`211`	`Query Query::LimitToFirst(size_t limit) {`