}

    @Override
    @BeforeEach
    public void setUp() throws Exception {
        super.setUp();
        EmptyLifecycleBindingsInjector.useEmpty();
    }

        EmptyLifecycleBindingsInjector.lifecycleRegistry = lifecycleRegistry;
        EmptyLifecycleBindingsInjector.packagingRegistry = packagingRegistry;
    }

    public static void useEmpty() {
        lifecycleRegistry = emptyLifecycleRegistry;
        packagingRegistry = emptyPackagingRegistry;
    }

    private static Plugin newPlugin(String artifactId, String... goals) {

        this.groupId = (groupId != null && !groupId.isEmpty()) ? groupId : null;
        this.artifactId = (artifactId != null && !artifactId.isEmpty()) ? artifactId : null;
        this.classifier = (classifier != null && !classifier.isEmpty()) ? classifier : null;
        this.extension = (extension != null && !extension.isEmpty()) ? extension : null;
        this.version = (version != null && !version.isEmpty()) ? version : null;

			default:
				return errUnknownXMLTag
			}
		}
	}
	return nil
}

// IsEmpty returns true if Filter is not specified in the XML
func (f Filter) IsEmpty() bool {
	return !f.set
}

// Validate - validates the filter element
func (f Filter) Validate() error {
	if f.IsEmpty() {
		return errXMLNotWellFormed
	}
	// A Filter must have exactly one of Prefix, Tag,

    }
    assertEquals(expectedSize, size2);
  }

  @CollectionSize.Require(ZERO)
  public void testIsEmptyYes() {
    assertTrue(multimap().isEmpty());
  }

  @CollectionSize.Require(absent = ZERO)
  public void testIsEmptyNo() {
    assertFalse(multimap().isEmpty());
  }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require(ALLOWS_NULL_KEYS)
  public void testSizeNullKey() {

  @CollectionSize.Require(ZERO)
  public void testIsEmpty_yes() {
    assertTrue("isEmpty() should return true", getMap().isEmpty());
  }

  @CollectionSize.Require(absent = ZERO)
  public void testIsEmpty_no() {
    assertFalse("isEmpty() should return false", getMap().isEmpty());
  }

    assertThat(requirements.getPresentFeatures()).isEmpty();
    assertThat(requirements.getAbsentFeatures()).isEmpty();
  }

  public void testBuildTesterRequirements_class_empty() throws Exception {
    @Require
    class Tester {}

    TesterRequirements requirements = buildTesterRequirements(Tester.class);

    assertThat(requirements.getPresentFeatures()).isEmpty();

    }

    public ExecutionListener chainListener(ExecutionListener listener) {
        if (eventSpies.isEmpty()) {
            return listener;
        }
        return new EventSpyExecutionListener(this, listener);
    }

    public RepositoryListener chainListener(RepositoryListener listener) {
        if (eventSpies.isEmpty()) {
            return listener;
        }
        return new EventSpyRepositoryListener(this, listener);

        Set<Artifact> resolved = new LinkedHashSet<>();

        if (projects == null || projects.isEmpty()) {
            return resolved;
        }

        if ((scopesToCollect == null || scopesToCollect.isEmpty())
                && (scopesToResolve == null || scopesToResolve.isEmpty())) {
            return resolved;
        }

        /*

        Logic for transitive global exclusions

    public boolean isEmpty() {
        return entry == null || vertices == null || vertices.isEmpty();
    }

    // ------------------------------------------------------------------------
    public boolean isEmptyEdges() {
        return isEmpty() || incidentEdges == null || incidentEdges.isEmpty();
    }