Java RandomPicks.randomFrom方法代码示例

import com.carrotsearch.randomizedtesting.generators.RandomPicks; //导入方法依赖的package包/类
public RandomizingClient(Client client, Random random) {
    super(client);
    // we don't use the QUERY_AND_FETCH types that break quite a lot of tests
    // given that they return `size*num_shards` hits instead of `size`
    defaultSearchType = RandomPicks.randomFrom(random, Arrays.asList(
            SearchType.DFS_QUERY_THEN_FETCH,
            SearchType.QUERY_THEN_FETCH));
    if (random.nextInt(10) == 0) {
        defaultPreference = RandomPicks.randomFrom(random, EnumSet.of(Preference.PRIMARY_FIRST, Preference.LOCAL)).type();
    } else if (random.nextInt(10) == 0) {
        String s = TestUtil.randomRealisticUnicodeString(random, 1, 10);
        defaultPreference = s.startsWith("_") ? null : s; // '_' is a reserved character
    } else {
        defaultPreference = null;
    }
    this.batchedReduceSize = 2 + random.nextInt(10);

}
 

import com.carrotsearch.randomizedtesting.generators.RandomPicks; //导入方法依赖的package包/类
private Set<Path> getTranslogDirs(String indexName) throws IOException {
    ClusterState state = client().admin().cluster().prepareState().get().getState();
    GroupShardsIterator shardIterators = state.getRoutingTable().activePrimaryShardsGrouped(new String[]{indexName}, false);
    final Index idx = state.metaData().index(indexName).getIndex();
    List<ShardIterator> iterators = iterableAsArrayList(shardIterators);
    ShardIterator shardIterator = RandomPicks.randomFrom(random(), iterators);
    ShardRouting shardRouting = shardIterator.nextOrNull();
    assertNotNull(shardRouting);
    assertTrue(shardRouting.primary());
    assertTrue(shardRouting.assignedToNode());
    String nodeId = shardRouting.currentNodeId();
    NodesStatsResponse nodeStatses = client().admin().cluster().prepareNodesStats(nodeId).setFs(true).get();
    Set<Path> translogDirs = new TreeSet<>(); // treeset makes sure iteration order is deterministic
    for (FsInfo.Path fsPath : nodeStatses.getNodes().get(0).getFs()) {
        String path = fsPath.getPath();
        final String relativeDataLocationPath =  "indices/"+ idx.getUUID() +"/" + Integer.toString(shardRouting.getId()) + "/translog";
        Path translogPath = PathUtils.get(path).resolve(relativeDataLocationPath);
        if (Files.isDirectory(translogPath)) {
            translogDirs.add(translogPath);
        }
    }
    return translogDirs;
}
 

import com.carrotsearch.randomizedtesting.generators.RandomPicks; //导入方法依赖的package包/类
public void testSerialization() throws Exception {
    UnassignedInfo.Reason reason = RandomPicks.randomFrom(random(), UnassignedInfo.Reason.values());
    UnassignedInfo meta = reason == UnassignedInfo.Reason.ALLOCATION_FAILED ?
        new UnassignedInfo(reason, randomBoolean() ? randomAsciiOfLength(4) : null, null, randomIntBetween(1, 100), System.nanoTime(),
                           System.currentTimeMillis(), false, AllocationStatus.NO_ATTEMPT):
        new UnassignedInfo(reason, randomBoolean() ? randomAsciiOfLength(4) : null);
    BytesStreamOutput out = new BytesStreamOutput();
    meta.writeTo(out);
    out.close();

    UnassignedInfo read = new UnassignedInfo(out.bytes().streamInput());
    assertThat(read.getReason(), equalTo(meta.getReason()));
    assertThat(read.getUnassignedTimeInMillis(), equalTo(meta.getUnassignedTimeInMillis()));
    assertThat(read.getMessage(), equalTo(meta.getMessage()));
    assertThat(read.getDetails(), equalTo(meta.getDetails()));
    assertThat(read.getNumFailedAllocations(), equalTo(meta.getNumFailedAllocations()));
}
 

import com.carrotsearch.randomizedtesting.generators.RandomPicks; //导入方法依赖的package包/类
/**
 * @return a {@link HasChildQueryBuilder} with random values all over the place
 */
@Override
protected NestedQueryBuilder doCreateTestQueryBuilder() {
    QueryBuilder innerQueryBuilder = RandomQueryBuilder.createQuery(random());
    if (randomBoolean()) {
        requiresRewrite = true;
        innerQueryBuilder = new WrapperQueryBuilder(innerQueryBuilder.toString());
    }
    NestedQueryBuilder nqb = new NestedQueryBuilder("nested1", innerQueryBuilder,
            RandomPicks.randomFrom(random(), ScoreMode.values()));
    nqb.ignoreUnmapped(randomBoolean());
    if (randomBoolean()) {
        nqb.innerHit(new InnerHitBuilder()
                .setName(randomAsciiOfLengthBetween(1, 10))
                .setSize(randomIntBetween(0, 100))
                .addSort(new FieldSortBuilder(INT_FIELD_NAME).order(SortOrder.ASC)), nqb.ignoreUnmapped());
    }
    return nqb;
}
 

import com.carrotsearch.randomizedtesting.generators.RandomPicks; //导入方法依赖的package包/类
protected RandomDocument(int fieldCount, int maxTermCount, Options options, String[] fieldNames, String[] sampleTerms, BytesRef[] sampleTermBytes) {
  if (fieldCount > fieldNames.length) {
    throw new IllegalArgumentException();
  }
  this.fieldNames = new String[fieldCount];
  fieldTypes = new FieldType[fieldCount];
  tokenStreams = new RandomTokenStream[fieldCount];
  Arrays.fill(fieldTypes, fieldType(options));
  final Set<String> usedFileNames = new HashSet<>();
  for (int i = 0; i < fieldCount; ++i) {
    do {
      this.fieldNames[i] = RandomPicks.randomFrom(random(), fieldNames);
    } while (usedFileNames.contains(this.fieldNames[i]));
    usedFileNames.add(this.fieldNames[i]);
    tokenStreams[i] = new RandomTokenStream(TestUtil.nextInt(random(), 1, maxTermCount), sampleTerms, sampleTermBytes);
  }
}
 

import com.carrotsearch.randomizedtesting.generators.RandomPicks; //导入方法依赖的package包/类
static long randomLong() {
  if (random().nextBoolean()) {
    long l = 1;
    if (random().nextBoolean()) {
      l *= -1;
    }
    for (long i : PRIMES) {
      final int m = random().nextInt(3);
      for (int j = 0; j < m; ++j) {
        l *= i;
      }
    }
    return l;
  } else if (random().nextBoolean()) {
    return random().nextLong();
  } else {
    return RandomPicks.randomFrom(random(), Arrays.asList(Long.MIN_VALUE, Long.MAX_VALUE, 0L, -1L, 1L));
  }
}
 

import com.carrotsearch.randomizedtesting.generators.RandomPicks; //导入方法依赖的package包/类
protected RandomDocument(int fieldCount, int maxTermCount, Options options, String[] fieldNames, String[] sampleTerms, BytesRef[] sampleTermBytes) {
  if (fieldCount > fieldNames.length) {
    throw new IllegalArgumentException();
  }
  this.fieldNames = new String[fieldCount];
  fieldTypes = new FieldType[fieldCount];
  tokenStreams = new RandomTokenStream[fieldCount];
  Arrays.fill(fieldTypes, fieldType(options));
  final Set<String> usedFileNames = new HashSet<String>();
  for (int i = 0; i < fieldCount; ++i) {
    do {
      this.fieldNames[i] = RandomPicks.randomFrom(random(), fieldNames);
    } while (usedFileNames.contains(this.fieldNames[i]));
    usedFileNames.add(this.fieldNames[i]);
    tokenStreams[i] = new RandomTokenStream(_TestUtil.nextInt(random(), 1, maxTermCount), sampleTerms, sampleTermBytes);
  }
}
 

import com.carrotsearch.randomizedtesting.generators.RandomPicks; //导入方法依赖的package包/类
static Directory newDirectoryImpl(Random random, String clazzName) {
  if (clazzName.equals("random")) {
    if (rarely(random)) {
      clazzName = RandomPicks.randomFrom(random, CORE_DIRECTORIES);
    } else {
      clazzName = "RAMDirectory";
    }
  }

  try {
    final Class<? extends Directory> clazz = CommandLineUtil.loadDirectoryClass(clazzName);
    // If it is a FSDirectory type, try its ctor(File)
    if (FSDirectory.class.isAssignableFrom(clazz)) {
      final File dir = _TestUtil.getTempDir("index");
      dir.mkdirs(); // ensure it's created so we 'have' it.
      return newFSDirectoryImpl(clazz.asSubclass(FSDirectory.class), dir);
    }

    // try empty ctor
    return clazz.newInstance();
  } catch (Exception e) {
    throw new RuntimeException(e);
  }
}
 

import com.carrotsearch.randomizedtesting.generators.RandomPicks; //导入方法依赖的package包/类
private void createRandomIndexes(int maxSegments) throws IOException {
  dir = newDirectory();
  numDocs = atLeast(150);
  final int numTerms = _TestUtil.nextInt(random(), 1, numDocs / 5);
  Set<String> randomTerms = new HashSet<String>();
  while (randomTerms.size() < numTerms) {
    randomTerms.add(_TestUtil.randomSimpleString(random()));
  }
  terms = new ArrayList<String>(randomTerms);
  final long seed = random().nextLong();
  final IndexWriterConfig iwc = newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(new Random(seed)));
  iwc.setMergePolicy(TestSortingMergePolicy.newSortingMergePolicy(sorter));
  iw = new RandomIndexWriter(new Random(seed), dir, iwc);
  for (int i = 0; i < numDocs; ++i) {
    final Document doc = randomDocument();
    iw.addDocument(doc);
    if (i == numDocs / 2 || (i != numDocs - 1 && random().nextInt(8) == 0)) {
      iw.commit();
    }
    if (random().nextInt(15) == 0) {
      final String term = RandomPicks.randomFrom(random(), terms);
      iw.deleteDocuments(new Term("s", term));
    }
  }
  reader = iw.getReader();
}
 

import com.carrotsearch.randomizedtesting.generators.RandomPicks; //导入方法依赖的package包/类
public void testEarlyTermination() throws IOException {
  createRandomIndexes(5);
  final int numHits = _TestUtil.nextInt(random(), 1, numDocs / 10);
  final Sort sort = new Sort(new SortField("ndv1", SortField.Type.LONG, false));
  final boolean fillFields = random().nextBoolean();
  final boolean trackDocScores = random().nextBoolean();
  final boolean trackMaxScore = random().nextBoolean();
  final boolean inOrder = random().nextBoolean();
  final TopFieldCollector collector1 = TopFieldCollector.create(sort, numHits, fillFields, trackDocScores, trackMaxScore, inOrder);
  final TopFieldCollector collector2 = TopFieldCollector.create(sort, numHits, fillFields, trackDocScores, trackMaxScore, inOrder);

  final IndexSearcher searcher = newSearcher(reader);
  final int iters = atLeast(5);
  for (int i = 0; i < iters; ++i) {
    final TermQuery query = new TermQuery(new Term("s", RandomPicks.randomFrom(random(), terms)));
    searcher.search(query, collector1);
    searcher.search(query, new EarlyTerminatingSortingCollector(collector2, sorter, numHits));
  }
  assertTrue(collector1.getTotalHits() >= collector2.getTotalHits());
  assertTopDocsEquals(collector1.topDocs().scoreDocs, collector2.topDocs().scoreDocs);
}
 

import com.carrotsearch.randomizedtesting.generators.RandomPicks; //导入方法依赖的package包/类
@Before
public void startHttpServer() throws IOException {
    this.sniffRequestTimeout = RandomNumbers.randomIntBetween(getRandom(), 1000, 10000);
    this.scheme = RandomPicks.randomFrom(getRandom(), ElasticsearchHostsSniffer.Scheme.values());
    if (rarely()) {
        this.sniffResponse = SniffResponse.buildFailure();
    } else {
        this.sniffResponse = buildSniffResponse(scheme);
    }
    this.httpServer = createHttpServer(sniffResponse, sniffRequestTimeout);
    this.httpServer.start();
}
 

import com.carrotsearch.randomizedtesting.generators.RandomPicks; //导入方法依赖的package包/类
public void testDuelIndexOrderQueryThenFetch() throws Exception {
    final SearchType searchType = RandomPicks.randomFrom(random(), Arrays.asList(SearchType.QUERY_THEN_FETCH,
        SearchType.DFS_QUERY_THEN_FETCH));
    final int numDocs = createIndex(false);
    testDuelIndexOrder(searchType, false, numDocs);
    testDuelIndexOrder(searchType, true, numDocs);
}
 

import com.carrotsearch.randomizedtesting.generators.RandomPicks; //导入方法依赖的package包/类
/**
 * Verifies that for anything but index creation, fetch data ends up being called, since we need to go and try
 * and find a better copy for the shard.
 */
public void testAsyncFetchOnAnythingButIndexCreation() {
    UnassignedInfo.Reason reason = RandomPicks.randomFrom(random(), EnumSet.complementOf(EnumSet.of(UnassignedInfo.Reason.INDEX_CREATED)));
    RoutingAllocation allocation = onePrimaryOnNode1And1Replica(yesAllocationDeciders(), Settings.EMPTY, reason);
    testAllocator.clean();
    testAllocator.allocateUnassigned(allocation);
    assertThat("failed with reason " + reason, testAllocator.getFetchDataCalledAndClean(), equalTo(true));
}
 

import com.carrotsearch.randomizedtesting.generators.RandomPicks; //导入方法依赖的package包/类
private void createRandomIndex() throws IOException {
  dir = newDirectory();
  numDocs = atLeast(150);
  final int numTerms = TestUtil.nextInt(random(), 1, numDocs / 5);
  Set<String> randomTerms = new HashSet<>();
  while (randomTerms.size() < numTerms) {
    randomTerms.add(TestUtil.randomSimpleString(random()));
  }
  terms = new ArrayList<>(randomTerms);
  final long seed = random().nextLong();
  final IndexWriterConfig iwc = newIndexWriterConfig(new MockAnalyzer(new Random(seed)));
  iwc.setMergeScheduler(new SerialMergeScheduler()); // for reproducible tests
  iwc.setMergePolicy(TestSortingMergePolicy.newSortingMergePolicy(sort));
  iw = new RandomIndexWriter(new Random(seed), dir, iwc);
  iw.setDoRandomForceMerge(false); // don't do this, it may happen anyway with MockRandomMP
  for (int i = 0; i < numDocs; ++i) {
    final Document doc = randomDocument();
    iw.addDocument(doc);
    if (i == numDocs / 2 || (i != numDocs - 1 && random().nextInt(8) == 0)) {
      iw.commit();
    }
    if (random().nextInt(15) == 0) {
      final String term = RandomPicks.randomFrom(random(), terms);
      iw.deleteDocuments(new Term("s", term));
    }
  }
  if (random().nextBoolean()) {
    iw.forceMerge(5);
  }
  reader = iw.getReader();
}
 

import com.carrotsearch.randomizedtesting.generators.RandomPicks; //导入方法依赖的package包/类
public void testEarlyTermination() throws IOException {
  final int iters = atLeast(8);
  for (int i = 0; i < iters; ++i) {
    createRandomIndex();
    for (int j = 0; j < iters; ++j) {
      final IndexSearcher searcher = newSearcher(reader);
      final int numHits = TestUtil.nextInt(random(), 1, numDocs);
      final Sort sort = new Sort(new SortField("ndv1", SortField.Type.LONG, false));
      final boolean fillFields = random().nextBoolean();
      final boolean trackDocScores = random().nextBoolean();
      final boolean trackMaxScore = random().nextBoolean();
      final boolean inOrder = random().nextBoolean();
      final TopFieldCollector collector1 = TopFieldCollector.create(sort, numHits, fillFields, trackDocScores, trackMaxScore, inOrder);
      final TopFieldCollector collector2 = TopFieldCollector.create(sort, numHits, fillFields, trackDocScores, trackMaxScore, inOrder);

      final Query query;
      if (random().nextBoolean()) {
        query = new TermQuery(new Term("s", RandomPicks.randomFrom(random(), terms)));
      } else {
        query = new MatchAllDocsQuery();
      }
      searcher.search(query, collector1);
      searcher.search(query, new EarlyTerminatingSortingCollector(collector2, sort, numHits));
      assertTrue(collector1.getTotalHits() >= collector2.getTotalHits());
      assertTopDocsEquals(collector1.topDocs().scoreDocs, collector2.topDocs().scoreDocs);
    }
    closeIndex();
  }
}