String c = getClassifier();
        return getGroupId()
                + ':'
                + getArtifactId()
                + ':'
                + getExtension()
                + (c.isEmpty() ? "" : ":" + c)
                + ':'
                + getVersion();
    }

    /**
     * {@return the group identifier of the artifact}.
     *
     * @see ArtifactCoordinates#getGroupId()
     */

        if (entry.getKey().equals(key)) {
          expectedValues.add(entry.getValue());
        }
      }

      Collection<V> collection = multimap().asMap().get(key);
      if (expectedValues.isEmpty()) {
        assertNull(collection);
      } else {
        assertEqualIgnoringOrder(expectedValues, collection);
      }
    }
  }

  @CollectionSize.Require(absent = ZERO)

        assertEquals(0, channelInfo.getRequestsPending());
        assertTrue(channelInfo.getPendingOperations().isEmpty());

        channelInfo.addPendingOperation(mockOperation);
        assertEquals(1, channelInfo.getRequestsPending());
        assertFalse(channelInfo.getPendingOperations().isEmpty());

        assertTrue(channelInfo.removePendingOperation(mockOperation));

    }

    public void clearModifiedInfo() {
        __modifiedProperties.clear();
    }

    public boolean hasModification() {
        return !__modifiedProperties.isEmpty();
    }

    protected EntityModifiedProperties newModifiedProperties() {
        return new EntityModifiedProperties();
    }

    protected void registerModifiedProperty(String propertyName) {

  }

  @Override
  public @Nullable E higher(E e) {
    return delegate.higher(checkValid(e));
  }

  @Override
  public boolean isEmpty() {
    return delegate.isEmpty();
  }

  @Override
  public Iterator<E> iterator() {
    return delegate.iterator();
  }

  @Override
  public E last() {
    return delegate.last();
  }

    List<Integer> sublist = list.subList(0, 5);
    assertThat(sublist).containsExactly(1, 2, 3, 4, 5).inOrder();

    sublist.clear();
    assertTrue(sublist.isEmpty());
    multimap.put("foo", 6);

    assertThrows(ConcurrentModificationException.class, () -> sublist.isEmpty());
  }

  public void testCreateFromMultimap() {
    Multimap<String, Integer> multimap = create();
    multimap.put("foo", 1);

        if (entry.getKey().equals(key)) {
          expectedValues.add(entry.getValue());
        }
      }

      Collection<V> collection = multimap().asMap().get(key);
      if (expectedValues.isEmpty()) {
        assertNull(collection);
      } else {
        assertEqualIgnoringOrder(expectedValues, collection);
      }
    }
  }

  @CollectionSize.Require(absent = ZERO)

    val mainMethod =
      Class
        .forName(className)
        .methods
        .find { it.name == "main" }
    try {
      if (mainMethod != null) {
        if (mainMethod.parameters.isEmpty()) {
          mainMethod.invoke(null)
        } else {
          mainMethod.invoke(null, arrayOf<String>())
        }
      } else {
        System.err.println("No main for $className")
      }

        System.out.println("Project " + project1.getId() + " " + project1);
        Set set = project1.getArtifacts();
        assertNotNull(set, "No artifacts");
        assertFalse(set.isEmpty(), "No Artifacts");
        assertTrue(set.size() == 3, "Set size should be 3, is " + set.size());

        for (Object aSet : set) {
            Artifact artifact = (Artifact) aSet;

        SearchResult result = new SearchResult(emptyList, 0L, "eq", 10L, false, null);

        assertNotNull(result.getDocumentList());
        assertTrue(result.getDocumentList().isEmpty());
        assertEquals(0L, result.getAllRecordCount());
        assertEquals("eq", result.getAllRecordCountRelation());
        assertEquals(10L, result.getQueryTime());
        assertFalse(result.isPartialResults());