crawlerStatsHelper.begin(key);
        crawlerStatsHelper.done(key);
        logger.info(localLogMsg.get());
        String[] values = localLogMsg.get().split("\t");
        assertEquals(3, values.length);
        assertEquals("url:test", values[0]);
        assertTrue(values[1].startsWith("time:"));
        assertTrue(values[2].startsWith("done:"));

        localLogMsg.remove();
        crawlerStatsHelper.done(key);

        parameterTypes = constructor.getParameterTypes();
        parameterizedClassDescs = new ParameterizedClassDesc[parameterTypes.length];
        final Map<TypeVariable<?>, Type> typeVariables = beanDesc.getTypeVariables();
        for (int i = 0; i < parameterTypes.length; ++i) {
            parameterizedClassDescs[i] = ParameterizedClassDescFactory.createParameterizedClassDesc(constructor, i, typeVariables);
        }
    }

            ret += "null";
        } else {
            ret += Hexdump.toHexString(serverChallenge, 0, serverChallenge.length * 2);
        }
        ret += ",signingKey=";
        if (signingKey == null) {
            ret += "null";
        } else {
            ret += Hexdump.toHexString(signingKey, 0, signingKey.length * 2);
        }
        ret += "]";
        return ret;
    }

    public boolean isEstablished() {

    E[] array = collection.toArray(empty);
    assertEquals(
        "toArray(emptyT[]) should return an array of type T", empty.getClass(), array.getClass());
    assertEquals("toArray(emptyT[]).length:", getNumElements(), array.length);
    expectArrayContentsAnyOrder(createSamplesArray(), array);
  }

  @CollectionFeature.Require(KNOWN_ORDER)
  public void testToArray_emptyArray_ordered() {

   * #create(Object...)}.
   */
  protected abstract List<String> create(String[] elements);

  @Override
  public String[] createArray(int length) {
    return new String[length];
  }

  /** Returns the original element list, unchanged. */
  @Override
  public List<String> order(List<String> insertionOrder) {
    return insertionOrder;
  }

      implements TestMultimapGenerator<String, String, M> {

    @Override
    public String[] createKeyArray(int length) {
      return new String[length];
    }

    @Override
    public String[] createValueArray(int length) {
      return new String[length];
    }

    @Override
    public SampleElements<String> sampleKeys() {

                ip = i = 0;
                for ( ; i < data.length && c == '.'; i++ ) {
                    int b = 0x00;

                    for ( ; i < data.length && ( c = data[ i ] ) >= 48 && c <= 57; i++ ) {
                        b = b * 10 + c - '0';
                    }
                    ip = ( ip << 8 ) + b;
                }
                while ( i < data.length && Character.isWhitespace(data[ i ]) ) {

	)

	decoder := NewDecoder(mkReader(body), 1)

	for mv = range decoder.Stream() {
		counter++
		t.Logf("depth=%d offset=%d len=%d (%v)", mv.Depth, mv.Offset, mv.Length, mv.Value)
	}

	if err := decoder.Err(); err != nil {
		t.Fatalf("decoder error: %s", err)
	}
}

func TestDecoderNested(t *testing.T) {
	var (
		counter int
		mv      *MetaValue
		body    = `{

                ip = i = 0;
                for( ; i < data.length && c == '.'; i++ ) {
                    int b = 0x00;

                    for( ; i < data.length && ( c = data[i] ) >= 48 && c <= 57; i++ ) {
                        b = b * 10 + c - '0';
                    }
                    ip = ( ip << 8 ) + b;
                }
                while( i < data.length && Character.isWhitespace( data[i] )) {
                    i++;

            assertTrue("No share found", list.length > 0);
            log.debug(Arrays.toString(list));

            String shareUrl = getTestShareURL();
            String link = shareUrl.substring(dfsRoot.length());

            Set<String> listLinks = new HashSet<>(Arrays.asList(list));
            int firstSep = link.indexOf('/');
            if ( firstSep == link.length() - 1 ) {
                // single level