* across different segments.
   *
   * The page replacement algorithm's data structures are kept casually consistent with the map. The
   * ordering of writes to a segment is sequentially consistent. An update to the map and recording
   * of reads may not be immediately reflected on the algorithm's data structures. These structures
   * are guarded by a lock and operations are applied in batches to avoid lock contention. The

                        persistentManager.storeHandle(uncPath, resp.getFileId(), resp.getDurableHandleGuid());
                    }
                }

                // Update lease state if granted
                if (config.isUseLeases() && resp.isLeaseGranted()) {
                    LeaseManager leaseManager = session.getLeaseManager();
                    if (leaseManager != null) {

  ASSERT_EQ(TF_OK, TF_GetCode(s)) << TF_Message(s);

  NodeDef node_def_neg;
  ASSERT_TRUE(GetNodeDef(neg, &node_def_neg));
  EXPECT_EQ(string("add"), node_def_neg.input(0));

  // update edge of neg
  TF_UpdateEdge(graph, TF_Output{one, 0}, TF_Input{neg, 0}, s);

  ASSERT_TRUE(GetNodeDef(neg, &node_def_neg));
  EXPECT_EQ(string("one:0"), node_def_neg.input(0));

  // Clean up

        // Test toLineString method
        StopwordsItem item = new StopwordsItem(1, "original");
        assertEquals("original", item.toLineString());

        // When updated, should return newInput
        item.setNewInput("updated");
        assertEquals("updated", item.toLineString());

        // When marked for deletion
        item.setNewInput("");
        assertEquals("", item.toLineString());

        assertEquals((int) offset, getFieldValue(write, "offset"), "Offset should be updated");
        assertEquals(remaining, getFieldValue(write, "remaining"), "Remaining should be updated");
        assertEquals(buffer, getFieldValue(write, "b"), "Buffer should be updated");
        assertEquals(off, getFieldValue(write, "off"), "Off should be updated");

a.jQuery)}(this,function(a){!function(a){function b(a,b,d){var e=new Date(a,b,d),f=new Date,g=f.getFullYear()-e.getFullYear();e.setFullYear(e.getFullYear()+g),e>f&&(g--,e.setFullYear(e.getFullYear()-1));var h=Math.floor((f.getTime()-e.getTime())/864e5),i=g+h/(c(f.getFullYear())?366:365),j=((i+"").split(".")[1]||"").substr(0,3);return i>=0?Math.floor(i)+(j>=915?1:0):(j*=10,Math.floor(i)+(j<=840?1:0))}function c(a){var b=new Date(a,1,28);return b.setDate(b.getDate()+1),1===b.getMonth()}a.formUtils...

    }

    // PUT /api/admin/accesstoken/setting
    /**
     * Updates an existing access token setting.
     *
     * @param body the edit body containing updated access token data
     * @return JSON response with the updated access token ID
     */
    @Execute
    public JsonResponse<ApiResult> put$setting(final EditBody body) {

     */
    @Nonnull
    Optional<Boolean> nonRecursive();

    /**
     * Indicates whether Maven should force a check for updated snapshots on remote repositories.
     *
     * @return an {@link Optional} containing true if snapshot updates should be forced, false if not, or empty if not specified
     */
    @Nonnull
    Optional<Boolean> updateSnapshots();

    /**

import java.util.function.LongBinaryOperator;
import java.util.function.LongUnaryOperator;
import org.jspecify.annotations.Nullable;

/**
 * A map containing {@code long} values that can be atomically updated. While writes to a
 * traditional {@code Map} rely on {@code put(K, V)}, the typical mechanism for writing to this map
 * is {@code addAndGet(K, long)}, which adds a {@code long} to the value currently associated with

    @DisplayName("getMechs returns configured mechs and setMechs updates them")
    void testGetSetMechs() {
        SpnegoContext ctx = newContext();
        assertArrayEquals(this.mechs, ctx.getMechs());
        ASN1ObjectIdentifier[] updated = new ASN1ObjectIdentifier[] { new ASN1ObjectIdentifier("1.2.840.113554.1.2.2") };
        ctx.setMechs(updated);
        assertArrayEquals(updated, ctx.getMechs());
    }

    @Test