public void testTypes() throws Exception { assertTrue(!FilterUtils.areProperSubset(tf1, tf2)); assertTrue(FilterUtils.areProperSubset(tf1, tf1)); assertTrue(FilterUtils.areDisjoint(tf1, tf2)); assertTrue(!FilterUtils.areDisjoint(tf1, tf1)); }
public void testOrAncestorDescendants() { FeatureFilter type_foo = new FeatureFilter.ByType("foo"); FeatureFilter type_bar = new FeatureFilter.ByType("bar"); FeatureFilter test = new FeatureFilter.ByAncestor(new FeatureFilter.OnlyDescendants(type_foo)); assertTrue(FilterUtils.areDisjoint(type_bar, test)); assertTrue(!FilterUtils.areDisjoint(type_foo, test)); }
public void testParentAncestor() throws Exception { assertTrue( FilterUtils.areProperSubset(parent_cf_ComponentFeature, ancestor_cf_ComponentFeature)); assertTrue( !FilterUtils.areProperSubset(ancestor_cf_ComponentFeature, parent_cf_ComponentFeature)); assertTrue( FilterUtils.areDisjoint(ancestor_cf_ComponentFeature, not_ancestor_cf_ComponentFeature)); assertTrue( FilterUtils.areDisjoint(not_ancestor_cf_ComponentFeature, parent_cf_ComponentFeature)); }
public void testAncestorLeafChildren() { FeatureFilter type_foo = new FeatureFilter.ByType("foo"); FeatureFilter type_bar = new FeatureFilter.ByType("bar"); FeatureFilter test = new FeatureFilter.ByAncestor( new FeatureFilter.OnlyChildren(new FeatureFilter.And(type_foo, FeatureFilter.leaf))); FeatureFilter test_nonleaf = new FeatureFilter.ByAncestor(new FeatureFilter.OnlyChildren(type_foo)); assertTrue(FilterUtils.areDisjoint(type_bar, test)); assertTrue(!FilterUtils.areDisjoint(type_bar, test_nonleaf)); assertTrue(!FilterUtils.areDisjoint(type_foo, test)); }
public void testDisjointAnnotationTypesContains() { AnnotationType atype = new AnnotationType.Impl(); atype.setDefaultConstraints(PropertyConstraint.NONE, CardinalityConstraint.ZERO); atype.setConstraints("foo", PropertyConstraint.ANY, CardinalityConstraint.ONE); assertTrue( FilterUtils.areDisjoint( new FeatureFilter.ByAnnotationType(atype), new FeatureFilter.AnnotationContains("bar", "some_value"))); assertTrue( !FilterUtils.areDisjoint( new FeatureFilter.ByAnnotationType(atype), new FeatureFilter.AnnotationContains("foo", "some_value"))); }
public void testParentChildren() { FeatureFilter type_foo = new FeatureFilter.ByType("foo"); FeatureFilter type_bar = new FeatureFilter.ByType("bar"); FeatureFilter type_baz = new FeatureFilter.ByType("baz"); FeatureFilter test = new FeatureFilter.ByParent( new FeatureFilter.OnlyChildren( new FeatureFilter.And( type_foo, new FeatureFilter.OnlyChildren( new FeatureFilter.And(type_baz, FeatureFilter.leaf))))); assertTrue(FilterUtils.areDisjoint(type_bar, test)); assertTrue(!FilterUtils.areDisjoint(type_foo, test)); assertTrue(FilterUtils.areDisjoint(type_baz, test)); }
/* (non-Javadoc) * @see fr.umlv.smoreau.beontime.filter.Filter#getQueryHQL() */ public String getHQLQuery() { try { return FilterUtils.createHQLQuery(this, corres); } catch (Exception e) { throw new RuntimeException("Erreur lors de l'introspection", e); } }
public void testOrOptimizeAllNone() { optimizeExact(all_or_all, FilterUtils.all()); optimizeExact(FilterUtils.or(all_or_all, all_or_all), FilterUtils.all()); optimizeExact(all_or_none, FilterUtils.all()); optimizeExact(FilterUtils.or(all_or_none, FilterUtils.none()), FilterUtils.all()); optimizeExact(none_or_none, FilterUtils.none()); }
public void testAndOptimizeAllNone() { optimizeExact(all_and_all, FilterUtils.all()); optimizeExact(FilterUtils.and(all_and_all, all_and_all), FilterUtils.all()); optimizeExact(all_and_none, FilterUtils.none()); optimizeExact(FilterUtils.and(all_and_none, FilterUtils.all()), FilterUtils.none()); optimizeExact(none_and_none, FilterUtils.none()); }
public MaterialFilter(Material material) { super(); try { FilterUtils.fillFilterClass(this, material, corres.keySet()); } catch (Exception e) { throw new RuntimeException("Erreur lors de l'introspection", e); } }
protected Filter(String name, Icon icon) { assert name != null; putValue(Action.SMALL_ICON, icon); putValue(Action.NAME, name); FilterUtils.addFilter(this); }
public void testOr() throws Exception { assertTrue(FilterUtils.areProperSubset(tf1, tf1_or_tf2)); assertTrue(!FilterUtils.areDisjoint(tf1, tf1_or_tf2)); assertTrue(FilterUtils.areDisjoint(tf3, tf1_or_tf2)); assertTrue(!FilterUtils.areProperSubset(tf1_or_tf2, tf2_or_tf3)); assertTrue(!FilterUtils.areDisjoint(tf1_or_tf2, tf2_or_tf3)); assertTrue(FilterUtils.areProperSubset(tf1_or_tf2, tf1_or_tf2_or_tf3)); assertTrue(FilterUtils.areProperSubset(tf2_or_tf3, tf1_or_tf2_or_tf3)); assertTrue(FilterUtils.areProperSubset(tf1_or_tf3, tf1_or_tf2_or_tf3)); }
/** * Obtiene el certificado de firma asociado a un certificado de autenticación dado. * * @param ksm Gestor del almacen en donde se encuentran los certificados. * @param cert Certificado de autenticación del que encontrar el asociado. * @param aliases Alias de los certificados del almacén. * @param pos Posición del listado de alias en el que se encuentra el alias del certificado * del que se busca pareja. * @return Alias del certificado asociado o {@code null} si no se encuentra. */ private String getAssociatedCertAlias( final KeyStoreManager ksm, final X509Certificate cert, final String[] aliases, final int pos) { X509Certificate tempCert; for (int j = 0; j < aliases.length; j++) { if (pos != j) { tempCert = ksm.getCertificate(aliases[j]); if (this.isSignatureDnieCert(tempCert) && FilterUtils.getSubjectSN(tempCert) != null && FilterUtils.getSubjectSN(tempCert).equalsIgnoreCase(FilterUtils.getSubjectSN(cert)) && SSLFilter.getExpiredDate(tempCert).equals(SSLFilter.getExpiredDate(cert))) { return aliases[j]; } } } return null; }
public void testByProperty() throws Exception { assertTrue("are disjoint: " + pf4 + ", " + pf5, FilterUtils.areDisjoint(pf4, pf5)); assertTrue("not disjoint: " + pf4 + ", " + pf6, !FilterUtils.areDisjoint(pf4, pf6)); assertTrue("not disjoint: " + pf5 + ", " + pf6, !FilterUtils.areDisjoint(pf5, pf6)); assertTrue("not subset: " + pf4 + ", " + pf5, !FilterUtils.areProperSubset(pf4, pf5)); assertTrue("not subset: " + pf4 + ", " + pf6, !FilterUtils.areProperSubset(pf4, pf6)); assertTrue("not subset: " + pf5 + ", " + pf6, !FilterUtils.areProperSubset(pf5, pf6)); assertTrue("are subset: " + pf4 + ", " + pf4, FilterUtils.areProperSubset(pf4, pf4)); }
public void testNot() throws Exception { assertTrue(FilterUtils.areProperSubset(ntf1, ntf1)); assertTrue(!FilterUtils.areDisjoint(ntf1, ntf1)); assertTrue(FilterUtils.areDisjoint(tf1, ntf1)); assertTrue(!FilterUtils.areProperSubset(tf1, ntf1)); assertTrue(!FilterUtils.areDisjoint(tf2, ntf1)); assertTrue(FilterUtils.areProperSubset(tf2, ntf1)); }
@Override public void configure(DocumentReader reader, Element element) { bitrates.clear(); try { for (Element bitrate : DocumentReader.getChildElements(reader.getElementByPath(element, CONFIG_TAG))) { BitrateInfo bri = new BitrateInfo(bitrate); log.debug("Adding BitrateInfo " + bri); bitrates.put(bri.getName(), bri); } } catch (Exception ex) { log.error("Error in filter.xml:" + ex, ex); } log.info("Configured bit rate labeler " + bitrates); FilterUtils.propertiesConfigure(this, reader, element); }
public void testLocation() throws Exception { // Simple comparison of locations. assertTrue(FilterUtils.areProperSubset(olf1, olf1)); assertTrue(!FilterUtils.areProperSubset(olf1, olf2)); assertTrue(!FilterUtils.areDisjoint(olf1, olf1)); // Assymetry between containment and overlapping assertTrue(FilterUtils.areProperSubset(clf1, olf1)); assertTrue(!FilterUtils.areProperSubset(olf1, clf1)); assertTrue(FilterUtils.areDisjoint(olf1, clf2)); assertTrue(FilterUtils.areDisjoint(clf1, olf2)); }
public static <C extends Containerable> ExistsFilter createExists( ItemPath itemPath, Class<C> clazz, PrismContext prismContext, ObjectFilter filter) throws SchemaException { ItemDefinition itemDefinition = FilterUtils.findItemDefinition(itemPath, clazz, prismContext); return new ExistsFilter(itemPath, itemDefinition, filter); }
/** * Recupera el número de serie de un certificado en formato hexadecimal. Los ceros ('0') a * la izquierda del número de serie se eliminan durante el proceso. Si el certificado no * tiene número de serie, devolverá {@code null}. * * @param cert Certificado. * @return Numero de serie en hexadecimal. */ private static String getCertificateSN(final X509Certificate cert) { return FilterUtils.bigIntegerToHex(cert.getSerialNumber()); }
/** {@inheritDoc} */ public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws IOException, ServletException { // According to CORS spec OPTIONS method does not pass auth info if (((HttpServletRequest) req).getMethod().equals("OPTIONS")) { chain.doFilter(req, resp); return; } Object auth = null; int numberOfTries = 0; if (!appConfig.isInitialized()) { appConfig.initialize(filterConfig, req); } int retries = appConfig.getRetries(); long pauseTime = appConfig.getPauseTime(); // Extract credential String token = ((HttpServletRequest) req).getHeader(TOKEN); if (token == null) { if (!appConfig.isDelayAuthDecision()) { logger.error(HttpServletResponse.SC_UNAUTHORIZED + " No token found."); ((HttpServletResponse) resp).sendError(HttpServletResponse.SC_UNAUTHORIZED, TOKEN_NOTFOUND); return; } else { logger.info("No token found...Skipping"); } } else { do { try { auth = FilterUtils.getCachedToken(token); } catch (ServiceUnavailableException e) { if (numberOfTries < retries) { FilterUtils.pause(pauseTime); logger.debug("Retrying connection after " + pauseTime + " seconds."); numberOfTries++; continue; } else { logger.debug("Exhausted retries.."); TokenExceptionHandler handler = TokenExceptionHandler.valueOf("ServiceUnavailableException"); handler.onException(e, resp, token); } return; } catch (ClientProtocolException e) { if (numberOfTries < retries) { FilterUtils.pause(pauseTime); logger.debug("Retrying connection after " + pauseTime + " seconds."); numberOfTries++; continue; } else { logger.debug("Exhausted retries.."); TokenExceptionHandler handler = TokenExceptionHandler.valueOf("ClientProtocolException"); handler.onException(e, resp, token); } return; } catch (UncheckedExecutionException e) { final TokenExceptionHandler handler; final Exception toHandle; if ((e.getCause() != null) && e.getCause() instanceof AdminAuthException) { toHandle = (AdminAuthException) e.getCause(); handler = TokenExceptionHandler.valueOf("AdminAuthException"); } else if ((e.getCause() != null) && e.getCause() instanceof AuthException) { toHandle = (AuthException) e.getCause(); handler = TokenExceptionHandler.valueOf("AuthException"); } else { toHandle = e; handler = TokenExceptionHandler.valueOf("UncheckedExecutionException"); } handler.onException(toHandle, resp, token); return; } } while (auth == null && numberOfTries <= retries); } req = FilterUtils.wrapRequest(req, auth); logger.debug("TokenAuth: Forwarding down stream to next filter/servlet"); // Forward downstream... chain.doFilter(req, resp); }
private void optimizeEquals(FeatureFilter raw, FeatureFilter target) { FeatureFilter result = FilterUtils.optimize(raw); assertTrue( "optimize: " + raw + " should be " + target + " but is " + result, result.equals(target)); }
public void testByClass() throws Exception { assertTrue(FilterUtils.areProperSubset(cf_HomologyFeature, cf_StrandedFeature)); assertTrue(FilterUtils.areProperSubset(cf_ComponentFeature, cf_StrandedFeature)); assertTrue(FilterUtils.areDisjoint(cf_ComponentFeature, cf_HomologyFeature)); }
public void testAndOr() throws Exception { assertTrue(FilterUtils.areProperSubset(pf1_and_tf1, pf1_AND_tf1_or_tf2)); assertTrue(FilterUtils.areProperSubset(pf1_and_pf2_and_tf1, pf1_and_pf2_OR_tf1)); }
public void testAnd() throws Exception { // all_and_all vs all assertTrue( "are subset: " + all_and_all + ", " + FeatureFilter.all, FilterUtils.areProperSubset(all_and_all, FeatureFilter.all)); assertTrue( "not disjoint: " + all_and_all + ", " + FeatureFilter.all, !FilterUtils.areDisjoint(all_and_all, FeatureFilter.all)); assertTrue( "are subset: " + FeatureFilter.all + ", " + all_and_all, FilterUtils.areProperSubset(FeatureFilter.all, all_and_all)); assertTrue( "not disjoint: " + FeatureFilter.all + ", " + all_and_all, !FilterUtils.areDisjoint(FeatureFilter.all, all_and_all)); // all_and_all vs none assertTrue( "not subset: " + all_and_all + ", " + FeatureFilter.none, !FilterUtils.areProperSubset(all_and_all, FeatureFilter.none)); assertTrue( "are disjoint: " + all_and_all + ", " + FeatureFilter.none, FilterUtils.areDisjoint(all_and_all, FeatureFilter.none)); assertTrue( "are subset: " + FeatureFilter.none + ", " + all_and_all, FilterUtils.areProperSubset(FeatureFilter.none, all_and_all)); assertTrue( "are disjoint: " + FeatureFilter.none + ", " + all_and_all, FilterUtils.areDisjoint(FeatureFilter.none, all_and_all)); // all_and_none vs all assertTrue( "are subset: " + all_and_none + ", " + FeatureFilter.all, FilterUtils.areProperSubset(all_and_none, FeatureFilter.all)); assertTrue( "are disjoint: " + all_and_none + ", " + FeatureFilter.all, FilterUtils.areDisjoint(all_and_none, FeatureFilter.all)); assertTrue( "not subset: " + FeatureFilter.all + ", " + all_and_none, !FilterUtils.areProperSubset(FeatureFilter.all, all_and_none)); assertTrue( "are disjoint: " + FeatureFilter.all + ", " + all_and_none, FilterUtils.areDisjoint(FeatureFilter.all, all_and_none)); // all_and_none vs none assertTrue( "are subset: " + all_and_none + ", " + FeatureFilter.none, FilterUtils.areProperSubset(all_and_none, FeatureFilter.none)); assertTrue( "are disjoint: " + all_and_none + ", " + FeatureFilter.none, FilterUtils.areDisjoint(all_and_none, FeatureFilter.none)); assertTrue( "are subset: " + FeatureFilter.none + ", " + all_and_none, FilterUtils.areProperSubset(FeatureFilter.none, all_and_none)); assertTrue( "are disjoint: " + FeatureFilter.none + ", " + all_and_none, FilterUtils.areDisjoint(FeatureFilter.none, all_and_none)); // none_and_all vs all assertTrue( "are subset: " + none_and_all + ", " + FeatureFilter.all, FilterUtils.areProperSubset(none_and_all, FeatureFilter.all)); assertTrue( "are disjoint: " + none_and_all + ", " + FeatureFilter.all, FilterUtils.areDisjoint(none_and_all, FeatureFilter.all)); assertTrue( "not subset: " + FeatureFilter.all + ", " + none_and_all, !FilterUtils.areProperSubset(FeatureFilter.all, none_and_all)); assertTrue( "are disjoint: " + FeatureFilter.all + ", " + none_and_all, FilterUtils.areDisjoint(FeatureFilter.all, none_and_all)); // none_and_all vs none assertTrue( "are subset: " + none_and_all + ", " + FeatureFilter.none, FilterUtils.areProperSubset(none_and_all, FeatureFilter.none)); assertTrue( "are disjoint: " + none_and_all + ", " + FeatureFilter.none, FilterUtils.areDisjoint(none_and_all, FeatureFilter.none)); assertTrue( "are subset: " + FeatureFilter.none + ", " + none_and_all, FilterUtils.areProperSubset(FeatureFilter.none, none_and_all)); assertTrue( "are disjoint: " + FeatureFilter.none + ", " + none_and_all, FilterUtils.areDisjoint(FeatureFilter.none, none_and_all)); // none_and_none vs all assertTrue( "are subset: " + none_and_none + ", " + FeatureFilter.all, FilterUtils.areProperSubset(none_and_none, FeatureFilter.all)); assertTrue( "are disjoint: " + none_and_none + ", " + FeatureFilter.all, FilterUtils.areDisjoint(none_and_none, FeatureFilter.all)); assertTrue( "not subset: " + FeatureFilter.all + ", " + none_and_none, !FilterUtils.areProperSubset(FeatureFilter.all, none_and_none)); assertTrue( "are disjoint: " + FeatureFilter.all + ", " + none_and_none, FilterUtils.areDisjoint(FeatureFilter.all, none_and_none)); // none_and_none vs none assertTrue( "are subset: " + none_and_none + ", " + FeatureFilter.none, FilterUtils.areProperSubset(none_and_none, FeatureFilter.none)); assertTrue( "are disjoint: " + none_and_none + ", " + FeatureFilter.none, FilterUtils.areDisjoint(none_and_none, FeatureFilter.none)); assertTrue( "are subset: " + FeatureFilter.none + ", " + none_and_none, FilterUtils.areProperSubset(FeatureFilter.none, none_and_none)); assertTrue( "are disjoint: " + FeatureFilter.none + ", " + none_and_none, FilterUtils.areDisjoint(FeatureFilter.none, none_and_none)); // pf1_and_pf2 vs pf1, pf2 assertTrue( "are subset: " + pf1_and_pf2 + ", " + pf1, FilterUtils.areProperSubset(pf1_and_pf2, pf1)); assertTrue( "not disjoint: " + pf1_and_pf2 + ", " + pf1, !FilterUtils.areDisjoint(pf1_and_pf2, pf1)); assertTrue( "are subset: " + pf1_and_pf2 + ", " + pf2, FilterUtils.areProperSubset(pf1_and_pf2, pf2)); assertTrue( "not disjoint: " + pf1_and_pf2 + ", " + pf2, !FilterUtils.areDisjoint(pf1_and_pf2, pf2)); assertTrue( "not subset: " + pf1_and_pf2 + ", " + pf3, !FilterUtils.areProperSubset(pf1_and_pf2, pf3)); assertTrue( "not subset: " + pf2_and_pf3 + ", " + pf1_and_pf2, !FilterUtils.areProperSubset(pf2_and_pf3, pf1_and_pf2)); assertTrue( "are subset: " + pf1_and_pf2_and_pf3 + ", " + pf1_and_pf2, FilterUtils.areProperSubset(pf1_and_pf2_and_pf3, pf1_and_pf2)); assertTrue( "are subset: " + pf1_and_pf2_and_pf3 + ", " + pf2_and_pf3, FilterUtils.areProperSubset(pf1_and_pf2_and_pf3, pf2_and_pf3)); assertTrue( "are subset: " + pf1_and_pf2_and_tf1 + ", " + pf1_and_pf2, FilterUtils.areProperSubset(pf1_and_pf2_and_tf1, pf1_and_pf2)); assertTrue( "are subset: " + pf1_and_pf2_and_tf1 + ", " + pf1_and_tf1, FilterUtils.areProperSubset(pf1_and_pf2_and_tf1, pf1_and_tf1)); assertTrue( "are disjoint: " + pf1_and_tf1 + ", " + tf2, FilterUtils.areDisjoint(pf1_and_tf1, tf2)); assertTrue( "are disjoint: " + pf1_and_pf2_and_tf1 + ", " + tf2, FilterUtils.areDisjoint(pf1_and_pf2_and_tf1, tf2)); }
public void testAndOrMethods() { checkEquals( FilterUtils.and(FilterUtils.and(tf1, tf2), tf3), FilterUtils.and(new FeatureFilter[] {tf1, tf2, tf3})); checkEquals( FilterUtils.and(tf1, FilterUtils.and(tf2, tf3)), FilterUtils.and(new FeatureFilter[] {tf1, tf2, tf3})); checkEquals( FilterUtils.or(FilterUtils.or(tf1, tf2), tf3), FilterUtils.or(new FeatureFilter[] {tf1, tf2, tf3})); checkEquals( FilterUtils.or(tf1, FilterUtils.or(tf2, tf3)), FilterUtils.or(new FeatureFilter[] {tf1, tf2, tf3})); }
public void testUseCases() { // schemas for our database features FeatureFilter transcript = FilterUtils.byType("transcript"); FeatureFilter exon = FilterUtils.byType("exon"); FeatureFilter repeat = FilterUtils.byType("repeat"); AnnotationType.Impl tsType = new AnnotationType.Impl(); tsType.setConstraints( "transcript.id", new PropertyConstraint.ByClass(String.class), CardinalityConstraint.ONE); tsType.setDefaultConstraints(PropertyConstraint.NONE, CardinalityConstraint.NONE); FeatureFilter tsID = FilterUtils.byAnnotationType(tsType); AnnotationType.Impl exType = new AnnotationType.Impl(); exType.setConstraints( "id", new PropertyConstraint.ByClass(String.class), CardinalityConstraint.ONE); exType.setDefaultConstraints(PropertyConstraint.NONE, CardinalityConstraint.NONE); FeatureFilter exID = FilterUtils.byAnnotationType(exType); AnnotationType.Impl rpType = new AnnotationType.Impl(); rpType.setConstraints("id", PropertyConstraint.ANY, CardinalityConstraint.ONE); rpType.setDefaultConstraints(PropertyConstraint.NONE, CardinalityConstraint.NONE); FeatureFilter repeatID = FilterUtils.byAnnotationType(rpType); FeatureFilter tsSchema = FilterUtils.and(transcript, tsID); FeatureFilter exSchema = FilterUtils.and(exon, exID); FeatureFilter reSchema = FilterUtils.and(repeat, repeatID); FeatureFilter dbFilter = FilterUtils.or(new FeatureFilter[] {tsSchema, exSchema, reSchema}); // pull out a feature by transcript.id FeatureFilter aTranscript = FilterUtils.byAnnotation("transcript.id", "ts:42"); // let the fun commence optimizeEquals( FilterUtils.and(tsSchema, aTranscript), FilterUtils.and(transcript, aTranscript)); optimizeExact(FilterUtils.and(exSchema, aTranscript), FilterUtils.none()); optimizeExact(FilterUtils.and(reSchema, aTranscript), FilterUtils.none()); optimizeEquals(dbFilter, dbFilter); optimizeEquals( FilterUtils.and(dbFilter, aTranscript), FilterUtils.and(transcript, aTranscript)); }
public void testAndOrAllNone() { optimizeExact(FilterUtils.or(all_and_all, FilterUtils.all()), FilterUtils.all()); optimizeExact(FilterUtils.or(all_and_none, FilterUtils.all()), FilterUtils.all()); optimizeExact(FilterUtils.or(all_and_all, FilterUtils.none()), FilterUtils.all()); optimizeExact(FilterUtils.or(all_and_none, FilterUtils.none()), FilterUtils.none()); optimizeExact(FilterUtils.and(all_or_all, FilterUtils.all()), FilterUtils.all()); }
/** {@inheritDoc} */ public void destroy() { FilterUtils.destroyFilter(); }
public void testHasByProperty() throws Exception { assertTrue("not disjoint: " + pf1 + ", " + pf4, !FilterUtils.areDisjoint(pf1, pf4)); assertTrue("not disjoint: " + pf2 + ", " + pf4, !FilterUtils.areDisjoint(pf2, pf4)); assertTrue("not disjoint: " + pf3 + ", " + pf4, !FilterUtils.areDisjoint(pf3, pf4)); assertTrue("not subset: " + pf1 + ", " + pf4, !FilterUtils.areProperSubset(pf1, pf4)); assertTrue("are subset: " + pf4 + ", " + pf1, FilterUtils.areProperSubset(pf4, pf1)); assertTrue("are subset: " + pf5 + ", " + pf1, FilterUtils.areProperSubset(pf5, pf1)); assertTrue("not subset: " + pf6 + ", " + pf1, !FilterUtils.areProperSubset(pf6, pf1)); assertTrue("not subset: " + pf2 + ", " + pf4, !FilterUtils.areProperSubset(pf2, pf4)); assertTrue("not subset: " + pf4 + ", " + pf2, !FilterUtils.areProperSubset(pf4, pf2)); assertTrue("not subset: " + pf5 + ", " + pf2, !FilterUtils.areProperSubset(pf5, pf2)); assertTrue("are subset: " + pf6 + ", " + pf2, FilterUtils.areProperSubset(pf6, pf2)); }