com.google.common.base.Predicates#alwaysFalse ( )源码实例Demo

public PanicAlarm() {
	// FIXME update the offline to take rule:state == DISABLED into account
	super(
			NAME,
			ExpressionCompiler.compile(
				"base:caps contains 'keypad' OR " +
				"(" +
					"rule:template == 'pendant-panic' OR " +
					"rule:template == 'button-panic' OR " +
					"rule:template == '01e7de' OR " +
					"rule:template == 'c2dd38'" +
				")"
			),
			Predicates.<Model>alwaysFalse()
	);
}
 

@VisibleForTesting
public static Predicate<BlueTestResult> filterByStatus(String status) {
    String[] statusAtoms = StringUtils.split(status, ',');
    Predicate<BlueTestResult> predicate = Predicates.alwaysFalse();
    if (statusAtoms == null || statusAtoms.length == 0) {
        throw new BadRequestException("status not provided");
    }
    for (String statusString : statusAtoms) {
        Predicate<BlueTestResult> statusPredicate;
        try {
            if (statusString.startsWith("!")) {
                statusPredicate = Predicates.not(new StatusPredicate(Status.valueOf(statusString.toUpperCase().substring(1))));
            } else {
                statusPredicate  = new StatusPredicate(Status.valueOf(statusString.toUpperCase()));
            }
        } catch (IllegalArgumentException e) {
            throw new BadRequestException("bad status " + status, e);
        }
        predicate = Predicates.or(predicate, statusPredicate );
    }
    return predicate;
}
 

public <S, P, R> List<R> collectReachable(Pda<S, P> pda, final Function<S, R> function) {
	final List<R> result = Lists.newArrayList();
	Iterator<P> stack = Collections.<P> emptyList().iterator();
	Predicate<S> matches = Predicates.<S> alwaysFalse();
	Predicate<S> canPass = new Predicate<S>() {
		@Override
		public boolean apply(S input) {
			R r = function.apply(input);
			if (r != null) {
				result.add(r);
				return false;
			} else {
				return true;
			}
		}
	};
	trace(pda, Collections.singleton(pda.getStart()), stack, matches, canPass);
	return result;
}
 

private static Predicate<MethodData> runnerFilter(TestRelatedClassData testData) {
  boolean hasRunWith =
      FluentIterable.from(testData.aggregatedClassAnnotations.get())
          .anyMatch(HAS_RUN_WITH_ANNOTATION);
  if (hasRunWith) {
    return IS_J4_TEST_METHOD;
  }
  if (testData.descendsFromJUnit3TestCase) {
    return IS_J3_TEST_METHOD;
  }
  return Predicates.<MethodData>alwaysFalse();
}
 

@Test
public void testNoMatchingModels() {
   EasyMock.replay(mockAction);
   
   ForEachModelAction selector = new ForEachModelAction(mockAction, Predicates.<Model>alwaysTrue(), Predicates.<Model>alwaysFalse(), "address");
   selector.execute(context);
   
   EasyMock.verify(mockAction);
}
 

@Test
public void testNoMatchingModels() {
   EasyMock.replay(mockAction);
   
   ForEachModelAction selector = new ForEachModelAction(mockAction, Predicates.<Model>alwaysFalse(), "address");
   selector.execute(context);
   
   EasyMock.verify(mockAction);
}
 

@Override
@Before
public void setUp() throws Exception {
   super.setUp();
   clientSession = new HubSession(null, null, new BridgeMetrics("test"), clientToken);
   authorizer = new DefaultHubMessageFilterImpl(
      Predicates.alwaysFalse(),
      Predicates.alwaysFalse(),
      new PlatformBusServiceImpl(ServiceLocator.getInstance(PlatformMessageBus.class), new BridgeMetrics("hub"), Collections.emptySet())
   );
}
 

/**
 * @return
 *      The filter configured in {@link #ENTITY_FILTER} ANDed with a check that the
 *      entity has the same application ID.
 */
protected Predicate<? super Entity> getEntityFilter() {
    Predicate<? super Entity> entityFilter = getConfig(ENTITY_FILTER);
    if (entityFilter == null) {
        entityFilter = Predicates.alwaysFalse();
    }
    return Predicates.and(
            EntityPredicates.applicationIdEqualTo(getApplicationId()),
            entityFilter);
}
 

public static void analyzeNewInstance(ThreadInfo ti, ElementInfo ei) {
  SymbolicObjectsContext ctx = new SymbolicObjectsContext(ti.getHeap(), Predicates.alwaysFalse(), Predicates.alwaysFalse(), Predicates.alwaysFalse());
  ClassInfo ci = ei.getClassInfo();
  FieldInfo[] fis = ci.getDeclaredInstanceFields();
  for(FieldInfo fi : fis) {
    if(isSymbolicField(fi)) {
      String fqn = ci.getName() + "." + fi.getName();
      ctx.processField(ei, fi, fqn);
    }
  }
  globalSymbolics.putAll(ctx.symbolicVars);
}
 

protected Predicate<ISemanticRegion> createPredicate(AbstractElement... ele) {
	Set<AbstractElement> result = Sets.newHashSet();
	for (AbstractElement e : ele)
		collectMatchableElements(e, result);
	switch (result.size()) {
		case 0:
			return Predicates.alwaysFalse();
		case 1:
			return new GrammarElementPredicate(result.iterator().next());
		default:
			return new GrammarElementsPredicate(result);
	}
}
 

public static void analyzeStatic(VM vm, ClassInfo ci) {
  SymbolicObjectsContext ctx = new SymbolicObjectsContext(vm.getHeap(), Predicates.alwaysFalse(), Predicates.alwaysFalse(), Predicates.alwaysFalse());
  FieldInfo[] fis = ci.getDeclaredStaticFields();
  ElementInfo sei = ci.getStaticElementInfo();
  for(FieldInfo fi : fis) {
    if(isSymbolicField(fi)) {
      String fqn = ci.getName() + "." + fi.getName();
      ctx.processField(sei, fi, fqn);
    }
  }
  
  globalSymbolics.putAll(ctx.symbolicVars);
}
 

@Override
public Predicate<Response> unassessedFilter() {
  return Predicates.alwaysFalse();
}
 

@Provides
@Named(DefaultHubMessageFilterImpl.ADMIN_ONLY_MESSAGES_PROP)
@Singleton
public Predicate<String> getHubAdminOnlyMessages(@Named("hub.bridge.admin.only.messages") String adminOnlyMessages) {
    List<Predicate<String>> components = new ArrayList<>();

    for (String msg : Splitter.on(',').omitEmptyStrings().trimResults().split(adminOnlyMessages)) {
        List<String> parts = Splitter.on(':').splitToList(msg);
        switch (parts.size()) {
            case 2:
                if (parts.get(1).isEmpty() || "*".equals(parts.get(1))) {
                    final String capMatch = parts.get(0) + ":";
                    log.warn("adding all commands to admin only list: {}", parts.get(0));
                    components.add(new Predicate<String>() {
                        @Override
                        public boolean apply(String msgType) {
                            return msgType != null && msgType.startsWith(capMatch);
                        }
                    });
                } else {
                    log.warn("adding command to admin only list: {}", msg);
                    components.add(Predicates.equalTo(msg));
                }
                break;

            default:
                log.warn("adding non-conforming command to admin only list: {}", msg);
                components.add(Predicates.equalTo(msg));
                break;
        }

    }

    switch (components.size()) {
        case 0:
            return Predicates.alwaysFalse();

        case 1:
            return components.get(0);

        default:
            return Predicates.or(components);
    }
}
 

@Override
public Predicate<Response> unassessedFilter() {
  // unassessed answers cannot be linked
  return Predicates.alwaysFalse();
}
 

@Override
public Predicate<Response> unassessedFilter() {
  return Predicates.alwaysFalse();
}
 

protected static <T> Predicate<T> constantPredicate(boolean val) {
    return val ? Predicates.alwaysTrue() : Predicates.alwaysFalse();
}
 

protected static <T> Predicate<T> constantPredicate(boolean val) {
    return val ? Predicates.alwaysTrue() : Predicates.alwaysFalse();
}
 

public LanguageResourcesSplitter() {
  this(/* pinResourceToMaster= */ Predicates.alwaysFalse());
}
 

@Override
public Predicate<String> getValidator() {
  return Predicates.alwaysFalse();
}
 

@Override
public Predicate<Response> unassessedFilter() {
  return Predicates.alwaysFalse();
}