Merge lp:~yshavit/namedparameterizedrunner/init_dump into lp:namedparameterizedrunner

[Yuval Shavit]

Initial commit, copied from lp:akiban-server/trunk

=== added file '.bzrignore'
--- .bzrignore	1970-01-01 00:00:00 +0000
+++ .bzrignore	2011-09-08 16:01:22 +0000
@@ -0,0 +1,4 @@
+named-parameterized-runner.iml
+named-parameterized-runner.ipr
+named-parameterized-runner.iws
+./target
 
=== added file 'pom.xml'
--- pom.xml	1970-01-01 00:00:00 +0000
+++ pom.xml	2011-09-08 16:01:22 +0000
@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project>
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.motpot</groupId>
+    <artifactId>named-parameterized-runner</artifactId>
+    <packaging>jar</packaging>
+    <version>0.8.0</version>
+    <name>named-parameterized-runner</name>
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.8.1</version>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+            <version>1.6.1</version>
+        </dependency>
+    </dependencies>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <version>2.2</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>test-jar</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>2.3.2</version>
+                <configuration>
+                    <source>1.6</source>
+                    <target>1.6</target>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-source-plugin</artifactId>
+                <version>2.1.2</version>
+                <executions>
+                    <execution>
+                        <id>attach-sources</id>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>jar</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-surefire-plugin</artifactId>
+            <version>2.6</version>
+        </plugin>
+    </plugins>
+</build>
+
+</project>
+
 
=== added directory 'src'
=== added directory 'src/main'
=== added directory 'src/main/java'
=== added directory 'src/main/java/com'
=== added directory 'src/main/java/com/motpot'
=== added directory 'src/main/java/com/motpot/npr'
=== added file 'src/main/java/com/motpot/npr/Failing.java'
--- src/main/java/com/motpot/npr/Failing.java	1970-01-01 00:00:00 +0000
+++ src/main/java/com/motpot/npr/Failing.java	2011-09-08 16:01:22 +0000
@@ -0,0 +1,22 @@
+package com.motpot.npr;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Represents a failing test.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface Failing
+{
+    /**
+     * For parameterized tests, the optional list of parameterizations that are failing.
+     *
+     * This is ignored by non-parameterized class runners. For parameterized runners,
+     * not specifying this value means that all parameterizations are failing.
+     */
+    String[] value() default {};
+}
 
=== added file 'src/main/java/com/motpot/npr/NamedParameterizedRunner.java'
--- src/main/java/com/motpot/npr/NamedParameterizedRunner.java	1970-01-01 00:00:00 +0000
+++ src/main/java/com/motpot/npr/NamedParameterizedRunner.java	2011-09-08 16:01:22 +0000
@@ -0,0 +1,570 @@
+package com.motpot.npr;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.junit.Ignore;
+import org.junit.internal.builders.IgnoredClassRunner;
+import org.junit.runner.Runner;
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runners.BlockJUnit4ClassRunner;
+import org.junit.runners.Suite;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.Statement;
+import org.junit.runners.model.TestClass;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.*;
+import java.util.regex.Pattern;
+
+public final class NamedParameterizedRunner extends Suite
+{
+    /**
+     * <p>Parameterization override filter (works by name).</p>
+     *
+     * <p>If this property is set, then only parameterization names that match its value will be processed. These
+     * names behave like @Failing names (in terms of regexes, etc). If this property is set and a test that matches
+     * it is marked as @Failing, that test will still get run. For instance, if a parameterization named
+     * <tt>myFooTest</tt> is marked as failing for a given test (either because the entire parameterization is marked
+     * as failing, or because of a <tt>@Failing</tt> annotation on the method), and if you have a system property
+     * <tt>{@value} == "/myFoo/"</tt>, then the test <em>will</em> be run.
+     */
+    public final static String PARAMETERIZATION_OVERRIDE = "test.params";
+	/**
+	 * <p>Annotation for a method which provides parameters for an
+     * {@link NamedParameterizedRunner} suite.</p>
+     *
+     * <p>A class that is run with {@linkplain NamedParameterizedRunner} <em>must</em> have exactly one method
+     * marked with this annotation, and that method must:</p>
+     * <ul>
+     *  <li>be public</li>
+     *  <li>be static</li>
+     *  <li>take no arguments</li>
+     *  <li>return Collection of {@link Parameterization} objects.</li>
+     * </ul>
+	 */
+	@Retention(RetentionPolicy.RUNTIME)
+	@Target(ElementType.METHOD)
+	public static @interface TestParameters {
+	}
+
+    private final static Logger logger = LoggerFactory.getLogger(NamedParameterizedRunner.class);
+    private final List<Runner> runners;
+
+    /**
+     * Adapted from {@link org.junit.runners.Parameterized}'s nested class
+     * @see
+     */
+    static class ReifiedParamRunner extends BlockJUnit4ClassRunner
+    {
+        private final Parameterization parameterization;
+        private final boolean overrideOn;
+        private Object testObject = null;
+
+        private static class OnlyIfErrorFrameworkMethod extends FrameworkMethod {
+            private final OnlyIfException exception;
+
+            private OnlyIfErrorFrameworkMethod(Method method, OnlyIfException exception) {
+                super(method);
+                this.exception = exception;
+            }
+
+            @Override
+            public Object invokeExplosively(Object target, Object... params) throws Throwable {
+                throw exception;
+            }
+        }
+
+        public ReifiedParamRunner(Class<?> klass, Parameterization parameterization, boolean overrideOn)
+                throws InitializationError
+        {
+            super(klass);
+            this.parameterization = parameterization;
+            this.overrideOn = overrideOn;
+        }
+
+        /**
+         * For debugging.
+         * @return parameterization.toString()
+         * @throws NullPointerException if parameterization is null
+         */
+        String paramToString()
+        {
+            return parameterization.toString();
+        }
+
+        /**
+         * For debugging
+         * @return the override value
+         */
+        boolean overrideOn()
+        {
+            return overrideOn;
+        }
+
+        /**
+         * For debugging.
+         * @param name the name of the child FrameworkMethod to get
+         * @return the child, or null if it doesn't exist
+         */
+        FrameworkMethod getChild(String name)
+        {
+            for (FrameworkMethod method : getChildren())
+            {
+                if (method.getMethod().toString().equals(name))
+                {
+                    return method;
+                }
+            }
+            return null;
+        }
+
+        /**
+         * For debugging
+         * @return the number of children in this runner
+         */
+        int getChildrenCount() {
+            return getChildren().size();
+        }
+
+        /**
+         * For debugging (and only for assertion messages)
+         * @return shows human-readable info about the children
+         */
+        String describeChildren() {
+            List<FrameworkMethod> children = getChildren();
+            if (children == null) {
+                return "null";
+            }
+            List<String> descriptions = new ArrayList<String>(children.size());
+            for (FrameworkMethod method : children) {
+                descriptions.add( method.getName() );
+            }
+            return descriptions.toString();
+        }
+
+        @Override
+        public Object createTest() throws Exception
+        {
+            if (testObject != null) {
+                return testObject;
+            }
+            try
+            {
+                testObject = getTestClass().getOnlyConstructor().newInstance(parameterization.getArguments());
+                return testObject;
+            }
+            catch(IllegalArgumentException e)
+            {
+                throw new IllegalArgumentException("parameters: " + Arrays.toString(parameterization.getArguments()), e);
+            }
+        }
+
+        @Override
+        protected List<FrameworkMethod> getChildren() {
+            List<FrameworkMethod> ret = super.getChildren();
+            for(ListIterator<FrameworkMethod> iter = ret.listIterator(); iter.hasNext(); ) {
+                FrameworkMethod frameworkMethod = iter.next();
+                try {
+                    if (!onlyIfFilter(frameworkMethod)) {
+                        iter.remove();
+                    }
+                } catch (OnlyIfException e) {
+                    iter.set(new OnlyIfErrorFrameworkMethod(frameworkMethod.getMethod(), e));
+                }
+            }
+            return ret;
+        }
+
+        @Override
+        public String getName()
+        {
+            return parameterization.getName();
+        }
+
+        @Override
+        public String testName(FrameworkMethod method)
+        {
+            return String.format("%s [%s]", method.getName(), parameterization.getName());
+        }
+
+		@Override
+		protected void validateConstructor(List<Throwable> errors)
+        {
+			validateOnlyOneConstructor(errors);
+		}
+
+		@Override
+		protected Statement classBlock(RunNotifier notifier)
+        {
+			return childrenInvoker(notifier);
+		}
+
+        @Override
+        protected void runChild(FrameworkMethod method, RunNotifier notifier)
+        {
+            if (expectedToPass(method))
+            {
+                super.runChild(method, notifier);
+            }
+            else
+            {
+                notifier.fireTestIgnored( describeChild(method));
+            }
+        }
+
+        private static class OnlyIfException extends Exception {
+            private OnlyIfException(String message, Throwable cause) {
+                super(message, cause);
+            }
+
+            private OnlyIfException(String message) {
+                super(message);
+            }
+        }
+
+        boolean onlyIfFilter(FrameworkMethod method) throws OnlyIfException {
+            OnlyIf onlyIf = method.getAnnotation(OnlyIf.class);
+            if (onlyIf != null) {
+                if (!runOnlyIf(onlyIf.value(), true)) {
+                    return false;
+                }
+            }
+            OnlyIfNot onlyIfNot = method.getAnnotation(OnlyIfNot.class);
+            return onlyIfNot == null || runOnlyIf(onlyIfNot.value(), false);
+        }
+
+        private boolean runOnlyIf(String methodName, boolean mustEqual) throws OnlyIfException {
+            boolean result;
+            if (methodName.endsWith("()")) {
+                methodName = methodName.substring(0, methodName.length() - 2); // snip off the "()"
+                result = execOnlyIfMethod(methodName);
+            }
+            else {
+                result = getOnlyIfField(methodName);
+            }
+            return result == mustEqual;
+        }
+
+
+        private boolean execOnlyIfMethod(String methodName) throws OnlyIfException {
+            final Object result;
+            final Method onlyIfMethod;
+            final Class<?> testClass = getTestClass().getJavaClass();
+            try {
+                onlyIfMethod = testClass.getMethod(methodName);
+            } catch (NoSuchMethodException e) {
+                throw new OnlyIfException("no such method: public boolean " + methodName + "()", e);
+            }
+            if (!onlyIfMethod.getReturnType().equals(boolean.class)) {
+                throw new OnlyIfException("no such method: public boolean " + methodName + "()");
+            }
+            try {
+                Object test = createTest();
+                result = onlyIfMethod.invoke(test);
+            } catch (Exception e) {
+                throw new OnlyIfException("couldn't invoke " + methodName + "()", e);
+            }
+            try {
+                return (Boolean) result;
+            } catch (ClassCastException e) {
+                throw new OnlyIfException("method " + methodName + "() didn't return boolean", e);
+            }
+        }
+
+        private boolean getOnlyIfField(String fieldName) throws OnlyIfException {
+            final Class<?> testClass = getTestClass().getJavaClass();
+            final Field field;
+            try {
+                field = testClass.getField(fieldName);
+            } catch (Exception e) {
+                throw new OnlyIfException("Can't get field: " + fieldName, e);
+            }
+            try {
+                Object test = createTest();
+                return field.getBoolean(test);
+            } catch (Exception e) {
+                throw new OnlyIfException("couldn't get boolean field " + fieldName + "()", e);
+            }
+        }
+
+        boolean expectedToPass(FrameworkMethod method)
+        {
+            if (overrideOn)
+            {
+                return true;
+            }
+            if (! parameterization.expectedToPass())
+            {
+                return false;
+            }
+            Failing failing = method.getAnnotation(Failing.class);
+            if (failing == null)
+            {
+                return true;
+            }
+            if (failing.value().length == 0)
+            {
+                return false;
+            }
+
+            for (final String paramName : failing.value())
+            {
+                if (paramNameUsesRegex(paramName))
+                {
+                    if (paramNameMatchesRegex(parameterization.getName(), paramName))
+                    {
+                        return false;
+                    }
+                }
+                else if (parameterization.getName().equals(paramName))
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+
+    static boolean paramNameUsesRegex(String paramName)
+    {
+        return paramName.length() > 2
+                && (paramName.charAt(0)=='/')
+                && (paramName.charAt(paramName.length()-1)=='/');
+    }
+
+    /**
+     * Returns whether a given parameterization matches a given regex. The regex should be in "/regex/" format.
+     * @param paramName the haystack, as it were
+     * @param paramRegex a string that starts and ends with '/', and between them has a needle.
+     * @return whether the paramRegex is found in paramName
+     */
+    static boolean paramNameMatchesRegex(String paramName, String paramRegex)
+    {
+        assert paramRegex.charAt(0)=='/';
+        assert paramRegex.charAt(paramRegex.length()-1)=='/';
+        assert paramRegex.length() > 2;
+        String regex = paramRegex.substring(1, paramRegex.length()-1);
+        return Pattern.compile(regex).matcher(paramName).find();
+    }
+
+    @SuppressWarnings("unused") // Invoked by reflection
+	public NamedParameterizedRunner(Class<?> klass) throws Throwable
+    {
+        super(klass, Collections.<Runner>emptyList());
+
+        if (getTestClass().getJavaClass().getAnnotation(Ignore.class) != null)
+        {
+            runners = Collections.unmodifiableList(Arrays.asList((Runner)new IgnoredClassRunner(klass)));
+            return;
+        }
+
+        List<Runner> localRunners = new LinkedList<Runner>();
+
+        Collection<Parameterization> parameterizations = getParameterizations();
+        checkFailingParameterizations(parameterizations);
+
+        final String override = System.getProperty(PARAMETERIZATION_OVERRIDE);
+        final boolean overrideIsRegex = (override != null) && paramNameUsesRegex(override);
+        if (override != null)
+        {
+            String msg = "Override is set to";
+            if (overrideIsRegex)
+            {
+                msg += " regex";
+            }
+            msg += ":" + override;
+            logger.info(msg);
+        }
+        for (Parameterization param : parameterizations)
+        {
+            final boolean useThisParam;
+            if (override == null)
+            {
+                useThisParam = true;
+            }
+            else if (overrideIsRegex)
+            {
+                useThisParam = paramNameMatchesRegex(param.getName(), override);
+            }
+            else
+            {
+                useThisParam = param.getName().equals(override);
+            }
+            if (useThisParam)
+            {
+                if (override != null)
+                {
+                    logger.info("Adding parameterization: " + param.getName());
+                }
+                localRunners.add(new ReifiedParamRunner(getTestClass().getJavaClass(), param, override != null));
+            }
+        }
+        runners = Collections.unmodifiableList(localRunners);
+    }
+
+	@Override
+	protected List<Runner> getChildren()
+    {
+		return runners;
+	}
+
+    /**
+     * Gets the parameterization
+     * @return the parameterization collection
+     * @throws Throwable if the annotation requirements are not met, or if there's an error in invoking
+     * the class's "get parameterizations" method.
+     */
+    private Collection<Parameterization> getParameterizations() throws Throwable
+    {
+        TestClass cls = getTestClass();
+        List<FrameworkMethod> methods = cls.getAnnotatedMethods(TestParameters.class);
+
+        if (methods.size() != 1)
+        {
+            throw new Exception("class " + cls.getName() + " must have exactly 1 method annotated with "
+                + TestParameters.class.getSimpleName() +"; found " + methods.size());
+        }
+
+        FrameworkMethod method = methods.get(0);
+        checkParameterizationMethod(method);
+
+        @SuppressWarnings("unchecked")
+        Collection<Parameterization> ret = (Collection<Parameterization>) method.invokeExplosively(null);
+        checkParameterizations(ret);
+        return ret;
+    }
+
+    /**
+     * Checks the parameterizations collection for correctness
+     * @param collection the collection
+     * @throws Exception if the collection was null or contained duplicates
+     */
+    private void checkParameterizations(Collection<Parameterization> collection) throws Exception
+    {
+        if (collection == null)
+        {
+            throw new Exception("parameterizations collection may not return null");
+        }
+        Set<String> duplicates = new HashSet<String>();
+        Set<Parameterization> checkSet = new HashSet<Parameterization>();
+        for (Parameterization param : collection)
+        {
+            if (param == null)
+            {
+                throw new Exception("parameterization collection may not contain null values");
+            }
+            if (!checkSet.add(param))
+            {
+                duplicates.add(param.getName());
+            }
+        }
+        if (duplicates.size() != 0)
+        {
+            throw new Exception("duplicated parameterization names: " + duplicates);
+        }
+    }
+
+    /**
+     * Checks the @Failing annotations on @Test methods.
+     *
+     * Specifically, this checks that no item in the @Failing list is repeated, and that each item in that list
+     * corresponds to an actual parameterization.
+     * @param parameterizations the known parameterizations; will not be modified.
+     * @throws org.junit.runners.model.InitializationError if a check fails
+     */
+    private void checkFailingParameterizations(Collection<Parameterization> parameterizations) throws InitializationError
+    {
+        Collection<String> paramNames = new HashSet<String>();
+        for (Parameterization param : parameterizations)
+        {
+            boolean added = paramNames.add(param.getName());
+            assert added : "uncaught duplicate: " + param;
+        }
+
+        Set<String> duplicatesChecker = new HashSet<String>();
+        for(FrameworkMethod method : super.getTestClass().getAnnotatedMethods(Failing.class))
+        {
+            String[] failing = method.getAnnotation(Failing.class).value();
+            if (failing != null)
+            {
+                for(int i=0; i < failing.length; ++i)
+                {
+                    if (!duplicatesChecker.add(failing[i]))
+                    {
+                        throw new InitializationError("duplicate parameterization name in @Failing list: "
+                                + method.getName() + "[" + i + "]<" + failing[i] + ">");
+                    }
+                    if ( !(paramNameUsesRegex(failing[i]) || paramNames.contains(failing[i])) )
+                    {
+                        throw new InitializationError("parameterization is marked as failing, "
+                                + "but isn't in list of parameterizations: "
+                                + method.getName() + "[" + i + "]<" + failing[i] +"> not in " + paramNames);
+                    }
+                }
+                duplicatesChecker.clear();
+            }
+        }
+    }
+
+
+    /**
+     * Checks the parameterization method for correctness.
+     * @param frameworkMethod the method
+     * @throws Exception if the annotation requirements are not met
+     */
+    private static void checkParameterizationMethod(FrameworkMethod frameworkMethod) throws Exception
+    {
+        final Method method = frameworkMethod.getMethod();
+
+        if (method.getParameterTypes().length != 0)
+        {
+            throw new Exception(complainingThat(method, "must take no arguments"));
+        }
+
+        final int modifiers = frameworkMethod.getMethod().getModifiers();
+        if (! Modifier.isPublic(modifiers))
+        {
+            throw new Exception(complainingThat(method, "must be public"));
+        }
+        if (! Modifier.isStatic(modifiers))
+        {
+            throw new Exception(complainingThat(method, "must be static"));
+        }
+
+        final Type genericRet = method.getGenericReturnType();
+        final String mustReturnCorrectly = "must return Collection of " + Parameterization.class;
+        if (! (genericRet instanceof ParameterizedType))
+        {
+            throw new Exception(complainingThat(method, mustReturnCorrectly));
+        }
+        final ParameterizedType ret = (ParameterizedType) genericRet;
+        if (!(ret.getRawType() instanceof Class) && Collection.class.isAssignableFrom((Class)ret.getRawType()))
+        {
+            throw new Exception(complainingThat(method, mustReturnCorrectly));
+        }
+        if (ret.getActualTypeArguments().length != 1)
+        {
+            throw new Exception(complainingThat(method, mustReturnCorrectly + "; raw Collection is not allowed"));
+        }
+        if (!ret.getActualTypeArguments()[0].equals(Parameterization.class))
+        {
+            throw new Exception(complainingThat(method, mustReturnCorrectly));
+        }
+    }
+
+    private static String complainingThat(Method method, String mustBe)
+    {
+        assert method != null;
+        assert mustBe != null;
+        return String.format("%s.%s() %s", method.getDeclaringClass().getName(), method.getName(), mustBe);
+    }
+}
 
=== added file 'src/main/java/com/motpot/npr/OnlyIf.java'
--- src/main/java/com/motpot/npr/OnlyIf.java	1970-01-01 00:00:00 +0000
+++ src/main/java/com/motpot/npr/OnlyIf.java	2011-09-08 16:01:22 +0000
@@ -0,0 +1,20 @@
+package com.motpot.npr;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Represents a condition for running a test.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface OnlyIf
+{
+    /**
+     * The method that should be invoked to see if this annotated method should be run
+     * @return
+     */
+    String value();
+}
 
=== added file 'src/main/java/com/motpot/npr/OnlyIfNot.java'
--- src/main/java/com/motpot/npr/OnlyIfNot.java	1970-01-01 00:00:00 +0000
+++ src/main/java/com/motpot/npr/OnlyIfNot.java	2011-09-08 16:01:22 +0000
@@ -0,0 +1,20 @@
+package com.motpot.npr;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Represents a condition for running a test.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface OnlyIfNot
+{
+    /**
+     * The method that should be invoked to see if this annotated method should be run
+     * @return
+     */
+    String value();
+}
 
=== added file 'src/main/java/com/motpot/npr/Parameterization.java'
--- src/main/java/com/motpot/npr/Parameterization.java	1970-01-01 00:00:00 +0000
+++ src/main/java/com/motpot/npr/Parameterization.java	2011-09-08 16:01:22 +0000
@@ -0,0 +1,152 @@
+package com.motpot.npr;
+
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+public final class Parameterization
+{
+    private String name;
+    private final List<Object> args;
+    private boolean expectedToPass;
+
+    public static Parameterization create(String name, Object... args)
+    {
+        return new Parameterization(name, true, args);
+    }
+
+    public static Parameterization failing(String name, Object... args)
+    {
+        return new Parameterization(name, false, args);
+    }
+
+    public Parameterization(String name, boolean isPassing, Object... args)
+    {
+        if (name == null) {
+            throw new IllegalArgumentException("name can't be null");
+        }
+        if (args == null) {
+            throw new IllegalArgumentException("args can't be null");
+        }
+        this.name = name;
+        this.args = new LinkedList<Object>(Arrays.asList(args));
+        this.expectedToPass = isPassing;
+    }
+
+    /**
+     * <p>Creates a copy of this parameterization.</p>
+     *
+     * <p>The original parameterization's arguments list is copied shallowly.</p>
+     * @param copyFrom the original parameterization
+     */
+    public Parameterization(Parameterization copyFrom)
+    {
+        this.name = copyFrom.name;
+        this.args = new LinkedList<Object>(copyFrom.args);
+        this.expectedToPass = copyFrom.expectedToPass;
+    }
+
+    public String getName()
+    {
+        return name;
+    }
+
+    public void setName(String name)
+    {
+        this.name = name;
+    }
+
+    /**
+     * Returns this parameterization's arguments as an Object array.
+     *
+     * This array is <em>not</em> backed by the parameterization, so changes in one are not reflected in the other.
+     * However, the array is a shallow copy, so modifying an element of the parameterization in the list will be
+     * reflected in the array, and the vice versa.
+     * @return the arguments
+     */
+    public Object[] getArguments()
+    {
+        return args.toArray();
+    }
+
+    /**
+     * Returns this parameterization's arguments as a list.
+     *
+     * This list is backed by the parameterization, so changes to one are reflected in the other.
+     * @return a list of arguments, backed by the parameterization
+     */
+    public List<Object> getArgsAsList()
+    {
+        return args;
+    }
+
+    public boolean expectedToPass()
+    {
+        return expectedToPass;
+    }
+
+    public void setExpectedToPass(boolean expectedToPass)
+    {
+        this.expectedToPass = expectedToPass;
+    }
+
+    @Override
+    public boolean equals(Object o)
+    {
+        if (this == o)
+        {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass())
+        {
+            return false;
+        }
+        Parameterization that = (Parameterization) o;
+        return name.equals(that.name);
+    }
+
+    @Override
+    public int hashCode()
+    {
+        return name.hashCode();
+    }
+
+    public boolean equivalent(Parameterization other)
+    {
+        if (!this.name.equals(other.name))
+            return false;
+        if (this.expectedToPass != other.expectedToPass)
+            return false;
+        if (this.args.size() != other.args.size())
+            return false;
+
+        Iterator<Object> myIter = this.args.iterator();
+        Iterator<Object> otherIter = other.args.iterator();
+
+        while (myIter.hasNext())
+        {
+            Object mine = myIter.next();
+            Object his = otherIter.next();
+
+            if (mine == null)
+            {
+                if (his != null)
+                {
+                    return false;
+                }
+            }
+            else if (!mine.equals(his))
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public String toString()
+    {
+        return "Parameterization[" + (expectedToPass? "PASSING " : "FAILING ") + name + ": " + args + " ]";
+    }
+}
 
=== added file 'src/main/java/com/motpot/npr/ParameterizationBuilder.java'
--- src/main/java/com/motpot/npr/ParameterizationBuilder.java	1970-01-01 00:00:00 +0000
+++ src/main/java/com/motpot/npr/ParameterizationBuilder.java	2011-09-08 16:01:22 +0000
@@ -0,0 +1,159 @@
+package com.motpot.npr;
+
+import java.util.LinkedList;
+import java.util.List;
+
+public final class ParameterizationBuilder
+{
+    private final List<Parameterization> list;
+
+    /**
+     * Creates a builder with no starting parameterizations.
+     */
+    public ParameterizationBuilder()
+    {
+        this(new LinkedList<Parameterization>());
+    }
+
+    /**
+     * Creates a builder backed by a list. Changes to the one will be reflected in the other, and {@linkplain #asList()}
+     * will return the same instance as is passed to this method.
+     * @param backingList The list that backs this builder.
+     */
+    public ParameterizationBuilder(List<Parameterization> backingList)
+    {
+        list = backingList;
+    }
+
+    /**
+     * Adds a parameterization to the end of the list.
+     * @param name the parameterization's name
+     * @param args the parameterization's arguments
+     */
+    public void add(String name, Object... args)
+    {
+        list.add(Parameterization.create(name, args));
+    }
+
+    /**
+     * Adds a parameterization that's expected to fail to the end of the list
+     * @param name the parameterization's name
+     * @param args the parameterization's arguments
+     */
+    public void addFailing(String name, Object... args)
+    {
+        list.add(Parameterization.failing(name, args));
+    }
+
+    /**
+     * Adds a parameterization to the end of the list.
+     * @param name the parameterization's name
+     * @param expectedToPass whether the parameterization is expected to pass any tests
+     * @param args the parameterization's arguments
+     */
+    public void create(String name, boolean expectedToPass, Object... args)
+    {
+        list.add(new Parameterization(name, expectedToPass, args));
+    }
+
+    /**
+     * <p>Performs a cartesian product of parameterizations by prepending each of the incoming args to each
+     * existing parameter's arg list.</p>
+     *
+     * For instance, if you have parameters <tt>[ ("A", 1, 2, 3) and ("B", 4, 5, 6) ]</tt>, and you called
+     * <tt>multiplyParametersByPrepending("foo-", 'c', "bar", 'd')</tt>, you would get the following
+     * parameterizations, in this order:
+     * <ol>
+     *  <li>"foo-A", 'c', 1, 2, 3</li>
+     *  <li>"bar-A", 'd', 1, 2, 3</li>
+     *  <li>"foo-B", 'c', 4, 5, 6</li>
+     *  <li>"bar-B", 'd', 1, 2, 3</li>
+     * </ol>
+     * @param args the list of named args to multiply by. Every other element (starting with the first) in the list must
+     * be a String that represents the name prefix; the element following each prefix is the argument to append to
+     * the args list.
+     * @throws IllegalArgumentException if the args aren't given as String-Object pairings.
+     * @throws IllegalStateException if there are no existing parameterizations to multiply by
+     */
+    public void multiplyParametersByPrepending(Object... args)
+    {
+        cartesianProduct(false, args);
+    }
+
+    /**
+     * <p>Performs a cartesian product of parameterizations by appending each of the incoming args to each
+     * existing parameter's arg list. If you supply a prefix, it will also be appended to each parameter's name.</p>
+     *
+     * <p>This works just like {@link #multiplyParametersByPrepending(Object...)}, only each parameter label and
+     * value is appended instead of prepended.</p>
+     * @param args the list of named args to multiply by. Every other element (starting with the first) in the list must
+     * be a String that represents the name suffix; the element following each suffix is the argument to append to
+     * the args list.
+     * @throws IllegalArgumentException if the args aren't given as String-Object pairings.
+     * @throws IllegalStateException if there are no existing parameterizations to multiply by
+     * @see #multiplyParametersByPrepending(Object...)
+     */
+    public void multiplyParametersByAppending(Object... args)
+    {
+        cartesianProduct(true, args);
+    }
+
+    private void cartesianProduct(boolean append, Object[] args)
+    {
+        if (list.size() == 0)
+        {
+            throw new IllegalStateException("can't multiply yet -- no args defined");
+        }
+        if ( (args.length % 2) != 0)
+        {
+            throw new IllegalArgumentException("odd number of arguments");
+        }
+
+        List<Parameterization> product = new LinkedList<Parameterization>();
+        for (Parameterization param : list)
+        {
+            Object[] origArgs = param.getArguments();
+            Object[] newArgs = new Object[origArgs.length + 1];
+            System.arraycopy(origArgs, 0, newArgs, append ? 0 : 1, origArgs.length);
+
+            for(int i=0; i < args.length; i+= 2)
+            {
+                String label;
+                try
+                {
+                    label = (String)args[i];
+                }
+                catch (ClassCastException e)
+                {
+                    throw new IllegalArgumentException("argument at index " + i + " is not a String");
+                }
+
+                if (label == null)
+                {
+                    label = param.getName();
+                }
+                else
+                {
+                    label = append ?
+                            param.getName() + label
+                            : label + param.getName();
+                }
+                newArgs[append ? origArgs.length : 0] = args[i+1];
+                product.add(new Parameterization(label, param.expectedToPass(), newArgs));
+            }
+        }
+
+        list.clear();
+        list.addAll(product);
+    }
+
+    /**
+     * Represents this builder's parameterizations. The returning list is backed by this builder, so changes
+     * to either are seen in both.
+     * @return the list that backs this builder
+     */
+    public List<Parameterization> asList()
+    {
+        return list;
+    }
+}
 
=== added directory 'src/test'
=== added directory 'src/test/java'
=== added directory 'src/test/java/com'
=== added directory 'src/test/java/com/motpot'
=== added directory 'src/test/java/com/motpot/npr'
=== added file 'src/test/java/com/motpot/npr/NamedParameterizedRunnerTest.java'
--- src/test/java/com/motpot/npr/NamedParameterizedRunnerTest.java	1970-01-01 00:00:00 +0000
+++ src/test/java/com/motpot/npr/NamedParameterizedRunnerTest.java	2011-09-08 16:01:22 +0000
@@ -0,0 +1,316 @@
+package com.motpot.npr;
+
+import com.motpot.npr.NamedParameterizedRunner.ReifiedParamRunner;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.Runner;
+import org.junit.runners.model.FrameworkMethod;
+
+import java.util.*;
+
+import static junit.framework.Assert.*;
+
+public final class NamedParameterizedRunnerTest
+{
+    private final static List<Parameterization> builderList = new LinkedList<Parameterization>();
+    private Properties oldProperties;
+    private Properties workingProperties;
+
+    @Before
+    public void setUp()
+    {
+        builderList.clear();
+        oldProperties = System.getProperties();
+        workingProperties = new Properties(oldProperties);
+        System.setProperties(workingProperties);
+    }
+
+    @After
+    public void tearDown()
+    {
+        System.setProperties(oldProperties);
+    }
+
+    public final static class RunEverythingTest
+    {
+        @NamedParameterizedRunner.TestParameters
+        @SuppressWarnings("unused")
+        public static List<Parameterization> params() { return builderList; }
+
+        public RunEverythingTest(char unused)
+        {
+            assert unused != 'a'; // just to shut it up about it not being used
+        }
+
+        @Test
+        public void one() {}
+
+        @Test
+        public void two() {}
+    }
+
+    public final static class OneFailingTest
+    {
+        @NamedParameterizedRunner.TestParameters
+        @SuppressWarnings("unused")
+        public static List<Parameterization> params() { return builderList; }
+
+        public OneFailingTest(char unused)
+        {
+            assert unused != 'a'; // just to shut it up about it not being used
+        }
+
+        @Test
+        public void passing() {}
+
+        @Failing @Test
+        public void failing() {}
+    }
+
+    public final static class OnlyIfTest
+    {
+        @NamedParameterizedRunner.TestParameters
+        @SuppressWarnings("unused")
+        public static List<Parameterization> params() { return builderList; }
+
+        private final int number;
+        @SuppressWarnings("unused") public final boolean numberIs1; // used by @OnlyIf
+
+        public OnlyIfTest(int number) {
+            this.number = number;
+            this.numberIs1 = is1();
+        }
+
+        @Test
+        public void alwaysRun() {}
+
+        @Test @OnlyIf("is1()")
+        public void testIs1Method() {
+            assertEquals("number", 1, number);
+        }
+
+        @Test @OnlyIf("numberIs1")
+        public void testIs1Field() {
+            assertEquals("number", 1, number);
+        }
+
+        public boolean is1() {
+            return number == 1;
+        }
+    }
+
+    @Test
+    public void testRegexUsed()
+    {
+        assertFalse("//", NamedParameterizedRunner.paramNameUsesRegex("//"));
+        assertTrue("/a/", NamedParameterizedRunner.paramNameUsesRegex("/a/"));
+    }
+
+    @Test
+    public void testRegexMatches()
+    {
+        assertFalse("/a/ against 'foo'", NamedParameterizedRunner.paramNameMatchesRegex("foo", "/a/"));
+        assertTrue("/a/ against 'foo bar'", NamedParameterizedRunner.paramNameMatchesRegex("foo bar", "/a/"));
+        assertFalse("/foo/ against 'o'", NamedParameterizedRunner.paramNameMatchesRegex("o", "/foo/"));
+    }
+
+    @Test
+    public void testRunEverythingPasses() throws Throwable
+    {
+        ParameterizationBuilder builder = new ParameterizationBuilder(builderList);
+        builder.add("alpha", 'a');
+        builder.add("beta", 'b');
+
+        NamedParameterizedRunner runner = new NamedParameterizedRunner(RunEverythingTest.class);
+
+        Map<String,ReifiedParamRunner> map = testParameterizations(runner,
+                "Parameterization[PASSING alpha: [a] ]",
+                "Parameterization[PASSING beta: [b] ]");
+
+        testOverrides(map.values(), false);
+
+        testFrameworkMethod(map.get("Parameterization[PASSING alpha: [a] ]"), RunEverythingTest.class, "one", true);
+        testFrameworkMethod(map.get("Parameterization[PASSING alpha: [a] ]"), RunEverythingTest.class, "two", true);
+        testFrameworkMethod(map.get("Parameterization[PASSING beta: [b] ]"), RunEverythingTest.class, "one", true);
+        testFrameworkMethod(map.get("Parameterization[PASSING beta: [b] ]"), RunEverythingTest.class, "two", true);
+    }
+
+    @Test
+    public void testRunEverythingAlphaPasses() throws Throwable
+    {
+        ParameterizationBuilder builder = new ParameterizationBuilder(builderList);
+        builder.add("alpha", 'a');
+        builder.addFailing("beta", 'b');
+
+        NamedParameterizedRunner runner = new NamedParameterizedRunner(RunEverythingTest.class);
+
+        Map<String,ReifiedParamRunner> map = testParameterizations(runner,
+                "Parameterization[PASSING alpha: [a] ]",
+                "Parameterization[FAILING beta: [b] ]");
+
+        testOverrides(map.values(), false);
+
+        testFrameworkMethod(map.get("Parameterization[PASSING alpha: [a] ]"), RunEverythingTest.class, "one", true);
+        testFrameworkMethod(map.get("Parameterization[PASSING alpha: [a] ]"), RunEverythingTest.class, "two", true);
+        testFrameworkMethod(map.get("Parameterization[FAILING beta: [b] ]"), RunEverythingTest.class, "one", false);
+        testFrameworkMethod(map.get("Parameterization[FAILING beta: [b] ]"), RunEverythingTest.class, "two", false);
+    }
+
+    @Test
+    public void testOneMethodFailing() throws Throwable
+    {
+        ParameterizationBuilder builder = new ParameterizationBuilder(builderList);
+        builder.add("alpha", 'a');
+        builder.add("beta", 'b');
+
+        NamedParameterizedRunner runner = new NamedParameterizedRunner(OneFailingTest.class);
+
+        Map<String,ReifiedParamRunner> map = testParameterizations(runner,
+                "Parameterization[PASSING alpha: [a] ]",
+                "Parameterization[PASSING beta: [b] ]");
+
+        testOverrides(map.values(), false);
+
+        testFrameworkMethod(map.get("Parameterization[PASSING alpha: [a] ]"), OneFailingTest.class, "passing", true);
+        testFrameworkMethod(map.get("Parameterization[PASSING alpha: [a] ]"), OneFailingTest.class, "failing", false);
+        testFrameworkMethod(map.get("Parameterization[PASSING beta: [b] ]"), OneFailingTest.class, "passing", true);
+        testFrameworkMethod(map.get("Parameterization[PASSING beta: [b] ]"), OneFailingTest.class, "failing", false);
+    }
+
+    @Test
+    public void testOverrideOfFailingMethod() throws Throwable
+    {
+        workingProperties.put(NamedParameterizedRunner.PARAMETERIZATION_OVERRIDE, "beta");
+        ParameterizationBuilder builder = new ParameterizationBuilder(builderList);
+        builder.add("alpha", 'a');
+        builder.add("beta", 'b');
+
+        NamedParameterizedRunner runner = new NamedParameterizedRunner(OneFailingTest.class);
+
+        Map<String,ReifiedParamRunner> map = testParameterizations(runner,
+                "Parameterization[PASSING beta: [b] ]");
+
+        testOverrides(map.values(), true);
+        
+        testFrameworkMethod(map.get("Parameterization[PASSING beta: [b] ]"), OneFailingTest.class, "passing", true);
+        testFrameworkMethod(map.get("Parameterization[PASSING beta: [b] ]"), OneFailingTest.class, "failing", true);
+    }
+
+    @Test
+    public void testOverrideOfFailingParam() throws Throwable
+    {
+        workingProperties.put(NamedParameterizedRunner.PARAMETERIZATION_OVERRIDE, "beta");
+        ParameterizationBuilder builder = new ParameterizationBuilder(builderList);
+        builder.add("alpha", 'a');
+        builder.addFailing("beta", 'b');
+
+        NamedParameterizedRunner runner = new NamedParameterizedRunner(OneFailingTest.class);
+
+        Map<String,ReifiedParamRunner> map = testParameterizations(runner,
+                "Parameterization[FAILING beta: [b] ]");
+
+        testOverrides(map.values(), true);
+
+        testFrameworkMethod(map.get("Parameterization[FAILING beta: [b] ]"), OneFailingTest.class, "passing", true);
+        testFrameworkMethod(map.get("Parameterization[FAILING beta: [b] ]"), OneFailingTest.class, "failing", true);
+    }
+
+    @Test
+    public void testOverrideUsingRegex() throws Throwable
+    {
+        workingProperties.put(NamedParameterizedRunner.PARAMETERIZATION_OVERRIDE, "/a/");
+        ParameterizationBuilder builder = new ParameterizationBuilder(builderList);
+        builder.add("alpha", 'a');
+        builder.addFailing("beta", 'b');
+
+        NamedParameterizedRunner runner = new NamedParameterizedRunner(OneFailingTest.class);
+
+        Map<String,ReifiedParamRunner> map = testParameterizations(runner,
+                "Parameterization[PASSING alpha: [a] ]",
+                "Parameterization[FAILING beta: [b] ]");
+
+        testOverrides(map.values(), true);
+
+        testFrameworkMethod(map.get("Parameterization[PASSING alpha: [a] ]"), OneFailingTest.class, "passing", true);
+        testFrameworkMethod(map.get("Parameterization[PASSING alpha: [a] ]"), OneFailingTest.class, "failing", true);
+        testFrameworkMethod(map.get("Parameterization[FAILING beta: [b] ]"), OneFailingTest.class, "passing", true);
+        testFrameworkMethod(map.get("Parameterization[FAILING beta: [b] ]"), OneFailingTest.class, "failing", true);
+    }
+
+    @Test
+    public void testOnlyIf() throws Throwable {
+        ParameterizationBuilder builder = new ParameterizationBuilder(builderList);
+        builder.add("one", 1);
+        builder.add("two", 2);
+
+        NamedParameterizedRunner runner = new NamedParameterizedRunner(OnlyIfTest.class);
+
+        Map<String,ReifiedParamRunner> map = testParameterizations(runner,
+                "Parameterization[PASSING one: [1] ]",
+                "Parameterization[PASSING two: [2] ]");
+
+        {
+            ReifiedParamRunner forOne = map.get("Parameterization[PASSING one: [1] ]");
+            assertEquals("param one: " + forOne.describeChildren(), 3, forOne.getChildrenCount());
+            testFrameworkMethod(forOne, OnlyIfTest.class, "testIs1Method", true);
+            testFrameworkMethod(forOne, OnlyIfTest.class, "testIs1Field", true);
+            testFrameworkMethod(forOne, OnlyIfTest.class, "alwaysRun", true);
+        }
+        {
+            ReifiedParamRunner forTwo = map.get("Parameterization[PASSING two: [2] ]");
+            assertEquals("param two: " + forTwo.describeChildren(), 1, forTwo.getChildrenCount());
+            testFrameworkMethod(forTwo, OnlyIfTest.class, "alwaysRun", true);
+        }
+    }
+
+    private static void testOverrides(Collection<ReifiedParamRunner> runners, boolean expectedOverride)
+    {
+        for (ReifiedParamRunner runner : runners)
+        {
+            assertEquals(runner.toString(), expectedOverride, runner.overrideOn());
+        }
+    }
+
+    private static void testFrameworkMethod(ReifiedParamRunner runner, Class<?> testClass, String testMethod,
+                                            boolean expectedToPass)
+    {
+        String frameworkMethodString = "public void " + testClass.getName() + "." + testMethod + "()";
+        FrameworkMethod method = runner.getChild(frameworkMethodString);
+        assertNotNull(frameworkMethodString, method);
+        assertEquals(frameworkMethodString, expectedToPass, runner.expectedToPass(method));
+    }
+
+    /**
+     * Confirms that each given name has a {@linkplain ReifiedParamRunner} associated with it, and returns the
+     * name -> runner map
+     * @param runner the parameterized runner
+     * @param names the expected names
+     * @return a map of names to reified runners
+     */
+    private static Map<String,ReifiedParamRunner> testParameterizations(NamedParameterizedRunner runner, String... names)
+    {
+        List<Runner> children = runner.getChildren();
+        assertEquals("children.size()", names.length, children.size());
+
+        Set<String> expectedNames = new HashSet<String>(names.length, 1.0f);
+        for (String name : names) {
+            assertTrue("unexpected error, duplicate name: " + name, expectedNames.add(name));
+        }
+
+        Map<String,ReifiedParamRunner> foundRunners = new HashMap<String, ReifiedParamRunner>();
+        for (Runner child : children)
+        {
+            ReifiedParamRunner reified = (ReifiedParamRunner)child;
+            String paramToString = reified.paramToString();
+            assertNull("duplicate name: " + paramToString, foundRunners.put(paramToString, reified));
+        }
+
+        for (String expected : expectedNames)
+        {
+            assertTrue("didn't find expected param: " + expected, foundRunners.containsKey(expected));
+        }
+
+        return foundRunners;
+    }
+}
 
=== added file 'src/test/java/com/motpot/npr/OnlyIfUsageTest.java'
--- src/test/java/com/motpot/npr/OnlyIfUsageTest.java	1970-01-01 00:00:00 +0000
+++ src/test/java/com/motpot/npr/OnlyIfUsageTest.java	2011-09-08 16:01:22 +0000
@@ -0,0 +1,68 @@
+package com.motpot.npr;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+@RunWith(NamedParameterizedRunner.class)
+public final class OnlyIfUsageTest {
+    @NamedParameterizedRunner.TestParameters
+    public static List<Parameterization> params() {
+        ParameterizationBuilder builder = new ParameterizationBuilder();
+        builder.add("foo", "foo");
+        builder.add("bar", "bar");
+        return builder.asList();
+    }
+
+    private final String string;
+    public final boolean stringIsFoo;
+
+    public OnlyIfUsageTest(String string) {
+        this.string = string;
+        stringIsFoo = "foo".equals(string);
+    }
+
+    @Test @OnlyIf("isFoo()")
+    public void equalsFoo() {
+        assertEquals("string", "foo", string);
+    }
+
+    @Test @OnlyIf("stringIsFoo")
+    public void equalsFooByField() {
+        assertEquals("string", "foo", string);
+    }
+
+    @Test @OnlyIfNot("isFoo()")
+    public void notEqualsFoo() {
+        if ("foo".equals(string)) {
+            fail("found a foo!");
+        }
+    }
+
+    @Test @OnlyIf("hasThreeChars()") @OnlyIfNot("lastCharR()")
+    public void threeCharNoTrailingR() {
+        assertEquals("string length", 3, string.length());
+        assertFalse("last char was r! <" + string + '>', string.charAt(2) == 'r');
+    }
+
+    @Test
+    public void stringNotNull() {
+        assertNotNull("string", string);
+    }
+
+    public boolean isFoo() {
+        return "foo".equals(string);
+    }
+
+    public boolean hasThreeChars() {
+        return string.length() == 3;
+    }
+
+    public boolean lastCharR() {
+        // for simplicity, we'll assume string not null, string.length > 0
+        return string.charAt( string.length() - 1) == 'r';
+    }
+}
 
=== added file 'src/test/java/com/motpot/npr/ParameterizationBuilderTest.java'
--- src/test/java/com/motpot/npr/ParameterizationBuilderTest.java	1970-01-01 00:00:00 +0000
+++ src/test/java/com/motpot/npr/ParameterizationBuilderTest.java	2011-09-08 16:01:22 +0000
@@ -0,0 +1,153 @@
+package com.motpot.npr;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static junit.framework.Assert.*;
+
+
+public final class ParameterizationBuilderTest
+{
+    @Test
+    public void testAdd()
+    {
+        ParameterizationBuilder builder = new ParameterizationBuilder();
+        builder.add("hello", 1, "someString", 50L);
+
+        List<Parameterization> params = builder.asList();
+        assertEquals("params size", 1, params.size());
+        assertEquivalent("only one",
+                Parameterization.create("hello", 1, "someString", 50L),
+                params.get(0));
+    }
+
+    @Test
+    public void testAddFailing()
+    {
+        ParameterizationBuilder builder = new ParameterizationBuilder();
+        builder.addFailing("hello", 1, "someString", 50L);
+
+        List<Parameterization> params = builder.asList();
+        assertEquals("params size", 1, params.size());
+        assertEquivalent("only one",
+                Parameterization.failing("hello", 1, "someString", 50L),
+                params.get(0));
+    }
+
+    @Test
+    public void testCreate()
+    {
+        ParameterizationBuilder builder = new ParameterizationBuilder();
+        builder.create("hello", true, 1, "someString", 50L);
+        builder.create("hi", false, -1, "anotherString", -50L);
+
+        List<Parameterization> params = builder.asList();
+        assertEquals("params size", 2, params.size());
+        assertEquivalent("passing",
+                new Parameterization("hello", true, 1, "someString", 50L),
+                params.get(0));
+        assertEquivalent("failing",
+                new Parameterization("hi", false, -1, "anotherString", -50L),
+                params.get(1));
+    }
+    
+    @Test
+    public void testAppend()
+    {
+        ParameterizationBuilder builder = new ParameterizationBuilder();
+        builder.add("ONE", 1, 2, 3);
+        builder.addFailing("TWO", 4, 5, 6);
+        builder.multiplyParametersByAppending("-a", 'a', "-b", 'b', "-c", 'c');
+
+        List<Parameterization> expected = Arrays.asList(
+                Parameterization.create("ONE-a", 1, 2, 3, 'a'),
+                Parameterization.create("ONE-b", 1, 2, 3, 'b'),
+                Parameterization.create("ONE-c", 1, 2, 3, 'c'),
+                Parameterization.failing("TWO-a", 4, 5, 6, 'a'),
+                Parameterization.failing("TWO-b", 4, 5, 6, 'b'),
+                Parameterization.failing("TWO-c", 4, 5, 6, 'c')
+        );
+        List<Parameterization> actual = builder.asList();
+
+        assertEquals("params size", expected.size(), actual.size());
+
+        for(int i=0, len=expected.size(); i<len; ++i)
+        {
+            assertEquivalent("param " + i, expected.get(i), actual.get(i));
+        }
+    }
+
+    @Test
+    public void testPrepend()
+    {
+        ParameterizationBuilder builder = new ParameterizationBuilder();
+        builder.add("ONE", 1, 2, 3);
+        builder.addFailing("TWO", 4, 5, 6);
+        builder.multiplyParametersByPrepending("a:", 'a', "b:", 'b', "c:", 'c');
+
+        List<Parameterization> expected = Arrays.asList(
+                Parameterization.create("a:ONE", 'a', 1, 2, 3),
+                Parameterization.create("b:ONE", 'b', 1, 2, 3),
+                Parameterization.create("c:ONE", 'c', 1, 2, 3),
+                Parameterization.failing("a:TWO", 'a', 4, 5, 6),
+                Parameterization.failing("b:TWO", 'b', 4, 5, 6),
+                Parameterization.failing("c:TWO", 'c', 4, 5, 6)
+        );
+        List<Parameterization> actual = builder.asList();
+
+        assertEquals("params size", expected.size(), actual.size());
+
+        for(int i=0, len=expected.size(); i<len; ++i)
+        {
+            assertEquivalent("param " + i, expected.get(i), actual.get(i));
+        }
+    }
+
+    @Test
+    public void testListBackedByBuilder()
+    {
+        ParameterizationBuilder builder = new ParameterizationBuilder();
+        List<Parameterization> list = builder.asList();
+
+        assertEquals("list size before building", 0, list.size());
+
+        builder.add("whatever", 'a');
+        assertEquals("list size after building", 1, list.size());
+
+        assertSame("new list", builder.asList(), list);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void builderMultiplierArgsNotPaired()
+    {
+        ParameterizationBuilder builder = new ParameterizationBuilder();
+        builder.add("whatever", 1);
+
+        builder.multiplyParametersByAppending("label", 2, 3);
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void builderMultiplierArgsLabelNotString()
+    {
+        ParameterizationBuilder builder = new ParameterizationBuilder();
+        builder.add("whatever", 1);
+
+        builder.multiplyParametersByAppending("label", 2, 3, "this label is in the wrong place");
+    }
+
+    @Test(expected=IllegalStateException.class)
+    public void builderMultipliesByZero()
+    {
+        new ParameterizationBuilder().multiplyParametersByAppending();
+    }
+
+    private static void assertEquivalent(String message, Parameterization expected, Parameterization actual)
+    {
+        if (!expected.equivalent(actual))
+        {
+            fail(message + " expected<" + expected + "> but was <" + actual + ">");
+        }
+    }
+}