id: current-behavior
    attributes:
      label: Current Behavior
      description: Tell us what happens
    validations:
      required: true
  - type: textarea
    id: expected-behavior
    attributes:
      label: Expected Behavior
      description: Tell us what should happen
    validations:
      required: true
  - type: textarea
    id: context
    attributes:
      label: Context (optional)

        String expected = "http://example/foo.jpg";
        assertGetThumbnailUrl(data, expected);

        data = "<meta property=\"og:image\" content=\"://example/foo.jpg\" />";
        expected = "http://example/foo.jpg";
        assertGetThumbnailUrl(data, expected);

        data = "<meta property=\"og:image\" content=\"http://example/foo.jpg\" />";
        expected = "http://example/foo.jpg";

    E[] array = createArrayWithNullElement();
    collection = getSubjectGenerator().create(array);
    assertTrue("add(nullPresent) should return true", getList().add(null));

    List<E> expected = copyToList(array);
    expected.add(null);
    expectContents(expected);
  }

  /**
   * Returns the {@link Method} instance for {@link #testAdd_supportedNullPresent()} so that tests

  @CollectionFeature.Require(KNOWN_ORDER)
  public void testForEachKnownOrder() {
    List<E> elements = new ArrayList<>();
    collection.forEach(elements::add);
    List<E> expected = copyToList(getOrderedElements());
    assertEquals("Different ordered iteration", expected, elements);
  }

    Thread waitingThread = new Thread(wasInterrupted);
    waitingThread.start();
    waitingThread.interrupt();
    ExecutionException expected = assertThrows(ExecutionException.class, wasInterrupted::get);
    assertTrue(expected.getCause().toString(), expected.getCause() instanceof InterruptedException);
  }

  public void testMakeUninterruptible_timedGetZeroTimeoutAttempted()

    ValueAndCloser<?> valueAndCloser = finishToValueAndCloser(closingFuture);
    try {
      valueAndCloser.get();
      fail();
    } catch (ExecutionException expected) {
      assertThat(expected).hasCauseThat().isSameInstanceAs(exception);
    }
    valueAndCloser.closeAsync();
  }

  @Override
  void assertBecomesCanceled(ClosingFuture<?> closingFuture) throws ExecutionException {

    try {
      visitor.visit(type);
      fail("Type not visited");
    } catch (UnsupportedOperationException expected) {
    }
    try {
      visitor.visit(new Type[] {type});
      fail("Type not visited");
    } catch (UnsupportedOperationException expected) {
    }
  }

  private static class BaseTypeVisitor extends TypeVisitor {
    @Override

    Thread waitingThread = new Thread(wasInterrupted);
    waitingThread.start();
    waitingThread.interrupt();
    ExecutionException expected = assertThrows(ExecutionException.class, wasInterrupted::get);
    assertTrue(expected.getCause().toString(), expected.getCause() instanceof InterruptedException);
  }

  public void testMakeUninterruptible_timedGetZeroTimeoutAttempted()

      fail("UnsupportedOperationException expected");
    } catch (UnsupportedOperationException expected) {
    }
    try {
      unmod.putAll(singletonMap(4, "four"));
      fail("UnsupportedOperationException expected");
    } catch (UnsupportedOperationException expected) {
    }
    try {
      unmod.remove(4);
      fail("UnsupportedOperationException expected");

    }

    @Test
    public void test_escapeValue_longString() {
        String input = "a]".repeat(1000) + "*";
        String expected = "a]".repeat(1000) + "\\2a";
        assertEquals(expected, LdapUtil.escapeValue(input));
    }

    @Test
    public void test_escapeValue_realWorldLdapInjectionAttempts() {
        // Authentication bypass attempt