return builder.execute();
        });
        final OpenSearchResultList<OpenSearchAccessResult> targetList = new OpenSearchResultList<>();
        final SearchHits hits = response.getHits();
        final TotalHits totalHits = hits.getTotalHits();
        final long totalHitsValue = totalHits != null ? totalHits.value() : 0;

        return profile.getActivation() != null && profile.getActivation().getProperty() != null;
    }

    @Override
    public boolean isActive(Profile profile) throws ProfileActivationException {
        Activation activation = profile.getActivation();

        ActivationProperty property = activation.getProperty();

        if (property != null) {
            String name = property.getName();

    if (sslSocket is BCSSLSocket) {
      when (val protocol = (sslSocket as BCSSLSocket).applicationProtocol) {
        // Handles both un-configured and none selected.
        null, "" -> null
        else -> protocol
      }
    } else {
      super.getSelectedProtocol(sslSocket)
    }

  companion object {
    val isSupported: Boolean =
      try {

        add(severity, version, message, null, null);
    }

    default void add(
            BuilderProblem.Severity severity, ModelProblem.Version version, String message, InputLocation location) {
        add(severity, version, message, location, null);
    }

    default void add(

        if (millis != null) {
            delayMillisAfterProcessing = millis;
        }

        millis = params.get("delayMillisAtNoUrlInQueue");
        if (millis != null) {
            delayMillisAtNoUrlInQueue = millis;
        }

        millis = params.get("delayMillisBeforeProcessing");
        if (millis != null) {
            delayMillisBeforeProcessing = millis;
        }

            byte[] buf;

            if (this.freeBuffers > 0) {
                for (int i = 0; i < this.cache.length; i++) {
                    if (this.cache[i] != null) {
                        buf = (byte[]) this.cache[i];
                        this.cache[i] = null;
                        this.freeBuffers--;
                        return buf;
                    }
                }
            }

    assertTrue(multimap().remove(getKeyForNullValue(), null));

    expectMissing(mapEntry(getKeyForNullValue(), (V) null));
    assertGet(getKeyForNullValue(), ImmutableList.<V>of());
  }

  @MapFeature.Require({SUPPORTS_REMOVE, ALLOWS_NULL_KEY_QUERIES})
  public void testRemoveNullKeyAbsent() {
    assertFalse(multimap().remove(null, v0()));
    expectUnchanged();
  }

        delete(file);
      }
    }
    filesToDelete.clear();
  }

  private File getTestDir() throws IOException {
    if (testDir != null) {
      return testDir;
    }

    URL testFileUrl = IoTestCase.class.getResource("testdata/i18n.txt");
    if (testFileUrl == null) {
      throw new RuntimeException("unable to locate testdata directory");
    }

    if (testFileUrl.getProtocol().equals("file")) {
      try {

        if (info != null) {
            System.arraycopy(fileId, 0, info.fileId, 0, 16);
            if (info.type == HandleType.PERSISTENT) {
                persistHandle(info);
            }
        }
    }
    
    public HandleInfo getHandleForReconnect(String path) {
        HandleInfo info = handles.get(path);
        if (info != null && !info.isExpired()) {

                @Override
                public void registerData(String key, Object value) {
                    // Mock implementation
                }
            };
        } catch (Exception e) {
            // If ActionRuntime constructor fails, return null and handle in test methods
            return null;
        }
    }