Small updates

examples/kotlin/shared/src/commonTest/kotlin/com/mongodb/realm/realmkmmapp/DeleteTest.kt

@@ -116,21 +116,19 @@ class DeleteTest: RealmTest() {
             // Open a write transaction
             realm.write {
                 // Query the Frog type and filter by primary key value
-                val frogToDelete: ExampleRealmObject_Frog =
-                    query<ExampleRealmObject_Frog>("_id == $0", PRIMARY_KEY_VALUE).find().first()
+                val frogToDelete: ExampleRealmObject_Frog = query<ExampleRealmObject_Frog>("_id == $0", PRIMARY_KEY_VALUE).find().first()
                 assertEquals(PRIMARY_KEY_VALUE, frogToDelete._id) // :remove:
                 // Pass the query results to delete()
                 delete(frogToDelete)
-                assertFalse(frogToDelete.isValid())
+                assertFalse(frogToDelete.isValid()) // :remove:
                 assertTrue(query<ExampleRealmObject_Frog>().find().size == 6) // :remove:
             }
             // :snippet-end:
             // :snippet-start: delete-multiple-realm-objects
             // Open a write transaction
             realm.write {
                 // Query by species and limit to 3 results
-                val bullfrogsToDelete: RealmResults<ExampleRealmObject_Frog> =
-                    query<ExampleRealmObject_Frog>("species == 'bullfrog' LIMIT(3)").find()
+                val bullfrogsToDelete: RealmResults<ExampleRealmObject_Frog> = query<ExampleRealmObject_Frog>("species == 'bullfrog' LIMIT(3)").find()
                 // Pass the query results to delete()
                 delete(bullfrogsToDelete)
                 assertTrue(query<ExampleRealmObject_Frog>("species == 'bullfrog'").find().size == 3) // :remove:
@@ -141,6 +139,7 @@ class DeleteTest: RealmTest() {
             realm.write {
                 // Query Frog type with no filter to return all frog objects
                 val frogsLeftInTheRealm = query<ExampleRealmObject_Frog>().find()
+                // Pass the query results to delete()
                 delete(frogsLeftInTheRealm)
                 assertTrue(frogsLeftInTheRealm.size == 0) // :remove:
                 deleteAll() // :remove:
@@ -221,11 +220,11 @@ class DeleteTest: RealmTest() {
                 assertEquals(PRIMARY_KEY_VALUE, parentObject._id) // :remove:
                 assertEquals(2, parentObject.favoritePonds.size)
 
-                // Delete the frog
+                // Delete the frog and all references to ponds
                 delete(parentObject)
                 assertFalse(parentObject.isValid()) // :remove:
 
-                // Confirm all ponds are still in the realm
+                // Confirm pond objects are still in the realm
                 val ponds = query<ExampleRealmList_Pond>().find()
                 assertEquals(2, ponds.size)
                 deleteAll() // :remove:
@@ -367,23 +366,23 @@ class DeleteTest: RealmTest() {
     @Test
     fun deleteRealmDictionaryType() {
         runBlocking {
-            val config = RealmConfiguration.Builder(setOf(RealmDictionary_Frog::class))
+            val config = RealmConfiguration.Builder(setOf(ExampleRealmDictionary_Frog::class))
                 .inMemory()
                 .build()
             val realm = Realm.open(config)
             Log.v("Successfully opened realm: ${realm.configuration.name}")
 
             realm.write {
                 deleteAll()
-                copyToRealm(RealmDictionary_Frog().apply {
+                copyToRealm(ExampleRealmDictionary_Frog().apply {
                     name = "Kermit"
                     favoritePondsByForest =
                         realmDictionaryOf("Hundred Acre Wood" to "Picnic Pond", "Lothlorien" to "Linya")
                 })
             }
             // :snippet-start: delete-realm-dictionary
             // Find frogs who have forests with favorite ponds
-            val thisFrog = realm.query<RealmDictionary_Frog>("favoritePondsByForest.@count > 1").find().first()
+            val thisFrog = realm.query<ExampleRealmDictionary_Frog>("favoritePondsByForest.@count > 1").find().first()
             // :remove-start:
             assertEquals(2, thisFrog.favoritePondsByForest.size)
             assertTrue(thisFrog.favoritePondsByForest.containsKey("Hundred Acre Wood"))
@@ -402,7 +401,7 @@ class DeleteTest: RealmTest() {
                 // Remove a key and its value
                 findLatest(thisFrog)?.favoritePondsByForest?.remove("Lothlorien")
                 // :remove-start:
-                val thisFrogUpdated = query<RealmDictionary_Frog>().find().first()
+                val thisFrogUpdated = query<ExampleRealmDictionary_Frog>().find().first()
                 assertFalse(thisFrogUpdated.favoritePondsByForest.containsKey("Lothlorien"))
                 assertTrue(thisFrogUpdated.favoritePondsByForest.containsKey("Hundred Acre Wood"))
                 assertFalse(thisFrogUpdated.favoritePondsByForest.containsValue("Picnic Pond"))
@@ -467,30 +466,33 @@ class DeleteTest: RealmTest() {
                 copyToRealm(business)
             }
             // :snippet-start: delete-embedded-object
+            // Delete an embedded object directly
             realm.write {
-                // Delete an embedded object directly
                 val addressToDelete = query<ExampleRelationship_EmbeddedAddress>("street == $0", "456 Lily Pad Ln").find().first()
                 // Delete the embedded object (nullifies the parent property)
                 delete(addressToDelete)
-
-                // Delete an embedded object through the parent
+                val parent = query<ExampleRelationship_Contact>("name == $0", "Froggy J. Frog").find().first() // :remove:
+                assertNull(parent.address) // :remove:
+            }
+            // Delete an embedded object through the parent
+            realm.write {
                 val propertyToClear = query<ExampleRelationship_Contact>("name == $0", "Kermit").find().first()
                 // Clear the parent property (deletes the embedded object instance)
                 propertyToClear.address = null
                 assertNull(propertyToClear.address) // :remove:
-
-                // Delete the parent object (deletes all embedded objects)
+            }
+            // :snippet-end:
+            // :snippet-start: delete-embedded-object-through-parent
+            // Delete the parent object
+            realm.write {
                 val businessToDelete = query<ExampleRelationship_Business>("name == $0", "Big Frog Corp.").find().first()
-                assertEquals(2, businessToDelete.addresses.size)
+                assertEquals(2, businessToDelete.addresses.size) // :remove:
+                // Delete the parent object (deletes all embedded objects)
                 delete(businessToDelete)
-                assertFalse(businessToDelete.isValid()) // :remove:
+                assertNull(businessToDelete) // :remove:
             }
             // :snippet-end:
             realm.write {
-                val nulledAddress = query<ExampleRelationship_Contact>("name == $0", "Froggy J. Frog").find().first()
-                assertNull(nulledAddress.address)
-                val deletedBusiness = query<ExampleRelationship_Business>("name == $0", "Big Frog Corp.").find().firstOrNull()
-                assertNull(deletedBusiness)
                 deleteAll()
             }
             realm.close()
@@ -518,21 +520,21 @@ class DeleteTest: RealmTest() {
                     name = "Kermit"
                     favoritePonds.addAll(
                         realmListOf(
-                            ExampleRealmList_Pond().apply { name = "Picnic Pond" },
-                            ExampleRealmList_Pond().apply { name = "Big Pond" },
-                            ExampleRealmList_Pond().apply { name = "Small Pond" },
-                            ExampleRealmList_Pond().apply { name = "Huge Pond" },
+                            ExampleRealmList_Pond().apply { name = "1" },
+                            ExampleRealmList_Pond().apply { name = "2" },
+                            ExampleRealmList_Pond().apply { name = "3" },
+                            ExampleRealmList_Pond().apply { name = "4" },
                         )
                     )
                 })
             }
             // :snippet-start: chain-delete-realm-list
             realm.write {
-                // Query for the parent frog object
+                // Query for the parent frog object with ponds
                 val frog = query<ExampleRealmList_Frog>("name == $0", "Kermit").find().first()
                 val ponds = frog.favoritePonds
-                assertEquals(4, ponds.size)
-                // Iterate over the list and delete each pond
+                assertEquals(4, ponds.size) // :remove:
+                // Iterate over the list and delete each pond object
                 if (ponds.isNotEmpty()) {
                     ponds.forEach { pond ->
                         delete(pond)
@@ -545,14 +547,6 @@ class DeleteTest: RealmTest() {
                 }
             }
             // :snippet-end:
-            realm.write {
-                val frogs = query<ExampleRealmList_Frog>().find()
-                Log.v("Frogs: ${frogs.size}")
-                delete(frogs)
-                val ponds = query<ExampleRealmList_Pond>().find()
-                Log.v("Ponds: ${ponds.size}")
-                delete(ponds)
-            }
             realm.close()
         }
     }

source/examples/generated/kotlin/DeleteTest.snippet.chain-delete-realm-list.kt

@@ -1,9 +1,8 @@
 realm.write {
-    // Query for the parent frog object
+    // Query for the parent frog object with ponds
     val frog = query<Frog>("name == $0", "Kermit").find().first()
     val ponds = frog.favoritePonds
-    assertEquals(4, ponds.size)
-    // Iterate over the list and delete each pond
+    // Iterate over the list and delete each pond object
     if (ponds.isNotEmpty()) {
         ponds.forEach { pond ->
             delete(pond)

source/examples/generated/kotlin/DeleteTest.snippet.delete-all-realm-object-types.kt

@@ -2,5 +2,6 @@
 realm.write {
     // Query Frog type with no filter to return all frog objects
     val frogsLeftInTheRealm = query<Frog>().find()
+    // Pass the query results to delete()
     delete(frogsLeftInTheRealm)
 }

source/examples/generated/kotlin/DeleteTest.snippet.delete-embedded-object-through-parent.kt

@@ -0,0 +1,6 @@
+// Delete the parent object
+realm.write {
+    val businessToDelete = query<Business>("name == $0", "Big Frog Corp.").find().first()
+    // Delete the parent object (deletes all embedded objects)
+    delete(businessToDelete)
+}

source/examples/generated/kotlin/DeleteTest.snippet.delete-embedded-object.kt

@@ -1,16 +1,12 @@
+// Delete an embedded object directly
 realm.write {
-    // Delete an embedded object directly
     val addressToDelete = query<EmbeddedAddress>("street == $0", "456 Lily Pad Ln").find().first()
     // Delete the embedded object (nullifies the parent property)
     delete(addressToDelete)
-
-    // Delete an embedded object through the parent
+}
+// Delete an embedded object through the parent
+realm.write {
     val propertyToClear = query<Contact>("name == $0", "Kermit").find().first()
     // Clear the parent property (deletes the embedded object instance)
     propertyToClear.address = null
-
-    // Delete the parent object (deletes all embedded objects)
-    val businessToDelete = query<Business>("name == $0", "Big Frog Corp.").find().first()
-    assertEquals(2, businessToDelete.addresses.size)
-    delete(businessToDelete)
 }

source/examples/generated/kotlin/DeleteTest.snippet.delete-multiple-realm-objects.kt

@@ -1,8 +1,7 @@
 // Open a write transaction
 realm.write {
     // Query by species and limit to 3 results
-    val bullfrogsToDelete: RealmResults<Frog> =
-        query<Frog>("species == 'bullfrog' LIMIT(3)").find()
+    val bullfrogsToDelete: RealmResults<Frog> = query<Frog>("species == 'bullfrog' LIMIT(3)").find()
     // Pass the query results to delete()
     delete(bullfrogsToDelete)
 }

source/examples/generated/kotlin/DeleteTest.snippet.delete-one-realm-object.kt

@@ -1,9 +1,7 @@
 // Open a write transaction
 realm.write {
     // Query the Frog type and filter by primary key value
-    val frogToDelete: Frog =
-        query<Frog>("_id == $0", PRIMARY_KEY_VALUE).find().first()
+    val frogToDelete: Frog = query<Frog>("_id == $0", PRIMARY_KEY_VALUE).find().first()
     // Pass the query results to delete()
     delete(frogToDelete)
-    assertFalse(frogToDelete.isValid())
 }

source/examples/generated/kotlin/DeleteTest.snippet.delete-realm-dictionary.kt

@@ -1,5 +1,5 @@
 // Find frogs who have forests with favorite ponds
-val thisFrog = realm.query<RealmDictionary_Frog>("favoritePondsByForest.@count > 1").find().first()
+val thisFrog = realm.query<Frog>("favoritePondsByForest.@count > 1").find().first()
 // Set an optional value for a key to null if the key exists
 if (thisFrog.favoritePondsByForest.containsKey("Hundred Acre Wood")) {
     realm.write {

source/examples/generated/kotlin/DeleteTest.snippet.delete-realm-object-with-related-objects.kt

@@ -4,10 +4,10 @@ realm.write {
     val parentObject = query<Frog>("_id == $0", PRIMARY_KEY_VALUE).find().first()
     assertEquals(2, parentObject.favoritePonds.size)
 
-    // Delete the frog
+    // Delete the frog and all references to ponds
     delete(parentObject)
 
-    // Confirm all ponds are still in the realm
+    // Confirm pond objects are still in the realm
     val ponds = query<Pond>().find()
     assertEquals(2, ponds.size)
 }