val list = new LinkedList()

        list.add("one")
        list.add("two")
        assertTrue(list.remove("one"))

        assertEquals(1, list.size())
        assertEquals("two", list.get(0))

        assertTrue(list.remove("two"))
        assertEquals(0, list.size())
    }

    @Test def testRemoveMissing(): Unit = {
        val list = new LinkedList()

        list.add("one")
        list.add("two")

	defer list.RUnlock()

	targets := make([]Target, 0, len(list.targets))
	for _, tgt := range list.targets {
		targets = append(targets, tgt)
	}

	return targets
}

// Empty returns true if targetList is empty.
func (list *TargetList) Empty() bool {
	list.RLock()
	defer list.RUnlock()

	return len(list.targets) == 0
}

// List - returns available target IDs.

	return nil
}

// List represents a doubly linked list.
// The zero value for List is an empty list ready to use.
type List[T any] struct {
	root Element[T] // sentinel list element, only &root, root.prev, and root.next are used
	len  int        // current list length excluding (this) sentinel element
}

// Init initializes or clears list l.
func (l *List[T]) Init() *List[T] {
	l.root.next = &l.root
	l.root.prev = &l.root
	l.len = 0

Text.
 - List immediately after.
 - Another.

More text.

 - List after blank line.
 - Another.

Even more text.
 - List immediately after.

 - Blank line between items.

Yet more text.

 - Another list after blank line.

 - Blank line between items.

Still more text.
 - One list item.

   Multiple paragraphs.
-- dump --
Doc
	Paragraph
		Plain "Text."

        if (setter != null) {
            List<U> list = new ArrayList<>(getter.get());
            list.add(index, revMapper.apply(element));
            setter.accept(list);
        } else {
            getter.get().add(index, revMapper.apply(element));
        }
    }

    @Override
    public T remove(int index) {
        if (setter != null) {
            List<U> list = new ArrayList<>(getter.get());

        list.toArray(new String[0]) == ['foo', 'bar', 'baz'] as String[]
    }

    def "can check contents"() {
        when:
        mutate {
            add 'foo'
            add 'bar'
            add 'baz'
        }

        then:
        def list = registry.realize(collectionPath, collectionType)
        list.contains('foo')
        !list.contains('echo')
        list.containsAll(['foo', 'baz'])

        #; !GreaterThan = map:{ $$ALL$$ = list:{ $$VersionNo$$ } }
        #; !LessThan = map:{ $$ALL$$ = list:{ $$VersionNo$$ } }
        #; !GreaterEqual = map:{ $$ALL$$ = list:{ $$VersionNo$$ } }
        #; !LessEqual = map:{ $$ALL$$ = list:{ $$VersionNo$$ } }
        #; !RangeOf = map:{ $$ALL$$ = list:{ $$VersionNo$$ } }
        #; !InScope = map:{ $$ALL$$ = list:{ $$VersionNo$$ } }

import java.util.Collection;
import java.util.List;
import java.util.function.BiConsumer;

public interface JavaPropertyReflectionUtilTestMethods<T> {
    T simpleTypeVariable();

    List<T> encapsulatedTypeVariable();

    T[] arrayTypeWithTypeVariable();

    List<Collection<? extends List<? super T>>[]> complexTypeWithTypeVariable();

        LinkedList list = new LinkedList();

        list.add("one");
        list.add("two");
        assertTrue(list.remove("one"));

        assertEquals(1, list.size());
        assertEquals("two", list.get(0));

        assertTrue(list.remove("two"));
        assertEquals(0, list.size());
    }

    @Test public void testRemoveMissing() {
        LinkedList list = new LinkedList();

        list.add("one");

-- input --
Text.
  1. List
2. Not indented, not a list.
  3. Another list.

-- gofmt --
Text.
 1. List

2. Not indented, not a list.
 3. Another list.

-- text --
Text.
 1. List

2. Not indented, not a list.
 3. Another list.

-- markdown --
Text.

 1. List

2\. Not indented, not a list.

 3. Another list.

-- html --
<p>Text.
<ol>
<li>List
</ol>