*/

  @Override
  public boolean equals(@Nullable Object object) {
    if (object instanceof Set) {
      Set<?> that = (Set<?>) object;
      return (this.size() == that.size()) && this.containsAll(that);
    }
    return false;
  }

  @Override
  public int hashCode() {
    int hashCodeSum = 0;
    for (Object o : this) {
      hashCodeSum += (o == null) ? 0 : o.hashCode();

        final List<String> wordList = Analysis.parseWordList(environment, settings, "stopwords", s -> s);
        if (wordList != null) {
            stopwords = wordList.toArray(new String[wordList.size()]);
        } else {
            stopwords = new String[0];
        }

        ignoreCase = settings.getAsBoolean("ignore_case", Boolean.FALSE).booleanValue();
        if (ignoreCase) {

        final String response = getJsonResponse("/api/admin/scheduler/settings");
        final List<Map<String, Object>> itemList = JsonPath.from(response).getList(getResponsePath(namePrefix));
        assertEquals(1, itemList.size());
        return itemList.get(0);
    }

    protected static List<String> getSchedulerIds(final String namePrefix) {
        final String response = getJsonResponse("/api/admin/scheduler/settings");

          "10000003b00102a032880f0290011faceb00c00000002",
      ),
    )
    dns = buildLocalhost(bootstrapClient, true)
    val result = dns.lookup("google.com")
    assertThat(result.size).isEqualTo(2)
    assertThat(result).contains(address("157.240.1.18"))
    assertThat(result).contains(address("2a03:2880:f029:11:face:b00c:0:2"))
    val request1 = server.takeRequest()

    private ArrayWithDuplicate(E[] elements, E duplicate) {
      this.elements = elements;
      this.duplicate = duplicate;
    }
  }

  /**
   * @return an array of the proper size with a duplicate element. The size must be at least three.
   */
  protected ArrayWithDuplicate<E> createArrayWithDuplicateElement() {
    E[] elements = createSamplesArray();
    E duplicate = elements[(elements.length / 2) - 1];

            CrawlingParameterUtil.setCrawlerContext(crawlerContext);
            httpClient.init();
            httpClient.processRobotsTxt(url);
            assertEquals(1, crawlerContext.getRobotsTxtUrlSet().size());
            assertTrue(crawlerContext.getRobotsTxtUrlSet().contains("http://localhost:7070/robots.txt"));
            assertFalse(urlFilter.match("http://localhost:7070/admin/"));

        dstIndex += nameBytes.length;

        return dstIndex - start;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Encodable#size()
     */
    @Override
    public int size() {
        return 20 + 2 * this.fileName.length();
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.fscc.FileInformation#getFileInformationLevel()
     */

	o = msgp.Require(b, z.Msgsize())
	// map header, size 4
	// string "LastHour"
	o = append(o, 0x84, 0xa8, 0x4c, 0x61, 0x73, 0x74, 0x48, 0x6f, 0x75, 0x72)
	o, err = z.LastHour.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "LastHour")
		return
	}
	// string "SinceUptime"
	o = append(o, 0xab, 0x53, 0x69, 0x6e, 0x63, 0x65, 0x55, 0x70, 0x74, 0x69, 0x6d, 0x65)
	// map header, size 2
	// string "Count"

	Start, End int64
}

// GetLength - get length of range
func (h *HTTPRangeSpec) GetLength(resourceSize int64) (rangeLength int64, err error) {
	switch {
	case resourceSize < 0:
		return 0, errors.New("Resource size cannot be negative")

	case h == nil:
		rangeLength = resourceSize

	case h.IsSuffixLength:
		specifiedLen := -h.Start
		rangeLength = min(specifiedLen, resourceSize)

	case h.Start >= resourceSize:

        final int qSize = queue.size();
        int endOffset = startOffset + 1;
        int posInc = 1;
        for (int len = 1; len < n && endOffset <= limitOffset; len++) {
            queue.add(new MyToken(block.substring(startOffset, endOffset), startOffset, endOffset, posInc));
            endOffset++;
            posInc = 0;
        }
        return queue.size() > qSize;
    }

    @Override