repository.getUrl(),
                    repository.getLayout(),
                    repository.getSnapshots(),
                    repository.getReleases());

            repository.setMirroredRepositories(Collections.singletonList(original));

            repository.setId(mirror.getId());
            repository.setUrl(mirror.getUrl());

            }
        }
    }

    protected void mergeModel_Url(Model target, Model source, boolean sourceDominant, Map<Object, Object> context) {
        String src = source.getUrl();
        if (src != null) {
            if (sourceDominant || target.getUrl() == null) {
                target.setUrl(src);
                target.setLocation("url", source.getLocation("url"));
            }
        }
    }

// auto* streamz = tensorflow::monitoring::Counter<1>::New("name",
// "description", "label");
// and then incremented that counter for various values of label:
// streamz->GetCell("label-value")->IncrementBy(1);
//
// The test code can then read and test the value of that counter:
//
// auto* reader = TFE_MonitoringNewCounterReader("name");
// test();

            throw new RuntimeCIFSException("NTLM handshake failed", e);
        }
        this.handshakeComplete = true;
    }

    @Override
    public URL getURL() {
        return this.connection.getURL();
    }

    @Override
    public int getContentLength() {
        handshake();
        return this.connection.getContentLength();
    }

    @Override

      protected Cell<R, C, @Nullable V> get(int index) {
        return getCell(index);
      }
    };
  }

  @Override
  Spliterator<Cell<R, C, @Nullable V>> cellSpliterator() {
    return CollectSpliterators.indexed(
        size(), Spliterator.ORDERED | Spliterator.NONNULL | Spliterator.DISTINCT, this::getCell);
  }

  private Cell<R, C, @Nullable V> getCell(int index) {
    return new Tables.AbstractCell<R, C, @Nullable V>() {

        urlList = fessXpathTransformer.convertChildUrlList(urlList);
        assertEquals(2, urlList.size());
        assertEquals("http://www.example.com", urlList.get(0).getUrl());
        assertEquals("http://www.test.com", urlList.get(1).getUrl());

        urlList.clear();
        urlList.add(RequestDataBuilder.newRequestData().get().url("feed://www.example.com").build());

        assertEquals(1, result.size());

        RequestData requestData = result.iterator().next();
        assertEquals("http://example.com", requestData.getUrl());
    }

    /**
     * Test getAnchorSet with blank string
     */
    @Test
    public void test_getAnchorSet_withBlankString() {
        FessCrawlerThread crawlerThread = new FessCrawlerThread();

        asDocMeta().version(version);
    }

    public void addField(final String key, final Object value) {
        fields.put(key, value);
    }

    public String getLogMessage() {
        return getUrl();
    }

    @Override
    public Map<String, Object> toSource() {
        final Map<String, Object> sourceMap = super.toSource();
        if (fields != null) {
            sourceMap.putAll(fields);
        }

        }
        final Extractor extractor = extractorFactory.getExtractor(responseData.getMimeType());
        if (logger.isDebugEnabled()) {
            logger.debug("url={}, extractor={}", responseData.getUrl(), extractor);
        }
        return extractor;
    }

    // Casts without copying.
    return ImmutableMap.copyOf(rowMap);
  }

  @Override
  public int size() {
    return cellRowIndices.length;
  }

  @Override
  Cell<R, C, V> getCell(int index) {
    int rowIndex = cellRowIndices[index];
    Entry<R, ImmutableMap<C, V>> rowEntry = rowMap.entrySet().asList().get(rowIndex);
    ImmutableMap<C, V> row = rowEntry.getValue();