}
    }
    List<Class<?>> result = new ArrayList<>();
    NEXT_CANDIDATE:
    for (Class<?> candidate : Iterables.filter(candidateClasses, classFilter)) {
      for (Class<?> testClass : testClasses.get(candidate)) {
        if (hasTest(testClass, explicitTestNames)) {
          // covered by explicit test
          continue NEXT_CANDIDATE;
        }
      }
      result.add(candidate);
    }
    return result;

    @Size(max = 100)
    public String docId;

    /** Highlight query parameters. */
    public String[] hq;

    /** Search query parameter for error page. */
    public String q;

    /** Number of results parameter for error page. */
    public String num;

    /** Sort parameter for error page. */
    public String sort;

    /** Language parameter for error page. */
    public String lang;

                }
            }
        }

        return abbreviateSite(url);
    }

    /**
     * Puts data into the result data map, handling value appending if configured.
     * If data appending is enabled and the key already exists, values are combined into arrays.
     *
     * @param dataMap the data map to modify

		objs := make([]ObjectToDelete, len(delObjs))
		for i, obj := range delObjs {
			objs[i] = obj.object
		}
		return objs
	}

	// The result of delete operation on all passed objects
	delErrs := make([]error, len(objects))

	// The result of delete objects
	delObjects := make([]DeletedObject, len(objects))

	// A map between a set and its associated objects
	objSetMap := make(map[int][]delObj)

    TreeMapImpl {
      @Override
      public <K extends Comparable<K>, V> SortedMap<K, V> create(Map<K, V> map) {
        SortedMap<K, V> result = Maps.newTreeMap();
        result.putAll(map);
        return result;
      }
    },
    ConcurrentSkipListImpl {
      @Override
      public <K extends Comparable<K>, V> SortedMap<K, V> create(Map<K, V> map) {

                  @Override
                  protected Multiset<String> create(String[] elements) {
                    Multiset<String> result = TreeMultiset.create(NullsBeforeB.INSTANCE);
                    Collections.addAll(result, elements);
                    return result;
                  }

                  @Override
                  public List<String> order(List<String> insertionOrder) {

    validations:
      required: true
  - type: input
    id: gradle-old-version
    attributes:
      label: Gradle version that used to work
      description: What version of Gradle gives proper result for your case?
    validations:
      required: true
  - type: input
    id: build-scan-url
    attributes:
      label: Build scan URL (optional)
      description: |

 */
package org.codelibs.fess.suggest.index.writer;

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

/**
 * The SuggestWriterResult class is used to store and manage the results of a suggest writer operation.
 * It keeps track of any failures that occur during the operation.
 */
public class SuggestWriterResult {
    /**
     * Constructs a new {@link SuggestWriterResult}.
     */

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.exception;

/**
 * This exception is thrown when the requested result offset exceeds the limit.
 */
public class ResultOffsetExceededException extends FessSystemException {
    private static final long serialVersionUID = 1L;

    /**
     * Constructor.

        final int start = bufferIndex;
        SmbFindFileBothDirectoryInfo e;

        lastNameBufferIndex = bufferIndex + lastNameOffset;

        results = new SmbFindFileBothDirectoryInfo[numEntries];
        for (int i = 0; i < numEntries; i++) {
            results[i] = e = new SmbFindFileBothDirectoryInfo();

            e.nextEntryOffset = readInt4(buffer, bufferIndex);