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,

     * Test method for
     * {@link org.codelibs.core.collection.CollectionsUtil#isEmpty(java.util.Collection)}
     * .
     */
    @Test
    public void testIsEmptyCollectionOfQ() {
        Collection<String> c = null;
        assertThat(CollectionsUtil.isEmpty(c), is(true));
        c = new ArrayList<String>();
        assertThat(CollectionsUtil.isEmpty(c), is(true));
    }

    /**
     * Test method for

        return ((groupId != null && !groupId.isEmpty()) ? groupId : "[unknown-group-id]")
                + ':'
                + ((artifactId != null && !artifactId.isEmpty()) ? artifactId : "[unknown-artifact-id]")
                + ':'
                + ((version != null && !version.isEmpty()) ? version : "[unknown-version]");
    }

    /**

      MutableNetwork<Integer, Object> network =
          networkBuilder.allowsParallelEdges(true).allowsSelfLoops(true).build();

      assertThat(network.nodes()).isEmpty();
      assertThat(network.edges()).isEmpty();
      AbstractNetworkTest.validateNetwork(network);

      while (network.nodes().size() < NUM_NODES) {
        network.addNode(gen.nextInt(NODE_POOL_SIZE));
      }

        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

    // source node and the second is the target node
    assertThat(network.edgesConnecting(N2, N1)).isEmpty();
  }

  @Test
  public void inEdges_oneEdge() {
    addEdge(N1, N2, E12);
    assertThat(network.inEdges(N2)).containsExactly(E12);
    // Edge direction handled correctly
    assertThat(network.inEdges(N1)).isEmpty();
  }

  @Test
  public void outEdges_oneEdge() {
    addEdge(N1, N2, E12);

    protected boolean isSiteEmpty(Site site) {
        return (site.getId() == null || site.getId().isEmpty())
                && (site.getName() == null || site.getName().isEmpty())
                && (site.getUrl() == null || site.getUrl().isEmpty());
    }

    @Override
    protected void mergeSite_Url(

    assertFalse(c3.isClosed());

    closer.close();

    assertTrue(c1.isClosed());
    assertTrue(c2.isClosed());
    assertTrue(c3.isClosed());

    assertTrue(suppressor.suppressions.isEmpty());
  }

  public void testExceptionThrown_fromTryBlock() throws IOException {
    Closer closer = new Closer(suppressor);

    TestCloseable c1 = closer.register(TestCloseable.normal());

    assertEquals(OPEN, range.lowerBoundType());
    assertTrue(range.hasUpperBound());
    assertEquals(8, (int) range.upperEndpoint());
    assertEquals(OPEN, range.upperBoundType());
    assertFalse(range.isEmpty());
    assertEquals("(4..8)", range.toString());
    reserializeAndAssert(range);
  }

  public void testOpen_invalid() {
    try {
      Range.open(4, 3);
      fail();

        assertTrue(docMap.isEmpty());
        value.clear();

        List<String> keys = Arrays.asList("test_2", "test_0", "lang", "test_1");
        value.put(keys.get(0), true);
        value.put(keys.get(1), 1000);
        value.put(keys.get(2), "ja");
        value.put(keys.get(3), "str");
        docMap = new DocMap(value);
        assertFalse(docMap.isEmpty());