org.junit.runner.Request.filterWith java code examples

Common ways to obtain Request

private void myMethod () {
     Request r =Class testClass;new ClassRequest(testClass, false)
Class testClass;new ClassRequest(testClass)
Class clazz;Request.aClass(clazz).filterWith(desiredDescription)
Smart code suggestions by Codota
}

private Request applyFilterSpecs(Request request) {
  try {
    for (String filterSpec : filterSpecs) {
      Filter filter = FilterFactories.createFilterFromFilterSpec(
          request, filterSpec);
      request = request.filterWith(filter);
    }
    return request;
  } catch (FilterNotCreatedException e) {
    return errorReport(e);
  }
}

/**
 * Returns a Request that only runs contains tests whose {@link Description}
 * equals <code>desiredDescription</code>
 *
 * @param desiredDescription {@link Description} of those tests that should be run
 * @return the filtered Request
 */
public Request filterWith(final Description desiredDescription) {
  return filterWith(Filter.matchMethodDescription(desiredDescription));
}

/**
 * Create a <code>Request</code> that, when processed, will run a single test.
 * This is done by filtering out all other tests. This method is used to support rerunning
 * single tests.
 *
 * @param clazz the class of the test
 * @param methodName the name of the test
 * @return a <code>Request</code> that will cause a single test be run
 */
public static Request method(Class<?> clazz, String methodName) {
  Description method = Description.createTestDescription(clazz, methodName);
  return Request.aClass(clazz).filterWith(method);
}

core.addListener(new RL());
Request r = Request.aClass(testCase);
return core.run(r.filterWith(new Filter() {

Request request = Request.classes(...
 Filter filter = new Filter() {
   @Override
   public boolean shouldRun(Description description) {
     ... get class and method and decide...
   }
   @Override
   public String describe() {
     return null;
   }
 };
 request.filterWith(filter);

 Request request = ...
Categories.CategoryFilter filter =
  Categories.CategoryFilter.include(
    testutils.SlowTests.class); 
request = request.filterWith(filter);
Result result = JUnitCore.run(request);

private Request applyFilterSpecs(Request request) {
  try {
    for (String filterSpec : filterSpecs) {
      Filter filter = FilterFactories.createFilterFromFilterSpec(
          request, filterSpec);
      request = request.filterWith(filter);
    }
    return request;
  } catch (FilterNotCreatedException e) {
    return errorReport(e);
  }
}

/**
 * Returns a Request that only runs tests whose {@link Description}
 * matches the given description.
 *
 * <p>Returns an empty {@code Request} if {@code desiredDescription} is not a single test and filters all but the single
 * test if {@code desiredDescription} is a single test.</p>
 *
 * @param desiredDescription {@code Description} of those tests that should be run
 * @return the filtered Request
 */
public Request filterWith(Description desiredDescription) {
  return filterWith(Filter.matchMethodDescription(desiredDescription));
}

/**
 * Returns a Request that only runs contains tests whose {@link Description}
 * equals <code>desiredDescription</code>
 *
 * @param desiredDescription {@link Description} of those tests that should be run
 * @return the filtered Request
 */
public Request filterWith(final Description desiredDescription) {
  return filterWith(Filter.matchMethodDescription(desiredDescription));
}

/**
 * Create a <code>Request</code> that, when processed, will run a single test.
 * This is done by filtering out all other tests. This method is used to support rerunning
 * single tests.
 *
 * @param clazz the class of the test
 * @param methodName the name of the test
 * @return a <code>Request</code> that will cause a single test be run
 */
public static Request method(Class<?> clazz, String methodName) {
  Description method = Description.createTestDescription(clazz, methodName);
  return Request.aClass(clazz).filterWith(method);
}

/**
 * Create a <code>Request</code> that, when processed, will run a single test.
 * This is done by filtering out all other tests. This method is used to support rerunning
 * single tests.
 *
 * @param clazz the class of the test
 * @param methodName the name of the test
 * @return a <code>Request</code> that will cause a single test be run
 */
public static Request method(Class<?> clazz, String methodName) {
  Description method = Description.createTestDescription(clazz, methodName);
  return Request.aClass(clazz).filterWith(method);
}

private Request applyFilterSpecs(Request request) {
  try {
    for (String filterSpec : filterSpecs) {
      Filter filter = FilterFactories.createFilterFromFilterSpec(
          request, filterSpec);
      request = request.filterWith(filter);
    }
    return request;
  } catch (FilterNotCreatedException e) {
    return errorReport(e);
  }
}

private Request applyFilterSpecs(Request request) {
  try {
    for (String filterSpec : filterSpecs) {
      Filter filter = FilterFactories.createFilterFromFilterSpec(
          request, filterSpec);
      request = request.filterWith(filter);
    }
    return request;
  } catch (FilterNotCreatedException e) {
    return errorReport(e);
  }
}

/**
 * Returns a Request that only runs contains tests whose {@link Description}
 * equals <code>desiredDescription</code>
 *
 * @param desiredDescription {@link Description} of those tests that should be run
 * @return the filtered Request
 */
public Request filterWith(final Description desiredDescription) {
  return filterWith(Filter.matchMethodDescription(desiredDescription));
}

/**
 * Returns a Request that only runs contains tests whose {@link Description}
 * equals <code>desiredDescription</code>
 *
 * @param desiredDescription {@link Description} of those tests that should be run
 * @return the filtered Request
 */
public Request filterWith(final Description desiredDescription) {
  return filterWith(Filter.matchMethodDescription(desiredDescription));
}

Javadoc

Returns a Request that only runs contains tests whose Descriptionequals desiredDescription

Popular methods of Request

getRunner
Returns a Runner for this Request
aClass
Create a Request that, when processed, will run all the tests in a class. The odd name is necessary
classes
Create a Request that, when processed, will run all the tests in a set of classes with the default C
method
Create a Request that, when processed, will run a single test. This is done by filtering out all oth
classWithoutSuiteMethod
Create a Request that, when processed, will run all the tests in a class. If the class has a suite()
runner
errorReport
Creates a Request that, when processed, will report an error for the given test class with the given

Popular classes and methods

getSystemService (Context)
getApplicationContext (Context)
getOriginalFilename (MultipartFile)
BufferedWriter (java.io)
Wraps an existing Writer and buffers the output. Expensive interaction with the underlying reader is
MessageFormat (java.text)
Produces concatenated messages in language-neutral way. New code should probably use java.util.Forma
Enumeration (java.util)
A legacy iteration interface.New code should use Iterator instead. Iterator replaces the enumeration
StringTokenizer (java.util)
Breaks a string into tokens; new code should probably use String#split.> // Legacy code: StringTo
Servlet (javax.servlet)
Defines methods that all servlets must implement.A servlet is a small Java program that runs within
DataSource (javax.sql)
An interface for the creation of Connection objects which represent a connection to a database. This
Reflections (org.reflections)
Reflections one-stop-shop objectReflections scans your classpath, indexes the metadata, allows you t

Best code snippets using org.junit.runner.Request.filterWith(Showing top 15 results out of 315)