}
  }

  /** Confirm that runtime exceptions thrown inside of OkHttp propagate to the caller.  */
  @Test
  fun unexpectedExceptionSync() {
    client =
      client
        .newBuilder()
        .dns { hostname: String? -> throw RuntimeException("boom!") }
        .build()
    server.enqueue(MockResponse())
    assertFailsWith<RuntimeException> {

      }
    } catch (e: Throwable) {
      if (KNOWN_FAILURES.contains(testData.toString())) {
        System.err.println("Ignoring known failure: $testData")
        e.printStackTrace()
      } else {
        throw e
      }
    }
  }

  private fun testHttpUrl(testData: WebPlatformUrlTestData) {
    val url =
      when (testData.base) {
        "about:blank" -> testData.input!!.toHttpUrlOrNull()

      }
    },
    KNUTH {
      @Override
      MeanAndVariance variance(double[] values, MeanAlgorithm meanAlgorithm) {
        if (meanAlgorithm != MeanAlgorithm.KNUTH) {
          throw new SkipThisScenarioException();
        }
        double mean = values[0];
        double s = 0.0;
        for (int i = 1; i < values.length; i++) {
          double nextMean = mean + (values[i] - mean) / (i + 1);

      }
    },
    KNUTH {
      @Override
      MeanAndVariance variance(double[] values, MeanAlgorithm meanAlgorithm) {
        if (meanAlgorithm != MeanAlgorithm.KNUTH) {
          throw new SkipThisScenarioException();
        }
        double mean = values[0];
        double s = 0.0;
        for (int i = 1; i < values.length; i++) {
          double nextMean = mean + (values[i] - mean) / (i + 1);

  @CollectionSize.Require(absent = ZERO)
  public void testPutIfAbsent_unsupportedPresentExistingValue() {
    try {
      assertEquals(
          "putIfAbsent(present, existingValue) should return present or throw",
          v0(),
          putIfAbsent(e0()));
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)

        assertEquals((byte) 0x74, msg.command, "Command should be SMB_COM_LOGOFF_ANDX");
    }

    @Test
    @DisplayName("constructor with null andx does not throw exception")
    void constructorWithNullAndxNoException() {
        // This test verifies that passing null doesn't cause any issues
        assertDoesNotThrow(() -> {

    }
    constructor.setAccessible(true); // accessibility check is too slow
    try {
      return constructor.newInstance();
    } catch (InstantiationException | IllegalAccessException impossible) {
      throw new AssertionError(impossible);
    } catch (InvocationTargetException e) {
      logger.log(Level.WARNING, "Exception while invoking default constructor.", e.getCause());
      return arbitraryConstantInstanceOrNull(type);

      return false;
    }

    addNodeInternal(node);
    return true;
  }

  /**
   * Adds {@code node} to the graph and returns the associated {@link GraphConnections}.
   *
   * @throws IllegalStateException if {@code node} is already present
   */
  @CanIgnoreReturnValue
  private GraphConnections<N, V> addNodeInternal(N node) {
    GraphConnections<N, V> connections = newConnections();

public class FessJsonResourceProviderTest extends UnitFessTestCase {

    private FessJsonResourceProvider provider;

    @Override
    protected void setUp(TestInfo testInfo) throws Exception {
        super.setUp(testInfo);
        provider = new FessJsonResourceProvider();
    }

    @Test
    public void test_isNullsSuppressed() {
        // Test that nulls are suppressed

    }

    @Test
    void testDelete_ng() {
        checkDeleteMethod(Collections.emptyMap()).then().body("response.status", equalTo(1));
    }

    @Test
    void testCRUD() throws Exception {
        List<Map<String, Object>> available =
                checkGetMethod(Collections.emptyMap(), getAvailableEndpointSuffix() + "/").body().jsonPath().get("response.plugins");