下面列出了org.junit.contrib.java.lang.system.Assertion#com.google.common.base.Predicate 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
/**
* Apply the supplied predicate against
* all possible result Nodes of the expression.
*/
static boolean anyResultsMatch(Node n, Predicate<Node> p) {
switch (n.getType()) {
case Token.ASSIGN:
case Token.COMMA:
return anyResultsMatch(n.getLastChild(), p);
case Token.AND:
case Token.OR:
return anyResultsMatch(n.getFirstChild(), p)
|| anyResultsMatch(n.getLastChild(), p);
case Token.HOOK:
return anyResultsMatch(n.getFirstChild().getNext(), p)
|| anyResultsMatch(n.getLastChild(), p);
default:
return p.apply(n);
}
}
@Test
public void testDoesNotLogPasswordsInEnvironmentVariables() {
List<String> loggerNames = ImmutableList.of(
SshMachineLocation.class.getName(),
BrooklynLogging.SSH_IO,
SshjTool.class.getName());
ch.qos.logback.classic.Level logLevel = ch.qos.logback.classic.Level.DEBUG;
Predicate<ILoggingEvent> filter = Predicates.or(
EventPredicates.containsMessage("DB_PASSWORD"),
EventPredicates.containsMessage("mypassword"));
try (LogWatcher watcher = new LogWatcher(loggerNames, logLevel, filter)) {
host.execCommands("mySummary", ImmutableList.of("true"), ImmutableMap.of("DB_PASSWORD", "mypassword"));
watcher.assertHasEventEventually();
Optional<ILoggingEvent> eventWithPasswd = Iterables.tryFind(watcher.getEvents(), EventPredicates.containsMessage("mypassword"));
assertFalse(eventWithPasswd.isPresent(), "event="+eventWithPasswd);
}
}
@Override
public void serialize(Configuration conf, JsonGenerator jsonGenerator,
SerializerProvider serializerProvider) throws IOException {
SerializationContext context = RestResource.serializationContext
.get();
Predicate<String> configFilter = context.getConfigurationFilter();
Iterator<Map.Entry<String, String>> keyValueIterator = conf.iterator();
jsonGenerator.writeStartObject();
// here's where we can filter out keys if we want
while (keyValueIterator.hasNext()) {
Map.Entry<String, String> kvp = keyValueIterator.next();
if (configFilter == null || configFilter.apply(kvp.getKey())) {
jsonGenerator.writeFieldName(kvp.getKey());
jsonGenerator.writeString(kvp.getValue());
}
}
jsonGenerator.writeEndObject();
}
/**
* Verify that only rule self directives are used for terminal, enum and data type rules.
*
* @param model
* the GrammarRule
*/
@Check
public void checkDataTypeOrEnumRule(final GrammarRule model) {
if (model.getTargetRule() instanceof TerminalRule || model.getTargetRule() instanceof EnumRule
|| (model.getTargetRule() instanceof ParserRule && GrammarUtil.isDatatypeRule((ParserRule) model.getTargetRule()))) {
Iterator<EObject> grammarElementAccessors = collectGrammarElementAccessors(model);
boolean selfAccessOnly = Iterators.all(grammarElementAccessors, new Predicate<EObject>() {
@Override
public boolean apply(final EObject input) {
return input instanceof GrammarElementReference && ((GrammarElementReference) input).getSelf() != null;
}
});
if (!selfAccessOnly) {
error(NLS.bind("For data type, enum or terminal rule {0} only ''rule'' directive may be used", model.getTargetRule().getName()), FormatPackage.Literals.GRAMMAR_RULE__DIRECTIVES, ILLEGAL_DIRECTIVE_CODE);
}
}
}
@Override
public List<Issue> searchIssues(final String name, final String label) {
Iterable<Issue> filteredIterable = Iterables.filter(issues.values(), new Predicate<Issue>() {
@Override
public boolean apply(Issue issue) {
boolean result = true;
if (name != null) {
result = issue.getName() != null && issue.getName().toLowerCase().contains(name.toLowerCase());
}
if (result && label != null) {
Iterable<String> filteredLabels = Iterables.filter(issue.getLabels(), new Predicate<String>() {
@Override
public boolean apply(String issueLabel) {
return issueLabel != null && issueLabel.toLowerCase().contains(label.toLowerCase());
}
});
result = result && filteredLabels.iterator().hasNext();
}
return result;
}
});
return Lists.newArrayList(filteredIterable);
}
private static void trueMain(final String[] argv) throws IOException {
if (argv.length == 1) {
final Parameters params = Parameters.loadSerifStyle(new File(argv[0]));
log.info(params.dump());
final Function<DocumentSystemOutput, DocumentSystemOutput> filter =
getSystemOutputFilter(params);
final Predicate<Symbol> docIdFilter = getDocIdFilter(params);
final SystemOutputLayout outputLayout = SystemOutputLayout.ParamParser.fromParamVal(
params.getString("outputLayout"));
final AssessmentSpecFormats.Format annStoreFileFormat =
params.getEnum("annStore.fileFormat", AssessmentSpecFormats.Format.class);
final ImmutableSet<SystemOutputStore> systemOutputs =
loadSystemOutputStores(params, outputLayout);
final ImmutableSet<AnnotationStore> annotationStores =
loadAnnotationStores(params, annStoreFileFormat);
importSystemOutputToAnnotationStore(systemOutputs, annotationStores, filter,
docIdFilter);
} else {
usage();
}
}
/**
* @return Whether the predicate is true for the node or any of its children.
*/
static boolean has(Node node,
Predicate<Node> pred,
Predicate<Node> traverseChildrenPred) {
if (pred.apply(node)) {
return true;
}
if (!traverseChildrenPred.apply(node)) {
return false;
}
for (Node c = node.getFirstChild(); c != null; c = c.getNext()) {
if (has(c, pred, traverseChildrenPred)) {
return true;
}
}
return false;
}
@Override
public Collection<ILinkingCandidate> getFollowUpErrors() {
Collection<?> rawResult = Collections2.filter(basicGetLinkingMap().values(), new Predicate<IApplicableCandidate>() {
@Override
public boolean apply(/* @Nullable */ IApplicableCandidate input) {
if (input == null)
throw new IllegalArgumentException();
if (input instanceof FollowUpError)
return true;
return false;
}
});
@SuppressWarnings("unchecked") // cast is safe
Collection<ILinkingCandidate> result = (Collection<ILinkingCandidate>) rawResult;
return result;
}
@Override
public List<TopicConsumerInfo> queryConsumeStatsList(final String topic, String groupName) {
ConsumeStats consumeStats = null;
try {
consumeStats = mqAdminExt.examineConsumeStats(groupName); // todo ConsumeStats examineConsumeStats(final String consumerGroup, final String topic) can use
} catch (Exception e) {
throw propagate(e);
}
List<MessageQueue> mqList = Lists.newArrayList(Iterables.filter(consumeStats.getOffsetTable().keySet(), new Predicate<MessageQueue>() {
@Override
public boolean apply(MessageQueue o) {
return StringUtils.isBlank(topic) || o.getTopic().equals(topic);
}
}));
Collections.sort(mqList);
List<TopicConsumerInfo> topicConsumerInfoList = Lists.newArrayList();
TopicConsumerInfo nowTopicConsumerInfo = null;
for (MessageQueue mq : mqList) {
if (nowTopicConsumerInfo == null || (!StringUtils.equals(mq.getTopic(), nowTopicConsumerInfo.getTopic()))) {
nowTopicConsumerInfo = new TopicConsumerInfo(mq.getTopic());
topicConsumerInfoList.add(nowTopicConsumerInfo);
}
nowTopicConsumerInfo.appendQueueStatInfo(QueueStatInfo.fromOffsetTableEntry(mq, consumeStats.getOffsetTable().get(mq)));
}
return topicConsumerInfoList;
}
/**
* Apply the supplied predicate against the potential
* all possible result of the expression.
*/
static boolean valueCheck(Node n, Predicate<Node> p) {
switch (n.getType()) {
case Token.ASSIGN:
case Token.COMMA:
return valueCheck(n.getLastChild(), p);
case Token.AND:
case Token.OR:
return valueCheck(n.getFirstChild(), p)
&& valueCheck(n.getLastChild(), p);
case Token.HOOK:
return valueCheck(n.getFirstChild().getNext(), p)
&& valueCheck(n.getLastChild(), p);
default:
return p.apply(n);
}
}
/**
* A raw dataset version is qualified to be deleted, iff the corresponding refined paths exist, and the latest
* mod time of all files is in the raw dataset is earlier than the latest mod time of all files in the refined paths.
*/
protected Collection<FileSystemDatasetVersion> listQualifiedRawFileSystemDatasetVersions(Collection<FileSystemDatasetVersion> allVersions) {
return Lists.newArrayList(Collections2.filter(allVersions, new Predicate<FileSystemDatasetVersion>() {
@Override
public boolean apply(FileSystemDatasetVersion version) {
Iterable<Path> refinedDatasetPaths = getRefinedDatasetPaths(version);
try {
Optional<Long> latestRawDatasetModTime = getLatestModTime(version.getPaths());
Optional<Long> latestRefinedDatasetModTime = getLatestModTime(refinedDatasetPaths);
return latestRawDatasetModTime.isPresent() && latestRefinedDatasetModTime.isPresent()
&& latestRawDatasetModTime.get() <= latestRefinedDatasetModTime.get();
} catch (IOException e) {
throw new RuntimeException("Failed to get modification time", e);
}
}
}));
}
/**
* Apply the supplied predicate against the potential
* all possible result of the expression.
*/
static boolean valueCheck(Node n, Predicate<Node> p) {
switch (n.getType()) {
case Token.ASSIGN:
case Token.COMMA:
return valueCheck(n.getLastChild(), p);
case Token.AND:
case Token.OR:
return valueCheck(n.getFirstChild(), p)
&& valueCheck(n.getLastChild(), p);
case Token.HOOK:
return valueCheck(n.getFirstChild().getNext(), p)
&& valueCheck(n.getLastChild(), p);
default:
return p.apply(n);
}
}
/**
* @return The number of times the the predicate is true for the node
* or any of its children.
*/
static int getCount(
Node n, Predicate<Node> pred, Predicate<Node> traverseChildrenPred) {
int total = 0;
if (pred.apply(n)) {
total++;
}
if (traverseChildrenPred.apply(n)) {
for (Node c = n.getFirstChild(); c != null; c = c.getNext()) {
total += getCount(c, pred, traverseChildrenPred);
}
}
return total;
}
@Override
public Condition generate(Map<String, Object> values) {
Preconditions.checkState(attribute != null, "must specify an attribute name");
String attributeName;
Object oldValue = null;
Object newValue = null;
Predicate<Model> query = Predicates.alwaysTrue();
attributeName = FunctionFactory.toString(this.attribute.toTemplate(), values);
if(this.oldValue != null) {
oldValue = this.oldValue.toTemplate().apply(values);
}
if(this.newValue != null) {
newValue = this.newValue.toTemplate().apply(values);
}
if(this.query != null) {
query = FunctionFactory.toModelPredicate(this.query.toTemplate(), values);
}
return new ValueChangeTrigger(attributeName, oldValue, newValue, query);
}
private boolean validateResource(Resource resource) {
if (resource.getErrors().size() == 0) {
List<Issue> issues = Lists.newArrayList(filter(((XtextResource) resource).getResourceServiceProvider()
.getResourceValidator().validate(resource, CheckMode.ALL, CancelIndicator.NullImpl),
new Predicate<Issue>() {
@Override
public boolean apply(Issue issue) {
String code = issue.getCode();
return issue.getSeverity() == Severity.ERROR
&& !(IssueCodes.DUPLICATE_TYPE.equals(code) || org.eclipse.xtend.core.validation.IssueCodes.XBASE_LIB_NOT_ON_CLASSPATH
.equals(code));
}
}));
return issues.size() == 0;
}
return false;
}
/**
* Apply the supplied predicate against the potential
* all possible result of the expression.
*/
static boolean valueCheck(Node n, Predicate<Node> p) {
switch (n.getType()) {
case Token.ASSIGN:
case Token.COMMA:
return valueCheck(n.getLastChild(), p);
case Token.AND:
case Token.OR:
return valueCheck(n.getFirstChild(), p)
&& valueCheck(n.getLastChild(), p);
case Token.HOOK:
return valueCheck(n.getFirstChild().getNext(), p)
&& valueCheck(n.getLastChild(), p);
default:
return p.apply(n);
}
}
boolean removeEntriesIf(Predicate<? super Entry<K, Collection<V>>> predicate) {
Iterator<Entry<K, Collection<V>>> entryIterator = unfiltered.asMap().entrySet().iterator();
boolean changed = false;
while (entryIterator.hasNext()) {
Entry<K, Collection<V>> entry = entryIterator.next();
K key = entry.getKey();
Collection<V> collection = filterCollection(entry.getValue(), new ValuePredicate(key));
if (!collection.isEmpty() && predicate.apply(Maps.immutableEntry(key, collection))) {
if (collection.size() == entry.getValue().size()) {
entryIterator.remove();
} else {
collection.clear();
}
changed = true;
}
}
return changed;
}
protected Iterable<Issue> doMatchIssues(final Resource resource, final EClass objectType, final String code,
final int offset, final int length, final Severity severity, final List<Issue> validate,
final String... messageParts) {
return Iterables.filter(validate, new Predicate<Issue>() {
@Override
public boolean apply(Issue input) {
if (Strings.equal(input.getCode(), code) && input.getSeverity()==severity) {
if ((offset < 0 || offset == input.getOffset()) && (length < 0 || length == input.getLength())) {
EObject object = resource.getResourceSet().getEObject(input.getUriToProblem(), true);
if (objectType.isInstance(object)) {
for (String messagePart : messageParts) {
if(!isValidationMessagePartMatches(input.getMessage(), messagePart)){
return false;
}
}
return true;
}
}
}
return false;
}
});
}
public static Predicate<TileEntity> isMatchingElevator(final EnumDyeColor color)
{
return new Predicate<TileEntity> ()
{
@Override
public boolean apply(TileEntity te)
{
if ((te instanceof TileEntityElevator) == false)
{
return false;
}
IBlockState state = te.getWorld().getBlockState(te.getPos());
return state.getBlock() instanceof BlockElevator && state.getValue(BlockElevator.COLOR) == color;
}
};
}
/**
* Returns whether the EntityAIBase should begin execution.
*/
@SuppressWarnings("unchecked")
public boolean shouldExecute() {
if (this.targetChance > 0 && this.taskOwner.getRNG().nextInt(this.targetChance) != 0) {
return false;
} else if (this.targetClass != EntityPlayer.class && this.targetClass != EntityPlayerMP.class) {
List<T> list = this.taskOwner.world.getEntitiesWithinAABB(this.targetClass, this.getTargetableArea(this.getTargetDistance()), this.targetEntitySelector);
if (list.isEmpty()) {
return false;
} else {
list.sort(this.sorter);
this.targetEntity = list.get(0);
return true;
}
} else {
this.targetEntity = (T) this.taskOwner.world.getNearestAttackablePlayer(this.taskOwner.posX, this.taskOwner.posY + (double) this.taskOwner.getEyeHeight(), this.taskOwner.posZ, this.getTargetDistance(), this.getTargetDistance(), new Function<EntityPlayer, Double>() {
@Nullable
public Double apply(@Nullable EntityPlayer p_apply_1_) {
ItemStack itemstack = p_apply_1_.getItemStackFromSlot(EntityEquipmentSlot.HEAD);
if (itemstack.getItem() == Items.SKULL) {
int i = itemstack.getItemDamage();
boolean flag = EntityAINearestAttackableTargetFiltered.this.taskOwner instanceof EntitySkeleton && i == 0;
boolean flag1 = EntityAINearestAttackableTargetFiltered.this.taskOwner instanceof EntityZombie && i == 2;
boolean flag2 = EntityAINearestAttackableTargetFiltered.this.taskOwner instanceof EntityCreeper && i == 4;
if (flag || flag1 || flag2) {
return Double.valueOf(0.5D);
}
}
return Double.valueOf(1.0D);
}
}, (Predicate<EntityPlayer>) this.targetEntitySelector);
return this.targetEntity != null;
}
}
@Test
public void filters_results_by_dst_port_greater_than_value_with_query_filter() throws Exception {
PcapOptions.FILTER_IMPL.put(configuration, new QueryPcapFilter.Configurator());
PcapOptions.START_TIME_NS.put(configuration, getTimestamp(0, pcapEntries));
PcapOptions.END_TIME_NS
.put(configuration, getTimestamp(pcapEntries.size() - 1, pcapEntries) + 1);
PcapOptions.FIELDS.put(configuration, "ip_dst_port > 55790");
PcapJob<String> job = new PcapJob<>();
Statusable<Path> results = job.submit(PcapFinalizerStrategies.CLI, configuration);
assertEquals(Statusable.JobType.MAP_REDUCE, results.getJobType());
waitForJob(results);
assertEquals(JobStatus.State.SUCCEEDED, results.getStatus().getState());
Pageable<Path> resultPages = results.get();
Iterable<byte[]> bytes = Iterables.transform(resultPages, path -> {
try {
return HDFSUtils.readBytes(path);
} catch (IOException e) {
throw new IllegalStateException(e);
}
});
assertInOrder(bytes);
assertEquals(Iterables.size(filterPcaps(pcapEntries, new Predicate<JSONObject>() {
@Override
public boolean apply(@Nullable JSONObject input) {
Object prt = input.get(Constants.Fields.DST_PORT.getName());
return prt != null && (Long) prt > 55790;
}
}, withHeaders)
), resultPages.getSize()
);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
PcapMerger.merge(baos, HDFSUtils.readBytes(resultPages.getPage(0)));
assertTrue(baos.toByteArray().length > 0);
}
public InputSetFlags toInputSetFlags(Predicate<? super T> predicate) {
boolean[] finites = new boolean[finiteArityList.size()];
for (int i = 0; i < finites.length; ++i) {
finites[i] = predicate.apply(finiteArityList.get(i));
}
boolean infinite = predicate.apply(infiniteArityElement);
return new InputSetFlags(finites, infinite);
}
private Predicate<FormMapping> withType(final FormMappingType type) {
return new Predicate<FormMapping>() {
@Override
public boolean apply(final FormMapping input) {
return input.getType() == type;
}
};
}
@Test
public final void givenEvenNumbers_whenCheckingIfAllSatisfyTheEvenPredicate_thenYes() {
final List<Integer> evenNumbers = Lists.newArrayList(2, 6, 8, 10, 34, 90);
final Predicate<Integer> acceptEvenNumber = new Predicate<Integer>() {
@Override
public final boolean apply(final Integer number) {
return (number % 2) == 0;
}
};
assertTrue(Iterables.all(evenNumbers, acceptEvenNumber));
}
FilteredKeyMap(
Map<K, V> unfiltered,
Predicate<? super K> keyPredicate,
Predicate<? super Entry<K, V>> entryPredicate) {
super(unfiltered, entryPredicate);
this.keyPredicate = keyPredicate;
}
private void addCreator(String path, ClosureExpression creator) {
final ImmutableMap<String, String> referenceAliasesMap = ImmutableMap.copyOf(referenceAliases);
ReferenceExtractor extractor = new ReferenceExtractor(sourceUnit, referenceAliasesMap);
Iterators.removeIf(creator.getVariableScope().getReferencedLocalVariablesIterator(), new Predicate<Variable>() {
public boolean apply(Variable variable) {
return referenceAliasesMap.keySet().contains(variable.getName());
}
});
creator.getCode().visit(extractor);
statementGenerator.addCreator(path, creator, extractor.getReferencedPaths());
}
private EPackage findPackageInScope(EObject context, QualifiedName packageNsURI) {
IScope scopedPackages = scopeProvider.getScope(context.eResource(), XtextPackage.Literals.ABSTRACT_METAMODEL_DECLARATION__EPACKAGE, new Predicate<IEObjectDescription>() {
@Override
public boolean apply(IEObjectDescription input) {
return isNsUriIndexEntry(input);
}
});
IEObjectDescription description = scopedPackages.getSingleElement(packageNsURI);
if (description != null) {
return getResolvedEPackage(description, context);
}
return null;
}
@Override
protected Predicate<Model> doBuild() {
switch(operator) {
case IS:
return Predicates.isA(namespace);
case HAS:
return Predicates.hasA(namespace);
default:
throw new IllegalArgumentException("Unrecognized operator " + operator);
}
}
@Override
public Set<Class<? super T>> rawTypes() {
// Java has no way to express ? super T when we parameterize TypeToken vs. Class.
@SuppressWarnings({"unchecked", "rawtypes"})
ImmutableList<Class<? super T>> collectedTypes = (ImmutableList) TypeCollector.FOR_RAW_TYPE.collectTypes(getRawTypes());
return FluentIterable.from(collectedTypes).filter(new Predicate<Class<?>>() {
@Override
public boolean apply(Class<?> type) {
return type.isInterface();
}
}).toSet();
}
@Override
public Iterable<IEObjectDescription> getExportedObjectsByType(final EClass type) {
if (allDescriptions.isEmpty())
return Collections.emptyList();
return Iterables.filter(allDescriptions, new Predicate<IEObjectDescription>() {
@Override
public boolean apply(IEObjectDescription input) {
return EcoreUtil2.isAssignableFrom(type, input.getEClass());
}
});
}