@Test
  public void checkGetElements() {
    assumeTrue(dataStructure instanceof INodeListDatastructureReadable);
    IReadable tempDS = (IReadable) dataStructure;

    int size = 20;
    IElement singleDummy;

    ArrayList<IElement> dummies = new ArrayList<>();
    for (int i = 0; i < size; i++) {
      singleDummy = mock(this.elementClass);

      /*
       * Nodes are stored with an index, so set it please!
       */
      if (singleDummy instanceof Node) {
        when(((Node) singleDummy).getIndex()).thenReturn(i);
      }
      if (singleDummy instanceof Edge) {
        when(((Edge) singleDummy).getHashString()).thenReturn("" + i);
      }

      assertTrue(tempDS.add(singleDummy));
      dummies.add(singleDummy);
    }

    Collection<IElement> elements = tempDS.getElements();

    /*
     * Check for the proper size and content
     */
    assertEquals(dummies.size(), elements.size());
    assertTrue(dummies.containsAll(elements));
    assertTrue(elements.containsAll(dummies));
  }
 public void testContainsAll_sameType() {
   Collection<String> c = of("a", "b", "c");
   assertFalse(c.containsAll(of("a", "b", "c", "d")));
   assertFalse(c.containsAll(of("a", "d")));
   assertTrue(c.containsAll(of("a", "c")));
   assertTrue(c.containsAll(of("a", "b", "c")));
 }
  public void test() {
    Graph g1 = new PrimaryGraph();
    Node[] n1 = g1.newNodes(2);
    g1.newEdge(n1[0], n1[1]);

    Graph g2 = new PrimaryGraph();
    Node[] n2 = g2.newNodes(2);
    g2.newEdge(n2[0], n2[1]);

    SecondaryGraph sg = new SecondaryGraph();
    sg.adoptGraph(g1);
    sg.adoptGraph(g2);

    Clusterer cc = Clusterers.connectedComponents(sg);

    Collection<Object> components = cc.getClusters();
    assertEquals(2, components.size());

    Iterator<Object> iterator = components.iterator();
    Object c1 = iterator.next();
    Object c2 = iterator.next();
    assertTrue(c1 != c2);
    assertTrue(components.contains(c1));
    assertTrue(components.contains(c2));

    Collection<Node> comp1 = cc.getCluster(c1);
    assertTrue(comp1.containsAll(Arrays.asList(n1)));

    Collection<Node> comp2 = cc.getCluster(c2);
    assertTrue(comp2.containsAll(Arrays.asList(n2)));

    assertTrue(cc.getCluster(c1).contains(n1[0]));
    assertTrue(cc.getCluster(c2).contains(n2[0]));
  }
Exemple #4
0
 @Override
 public boolean containsAll(Collection<?> arg0) {
   if (containsCounter.incrementAndGet() >= maxContains && !copyDone.get()) {
     try {
       writeLock.lock();
       // many calls to contains, inefficient if the delegate
       // is not a set
       // copyDone is doublechecked, but here it's protected by
       // the write
       // lock as in all other instances in which its value is
       // changed
       if (!(delegate instanceof Set)) {
         if (!copyDone.getAndSet(true)) {
           delegate = new SyncSet<T>(delegate);
         }
       }
       // skip the second portion of the method: no need to
       // reacquire
       // the lock, it's already a write lock
       return delegate.containsAll(arg0);
     } finally {
       writeLock.unlock();
     }
   }
   try {
     readLock.lock();
     return delegate.containsAll(arg0);
   } finally {
     readLock.unlock();
   }
 }
 public void testToCollection() {
   setUpTest();
   one.add("1");
   two.add("2");
   c.addComposited(one, two);
   Collection foo = c.toCollection();
   assertTrue(foo.containsAll(c));
   assertEquals(c.size(), foo.size());
   one.add("3");
   assertTrue(!foo.containsAll(c));
 }
 /**
  * Additional assert method for testing that will test that two Collections have equal contents
  * The Collections must be of equal size, and each object from one Collection must equal an object
  * in the other Collection Order is not considered.
  *
  * @param expected
  * @param actual
  */
 @SuppressWarnings("unchecked")
 public static void assertCollectionContentsEquals(Collection expected, Collection actual)
     throws AssertionError {
   try {
     if (!expected.containsAll(actual) || !actual.containsAll(expected)) {
       throw new AssertionError("Expected " + expected + " but found " + actual);
     }
   } catch (Exception e) {
     throw new AssertionError(e);
   }
 }
 private void testGetGrantedAuthorities(
     MapBasedAttributes2GrantedAuthoritiesMapper mapper, String[] roles, String[] expectedGas) {
   List<GrantedAuthority> result = mapper.getGrantedAuthorities(Arrays.asList(roles));
   Collection resultColl = new ArrayList(result.size());
   for (GrantedAuthority auth : result) {
     resultColl.add(auth.getAuthority());
   }
   Collection expectedColl = Arrays.asList(expectedGas);
   assertTrue(
       "Role collections should match; result: " + resultColl + ", expected: " + expectedColl,
       expectedColl.containsAll(resultColl) && resultColl.containsAll(expectedColl));
 }
 private void testGetGrantedAuthorities(
     SimpleAttributes2GrantedAuthoritiesMapper mapper, String[] roles, String[] expectedGas) {
   List<GrantedAuthority> result = mapper.getGrantedAuthorities(Arrays.asList(roles));
   Collection<String> resultColl = new ArrayList<String>(result.size());
   for (int i = 0; i < result.size(); i++) {
     resultColl.add(result.get(i).getAuthority());
   }
   Collection<String> expectedColl = Arrays.asList(expectedGas);
   assertTrue(
       "Role collections do not match; result: " + resultColl + ", expected: " + expectedColl,
       expectedColl.containsAll(resultColl) && resultColl.containsAll(expectedColl));
 }
 // Again, overriding for generics
 @Override
 public int compareTo(M o) {
   final Map<K, V> thisMap = getValue();
   final Map<K, V> otherMap = o.asMap();
   final Set<K> thisKeySet = thisMap.keySet();
   final Set<K> otherKeySet = otherMap.keySet();
   final Collection<V> thisValueSet = thisMap.values();
   final Collection<V> otherValueSet = otherMap.values();
   return ComparisonChain.start()
       .compare(thisKeySet.containsAll(otherKeySet), otherKeySet.containsAll(thisKeySet))
       .compare(thisValueSet.containsAll(otherValueSet), otherValueSet.containsAll(thisValueSet))
       .result();
 }
  @SmallTest
  @MediumTest
  @LargeTest
  public void testCollectionContainsAll() throws JSONException {
    JSONArray array = new JSONArray();
    array.put(5);
    array.put(-1);

    Collection<Integer> collection = GraphObject.Factory.createList(array, Integer.class);
    assertTrue(collection.containsAll(Arrays.asList(5)));
    assertTrue(collection.containsAll(Arrays.asList(5, -1)));
    assertFalse(collection.containsAll(Arrays.asList(5, -1, 2)));
  }
  public static void main(String[] args) {

    Collection<String> collection = new HashSet<String>();
    collection.add("one");
    collection.add("two");

    Iterator<String> iterator = collection.iterator();
    while (iterator.hasNext()) {
      String s = iterator.next();
      System.out.println(s);
    }
    System.out.println("======================================");

    TreeSet<String> set = new TreeSet<String>(collection);
    Iterator<String> itor = set.iterator();
    while (itor.hasNext()) {
      System.out.println(itor.next());
    }

    Collection<String> colList = new ArrayList<String>();
    colList.add("one");
    colList.add("two");
    colList.add("three");

    if (colList.containsAll(collection)) {
      System.out.println("true");
    }

    System.out.println("=================");

    String[] strings = colList.toArray(new String[0]);
    String[] strings1 = (String[]) colList.toArray();
  }
  /** Tests the hash code computation. */
  @Test
  public void testHashCode() {
    final CitationImpl citation = new CitationImpl();
    final PropertyAccessor accessor = createPropertyAccessor(citation);
    int hashCode = accessor.hashCode(citation);
    assertEquals("Empty metadata.", 0, hashCode);

    final String ISBN = "Dummy ISBN";
    citation.setISBN(ISBN);
    hashCode = accessor.hashCode(citation);
    assertEquals("Metadata with a single String value.", ISBN.hashCode(), hashCode);

    final Set<Object> set = new HashSet<Object>();
    assertEquals("By Set.hashCode() contract.", 0, set.hashCode());
    assertTrue(set.add(ISBN));
    assertEquals("Expected Metadata.hashCode() == Set.hashCode().", set.hashCode(), hashCode);

    final InternationalString title = new SimpleInternationalString("Dummy title");
    citation.setTitle(title);
    hashCode = accessor.hashCode(citation);
    assertEquals("Metadata with two values.", ISBN.hashCode() + title.hashCode(), hashCode);
    assertTrue(set.add(title));
    assertEquals("Expected Metadata.hashCode() == Set.hashCode().", set.hashCode(), hashCode);
    assertEquals("CitationsImpl.hashCode() should delegate.", hashCode, citation.hashCode());

    final Collection<Object> values = citation.asMap().values();
    assertEquals(hashCode, new HashSet<Object>(values).hashCode());
    assertTrue(values.containsAll(set));
    assertTrue(set.containsAll(values));
  }
  @NotNull
  public static Library updatePackagesLibraryRoots(
      @NotNull final Project project, @NotNull final DartLibInfo libInfo) {
    final LibraryTable projectLibraryTable = ProjectLibraryTable.getInstance(project);
    final Library existingLibrary =
        projectLibraryTable.getLibraryByName(DartPackagesLibraryType.DART_PACKAGES_LIBRARY_NAME);
    final Library library =
        existingLibrary != null
            ? existingLibrary
            : ApplicationManager.getApplication()
                .runWriteAction(
                    new Computable<Library>() {
                      @Override
                      public Library compute() {
                        final LibraryTableBase.ModifiableModel libTableModel =
                            ProjectLibraryTable.getInstance(project).getModifiableModel();
                        final Library lib =
                            libTableModel.createLibrary(
                                DartPackagesLibraryType.DART_PACKAGES_LIBRARY_NAME,
                                DartPackagesLibraryType.LIBRARY_KIND);
                        libTableModel.commit();
                        return lib;
                      }
                    });

    final String[] existingUrls = library.getUrls(OrderRootType.CLASSES);

    final Collection<String> libRootUrls = libInfo.getLibRootUrls();

    if ((!libInfo.isProjectWithoutPubspec()
            && isBrokenPackageMap(((LibraryEx) library).getProperties()))
        || existingUrls.length != libRootUrls.size()
        || !libRootUrls.containsAll(Arrays.asList(existingUrls))) {
      ApplicationManager.getApplication()
          .runWriteAction(
              new Runnable() {
                @Override
                public void run() {
                  final LibraryEx.ModifiableModelEx model =
                      (LibraryEx.ModifiableModelEx) library.getModifiableModel();
                  for (String url : existingUrls) {
                    model.removeRoot(url, OrderRootType.CLASSES);
                  }

                  for (String url : libRootUrls) {
                    model.addRoot(url, OrderRootType.CLASSES);
                  }

                  final DartPackagesLibraryProperties libraryProperties =
                      new DartPackagesLibraryProperties();
                  libraryProperties.setPackageNameToDirsMap(libInfo.getPackagesMap());
                  model.setProperties(libraryProperties);

                  model.commit();
                }
              });
    }

    return library;
  }
 private static void compareDatabaseVersionFileHistories(
     Collection<PartialFileHistory> writtenFileHistories,
     Collection<PartialFileHistory> readFileHistories) {
   assertTrue(
       "FileHistory objects in written/read database version different.",
       writtenFileHistories.containsAll(readFileHistories));
 }
 public static void main(String[] args) {
   Collection c = new ArrayList();
   // 添加元素
   c.add("孙悟空");
   // 虽然集合里不能放基本类型的值,但Java支持自动装箱
   c.add(6);
   System.out.println("c集合的元素个数为:" + c.size());
   // 删除指定元素
   c.remove(6);
   System.out.println("c集合的元素个数为:" + c.size());
   // 判断是否包含指定字符串
   System.out.println("c集合的是否包含\"孙悟空\"字符串:" + c.contains("孙悟空"));
   c.add("轻量级Java EE企业应用实战");
   System.out.println("c集合的元素:" + c);
   Collection books = new HashSet();
   books.add("轻量级Java EE企业应用实战");
   books.add("疯狂Java讲义");
   System.out.println("c集合是否完全包含books集合?" + c.containsAll(books));
   // 用c集合减去books集合里的元素
   c.removeAll(books);
   System.out.println("c集合的元素:" + c);
   // 删除c集合里所有元素
   c.clear();
   System.out.println("c集合的元素:" + c);
   // books集合里只剩下c集合里也包含的元素
   books.retainAll(c);
   System.out.println("books集合的元素:" + books);
 }
 public boolean retainAll(Collection<?> c) {
   if (c.containsAll(this)) return false;
   for (int i = 0; i < backingArray.length; i++) {
     if (!c.contains(backingArray[i])) remove(i);
   }
   return true;
 }
  public void testEnvironmentVariablesNotExist() {
    final ISymbolMap symbolTable = context.mock(ISymbolMap.class);
    final CapabilitySymbol capSym =
        new CapabilitySymbol(
            EnvironmentTestXML.capabilityId,
            EnvironmentTestXML.capabilityDesc,
            EnvironmentTestXML.capabilityClass);

    context.checking(
        new Expectations() {
          {
            one(symbolTable).put(EnvironmentTestXML.capabilityId, capSym);
          }
        });

    final byte[] xmlBytes = EnvironmentTestXML.noExistsProfileXML.getBytes();
    final ByteArrayInputStream stream = new ByteArrayInputStream(xmlBytes);
    try {
      parser.setSymbolTable(symbolTable).parse(stream);
    } catch (ParserException ex) {
      if (ex instanceof ProfileParserException) {
        final Collection<String> missing = ((ProfileParserException) ex).getMissingEnvironment();
        assertTrue(missing.size() == EnvironmentTestXML.varNames.length);
        final Collection<String> expectedMissing = new HashSet<String>();
        for (int idx = 0; idx < missing.size(); idx++) {
          expectedMissing.add(EnvironmentTestXML.varNames[idx]);
        }
        assertTrue(expectedMissing.containsAll(missing));
        context.assertIsSatisfied();
        return;
      }
    }

    assertTrue(false);
  }
  @Test
  public void testGetRuleNames() {
    final KieServices ks = KieServices.Factory.get();

    final KieFileSystem kfs = ks.newKieFileSystem();
    kfs.write(
        "src/main/resources/test1.drl",
        "package org.test\n"
            + "rule A\n"
            + " when\n"
            + "then\n"
            + "end\n"
            + "rule B\n"
            + " when\n"
            + "then\n"
            + "end\n");
    kfs.write(
        "src/main/resources/test2.drl",
        "package org.test\n" + "rule C\n" + " when\n" + "then\n" + "end\n");

    final KieBuilder kieBuilder = ks.newKieBuilder(kfs);
    final List<Message> messages = kieBuilder.buildAll().getResults().getMessages();
    assertTrue(messages.isEmpty());

    final KieModule kieModule = kieBuilder.getKieModule();
    final KieModuleMetaData kieModuleMetaData =
        KieModuleMetaData.Factory.newKieModuleMetaData(kieModule);

    Collection<String> rules = kieModuleMetaData.getRuleNamesInPackage("org.test");
    assertEquals(3, rules.size());
    assertTrue(rules.containsAll(asList("A", "B", "C")));
  }
  public Mapping getParentMapping(Collection<?> collection) {
    // Barring a better result, this will be the result.
    //
    Mapping result = this;

    // Cache the tree path for each object.
    //
    final Collection<List<?>> allTreePaths = new ArrayList<List<?>>();
    for (Object object : collection) {
      allTreePaths.add(domain.getTreePath(object));
    }

    // Iterate over the mappings in the tree.
    //
    OuterLoop:
    for (TreeIterator<Mapping> mappings = treeIterator(); mappings.hasNext(); ) {
      Mapping mapping = mappings.next();

      // Check to make sure that every object in the collection has an ancestor that is contained in
      // this mapping.
      //
      for (Iterator<List<?>> treePaths = allTreePaths.iterator(); treePaths.hasNext(); ) {
        List<?> treePath = treePaths.next();
        Collection<?> mappedObjects = mapping.getMappedObjects();
        mappedObjects.retainAll(treePath);

        // If the intersection is empty, i.e., no ancestor is in the mapping...
        //
        if (mappedObjects.isEmpty()) {
          // If this mapping isn't a parent, it's children definitely won't be either.
          //
          mappings.prune();
          continue OuterLoop;
        }
      }

      // Make sure the collections aren't identical...
      //
      Collection<?> mappedObjects = mapping.getMappedObjects();
      if (!collection.containsAll(mappedObjects) || !mappedObjects.containsAll(collection)) {
        result = mapping;
      }
    }

    return result;
  }
 public static <T> void assertEquals(Collection<T> expected, Collection<T> actual) {
   Assert.assertEquals(
       "The two collections do not have the same number of items!",
       expected.size(),
       actual.size());
   Assert.assertTrue(
       "The actual collection didn't contain all of the items from the expected!",
       actual.containsAll(expected));
 }
 @Test
 public void valuesCollection_PostSerializedEquality_chainedMap() {
   MutableMap<Integer, Integer> map = this.mapWithCollisionsOfSize(2);
   Collection<Integer> values = map.values();
   Collection<Integer> revived = SerializeTestHelper.serializeDeserialize(values);
   Assert.assertNotNull(revived);
   Verify.assertSize(values.size(), revived);
   Assert.assertTrue(revived.containsAll(values));
 }
Exemple #22
0
  @Test
  public void resultCanBeExtractedAsHashSet() {
    assertThat($(integerInput).asHashSet(), instanceOf(HashSet.class));

    Collection<String> stringInputAsSet = $(stringInput).asCollection();

    assertTrue($(stringInput).asHashSet().containsAll(stringInputAsSet));
    assertTrue(stringInputAsSet.containsAll($(stringInput).asHashSet()));
  }
  /** @return {@code True} if all replies are received. */
  private boolean allReceived() {
    Collection<UUID> rmtIds = this.rmtIds;

    assert rmtIds != null : "Remote Ids can't be null: " + this;

    synchronized (rcvdIds) {
      return rcvdIds.containsAll(rmtIds);
    }
  }
 private static void compareDatabaseVersionChunks(
     Collection<ChunkEntry> writtenChunks, Collection<ChunkEntry> readChunks) {
   assertEquals("Different amount of Chunk objects.", writtenChunks.size(), readChunks.size());
   assertTrue(
       "Chunk objects in written/read database version different.",
       writtenChunks.containsAll(readChunks));
   // assertCollectionEquals("Chunk objects in written/read database version different.",
   // writtenChunks, readChunks);
 }
  public Collection<? extends Mapping> getExactMappings(Collection<?> collection) {
    Collection<Mapping> result = new ArrayList<Mapping>();
    for (Mapping mapping : getAllMappings(collection)) {
      if (collection.containsAll(mapping.getMappedObjects())) {
        result.add(mapping);
      }
    }

    return result;
  }
 /**
  * Asserts that the given {@link MonitoringRequest} is for {@link #CRUD_OPERATIONS} on the current
  * directory.
  *
  * @param monitoringRequest the request to check (required)
  * @param expectedToWatchSubTree whether we expect the sub-tree to be monitored as well
  */
 private void assertMonitorsCurrentDirectory(
     final MonitoringRequest monitoringRequest, final boolean expectedToWatchSubTree) {
   assertEquals(DirectoryMonitoringRequest.class, monitoringRequest.getClass());
   assertEquals(
       expectedToWatchSubTree, ((DirectoryMonitoringRequest) monitoringRequest).isWatchSubtree());
   final Collection<FileOperation> notifyOn = monitoringRequest.getNotifyOn();
   assertEquals(CRUD_OPERATIONS.length, notifyOn.size());
   assertTrue(notifyOn.containsAll(Arrays.asList(CRUD_OPERATIONS)));
   assertEquals(new File("."), monitoringRequest.getFile());
 }
 public void testAddAllToCollection() {
   setUpTest();
   one.add("1");
   two.add("2");
   c.addComposited(one, two);
   Collection toCollection = new HashSet();
   toCollection.addAll(c);
   assertTrue(toCollection.containsAll(c));
   assertEquals(c.size(), toCollection.size());
 }
Exemple #28
0
 @SuppressWarnings("rawtypes")
 @Override
 public boolean equals(Object obj) {
   if (obj == null) {
     return false;
   }
   if (this == obj) {
     return true;
   }
   if (obj instanceof ConditionalCopySet) {
     return delegate.containsAll(((ConditionalCopySet) obj).delegate)
         && ((ConditionalCopySet<?>) obj).delegate.containsAll(delegate);
   }
   if (obj instanceof Collection) {
     return delegate.containsAll((Collection<?>) obj)
         && ((Collection<?>) obj).containsAll(delegate);
   }
   return false;
 }
  /** Asserts that all the expected methods were found in the call results. */
  public void assertCalls(Collection expectedMembers, Collection calls) {
    Collection foundMembers = new ArrayList();

    for (Iterator iter = calls.iterator(); iter.hasNext(); ) {
      MethodWrapper element = (MethodWrapper) iter.next();
      foundMembers.add(element.getMember());
    }

    Assert.assertEquals("Wrong number of calls", expectedMembers.size(), calls.size());
    Assert.assertTrue("One or more members not found", foundMembers.containsAll(expectedMembers));
  }
 private static void compareDatabaseVersionFileContents(
     Collection<FileContent> writtenFileContents, Collection<FileContent> readFileContents) {
   assertEquals(
       "Different amount of FileContent objects.",
       writtenFileContents.size(),
       readFileContents.size());
   assertTrue(
       "FileContent objects in written/read database version different.",
       writtenFileContents.containsAll(readFileContents));
   // assertCollectionEquals("FileContent objects in written/read database version different.",
   // writtenFileContents, readFileContents);
 }