chore: generate libraries at Fri Feb 20 20:58:24 UTC 2026

Author: cloud-java-bot

google-cloud-firestore/src/main/java/com/google/cloud/firestore/pipeline/expressions/Expression.java

@@ -1970,9 +1970,9 @@ public static Expression mapRemove(String mapField, String key) {
    * Creates an expression that returns a new map with the specified entries added or updated.
    *
    * <ul>
-   *  <li>Only performs shallow updates to the map.</li>
-   *  <li>Setting a value to {@code null} will retain the key with a {@code null} value. To remove a
-   *      key entirely, use {@code mapRemove}.</li>
+   *   <li>Only performs shallow updates to the map.
+   *   <li>Setting a value to {@code null} will retain the key with a {@code null} value. To remove
+   *       a key entirely, use {@code mapRemove}.
    * </ul>
    *
    * @param mapExpr The expression representing the map.
@@ -1994,11 +1994,11 @@ public static Expression mapSet(
 
   /**
    * Creates an expression that returns a new map with the specified entries added or updated.
-   * 
+   *
    * <ul>
-   *  <li>Only performs shallow updates to the map.</li>
-   *  <li>Setting a value to {@code null} will retain the key with a {@code null} value. To remove a
-   *      key entirely, use {@code mapRemove}.</li>
+   *   <li>Only performs shallow updates to the map.
+   *   <li>Setting a value to {@code null} will retain the key with a {@code null} value. To remove
+   *       a key entirely, use {@code mapRemove}.
    * </ul>
    *
    * @param mapField The map field to set entries in.
@@ -2019,11 +2019,11 @@ public static Expression mapSet(
 
   /**
    * Creates an expression that returns a new map with the specified entries added or updated.
-   * 
+   *
    * <ul>
-   *  <li>Only performs shallow updates to the map.</li>
-   *  <li>Setting a value to {@code null} will retain the key with a {@code null} value. To remove a
-   *      key entirely, use {@code mapRemove}.</li>
+   *   <li>Only performs shallow updates to the map.
+   *   <li>Setting a value to {@code null} will retain the key with a {@code null} value. To remove
+   *       a key entirely, use {@code mapRemove}.
    * </ul>
    *
    * @param mapField The map field to set entries in.
@@ -2040,11 +2040,11 @@ public static Expression mapSet(
 
   /**
    * Creates an expression that returns a new map with the specified entries added or updated.
-   * 
+   *
    * <ul>
-   *  <li>Only performs shallow updates to the map.</li>
-   *  <li>Setting a value to {@code null} will retain the key with a {@code null} value. To remove a
-   *      key entirely, use {@code mapRemove}.</li>
+   *   <li>Only performs shallow updates to the map.
+   *   <li>Setting a value to {@code null} will retain the key with a {@code null} value. To remove
+   *       a key entirely, use {@code mapRemove}.
    * </ul>
    *
    * @param mapField The map field to set entries in.
@@ -2058,7 +2058,7 @@ public static Expression mapSet(
       String mapField, String key, Object value, Object... moreKeyValues) {
     return mapSet(field(mapField), key, value, moreKeyValues);
   }
-  
+
   /**
    * Creates an expression that returns the keys of a map.
    *
@@ -4614,8 +4614,8 @@ public final Expression mapValues() {
   }
 
   /**
-   * Creates an expression that returns the entries of this map expression as an array of maps, where
-   * each map contains a "k" property for the key and a "v" property for the value.
+   * Creates an expression that returns the entries of this map expression as an array of maps,
+   * where each map contains a "k" property for the key and a "v" property for the value.
    *
    * <p>While the backend generally preserves insertion order, relying on the order of the output
    * array is not guaranteed and should be avoided.

google-cloud-firestore/src/test/java/com/google/cloud/firestore/it/ITPipelineTest.java

@@ -17,7 +17,6 @@
 package com.google.cloud.firestore.it;
 
 import static com.google.cloud.firestore.FieldValue.vector;
-import static com.google.cloud.firestore.LocalFirestoreHelper.query;
 import static com.google.cloud.firestore.it.ITQueryTest.map;
 import static com.google.cloud.firestore.it.TestHelper.isRunningAgainstFirestoreEmulator;
 import static com.google.cloud.firestore.pipeline.expressions.AggregateFunction.count;
@@ -51,12 +50,8 @@
 import static com.google.cloud.firestore.pipeline.expressions.Expression.log;
 import static com.google.cloud.firestore.pipeline.expressions.Expression.logicalMaximum;
 import static com.google.cloud.firestore.pipeline.expressions.Expression.logicalMinimum;
-import static com.google.cloud.firestore.pipeline.expressions.Expression.mapEntries;
-import static com.google.cloud.firestore.pipeline.expressions.Expression.mapKeys;
 import static com.google.cloud.firestore.pipeline.expressions.Expression.mapMerge;
 import static com.google.cloud.firestore.pipeline.expressions.Expression.mapRemove;
-import static com.google.cloud.firestore.pipeline.expressions.Expression.mapSet;
-import static com.google.cloud.firestore.pipeline.expressions.Expression.mapValues;
 import static com.google.cloud.firestore.pipeline.expressions.Expression.notEqual;
 import static com.google.cloud.firestore.pipeline.expressions.Expression.nullValue;
 import static com.google.cloud.firestore.pipeline.expressions.Expression.or;
@@ -86,7 +81,6 @@
 import com.google.cloud.Timestamp;
 import com.google.cloud.firestore.Blob;
 import com.google.cloud.firestore.CollectionReference;
-import com.google.cloud.firestore.DocumentReference;
 import com.google.cloud.firestore.Firestore;
 import com.google.cloud.firestore.FirestoreOptions;
 import com.google.cloud.firestore.GeoPoint;
@@ -112,7 +106,6 @@
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Lists;
-import java.util.Arrays;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
@@ -1384,7 +1377,8 @@ public void testMapGet() throws Exception {
                 map("hugoAward", true, "title", "The Hitchhiker's Guide to the Galaxy"),
                 map("hugoAward", true, "title", "Dune")));
   }
-@Test
+
+  @Test
   public void testMapSet() throws Exception {
     Map<String, Object> docData = new HashMap<>();
     docData.put("existingField", ImmutableMap.of("foo", 1L));
@@ -1400,18 +1394,30 @@ public void testMapSet() throws Exception {
                 Expression.mapSet(constant(ImmutableMap.of()), "a", 1).as("simple"),
                 Expression.mapSet(constant(ImmutableMap.of("a", 1)), "b", 2).as("add"),
                 Expression.mapSet(constant(ImmutableMap.of("a", 1)), "a", 2).as("overwrite"),
-                Expression.mapSet(constant(ImmutableMap.of("a", 1, "b", 2)), "a", 3, "c", 4).as("multi"),
-                Expression.mapSet(constant(ImmutableMap.of("a", 1)), "a", field("non_existent")).as("remove"),
+                Expression.mapSet(constant(ImmutableMap.of("a", 1, "b", 2)), "a", 3, "c", 4)
+                    .as("multi"),
+                Expression.mapSet(constant(ImmutableMap.of("a", 1)), "a", field("non_existent"))
+                    .as("remove"),
                 Expression.mapSet(constant(ImmutableMap.of("a", 1)), "b", null).as("setNull"),
-                Expression.mapSet(constant(ImmutableMap.of("a", ImmutableMap.of("b", 1))), "a.b", 2).as("setDotted"),
+                Expression.mapSet(constant(ImmutableMap.of("a", ImmutableMap.of("b", 1))), "a.b", 2)
+                    .as("setDotted"),
                 Expression.mapSet(constant(ImmutableMap.of()), "", "empty").as("setEmptyKey"),
-                Expression.mapSet(constant(ImmutableMap.of("a", 1)), "b", Expression.add(constant(1), constant(2))).as("setExprVal"),
-                Expression.mapSet(constant(ImmutableMap.of()), "obj", constant(ImmutableMap.of("hidden", true))).as("setNestedMap"),
-                Expression.mapSet(constant(ImmutableMap.of()), "~!@#$%^&*()_+", "special").as("setSpecialChars"),
-
+                Expression.mapSet(
+                        constant(ImmutableMap.of("a", 1)),
+                        "b",
+                        Expression.add(constant(1), constant(2)))
+                    .as("setExprVal"),
+                Expression.mapSet(
+                        constant(ImmutableMap.of()),
+                        "obj",
+                        constant(ImmutableMap.of("hidden", true)))
+                    .as("setNestedMap"),
+                Expression.mapSet(constant(ImmutableMap.of()), "~!@#$%^&*()_+", "special")
+                    .as("setSpecialChars"),
                 field("existingField").mapSet("instanceKey", 100).as("instanceSetField"),
-                constant(ImmutableMap.of("x", 1)).mapSet(constant("y"), constant(2)).as("instanceSetConstant")
-            )
+                constant(ImmutableMap.of("x", 1))
+                    .mapSet(constant("y"), constant(2))
+                    .as("instanceSetConstant"))
             .execute()
             .get();
 
@@ -1426,17 +1432,19 @@ public void testMapSet() throws Exception {
     assertThat((Map<?, ?>) data.get("multi")).containsExactly("a", 3L, "b", 2L, "c", 4L);
     assertThat((Map<?, ?>) data.get("remove")).isEmpty();
     assertThat((Map<?, ?>) data.get("setNull")).containsExactly("a", 1L, "b", null);
-    
+
     Map<?, ?> setDotted = (Map<?, ?>) data.get("setDotted");
     assertThat(setDotted).containsEntry("a.b", 2L);
     assertThat((Map<?, ?>) setDotted.get("a")).containsExactly("b", 1L);
 
     assertThat((Map<?, ?>) data.get("setEmptyKey")).containsExactly("", "empty");
     assertThat((Map<?, ?>) data.get("setExprVal")).containsExactly("a", 1L, "b", 3L);
-    assertThat((Map<?, ?>) data.get("setNestedMap")).isEqualTo(ImmutableMap.of("obj", ImmutableMap.of("hidden", true)));
+    assertThat((Map<?, ?>) data.get("setNestedMap"))
+        .isEqualTo(ImmutableMap.of("obj", ImmutableMap.of("hidden", true)));
     assertThat((Map<?, ?>) data.get("setSpecialChars")).containsExactly("~!@#$%^&*()_+", "special");
 
-    assertThat((Map<?, ?>) data.get("instanceSetField")).containsExactly("foo", 1L, "instanceKey", 100L);
+    assertThat((Map<?, ?>) data.get("instanceSetField"))
+        .containsExactly("foo", 1L, "instanceKey", 100L);
     assertThat((Map<?, ?>) data.get("instanceSetConstant")).containsExactly("x", 1L, "y", 2L);
   }
 
@@ -1455,11 +1463,10 @@ public void testMapKeys() throws Exception {
                 Expression.mapKeys("existingField").as("existingKeys"),
                 Expression.mapKeys(constant(ImmutableMap.of("a", 1, "b", 2))).as("keys"),
                 Expression.mapKeys(constant(ImmutableMap.of())).as("empty_keys"),
-                Expression.mapKeys(constant(ImmutableMap.of("a", ImmutableMap.of("nested", true)))).as("nested_keys"),
-
+                Expression.mapKeys(constant(ImmutableMap.of("a", ImmutableMap.of("nested", true))))
+                    .as("nested_keys"),
                 field("existingField").mapKeys().as("instanceExistingKeys"),
-                constant(ImmutableMap.of("x", 10, "y", 20)).mapKeys().as("instanceKeys")
-            )
+                constant(ImmutableMap.of("x", 10, "y", 20)).mapKeys().as("instanceKeys"))
             .execute()
             .get();
 
@@ -1468,7 +1475,7 @@ public void testMapKeys() throws Exception {
     Map<String, Object> data = resultList.get(0).getData();
 
     assertThat((List<?>) data.get("existingKeys")).containsExactly("foo");
-    assertThat((List<?>) data.get("keys")).containsExactly("a", "b"); 
+    assertThat((List<?>) data.get("keys")).containsExactly("a", "b");
     assertThat((List<?>) data.get("empty_keys")).isEmpty();
     assertThat((List<?>) data.get("nested_keys")).containsExactly("a");
 
@@ -1491,11 +1498,11 @@ public void testMapValues() throws Exception {
                 Expression.mapValues("existingField").as("existingValues"),
                 Expression.mapValues(constant(ImmutableMap.of("a", 1, "b", 2))).as("values"),
                 Expression.mapValues(constant(ImmutableMap.of())).as("empty_values"),
-                Expression.mapValues(constant(ImmutableMap.of("a", ImmutableMap.of("nested", true)))).as("nested_values"),
-
+                Expression.mapValues(
+                        constant(ImmutableMap.of("a", ImmutableMap.of("nested", true))))
+                    .as("nested_values"),
                 field("existingField").mapValues().as("instanceExistingValues"),
-                constant(ImmutableMap.of("x", 10, "y", 20)).mapValues().as("instanceValues")
-            )
+                constant(ImmutableMap.of("x", 10, "y", 20)).mapValues().as("instanceValues"))
             .execute()
             .get();
 
@@ -1506,7 +1513,8 @@ public void testMapValues() throws Exception {
     assertThat((List<?>) data.get("existingValues")).containsExactly(1L);
     assertThat((List<?>) data.get("values")).containsExactly(1L, 2L);
     assertThat((List<?>) data.get("empty_values")).isEmpty();
-    assertThat((List<?>) data.get("nested_values")).containsExactly(ImmutableMap.of("nested", true));
+    assertThat((List<?>) data.get("nested_values"))
+        .containsExactly(ImmutableMap.of("nested", true));
 
     assertThat((List<?>) data.get("instanceExistingValues")).containsExactly(1L);
     assertThat((List<?>) data.get("instanceValues")).containsExactly(10L, 20L);
@@ -1527,11 +1535,11 @@ public void testMapEntries() throws Exception {
                 Expression.mapEntries("existingField").as("existingEntries"),
                 Expression.mapEntries(constant(ImmutableMap.of("a", 1, "b", 2))).as("entries"),
                 Expression.mapEntries(constant(ImmutableMap.of())).as("empty_entries"),
-                Expression.mapEntries(constant(ImmutableMap.of("a", ImmutableMap.of("nested", true)))).as("nested_entries"),
-
+                Expression.mapEntries(
+                        constant(ImmutableMap.of("a", ImmutableMap.of("nested", true))))
+                    .as("nested_entries"),
                 field("existingField").mapEntries().as("instanceExistingEntries"),
-                constant(ImmutableMap.of("x", 10, "y", 20)).mapEntries().as("instanceEntries")
-            )
+                constant(ImmutableMap.of("x", 10, "y", 20)).mapEntries().as("instanceEntries"))
             .execute()
             .get();
 
@@ -1545,7 +1553,7 @@ public void testMapEntries() throws Exception {
     @SuppressWarnings("unchecked")
     List<Map<String, Object>> entries = (List<Map<String, Object>>) data.get("entries");
     assertThat(entries).hasSize(2);
-    
+
     // Map entry order is not guaranteed, so we check containment instead of strict ordering
     assertThat(entries).contains(ImmutableMap.of("k", "a", "v", 1L));
     assertThat(entries).contains(ImmutableMap.of("k", "b", "v", 2L));
@@ -1558,11 +1566,13 @@ public void testMapEntries() throws Exception {
         .containsExactly(ImmutableMap.of("k", "foo", "v", 1L));
 
     @SuppressWarnings("unchecked")
-    List<Map<String, Object>> instanceEntries = (List<Map<String, Object>>) data.get("instanceEntries");
+    List<Map<String, Object>> instanceEntries =
+        (List<Map<String, Object>>) data.get("instanceEntries");
     assertThat(instanceEntries).hasSize(2);
     assertThat(instanceEntries).contains(ImmutableMap.of("k", "x", "v", 10L));
     assertThat(instanceEntries).contains(ImmutableMap.of("k", "y", "v", 20L));
   }
+
   @Test
   public void testDataManipulationExpressions() throws Exception {
     List<PipelineResult> results =
@@ -2933,5 +2943,4 @@ public void disallowDuplicateAliasesAcrossStages() {
             });
     assertThat(exception).hasMessageThat().contains("Duplicate alias or field name");
   }
-
 }