org.hamcrest.FeatureMatcher Java Examples

@Override
public boolean matches(RestClientCall argument) {
  invalidMatcherList.clear();
  mismatchDescription = new StringDescription();
  for (Pair<FeatureMatcher, Function<RestClientCall, ?>> pair : featureMatcherList) {
    FeatureMatcher featureMatcher = pair.getLeft();
    featureMatcher.describeMismatch(argument, mismatchDescription);

    if (!featureMatcher.matches(argument)) {
      Function<RestClientCall, ?> valueExtractor = pair.getRight();
      Object apply = argument == null ? null : valueExtractor.apply(argument);
      invalidMatcherList.add(Pair.of(featureMatcher, apply));
    }
  }
  boolean isValid = invalidMatcherList.size() == 0;
  if (isValid) {
    captureArgumentValues(argument);
  }
  return isValid;
}
 

public String toString() {
  if (invalidMatcherList.isEmpty()) {
    String validMatchers =
        featureMatcherList.stream()
            .map(Pair::getLeft)
            .map(BaseMatcher::toString)
            .collect(Collectors.joining(","));

    return "All matchers suceeded: " + validMatchers;
  }

  Description description = new StringDescription();
  // result.append("A ClientCall with the following properties:");
  for (Pair<FeatureMatcher, Object> pair : invalidMatcherList) {
    FeatureMatcher invalidMatcher = pair.getLeft();

    description.appendText("Expecting '");
    invalidMatcher.describeTo(description);
    description.appendText("', but got values:").appendValue(pair.getRight());
  }

  return description.toString();
}
 

public static <T> Matcher<Task<? extends T>> taskId(Matcher<TaskId> taskIdMatcher) {
  return new FeatureMatcher<Task<? extends T>, TaskId>(taskIdMatcher, "Task with id", "taskId") {
    @Override
    protected TaskId featureValueOf(Task<? extends T> actual) {
      return actual.id();
    }
  };
}
 

private static Matcher<Either<? extends Throwable, Evaluation>> hasCompilationError() {
    return new FeatureMatcher<Either<? extends Throwable, Evaluation>, Object>(Matchers.<Object>is(instanceOf(ExpressionCompilationException.class)), "result value", "result value") {
        protected Throwable featureValueOf(Either<? extends Throwable, Evaluation> evaluation) {
            return evaluation.left();
        }
    };
}
 

private Matcher<Request> hasAuthorisationHeader(String authHeader) {
    return new FeatureMatcher<Request, String>(equalTo(authHeader),
            "Authorisation header",
            "Unexpected auth header") {
        @Override protected String featureValueOf(Request actual) {
            return actual.header(AUTHORIZATION);
        }
    };
}
 

private Matcher<Job> hasMetadata(final Matcher<Map<String, String>> matcher) {
  return new FeatureMatcher<Job, Map<String, String>>(matcher, "metadata", "metadata") {
    @Override
    protected Map<String, String> featureValueOf(final Job actual) {
      return actual.getMetadata();
    }
  };
}
 

/** A Matcher that tests that the URI has a path equal to the given path. */
private static Matcher<URI> hasPath(final String path) {
  return new FeatureMatcher<URI, String>(Matchers.equalTo(path), "path", "path") {
    @Override
    protected String featureValueOf(final URI actual) {
      return actual.getPath();
    }
  };
}
 

/**
 * Creates a matcher that matches when the examined watermark has the given timestamp.
 */
public static Matcher<Watermark> legacyWatermark(long timestamp) {
	return new FeatureMatcher<Watermark, Long>(
			equalTo(timestamp),
			"a watermark with value",
			"value of watermark"
	) {
		@Override
		protected Long featureValueOf(Watermark actual) {
			return actual.getTimestamp();
		}
	};
}
 

private Matcher<XCScheme.TestableReference> testableReferenceWithName(String name) {
  return new FeatureMatcher<XCScheme.TestableReference, String>(
      equalTo(name), "TestableReference named", "name") {
    @Override
    protected String featureValueOf(XCScheme.TestableReference testableReference) {
      return testableReference.getBuildableReference().blueprintName;
    }
  };
}
 

private static Matcher<SqlNode> hasLikeClause(Matcher<SqlTableLike> likeMatcher) {
	return new FeatureMatcher<SqlNode, SqlTableLike>(
		likeMatcher,
		"create table statement has like clause",
		"like clause") {

		@Override
		protected SqlTableLike featureValueOf(SqlNode actual) {
			if (!(actual instanceof SqlCreateTable)) {
				throw new AssertionError("Node is not a CREATE TABLE stmt.");
			}
			return ((SqlCreateTable) actual).getTableLike().orElse(null);
		}
	};
}
 

public static Matcher<Settings> hasKey(String key) {
    return new FeatureMatcher<>(equalTo(true), key, "hasKey") {
        @Override
        protected Boolean featureValueOf(Settings actual) {
            return actual.keySet().contains(key);
        }
    };
}
 

public static Matcher<SQLResponse> isPrintedTable(String expectedPrintedResponse) {
    return new FeatureMatcher<>(equalTo(expectedPrintedResponse), "same output", "printedTable") {
        @Override
        protected String featureValueOf(SQLResponse actual) {
            return printedTable(actual.rows());
        }
    };
}
 

private static Matcher<ImageRef> hasRegistryUrl(final String expected) {
  return new FeatureMatcher<ImageRef, String>(equalTo(expected),
      "registryNameUrl", "registryNameUrl") {
    @Override
    protected String featureValueOf(final ImageRef actual) {
      return actual.getRegistryUrl();
    }
  };
}
 

private static Matcher<ImageRef> hasRegistry(final String expected) {
  return new FeatureMatcher<ImageRef, String>(equalTo(expected), "registryName", "registryName") {
    @Override
    protected String featureValueOf(final ImageRef actual) {
      return actual.getRegistryName();
    }
  };
}
 

/**
 * Matcher for the message of an Exception.
 *
 * @param matcher
 *         Matcher for the exception message
 * @return The Matcher
 */
public static Matcher<Exception> message(final Matcher<String> matcher) {
    return new FeatureMatcher<Exception, String>(matcher, "exception message", "exception message") {
        @Override
        protected String featureValueOf(Exception e) {
            return e.getMessage();
        }
    };
}
 

/**
 * Matcher for the value of {@link java.sql.SQLException#getSQLState()}.
 *
 * @param matcher
 *         Matcher for the value of the SQL State
 * @return The Matcher
 */
public static Matcher<SQLException> sqlState(final Matcher<String> matcher) {
    return new FeatureMatcher<SQLException, String>(matcher, "SQL state", "SQL state") {
        @Override
        protected String featureValueOf(SQLException e) {
            return e.getSQLState();
        }
    };
}
 

private Matcher<XCScheme.BuildActionEntry> withNameAndBuildingFor(
    String name, Matcher<? super EnumSet<XCScheme.BuildActionEntry.BuildFor>> buildFor) {
  return AllOf.allOf(
      buildActionEntryWithName(name),
      new FeatureMatcher<XCScheme.BuildActionEntry, EnumSet<XCScheme.BuildActionEntry.BuildFor>>(
          buildFor, "Building for", "BuildFor") {
        @Override
        protected EnumSet<XCScheme.BuildActionEntry.BuildFor> featureValueOf(
            XCScheme.BuildActionEntry entry) {
          return entry.getBuildFor();
        }
      });
}
 

public static Matcher<DataType> hasLogicalType(LogicalType logicalType) {
	return new FeatureMatcher<DataType, LogicalType>(
			CoreMatchers.equalTo(logicalType),
			"logical type of the data type",
			"logical type") {

		@Override
		protected LogicalType featureValueOf(DataType actual) {
			return actual.getLogicalType();
		}
	};
}
 

public static Matcher<InternalResult<?>> isInternalResult(Matcher<?> valueMatcher, Iterable<String> warnings) {
    return new FeatureMatcher<InternalResult<?>, Result<?>>(isResult(valueMatcher, warnings), "InternalResult as Result", "Result") {
        @Override
        protected Result<?> featureValueOf(InternalResult<?> actual) {
            return actual.toResult();
        }
    };
}
 

public static FeatureMatcher<Component, String> name(Matcher<String> matcher) {
  return new FeatureMatcher<Component, String>(matcher, "name", "name")
  {
    @Override
    protected String featureValueOf(Component actual) {
      return actual.name();
    }
  };
}
 

public static FeatureMatcher<Asset, String> path(Matcher<String> matcher) {
  return new FeatureMatcher<Asset, String>(matcher, "path", "path")
  {
    @Override
    protected String featureValueOf(Asset actual) {
      return actual.path();
    }
  };
}
 

private static org.hamcrest.Matcher<CompletionProposal> proposalThat(org.hamcrest.Matcher<String> matcher) {
	return new FeatureMatcher<CompletionProposal, String>(matcher, "a proposal whose text", "text") {
		@Override
		protected String featureValueOf(CompletionProposal actual) {
			return actual.getText();
		}
	};
}
 

/**
 * Matches if the File exists.
 *
 * @return the Matcher.
 */
public static Matcher<File> exists() {
    return new FeatureMatcher<File, Boolean>(is(true), "file exists", "file exists") {
        @Override
        protected Boolean featureValueOf(final File actual) {
            return actual.exists();
        }
    };
}
 

private static Matcher<PipelineOptionSpec> shouldSerialize() {
  return new FeatureMatcher<PipelineOptionSpec, Boolean>(
      equalTo(true), "should serialize", "shouldSerialize") {

    @Override
    protected Boolean featureValueOf(PipelineOptionSpec actual) {
      return actual.shouldSerialize();
    }
  };
}
 

private static Matcher<PipelineOptionSpec> hasGetter(String methodName) {
  return new FeatureMatcher<PipelineOptionSpec, String>(is(methodName), "getter method", "name") {
    @Override
    protected String featureValueOf(PipelineOptionSpec actual) {
      return actual.getGetterMethod().getName();
    }
  };
}
 

private static Matcher<PipelineOptionSpec> hasClass(Class<?> clazz) {
  return new FeatureMatcher<PipelineOptionSpec, Class<?>>(
      Matchers.<Class<?>>is(clazz), "defining class", "class") {
    @Override
    protected Class<?> featureValueOf(PipelineOptionSpec actual) {
      return actual.getDefiningInterface();
    }
  };
}
 

private static Matcher<PipelineOptionSpec> hasName(Matcher<String> matcher) {
  return new FeatureMatcher<PipelineOptionSpec, String>(matcher, "name", "name") {
    @Override
    protected String featureValueOf(PipelineOptionSpec actual) {
      return actual.getName();
    }
  };
}
 

/**
 * Creates a matcher that matches if the examined {@link DisplayData.Item} has a label matching
 * the specified label matcher.
 */
public static Matcher<DisplayData.Item> hasLabel(Matcher<String> labelMatcher) {
  return new FeatureMatcher<DisplayData.Item, String>(
      labelMatcher, "display item with label", "label") {
    @Override
    protected String featureValueOf(DisplayData.Item actual) {
      return actual.getLabel();
    }
  };
}
 

/**
 * Creates a matcher that matches if the examined {@link DisplayData.Item} contains a value
 * matching the specified value matcher.
 */
public static <T> Matcher<DisplayData.Item> hasValue(Matcher<T> valueMatcher) {
  return new FeatureMatcher<DisplayData.Item, T>(valueMatcher, "with value", "value") {
    @Override
    protected T featureValueOf(DisplayData.Item actual) {
      @SuppressWarnings("unchecked")
      T value = (T) actual.getValue();
      return value;
    }
  };
}
 

/**
 * Creates a matcher that matches if the examined {@link DisplayData.Item} has a type matching the
 * specified type matcher.
 */
public static Matcher<DisplayData.Item> hasType(Matcher<DisplayData.Type> typeMatcher) {
  return new FeatureMatcher<DisplayData.Item, DisplayData.Type>(
      typeMatcher, "with type", "type") {
    @Override
    protected DisplayData.Type featureValueOf(DisplayData.Item actual) {
      return actual.getType();
    }
  };
}