Public

Creates an empty named test suite. The declared will be assigned to tests added
to this test suite t

<init>

If the suite is not a ProxyTestSuite, then the tests in the suite are
recursively enumerated and a p

addTest

We override the implementation of TestSuite#addTestSuite(Class theClass) to wrap
thetestClass in ano

addTestSuite

Returns the delegate supplied to the constructor.

getDelegate

 Invoked automatically by the constructors.

checkDelegate

 Sets the delegate on each instantiated Test that implements IProxyTest.

flowDown

OutputStreamWriter

Reading from database using SQL prepared statement

Wraps an existing Writer and buffers the output. Expensive interaction with the
underlying reader is

java.io.BufferedWriter

This class represents a server-side socket that waits for incoming client
connections. A ServerSocke

java.net.ServerSocket

Produces concatenated messages in language-neutral way. New code should probably
use java.util.Forma

java.text.MessageFormat

A Properties object is a Hashtable where the keys and values must be Strings.
Each property can have

java.util.Properties

javax.swing.JList

scala.Option

getContentResolver

getResourceAsStream

getSupportFragmentManager

/**
 * 
 * Sets the delegate on each instantiated {@link Test} that implements
 * {@link IProxyTest}.
 * 
 */

/**
 * If the suite is not a {@link ProxyTestSuite}, then the tests in the
 * suite are recursively enumerated and a proxy test suite is created with
 * the same name and tests. This ensures that the common delegate flows down
 * through all tests even when using the traditional
 * <code>static Test suite() {...}</code> construction.
 * 
 * @param test
 * A test.
 */

/*
             * The delegate will be null if this method gets invoked from the
             * super class constructor since that will happen before we have a
             * chance to set the [m_delegate] field.  The constructors handle
             * this situation by explictly flowing down the delegate after the
             * super class constructor has been invoked.
             */

/*
             * Flow down the delegate to any container IProxyTest instances.
             */

/**
 * 
 * A simple wrapper around {@link TestSuite} that permits the caller to specify
 * the delegate {@link Test} for either directly or recursively contained
 * {@link IProxyTest}s added to a {@link ProxyTestSuite}. There are three cases
 * for junit:
 * <ol>
 * <li>An instantiated test. This is an instance of some class that extends
 * {@link TestCase}. If the class implements {@link IProxyTest} then the
 * delegate will be set on the test instance and will be available when
 * that test runs.</li>
 * <li>A test case. This is a class named to
 * {@link TestSuite#addTestSuite(java.lang.Class)}. That method scans the test
 * case class and generates an instantiated test for each conforming test method
 * identified in the test case. The delegate is then set per above.</li>
 * <li>A test suite. The delegate declared in a {@link ProxyTestSuite}
 * constructor will be flowed down to each test added either directly or
 * indirectly to that {@link ProxyTestSuite}. The various constructors all
 * invoke this method to flow down the delegate. In addition, the
 * {@link #addTest(Test)} and {@link #addTestSuite(Class)} methods also
 * invoke this method to flow down the delegate to instantiated tests that
 * implement {@link IProxyTest}.</li>
 * </ol>
 * 
 * 
 * The only case when flow down does not occur is when you have created a
 * standard test suite, addeded it to a proxy test suite, and then
 * you add additional tests to the standard test suite. There is no event
 * notification model in junit and this action is not noticed by the {@link
 * ProxyTestSuite}.
 * 
 */

/**
     * The {@link Logger} is named for this class.
     */

/**
     * The delegate that will be used by each {@link IProxyTest}added to this
     * {@link ProxyTestSuite}.
     */

/**
 * 
 * Invoked automatically by the constructors.
 * 
 * 
 * @exception IllegalArgumentException
 * if the delegate is <code>null</code>.
 */

//            throw new IllegalStateException("The delegate is already set.");

/**
 * Returns the delegate supplied to the constructor.
 */

/**
 * Creates an empty unnamed test suite. The delegate will be
 * assigned to tests added to this test suite that implement
 * {@link IProxyTest}.
 * 
 * @param delegate
 * The delegate (non-null).
 */

/**
 * Creates a named test suite and populates it with test instances
 * identified by scanning the testClass . The delegate will
 * be assigned to tests added to this test suite that implement
 * {@link IProxyTest}, including those created from testClass .
 * 
 * @param delegate
 * The delegate (non-null).
 * @param testClass
 * A class containing one or more tests.
 * @param name
 * The name of the test suite (optional).
 */

/*
	 * Let the super class do all the heavy lifting. Note that it can not set
	 * the delegate for us since we can not set our private fields until after
	 * we have invoked the super class constructor.
	 */

/*
	 * Apply delegate to all instantiated tests that were created by
	 * junit from testClass and which implement IProxyTest.
	 */

/**
 * Creates an unnamed test suite and populates it with test instances
 * identified by scanning the testClass . The delegate will
 * be assigned to tests added to this test suite that implement
 * {@link IProxyTest}, including those created from testClass .
 * 
 * @param delegate
 * The delegate (non-null).
 * @param testClass
 * A class containing one or more tests.
 */

/**
     * Creates an empty named test suite. The declared will be assigned to tests
     * added to this test suite that implement {@link IProxyTest}.
     * 
     * @param delegate
     *            The delegate (non-null).
     * @param name
     *            The test suite name (optional).
     */

/**
 * We override the implementation of {@link
 * TestSuite#addTestSuite( Class theClass )} to wrap the
 * testClass in another instance of this {@link
 * ProxyTestSuite} class using the same delegate that was provided
 * to our constructor. This causes the delegation to be inherited
 * by any recursively contained testClass which implements
 * {@link IProxyTest}.
 */

/*
             * The delegate will be null if this method gets invoked from the
             * super class constructor since that will happen before we have a
             * chance to set the [m_delegate] field. The constructors handle
             * this situation by explictly flowing down the delegate after the
             * super class constructor has been invoked.
             */

// This is the default implementation from TestSuite:

// Our implementation just substitutes new ProxyTestSuite(

// delegate, testClass ) for new TestSuite( testClass ).

How to use flowDownmethodin junit.extensions.proxy.ProxyTestSuite

Best Java code snippets using junit.extensions.proxy.ProxyTestSuite.flowDown (Showing top 8 results out of 315)

How to use
flowDown
method
in
junit.extensions.proxy.ProxyTestSuite