</la:link>
                                    <la:link href="list/1?dictId=${f:u(dictId)}"
                                             styleClass="btn btn-primary btn-xs">
                                        <em class="fa fa-th-list">
                                        <la:message key="labels.dict_synonym_list_link"/>
                                    </la:link>

  public void testIterator() {
    List<E> iteratorElements = new ArrayList<>();
    for (E element : collection) { // uses iterator()
      iteratorElements.add(element);
    }
    assertEqualIgnoringOrder(asList(createSamplesArray()), iteratorElements);
  }

  @CollectionFeature.Require(KNOWN_ORDER)
  public void testIterationOrdering() {
    List<E> iteratorElements = new ArrayList<>();

   * implementation, however, has the advantage of working for insertion-ordered containers, as
   * well.
   */
  @Override
  public List<Integer> order(List<Integer> insertionOrder) {
    return insertionOrder;
  }

    synchronized (lock) {
      stack.addFirst(checkNotNull(tearDown));
    }
  }

  /** Causes teardown to execute. */
  public final void runTearDown() {
    List<Throwable> exceptions = new ArrayList<>();
    List<TearDown> stackCopy;
    synchronized (lock) {
      stackCopy = Lists.newArrayList(stack);
      stack.clear();
    }
    for (TearDown tearDown : stackCopy) {
      try {

                return true;
            }
        });

        List<Profile> profiles = Collections.singletonList(newProfile("one"));
        DefaultProfileActivationContext context = new DefaultProfileActivationContext();
        SimpleProblemCollector problems = new SimpleProblemCollector();
        List<Profile> active = selector.getActiveProfiles(profiles, context, problems);
        assertTrue(active.isEmpty());

    synchronized (lock) {
      stack.addFirst(checkNotNull(tearDown));
    }
  }

  /** Causes teardown to execute. */
  public final void runTearDown() {
    List<Throwable> exceptions = new ArrayList<>();
    List<TearDown> stackCopy;
    synchronized (lock) {
      stackCopy = Lists.newArrayList(stack);
      stack.clear();
    }
    for (TearDown tearDown : stackCopy) {
      try {

		{"VADDPD.Z.Z X0, X1, X2", `Z suffix should be the last; duplicate suffix "Z"`},
		{"VADDPD.SAE.BCST X0, X1, X2", `can't combine rounding/SAE and broadcast`},
		{"VADDPD.BCST.SAE X0, X1, X2", `can't combine rounding/SAE and broadcast`},
		{"VADDPD.BCST.Z.SAE X0, X1, X2", `Z suffix should be the last; can't combine rounding/SAE and broadcast`},
		{"VADDPD.SAE.SAE X0, X1, X2", `duplicate suffix "SAE"`},

import org.gradle.api.Transformer;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

public abstract class AbstractLanguageElement implements LanguageElement, Serializable {
    private String rawCommentText;
    private final List<String> annotationNames = new ArrayList<String>();
    private String replacement;

    protected AbstractLanguageElement() {
    }

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.helper;

import java.util.ArrayList;
import java.util.List;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.codelibs.fess.app.service.DuplicateHostService;
import org.codelibs.fess.es.config.exentity.DuplicateHost;

            request.setSystemProperties(props);
        }

        return request;
    }

    @SuppressWarnings("unchecked")
    private List<ArtifactRepository> normalizeToArtifactRepositories(
            List<?> repositories, ProjectBuildingRequest request) throws ProjectBuildingException {
        /*