How to use

containsAll

method

in

java.util.List

/**
 * @deprecated apparently unused
 */
@Deprecated
public boolean hasSame(AbstractProject owner, Collection<? extends AbstractProject> projects) {
  List<AbstractProject> children = getChildProjects(owner);
  return children.size()==projects.size() && children.containsAll(projects);
}

/**
 * compares the dirty fields of an entity with a set of expected values
 */
public static void checkDirtyTracking(Object entityInstance, String... dirtyFields) {
  SelfDirtinessTracker selfDirtinessTracker = (SelfDirtinessTracker) entityInstance;
  assertEquals( dirtyFields.length > 0, selfDirtinessTracker.$$_hibernate_hasDirtyAttributes() );
  String[] tracked = selfDirtinessTracker.$$_hibernate_getDirtyAttributes();
  assertEquals( dirtyFields.length, tracked.length );
  assertTrue( Arrays.asList( tracked ).containsAll( Arrays.asList( dirtyFields ) ) );
}

public Map<Array<TblColRef>, List<DeriveInfo>> getHostToDerivedInfo(List<TblColRef> rowCols,
    Collection<TblColRef> wantedCols) {
  Map<Array<TblColRef>, List<DeriveInfo>> result = new HashMap<Array<TblColRef>, List<DeriveInfo>>();
  for (Entry<Array<TblColRef>, List<DeriveInfo>> entry : hostToDerivedMap.entrySet()) {
    Array<TblColRef> hostCols = entry.getKey();
    boolean hostOnRow = rowCols.containsAll(Arrays.asList(hostCols.data));
    if (!hostOnRow)
      continue;
    List<DeriveInfo> wantedInfo = new ArrayList<DeriveInfo>();
    for (DeriveInfo info : entry.getValue()) {
      if (wantedCols == null || Collections.disjoint(wantedCols, Arrays.asList(info.columns)) == false) // has any wanted columns?
        wantedInfo.add(info);
    }
    if (wantedInfo.size() > 0)
      result.put(hostCols, wantedInfo);
  }
  return result;
}

@Test
public void innerJoinInstructorStudentOnAge() {
  Table table1 = createINSTRUCTOR();
  Table table2 = createSTUDENT();
  Table joined = table1.join("Age").inner(true, table2);
  assert(joined.columnNames().containsAll(Arrays.asList(
      "T2.ID", "T2.City", "T2.State", "T2.USID", "T2.GradYear")));
  assertEquals(16, joined.columnCount());
  assertEquals(14, joined.rowCount());
}

 @Test
 public void testValues() {
  assertThat(
    Arrays.asList(Letter.values()).containsAll(Arrays.asList(Letter.A, Letter.B, Letter.C)));
 }
}

@Override
@SuppressWarnings("unchecked")
public ListBodySpec<E> contains(E... elements) {
  List<E> expected = Arrays.asList(elements);
  List<E> actual = getResult().getResponseBody();
  String message = "Response body does not contain " + expected;
  getResult().assertWithDiagnostics(() ->
      AssertionErrors.assertTrue(message, (actual != null && actual.containsAll(expected))));
  return this;
}

@Test
public void testValues() {
 Map<JsonObject, Buffer> map = genJsonToBuffer(100);
 loadData(map, (vertx, asyncMap) -> {
  asyncMap.values(onSuccess(values -> {
   assertEquals(map.values().size(), values.size());
   assertTrue(map.values().containsAll(values));
   assertTrue(values.containsAll(map.values()));
   testComplete();
  }));
 });
 await();
}

private void assertArchiveFiles(FileSystem fs, List<String> storeFiles, long timeout)
    throws IOException {
 long end = System.currentTimeMillis() + timeout;
 Path archiveDir = HFileArchiveUtil.getArchivePath(UTIL.getConfiguration());
 List<String> archivedFiles = new ArrayList<>();
 // We have to ensure that the DeleteTableHandler is finished. HBaseAdmin.deleteXXX()
 // can return before all files
 // are archived. We should fix HBASE-5487 and fix synchronous operations from admin.
 while (System.currentTimeMillis() < end) {
  archivedFiles = getAllFileNames(fs, archiveDir);
  if (archivedFiles.size() >= storeFiles.size()) {
   break;
  }
 }
 Collections.sort(storeFiles);
 Collections.sort(archivedFiles);
 LOG.debug("Store files:");
 for (int i = 0; i < storeFiles.size(); i++) {
  LOG.debug(i + " - " + storeFiles.get(i));
 }
 LOG.debug("Archive files:");
 for (int i = 0; i < archivedFiles.size(); i++) {
  LOG.debug(i + " - " + archivedFiles.get(i));
 }
 assertTrue("Archived files are missing some of the store files!",
  archivedFiles.containsAll(storeFiles));
}

@Test
public void testFindAll() {
 final List<Integer> numbers = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 9);
 // accept all even numbers
 final List<Integer> matches = CollectionUtils.findAll(numbers, number -> (number % 2 == 0));
 assertNotNull(matches);
 assertFalse(matches.isEmpty());
 assertTrue(matches.containsAll(Arrays.asList(0, 2, 4, 6, 8)));
}

@Test
public void createDirectChildrenCacheTest() {
  Set<Long> cuboidSet = generateCuboidSet();
  Map<Long, List<Long>> directChildrenCache = CuboidStatsUtil.createDirectChildrenCache(cuboidSet);
  Assert.assertTrue(directChildrenCache.get(255L).containsAll(Lists.newArrayList(239L, 159L, 50L)));
  Assert.assertTrue(directChildrenCache.get(159L).contains(6L));
  Assert.assertTrue(directChildrenCache.get(50L).contains(2L));
  Assert.assertTrue(directChildrenCache.get(239L).contains(199L));
  Assert.assertTrue(directChildrenCache.get(199L).contains(6L));
  Assert.assertTrue(directChildrenCache.get(6L).containsAll(Lists.newArrayList(4L, 2L)));
}

private void testOrderingHappened(Language language, String rule_id) throws IOException {
 JLanguageTool languageTool = new JLanguageTool(language);
 SuggestionsOrderer suggestionsOrderer = new SuggestionsOrderer(language, rule_id);
 String word = "wprd";
 String sentence = String.join(" ","a", word, "containing", "sentence");
 LinkedList<String> suggestions = new LinkedList<>();
 suggestions.add("word");
 suggestions.add("weird");
 int startPos = sentence.indexOf(word);
 int wordLength = word.length();
 List<String> suggestionsOrdered = suggestionsOrderer.orderSuggestionsUsingModel(
     suggestions, word, languageTool.getAnalyzedSentence(sentence), startPos, wordLength);
 assertTrue(suggestionsOrdered.containsAll(suggestions));
}

@Test
public void testParseAndValidateAddressesWithReverseLookup() {
  checkWithoutLookup("127.0.0.1:8000");
  checkWithoutLookup("localhost:8080");
  checkWithoutLookup("[::1]:8000");
  checkWithoutLookup("[2001:db8:85a3:8d3:1319:8a2e:370:7348]:1234", "localhost:10000");
  // With lookup of example.com, either one or two addresses are expected depending on
  // whether ipv4 and ipv6 are enabled
  List<InetSocketAddress> validatedAddresses = checkWithLookup(Arrays.asList("example.com:10000"));
  assertTrue("Unexpected addresses " + validatedAddresses, validatedAddresses.size() >= 1);
  List<String> validatedHostNames = validatedAddresses.stream().map(InetSocketAddress::getHostName)
      .collect(Collectors.toList());
  List<String> expectedHostNames = Arrays.asList("93.184.216.34", "2606:2800:220:1:248:1893:25c8:1946");
  assertTrue("Unexpected addresses " + validatedHostNames, expectedHostNames.containsAll(validatedHostNames));
  validatedAddresses.forEach(address -> assertEquals(10000, address.getPort()));
}

score = updateScoreForMatch(score, targetTag, tag, 2);
score = updateScoreForMatch(score, targetVoice, voice, 4);
if (score == -1 || !Arrays.asList(classes).containsAll(targetClasses)) {
 return 0;
} else {
 score += targetClasses.size() * 4;

@Test
public void innerJoinOnPartiallyMismatchedColNames() {
  Table table1 = createANIMALHOMES();
  Table table2 = createDOUBLEINDEXEDPEOPLENameDwellingYearsMoveInDate();
  Table joined = table1.join("Name", "Home", "Age")
      .inner(table2, true,
      "Name", "Dwelling", "Years");
  assert(joined.columnNames().containsAll(Arrays.asList("Name", "Home", "Age")));
  assertEquals(7, joined.columnCount());
  assertEquals(2, joined.rowCount());
}

/**
 * 判断两个list中的url是否一致。 如果任意一个list为空，则返回false； 此方法并未做严格互相判等
 *
 * @param urls1
 * @param urls2
 * @return
 */
public static boolean isSame(List<URL> urls1, List<URL> urls2) {
  if (urls1 == null || urls2 == null) {
    return false;
  }
  if (urls1.size() != urls2.size()) {
    return false;
  }
  return urls1.containsAll(urls2);
}

@Test
public void testModificationsSince() throws Exception {
  List<Modification> modifications = new ArrayList<>();
  modifications.add(new Modification(user, "comment latest", "email", new Date(), "10"));
  modifications.add(new Modification(user, "comment latest", "email", new Date(), "9"));
  modifications.add(new Modification(user, "comment latest", "email", new Date(), "8"));
  when(tfsCommand.history(null, 1)).thenReturn(Arrays.asList(modifications.get(0)));
  when(tfsCommand.history("10", 3)).thenReturn(modifications);
  List<Modification> actual = tfsCommand.modificationsSince(workDir, new StringRevision("7"));
  assertThat(actual.containsAll(modifications), is(true));
}

@Override
@SuppressWarnings("unchecked")
public ListBodySpec<E> doesNotContain(E... elements) {
  List<E> expected = Arrays.asList(elements);
  List<E> actual = getResult().getResponseBody();
  String message = "Response body should not have contained " + expected;
  getResult().assertWithDiagnostics(() ->
      AssertionErrors.assertTrue(message, (actual == null || !actual.containsAll(expected))));
  return this;
}

@Test
public void testEnqueueAll() throws IOException, ExecutorManagerException {
 final QueuedExecutions queue = new QueuedExecutions(5);
 final List<Pair<ExecutionReference, ExecutableFlow>> dataList = getDummyData();
 queue.enqueueAll(dataList);
 Assert.assertTrue(queue.getAllEntries().containsAll(dataList));
 Assert.assertTrue(dataList.containsAll(queue.getAllEntries()));
}

private static void verifyPartitionsPublished(HiveMetaStoreClient client,
  String dbName, String tblName, List<String> partialSpec,
  List<Partition> expectedPartitions) throws TException {
 // Test partition listing with a partial spec
 List<Partition> mpartial = client.listPartitions(dbName, tblName, partialSpec,
   (short) -1);
 assertEquals("Should have returned "+expectedPartitions.size()+
   " partitions, returned " + mpartial.size(),
   expectedPartitions.size(), mpartial.size());
 assertTrue("Not all parts returned", mpartial.containsAll(expectedPartitions));
}

public void assertMethodsCalled(ClientEvent... events) {
  if (methodsCalled.size() != events.length) {
    throw new AssertionError("Unexpected methods called count. Methods called: " + methodsCalled.size()
                 + ". Expected: " + events.length);
  }
  if (!methodsCalled.containsAll(Arrays.asList(events))) {
    throw new AssertionError("Unexpected methods called count. Methods called: " + methodsCalled
                 + ". Expected: " + Arrays.toString(events));
  }
}