@Execute
    @Secured({ ROLE, ROLE + VIEW })
    public HtmlResponse index(final SearchForm form) {
        validate(form, messages -> {}, this::asDictIndexHtml);
        synonymPager.clear();
        return asHtml(path_AdminDictSynonym_AdminDictSynonymJsp).renderWith(data -> {
            searchPaging(data, form);
        });
    }

    @Execute
    @Secured({ ROLE, ROLE + VIEW })

            return parent.removeAll(c);
        }

        public boolean retainAll(final Collection<?> c) {
            return parent.retainAll(c);
        }

        public void clear() {
            parent.clear();
        }

        public boolean equals(final Object o) {
            return parent.equals(o);
        }

        public int hashCode() {
            return parent.hashCode();

        try (PrintWriter fw = new PrintWriter(new FileWriter(reportFile))) {
            writeHeader(fw);
            if (errors.isEmpty()) {
                fw.println("All clear!");
                return;
            }
            for (Map.Entry<File, List<Error>> e : errors.entrySet()) {
                File file = e.getKey();
                List<Error> errorsForFile = e.getValue();

        return delegate;
    }

    private void feedConsumer() {
        final ArrayList<Exchange> batch = new ArrayList<>(batchMaxSize);
        try {
            while (true) {
                batch.clear();
                if (eventQueue.drainTo(batch, BATCH_MAX_SIZE) == 0) {
                    batch.add(eventQueue.take());
                }
                demux(batch);
            }

        // however, SISU visibility filtering can only happen when an explicit
        // lookup is performed. The whole problem here is caused by "project extensions"
        // which are bound to a project's classloader, without any clear definition
        // of a "project scope"
        LifecycleMapping lifecycleMapping =
                lookup.lookupOptional(LifecycleMapping.class, id).orElse(null);
        if (lifecycleMapping == null) {

func (j *xlMetaV2Version) unmarshalV(v uint8, bts []byte) (o []byte, err error) {
	if v > xlMetaVersion {
		return bts, fmt.Errorf("unknown xlMetaVersion: %d", v)
	}

	// Clear omitempty fields:
	if j.ObjectV2 != nil && len(j.ObjectV2.PartIndices) > 0 {
		j.ObjectV2.PartIndices = j.ObjectV2.PartIndices[:0]
	}
	o, err = j.UnmarshalMsg(bts)

import org.codelibs.fess.unit.UnitFessTestCase;

public class ParameterUtilTest extends UnitFessTestCase {

    @Override
    public void setUp() throws Exception {
        super.setUp();
        FessProp.propMap.clear();
        FessConfig fessConfig = new FessConfig.SimpleImpl() {
            @Override
            public String getAppEncryptPropertyPattern() {
                return ".*password|.*key";
            }
        };

    buf2 = CharBuffer.allocate(5);
    builder = new StringBuilder();
    while (reader.read(buf2) != -1) {
      Java8Compatibility.flip(buf2);
      builder.append(buf2);
      Java8Compatibility.clear(buf2);
    }
    assertEquals(expected, builder.toString());
    assertFullyRead(reader);

    // skip fully
    reader = new CharSequenceReader(charSequence);

                                        List<Object> originalValues = new ArrayList<>(c);
                                        try {
                                            c.clear();
                                        } catch (UnsupportedOperationException e) {
                                            if (debugEnabled && logger != null) {

        synchronized ( PROTOCOL_HANDLERS ) {
            if ( Handler.factory != null ) {
                throw new IllegalStateException("URLStreamHandlerFactory already set.");
            }
            PROTOCOL_HANDLERS.clear();
            Handler.factory = factory;
        }
    }


    /**
     * @param tc
     *            context to use
     * 
     */
    public Handler ( CIFSContext tc ) {