for (cookie in cookies) {
      cookieStrings.add(cookieToString(cookie, true))
    }
    val multimap = mapOf("Set-Cookie" to cookieStrings)
    try {
      cookieHandler.put(url.toUri(), multimap)
    } catch (e: IOException) {
      Platform.get().log("Saving cookies failed for " + url.resolve("/...")!!, WARN, e)
    }
  }

  override fun loadForRequest(url: HttpUrl): List<Cookie> {
    val cookieHeaders =
      try {

    try {
      assertEquals(
          "getOrDefault(null, def) should return default or throw",
          v3(),
          getMap().getOrDefault(null, v3()));
    } catch (NullPointerException tolerated) {
    }
  }

  @MapFeature.Require(ALLOWS_NULL_KEYS)
  @CollectionSize.Require(absent = ZERO)
  public void testGetOrDefault_nonNullWhenNullContained() {
    initMapWithNullKey();

            validator.validatePath("\\share\\con");
            fail("Should block lowercase reserved name");
        } catch (SmbException e) {
            // Expected
        }

        try {
            validator.validatePath("\\share\\Con");
            fail("Should block mixed case reserved name");
        } catch (SmbException e) {
            // Expected
        }
    }

    @Test

      boolean isPowerOf2 = IntMath.isPowerOfTwo(x);
      try {
        assertEquals(x, 1 << IntMath.log2(x, UNNECESSARY));
        assertTrue(isPowerOf2);
      } catch (ArithmeticException e) {
        assertFalse(isPowerOf2);
      }
    }
  }

  @GwtIncompatible // log10
  public void testLog10ZeroAlwaysThrows() {
    for (RoundingMode mode : ALL_ROUNDING_MODES) {

                }
                jobLog.setScriptResult(ret.toString());
            }
            jobLog.setJobStatus(Constants.OK);
        } catch (final Throwable t) {
            logger.warn("Failed to execute job: id={}, script={}", id, script, t);
            jobLog.setJobStatus(Constants.FAIL);

        try (final XContentBuilder builder = func.apply(mediaType.contentBuilder(), ToXContent.EMPTY_PARAMS)) {
            builder.flush();
            return builder.getOutputStream();
        } catch (final IOException e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Failed to print the output.", e);
            }
            return new ByteArrayOutputStream();
        }
    }

          getMap()
              .computeIfAbsent(
                  k0(),
                  k -> {
                    assertEquals(k0(), k);
                    return v0();
                  }));
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)

                    return true;
                }

            } catch (InterruptedException e) {
                log.debug("RDMA recovery interrupted");
                Thread.currentThread().interrupt();
                break;
            } catch (Exception recoveryError) {
                log.warn("RDMA recovery attempt {} failed: {}", retryCount, recoveryError.getMessage());

        try {
            BaseConfiguration config = new BaseConfiguration(false);
            mockContext = new BaseContext(config);
            response = new SmbComNegotiateResponse(mockContext);
        } catch (Exception e) {
            throw new RuntimeException("Failed to set up test", e);
        }
    }

    @Test
    public void testConstructor() {
        assertNotNull(response);

        MockSMailPostingDiscloser discloser = new MockSMailPostingDiscloser();

        // Should return early without doing anything
        try {
            notificationHelper.sendToSlack(null, discloser);
        } catch (Exception e) {
            fail("sendToSlack() should not throw an exception with blank URLs: " + e.getMessage());
        }
    }

    @Test
    public void test_sendToSlack_withNullWebhookUrls() {