chore: generate libraries at Thu May 7 18:09:23 UTC 2026

Author: cloud-java-bot

google-cloud-firestore/src/main/java/com/google/cloud/firestore/Blob.java

@@ -89,8 +89,8 @@ public static Blob createBsonBinary(@Nonnull ByteString data) {
   }
 
   /**
-   * Creates a new Blob instance representing a BSON binary data type with a specific subtype.
-   * Sets representation to BSON.
+   * Creates a new Blob instance representing a BSON binary data type with a specific subtype. Sets
+   * representation to BSON.
    *
    * @param subtype The subtype to use for this instance.
    * @param bytes The bytes to use for this Blob instance.
@@ -102,8 +102,8 @@ public static Blob createBsonBinary(int subtype, @Nonnull byte[] bytes) {
   }
 
   /**
-   * Creates a new Blob instance representing a BSON binary data type with a specific subtype.
-   * Sets representation to BSON.
+   * Creates a new Blob instance representing a BSON binary data type with a specific subtype. Sets
+   * representation to BSON.
    *
    * @param subtype The subtype to use for this instance.
    * @param data The ByteString to use for this Blob instance.
@@ -188,7 +188,9 @@ public String toString() {
         + ", isBson="
         + this.isBson
         + ", data="
-        + com.google.common.io.BaseEncoding.base16().lowerCase().encode(this.byteString.toByteArray())
+        + com.google.common.io.BaseEncoding.base16()
+            .lowerCase()
+            .encode(this.byteString.toByteArray())
         + "}";
   }
 }

google-cloud-firestore/src/main/java/com/google/cloud/firestore/DocumentSnapshot.java

@@ -482,8 +482,6 @@ public BsonTimestamp getBsonTimestamp(@Nonnull String field) {
     return (BsonTimestamp) get(field);
   }
 
-
-
   /**
    * Gets the reference to the document.
    *

google-cloud-firestore/src/main/java/com/google/cloud/firestore/Order.java

@@ -424,8 +424,6 @@ private int compareBsonTimestamp(Value left, Value right) {
     return secondsDiff != 0 ? secondsDiff : Long.compare(lhs.increment, rhs.increment);
   }
 
-
-
   private boolean isNaN(Value value) {
     if (value.hasDoubleValue() && Double.isNaN(value.getDoubleValue())) {
       return true;

google-cloud-firestore/src/main/java/com/google/cloud/firestore/Quadruple.java

@@ -39,6 +39,7 @@ public final class Quadruple implements Comparable<Quadruple>, Serializable {
   private final int biasedExponent;
   private final long mantHi;
   private final long mantLo;
+
   /**
    * Build a new quadruple from its raw representation - sign, biased exponent, 128-bit mantissa.
    *
@@ -53,38 +54,47 @@ public Quadruple(boolean negative, int biasedExponent, long mantHi, long mantLo)
     this.mantHi = mantHi;
     this.mantLo = mantLo;
   }
+
   /** Return the sign of this {@link Quadruple}. */
   public boolean negative() {
     return negative;
   }
+
   /** Return the unsigned-32-bit biased exponent of this {@link Quadruple}. */
   public int biasedExponent() {
     return biasedExponent;
   }
+
   /** Return the high-order unsigned-64-bits of the mantissa of this {@link Quadruple}. */
   public long mantHi() {
     return mantHi;
   }
+
   /** Return the low-order unsigned-64-bits of the mantissa of this {@link Quadruple}. */
   public long mantLo() {
     return mantLo;
   }
+
   /** Return the (unbiased) exponent of this {@link Quadruple}. */
   public int exponent() {
     return biasedExponent - QuadrupleBuilder.EXPONENT_BIAS;
   }
+
   /** Return true if this {@link Quadruple} is -0 or +0 */
   public boolean isZero() {
     return biasedExponent == 0 && mantHi == 0 && mantLo == 0;
   }
+
   /** Return true if this {@link Quadruple} is -infinity or +infinity */
   public boolean isInfinite() {
     return biasedExponent == (int) EXPONENT_OF_INFINITY && mantHi == 0 && mantLo == 0;
   }
+
   /** Return true if this {@link Quadruple} is a NaN. */
   public boolean isNaN() {
     return biasedExponent == (int) EXPONENT_OF_INFINITY && !(mantHi == 0 && mantLo == 0);
   }
+
   // equals (and hashCode) follow Double.equals: all NaNs are equal and -0 != 0
   @Override
   public boolean equals(Object other) {
@@ -116,6 +126,7 @@ public int hashCode() {
   }
 
   private static final int HASH_NAN = 31 * 31 * Integer.hashCode((int) EXPONENT_OF_INFINITY);
+
   // Compare two quadruples, with -0 < 0, and all NaNs equal and larger than all numbers.
   @Override
   public int compareTo(Quadruple other) {
@@ -211,6 +222,7 @@ public static Quadruple fromDouble(double value) {
     }
     return new Quadruple(value < 0, bias((int) (exponent - 1023)), mantHi, 0);
   }
+
   /**
    * Converts a decimal number to a {@link Quadruple}. The supported format (no whitespace allowed)
    * is:

google-cloud-firestore/src/main/java/com/google/cloud/firestore/QuadrupleBuilder.java

@@ -38,6 +38,7 @@ public static QuadrupleBuilder parseDecimal(byte[] digits, int exp10) {
     q.parse(digits, exp10);
     return q;
   }
+
   // The fields containing the value of the instance
   public int exponent;
   public long mantHi;
@@ -425,6 +426,7 @@ private int parseMantissa(byte[] digits, long[] mantissa) {
     }
     return expCorr;
   }
+
   // Divides the unpacked value stored in the given buffer by 10
   // @param buffer contains the unpacked value to divide (32 least significant bits are used)
   private void divBuffBy10(long[] buffer) {
@@ -438,6 +440,7 @@ private void divBuffBy10(long[] buffer) {
       }
     }
   }
+
   // Checks if the buffer is empty (contains nothing but zeros)
   // @param buffer the buffer to check
   // @return {@code true} if the buffer is empty, {@code false} otherwise
@@ -449,6 +452,7 @@ private boolean isEmpty(long[] buffer) {
     }
     return true;
   }
+
   // Adds one to a decimal number represented as a sequence of decimal digits. propagates carry as
   // needed, so that {@code addCarryTo("6789") = "6790", addCarryTo("9999") = "10000"} etc.
   // @return 1 if an additional higher "1" was added in front of the number as a result of
@@ -466,6 +470,7 @@ private int addCarry(byte[] digits) {
     digits[0] = 1;
     return 1;
   }
+
   // Finds binary exponent, using decimal exponent and mantissa.<br>
   // exp2 = exp10 * log<sub>2</sub>(10) + log<sub>2</sub>(mant)<br>
   // @param exp10 decimal exponent
@@ -479,6 +484,7 @@ private double findBinaryExponent(int exp10, long[] mantissa) {
     double mant10d = ((double) (mant10)) / TWO_POW_63_DIV_10;
     return ((long) Math.floor(((double) (exp10)) * LOG2_10 + log2(mant10d))); // Binary exponent
   }
+
   // Calculates log<sub>2</sub> of the given x
   // @param x argument that can't be 0
   // @return the value of log<sub>2</sub>(x)
@@ -517,6 +523,7 @@ private void findBinaryMantissa(int exp10, double exp2, long[] mantissa) {
       this.mantLo = ((product[2] << 32L) + product[3]);
     }
   }
+
   // Calculates the required power and returns the result in the quasidecimal format (an array of
   // longs, where result[0] is the decimal exponent of the resulting value, and result[1] --
   // result[3] contain 192 bits of the mantissa divided by ten (so that 8 looks like
@@ -557,12 +564,14 @@ private void powerOfTwo(double exp, long[] power) {
       currPowOf2 = currPowOf2 * 0.5; // Note: this is exact
     }
   }
+
   // Copies from into to.
   private void array_copy(long[] source, long[] dest) {
     for (int i = (0); i < ((dest).length); i++) {
       dest[i] = source[i];
     }
   }
+
   // Multiplies two quasidecimal numbers contained in buffers of 3 x 64 bits with exponents, puts
   // the product to <b><i>buffer4x64B</i></b><br>
   // and returns it. Both each of the buffers and the product contain 4 longs - exponent and 3 x 64
@@ -576,6 +585,7 @@ private void multPacked3x64_AndAdjustExponent(long[] factor1, long[] factor2, lo
     // result[0] is a signed int64 value stored in an uint64
     result[0] = factor1[0] + factor2[0] + ((long) (expCorr)); // product.exp = f1.exp + f2.exp
   }
+
   // Multiplies mantissas of two packed quasidecimal values (each is an array of 4 longs, exponent +
   // 3 x 64 bits of mantissa) Returns the product as unpacked buffer of 12 x 32 (12 x 32 bits of
   // product)
@@ -604,6 +614,7 @@ private void multPacked3x64_simply(long[] factor1, long[] factor2, long[] result
       result[i] &= LOWER_32_BITS;
     }
   }
+
   // Corrects possible underflow of the decimal mantissa, passed in in the {@code mantissa}, by
   // multiplying it by a power of ten. The corresponding value to adjust the decimal exponent is
   // returned as the result
@@ -617,6 +628,7 @@ private int correctPossibleUnderflow(long[] mantissa) {
     }
     return expCorr;
   }
+
   // Checks if the unpacked quasidecimal value held in the given buffer is less than one (in this
   // format, one is represented as { 0x1999_9999L, 0x9999_9999L, 0x9999_9999L,...}
   // @param buffer a buffer containing the value to check
@@ -644,6 +656,7 @@ private boolean isLessThanOne(long[] buffer) {
     // and it can never reach this point in real life.
     return false; // Still Java requires the return statement here.
   }
+
   // Multiplies unpacked 192-bit value by a packed 192-bit factor <br>
   // uses static arrays <b><i>buffer6x32B</i></b>
   // @param factor1 a buffer containing unpacked quasidecimal mantissa (6 x 32 bits)
@@ -669,6 +682,7 @@ private void multUnpacked6x32byPacked(long[] factor1, long[] factor2, long[] pro
       product[i] &= LOWER_32_BITS;
     }
   }
+
   // Multiplies the unpacked value stored in the given buffer by 10
   // @param buffer contains the unpacked value to multiply (32 least significant bits are used)
   private void multBuffBy10(long[] buffer) {
@@ -680,6 +694,7 @@ private void multBuffBy10(long[] buffer) {
       buffer[i + 1] &= LOWER_32_BITS;
     }
   }
+
   // Makes sure that the (unpacked) mantissa is normalized,
   // i.e. buff[0] contains 1 in bit 32 (the implied integer part) and higher 32 of mantissa in bits
   // 31..0,
@@ -696,6 +711,7 @@ private int normalizeMant(long[] mantissa) {
     }
     return expCorr;
   }
+
   // Rounds up the contents of the unpacked buffer to 128 bits by adding unity one bit lower than
   // the lowest of these 128 bits. If carry propagates up to bit 33 of buff[0], shifts the buffer
   // rightwards to keep it normalized.
@@ -726,6 +742,7 @@ private int roundUp(long[] mantissa) {
     }
     return 0;
   }
+
   // converts 192 most significant bits of the mantissa of a number from an unpacked quasidecimal
   // form (where 32 least significant bits only used) to a packed quasidecimal form (where buff[0]
   // contains the exponent and buff[1]..buff[3] contain 3 x 64 = 192 bits of mantissa)
@@ -738,6 +755,7 @@ private void pack_6x32_to_3x64(long[] unpackedMant, long[] result) {
     result[2] = (unpackedMant[2] << 32L) + unpackedMant[3];
     result[3] = (unpackedMant[4] << 32L) + unpackedMant[5];
   }
+
   // Unpacks the mantissa of a 192-bit quasidecimal (4 longs: exp10, mantHi, mantMid, mantLo) to a
   // buffer of 6 longs, where the least significant 32 bits of each long contains respective 32 bits
   // of the mantissa
@@ -751,6 +769,7 @@ private void unpack_3x64_to_6x32(long[] qd192, long[] buff_6x32) {
     buff_6x32[4] = ((qd192[3]) >>> (32L));
     buff_6x32[5] = qd192[3] & LOWER_32_BITS;
   }
+
   // Divides the contents of the buffer by 2^exp2<br>
   // (shifts the buffer rightwards by exp2 if the exp2 is positive, and leftwards if it's negative),
   // keeping it unpacked (only lower 32 bits of each element are used, except the buff[0] whose
@@ -778,6 +797,7 @@ private void divBuffByPower2(long[] buffer, int exp2) {
       buffer[maxIdx] = (buffer[maxIdx] << exp2Shift) & LOWER_32_BITS;
     }
   }
+
   // Adds the summand to the idx'th word of the unpacked value stored in the buffer
   // and propagates carry as necessary
   // @param buff the buffer to add the summand to

google-cloud-firestore/src/main/java/com/google/cloud/firestore/UserDataConverter.java

@@ -174,7 +174,9 @@ static Value encodeValue(
     } else if (sanitizedObject instanceof Blob) {
       Blob blob = (Blob) sanitizedObject;
       if (blob.isBson() && blob.subtype() != 0) {
-        return Value.newBuilder().setMapValue(encodeBsonBinaryData(blob.subtype(), blob.toByteString())).build();
+        return Value.newBuilder()
+            .setMapValue(encodeBsonBinaryData(blob.subtype(), blob.toByteString()))
+            .build();
       } else {
         return Value.newBuilder().setBytesValue(blob.toByteString()).build();
       }
@@ -233,7 +235,6 @@ static Value encodeValue(
     } else if (sanitizedObject instanceof BsonTimestamp) {
       BsonTimestamp bsonTimestamp = (BsonTimestamp) sanitizedObject;
       return Value.newBuilder().setMapValue(bsonTimestamp.toProto()).build();
-
     }
 
     throw FirestoreException.forInvalidArgument(

google-cloud-firestore/src/main/java/com/google/cloud/firestore/encoding/CustomClassMapper.java

@@ -19,7 +19,6 @@
 import com.google.api.core.InternalApi;
 import com.google.cloud.Timestamp;
 import com.google.cloud.firestore.Blob;
-
 import com.google.cloud.firestore.BsonObjectId;
 import com.google.cloud.firestore.BsonTimestamp;
 import com.google.cloud.firestore.Decimal128Value;
@@ -171,7 +170,6 @@ static <T> Object serialize(T o, DeserializeContext.ErrorPath path) {
         || o instanceof Decimal128Value
         || o instanceof BsonTimestamp
         || o instanceof BsonObjectId
-
         || o instanceof GeoPoint
         || o instanceof Blob
         || o instanceof DocumentReference

google-cloud-firestore/src/test/java/com/google/cloud/firestore/LocalFirestoreHelper.java

@@ -1152,8 +1152,7 @@ public boolean equals(Object o) {
     ALL_SUPPORTED_TYPES_MAP.put("decimal128Value", new Decimal128Value("1.2e3"));
     ALL_SUPPORTED_TYPES_MAP.put("bsonObjectId", new BsonObjectId("507f191e810c19729de860eb"));
     ALL_SUPPORTED_TYPES_MAP.put("bsonTimestamp", new BsonTimestamp(100, 10));
-    ALL_SUPPORTED_TYPES_MAP.put(
-        "bsonBinaryData", Blob.createBsonBinary(127, new byte[] {1, 2, 3}));
+    ALL_SUPPORTED_TYPES_MAP.put("bsonBinaryData", Blob.createBsonBinary(127, new byte[] {1, 2, 3}));
     ALL_SUPPORTED_TYPES_PROTO =
         ImmutableMap.<String, Value>builder()
             .put("foo", Value.newBuilder().setStringValue("bar").build())

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

@@ -117,7 +117,6 @@
 import com.google.api.gax.rpc.StatusCode;
 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.DocumentSnapshot;
@@ -434,17 +433,17 @@ public void canFilterAndOrderBlobWithSubtypes() throws Exception {
         firestore
             .pipeline()
             .createFrom(coll)
-            .where(Expression.greaterThan(field("key"), constant(Blob.createBsonBinary(1, new byte[] {1, 2, 3}))))
+            .where(
+                Expression.greaterThan(
+                    field("key"), constant(Blob.createBsonBinary(1, new byte[] {1, 2, 3}))))
             .sort(field("key").descending())
             .execute()
             .get()
             .getResults();
 
     List<Map<String, Object>> resultData = data(results);
     // Expected: doc3 (subtype 2), then doc2 (subtype 1, data larger)
-    assertThat(resultData)
-        .containsExactly(data.get("doc3"), data.get("doc2"))
-        .inOrder();
+    assertThat(resultData).containsExactly(data.get("doc3"), data.get("doc2")).inOrder();
   }
 
   private String stringOfOrderedKeyValues(Map<String, Object> map) {

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

@@ -25,14 +25,12 @@
 import static java.util.Collections.singletonList;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
-
-import com.google.api.core.ApiFuture;
 import static org.junit.Assume.assumeTrue;
 
+import com.google.api.core.ApiFuture;
 import com.google.api.core.ApiFutures;
 import com.google.cloud.Timestamp;
 import com.google.cloud.firestore.Blob;
-
 import com.google.cloud.firestore.BsonObjectId;
 import com.google.cloud.firestore.BsonTimestamp;
 import com.google.cloud.firestore.CollectionReference;
@@ -976,15 +974,16 @@ public void canFilterBlobWithSubtypeZero() throws Exception {
     assumeTrue(getFirestoreEdition() == FirestoreEdition.ENTERPRISE);
     Map<String, Map<String, Object>> data =
         map(
-            "doc1", map("key", Blob.fromBytes(new byte[] {1, 2, 3})), // Native (subtype 0 implicitly)
+            "doc1",
+                map("key", Blob.fromBytes(new byte[] {1, 2, 3})), // Native (subtype 0 implicitly)
             "doc2", map("key", Blob.createBsonBinary(new byte[] {1, 2, 3})), // BSON with subtype 0
-            "doc3", map("key", Blob.createBsonBinary(1, new byte[] {1, 2, 3}))); // BSON with subtype 1
+            "doc3",
+                map("key", Blob.createBsonBinary(1, new byte[] {1, 2, 3}))); // BSON with subtype 1
     addDocs(data);
 
     // Query for native blob
     QuerySnapshot snapshot =
-        getFirstSnapshot(
-            randomColl.whereEqualTo("key", Blob.fromBytes(new byte[] {1, 2, 3})));
+        getFirstSnapshot(randomColl.whereEqualTo("key", Blob.fromBytes(new byte[] {1, 2, 3})));
     List<Map<String, Object>> resultData = toDataArray(snapshot);
     // Should match both doc1 and doc2!
     assertThat(resultData).containsExactly(data.get("doc1"), data.get("doc2"));