fail();
        } catch (final MultipleCrawlingAccessException e) {
            // ok
            final Throwable[] causes = e.getCauses();
            assertEquals(5, causes.length);
        }
        assertEquals(1, testListener.startCount);
        assertEquals(5, testListener.requestCount);
        assertEquals(5, testListener.exceptionCount);
        assertEquals(1, testListener.endCount);

  }

  static void testSort(int[] input, int[] expected) {
    input = Arrays.copyOf(input, input.length);
    UnsignedInts.sort(input);
    assertThat(input).isEqualTo(expected);
  }

  static void testSort(int[] input, int from, int to, int[] expected) {
    input = Arrays.copyOf(input, input.length);
    UnsignedInts.sort(input, from, to);
    assertThat(input).isEqualTo(expected);
  }

          && method.getParameterTypes().length == 1
          && method.getParameterTypes()[0] == Object.class) {
        continue;
      }
      if (method.getName().equals("hashCode") && method.getParameterTypes().length == 0) {
        continue;
      }
      if (method.getName().equals("toString") && method.getParameterTypes().length == 0) {
        continue;
      }

    private String readString(byte[] buffer, int offset, int maxLength) {
        int length = 0;
        for (int i = offset; i < offset + maxLength && i < buffer.length; i++) {
            if (buffer[i] == 0) {
                break;
            }
            length++;
        }
        return new String(buffer, offset, length);
    }

    val rangesLimit =
      when {
        sectionsIndex + 4 < sections.length -> sections.read14BitInt(sectionsIndex + 6)
        else -> ranges.length / 4
      }

    val rangesIndex = findRangesOffset(codePoint, rangesPosition, rangesLimit)

    when (val b1 = ranges[rangesIndex + 1].code) {
      in 0..63 -> {
        // Length of the UTF-16 sequence that this range maps to. The offset is b2b3.

    assertThat(compactTable.sections.length).isLessThan(1 shl 14)

    // Less than 65,536 bytes, because we binary search on a 14-bit index with a stride of 4 bytes.
    assertThat(compactTable.ranges.length).isLessThan((1 shl 14) * 4)

    // Less than 16,384 chars, because we index on a 14-bit index in the ranges table.
    assertThat(compactTable.mappings.length).isLessThan(1 shl 14)

        // execute
        ToolchainPrivate[] toolchains = toolchainManager.getToolchainsForType("basic", session);

        // verify
        verify(logger, never()).error(anyString());
        assertEquals(1, toolchains.length);
    }

    @Test
    void testToolchainsForUnknownType() throws Exception {
        // prepare
        MavenSession session = mock(MavenSession.class);

        sb.append(dm).append(permissions);
        sb.append(dm).append(token);
        sb.append(dm).append(updatedBy);
        sb.append(dm).append(updatedTime);
        if (sb.length() > dm.length()) {
            sb.delete(0, dm.length());
        }
        sb.insert(0, "{").append("}");
        return sb.toString();
    }

    // ===================================================================================

      this.replacements = replacements;
      this.replaceLength = replacements.length;
    }

    /*
     * Overriding escape method to be slightly faster for this decorator. We test the replacements
     * array directly, saving a method call.
     */
    @Override
    public String escape(String s) {
      int slen = s.length();
      for (int index = 0; index < slen; index++) {
        char c = s.charAt(index);

    @Override
    public Collection<E> create(Object... elements) {
      return SerializableTester.reserialize(gen.create(elements));
    }

    @Override
    public E[] createArray(int length) {
      return gen.createArray(length);
    }

    @Override
    public Iterable<E> order(List<E> insertionOrder) {
      return gen.order(insertionOrder);
    }
  }