*     // If an exception occurs, rethrow it only if threw==false:
   *     Closeables.close(stream, threw);
   *   }
   * }
   * }
   *
   * @param closeable the {@code Closeable} object to be closed, or null, in which case this method
   *     does nothing
   * @param swallowIOException if true, don't propagate IO exceptions thrown by the {@code close}
   *     methods

 * @param <V> the type of the cache's values, which are not permitted to be null
 * @author Charles Fry
 * @since 10.0
 */
@DoNotMock("Use CacheBuilder.newBuilder().build()")
@GwtCompatible
public interface Cache<K, V> {

  /**
   * Returns the value associated with {@code key} in this cache, or {@code null} if there is no
   * cached value for {@code key}.
   *

            Smb2TransformHeader.decode(invalidBuffer, 0);
        });
    }

    @Test
    @DisplayName("Should handle null nonce")
    void testNullNonce() {
        // When/Then
        assertThrows(NullPointerException.class, () -> {
            transformHeader.setNonce(null);
        });
    }

    @Test
    @DisplayName("Should handle invalid nonce length")
    void testInvalidNonceLength() {

    }

    // Test edge cases
    @Test
    public void test_addQuery_withNullValues() {
        facetQueryView.addQuery(null, "query1");
        assertEquals("query1", facetQueryView.getQueryMap().get(null));

        facetQueryView.addQuery("key1", null);
        assertNull(facetQueryView.getQueryMap().get("key1"));
    }

    @Test
    public void test_init_multipleCallsShouldNotDuplicate() {

        }

        @Override
        public GeoInfo getGeoInfo() {
            return null;
        }

        @Override
        public FacetInfo getFacetInfo() {
            return null;
        }

        @Override
        public HighlightInfo getHighlightInfo() {
            return null;
        }

        @Override
        public String getSort() {
            return sort;

      try {
        closeable.close();
      } catch (Throwable e) {
        if (throwable == null) {
          throwable = e;
        } else {
          suppressor.suppress(closeable, throwable, e);
        }
      }
    }

    if (thrown == null && throwable != null) {
      throwIfInstanceOf(throwable, IOException.class);
      throwIfUnchecked(throwable);

        String queryId = JsonPath.from(searchResponse).getString("query_id");
        assertTrue(queryId != null && !queryId.isEmpty(), "queryId should not be null");

        // Now test the favorites API
        Map<String, String> params = new HashMap<>();
        params.put("queryId", queryId);

        given().contentType("application/json")

  @Override
  public int size() {
    return Ints.saturatedCast(size);
  }

  @Override
  public int count(@Nullable Object element) {
    // isActuallyE checks for null, but we check explicitly to help nullness checkers.
    if (element == null || !isActuallyE(element)) {
      return 0;
    }
    Enum<?> e = (Enum<?>) element;
    return counts[e.ordinal()];
  }

  // Modification Operations

    assert app.openapi()["components"]["schemas"][body_model_name] == {
        "properties": {
            "p": {
                "anyOf": [{"type": "string"}, {"type": "null"}],
                "title": "P",
            },
        },
        "title": body_model_name,
        "type": "object",
    }


def test_optional_str_missing():
    client = TestClient(app)

    }

    @Override
    protected Map<String, Object> createTestParam(int id) {
        fail(); // Unreachable
        return null;
    }

    @Override
    protected Map<String, Object> getUpdateMap() {
        fail(); // Unreachable
        return null;
    }

    @Override
    protected void testRead() {
        final Map<String, Object> searchBody = new HashMap<>();