diff --git a/src/main/java/com/github/jcunit/annotations/JCUnitParameter.java b/src/main/java/com/github/jcunit/annotations/JCUnitParameter.java
index 28623e6d2..f050815ad 100644
--- a/src/main/java/com/github/jcunit/annotations/JCUnitParameter.java
+++ b/src/main/java/com/github/jcunit/annotations/JCUnitParameter.java
@@ -5,7 +5,6 @@
 import com.github.jcunit.model.ValueResolver;
 import com.github.jcunit.factorspace.Parameter;
 
-import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
@@ -13,7 +12,6 @@
 import java.util.function.Supplier;
 
 import static com.github.jcunit.model.ParameterSpec.Utils.createConstraints;
-import static com.github.jcunit.model.ParameterSpec.Utils.isRequired;
 import static java.lang.annotation.ElementType.METHOD;
 import static java.util.Collections.emptyList;
 import static java.util.stream.Collectors.toList;
@@ -32,15 +30,14 @@ enum Type {
     };
 
 
-    public static <T> Parameter<List<ValueResolver<T>>> createListSimple(ParameterSpec<T> parameterSpec, ParameterSpaceSpec parameterSpaceSpec) {
-      boolean isSeed = isRequired(parameterSpaceSpec, parameterSpec.name(), parameterSpaceSpec.parameterNames());
-      return new Parameter.Simple.Impl<>(!isSeed,
+    public static <T> Parameter<List<ValueResolver<T>>> createListSimple(ParameterSpec<T> parameterSpec, ParameterSpaceSpec parameterSpaceSpec, boolean optional) {
+      return new Parameter.Simple.Impl<>(optional,
                                          parameterSpec.name(),
                                          parameterSpec.valueResolvers()
                                                       .stream()
                                                       .map(Collections::singletonList)
                                                       .collect(toList()),
-                                         createConstraints(isSeed,
+                                         createConstraints(!optional,
                                                            parameterSpaceSpec,
                                                            parameterSpec.name()));
     }
diff --git a/src/main/java/com/github/jcunit/factorspace/ParameterSpace.java b/src/main/java/com/github/jcunit/factorspace/ParameterSpace.java
index 3d5bc4a24..5ed3323d2 100644
--- a/src/main/java/com/github/jcunit/factorspace/ParameterSpace.java
+++ b/src/main/java/com/github/jcunit/factorspace/ParameterSpace.java
@@ -8,84 +8,81 @@
 import java.util.List;
 
 import static java.lang.String.format;
+import static java.util.Collections.unmodifiableList;
 import static java.util.stream.Collectors.toList;
 
 public interface ParameterSpace {
   List<String> getParameterNames();
-  
+
   <P> Parameter<P> getParameter(String name);
-  
+
   List<Constraint> getConstraints();
-  
+
   default Tuple encodeTuple(Tuple tuple) {
     Tuple.Builder builder = Tuple.builder();
     this.getParameterNames()
         .forEach(
             each -> this.getParameter(each)
-                .decomposeValue(tuple.get(each))
-                .ifPresent(builder::putAll));
+                        .decomposeValue(tuple.get(each))
+                        .ifPresent(builder::putAll));
     return builder.build();
   }
-  
+
   static List<Tuple> encodeSeedTuples(ParameterSpace parameterSpace, List<Tuple> seeds) {
     return seeds.stream()
-        .map(parameterSpace::encodeTuple)
-        .collect(toList());
+                .map(parameterSpace::encodeTuple)
+                .collect(toList());
   }
-  
+
   class Builder {
     List<Parameter<?>> parameters = new LinkedList<>();
     List<Constraint> constraints = new LinkedList<>();
-    
+
     public Builder addParameter(Parameter<?> parameter) {
       this.parameters.add(parameter);
       return this;
     }
-    
+
     public Builder addAllParameters(Collection<? extends Parameter<?>> parameters) {
       parameters.forEach(Builder.this::addParameter);
       return this;
     }
-    
+
     public Builder addConstraint(Constraint constraint) {
       this.constraints.add(constraint);
       return this;
     }
-    
+
     public Builder addAllConstraints(Collection<? extends Constraint> constraints) {
       constraints.forEach(Builder.this::addConstraint);
       return this;
     }
-    
+
     public ParameterSpace build() {
       return new ParameterSpace() {
         @Override
         public List<String> getParameterNames() {
-          return parameters.stream().map(Parameter::getName).collect(toList());
+          return parameters.stream()
+                           .map(Parameter::getName)
+                           .collect(toList());
         }
-        
+
         @SuppressWarnings("unchecked")
         @Override
         public <P> Parameter<P> getParameter(String name) {
-          return (Parameter<P>) (parameters.stream(
-          
-          ).filter(
-              parameter -> parameter.getName().equals(name)
-          ).findFirst(
-          ).orElseThrow(
-              () -> new RuntimeException(format(
-                  "Parameter '%s' was requested but not found. Existing parameters are %s",
-                  name,
-                  getParameterNames()
-              ))
-          ));
+          return (Parameter<P>) (parameters.stream()
+                                           .filter(parameter -> parameter.getName().equals(name))
+                                           .findFirst()
+                                           .orElseThrow(() -> new RuntimeException(format("Parameter '%s' was requested but not found. Existing parameters are %s",
+                                                                                          name,
+                                                                                          getParameterNames()))));
         }
-        
+
         @Override
         public List<Constraint> getConstraints() {
-          return Collections.unmodifiableList(constraints);
+          return unmodifiableList(constraints);
         }
-        
+
         @Override
         public String toString() {
           return format("parameters:%s,constraints:%s", parameters, constraints);
diff --git a/src/main/java/com/github/jcunit/model/ParameterSpaceSpec.java b/src/main/java/com/github/jcunit/model/ParameterSpaceSpec.java
index 96d3bce8c..9e86b6e99 100644
--- a/src/main/java/com/github/jcunit/model/ParameterSpaceSpec.java
+++ b/src/main/java/com/github/jcunit/model/ParameterSpaceSpec.java
@@ -7,6 +7,7 @@
 import java.util.function.Function;
 
 import static java.util.stream.Collectors.toMap;
+import static java.util.stream.Collectors.toSet;
 
 /**
  * // @formatter:off 
@@ -59,15 +60,103 @@ public <E> ParameterSpec<E> parameterSpecFor(String parameterName) {
 
   <E> ParameterSpec<E> parameterSpecFor(String parameterName);
 
-  default ParameterSpace toParameterSpace() {
+  default ParameterSpace toParameterSpace(List<String> seedParameterNames) {
+    Set<String> optionals = Utils.optionalParameterNamesIn(this.parameterNames()
+                                                               .stream()
+                                                               .map(this::parameterSpecFor)
+                                                               .collect(toSet()),
+                                                           seedParameterNames);
     ParameterSpace.Builder b = new ParameterSpace.Builder();
     this.parameterNames()
         .stream()
         .map(this::parameterSpecFor)
-        .map(each -> each.toParameter(this))
+        .map(each -> each.toParameter(this, optionals.contains(each.name())))
         .forEach(b::addParameter);
     this.constraints()
         .forEach(b::addConstraint);
     return b.build();
   }
+
+  enum Utils {
+    ;
+
+    private static Set<String> optionalParameterNamesIn(Collection<ParameterSpec<?>> allParameterSpecs, Collection<String> seedParameterNames) {
+      return optionalParameterNamesIn(allParameterSpecs.stream()
+                                                       .collect(toMap(ParameterSpec::name, e -> e)), seedParameterNames
+      );
+    }
+
+    private static Set<String> optionalParameterNamesIn(Map<String, ParameterSpec<?>> allParameterSpecs, Collection<String> seedParameterNames) {
+      Set<String> ret = reachableParameterNamesIn(allParameterSpecs, seedParameterNames);
+      ret.removeAll(requiredParameterNamesIn(allParameterSpecs, seedParameterNames));
+      return ret;
+    }
+
+    private static Set<String> reachableParameterNamesIn(Map<String, ParameterSpec<?>> allParameterSpecs, Collection<String> seedParameterNames) {
+      return seedParameterNames.stream()
+                               .flatMap(n -> reachableParameterNamesFrom(allParameterSpecs.get(n),
+                                                                         new HashSet<>(allParameterSpecs.values())).stream())
+                               .collect(toSet());
+    }
+
+    private static Set<String> requiredParameterNamesIn(Map<String, ParameterSpec<?>> allParameterSpecs, Collection<String> seedParameterNames) {
+      return seedParameterNames.stream()
+                               .flatMap(n -> requiredParameterNamesBy(allParameterSpecs.get(n),
+                                                                      new HashSet<>(allParameterSpecs.values())).stream())
+                               .collect(toSet());
+    }
+
+    private static Set<String> reachableParameterNamesFrom(ParameterSpec<?> cur, Set<ParameterSpec<?>> allParameterSpecs) {
+      Set<String> ret = new HashSet<>();
+      Set<ParameterSpec<?>> visited = new HashSet<>();
+      reachableParameterNamesFrom(ret, cur, visited, allParameterSpecs);
+      return ret;
+    }
+
+    private static void reachableParameterNamesFrom(Set<String> out, ParameterSpec<?> cur, Set<ParameterSpec<?>> visited, Set<ParameterSpec<?>> allParameterSpecs) {
+      if (visited.contains(cur)) {
+        return;
+      }
+      visited.add(cur);
+      out.addAll(directlyReachableParameterNamesFrom(cur));
+      allParameterSpecs.forEach(p -> reachableParameterNamesFrom(out, p, visited, allParameterSpecs));
+    }
+
+    private static Set<String> directlyReachableParameterNamesFrom(ParameterSpec<?> parameterSpec) {
+      return parameterSpec.valueResolvers()
+                          .stream()
+                          .flatMap(r -> r.dependencies().stream())
+                          .collect(toSet());
+    }
+
+    private static Set<String> requiredParameterNamesBy(ParameterSpec<?> cur, Set<ParameterSpec<?>> allParameterSpecs) {
+      Set<String> ret = new HashSet<>();
+      Set<ParameterSpec<?>> visited = new HashSet<>();
+      requiredParameterNamesBy(ret, cur, visited, allParameterSpecs);
+      return ret;
+    }
+
+
+    private static void requiredParameterNamesBy(Set<String> out, ParameterSpec<?> cur, Set<ParameterSpec<?>> visited, Set<ParameterSpec<?>> allParameterSpecs) {
+      if (visited.contains(cur)) {
+        return;
+      }
+      visited.add(cur);
+      out.addAll(directlyRequiredParameterNamesBy(cur));
+      allParameterSpecs.forEach(p -> reachableParameterNamesFrom(out, p, visited, allParameterSpecs));
+    }
+
+    static Set<String> directlyRequiredParameterNamesBy(ParameterSpec<?> parameterSpec) {
+      Set<String> requiredParameterNames = null;
+      for (ValueResolver<?> r : parameterSpec.valueResolvers()) {
+        if (requiredParameterNames == null) requiredParameterNames = new HashSet<>(r.dependencies());
+        else requiredParameterNames.retainAll(r.dependencies());
+        if (requiredParameterNames.isEmpty()) {
+          break;
+        }
+      }
+      return requiredParameterNames == null ? new HashSet<>()
+                                            : requiredParameterNames;
+    }
+  }
 }
diff --git a/src/main/java/com/github/jcunit/model/ParameterSpec.java b/src/main/java/com/github/jcunit/model/ParameterSpec.java
index 69f5bab36..1e0a8955f 100644
--- a/src/main/java/com/github/jcunit/model/ParameterSpec.java
+++ b/src/main/java/com/github/jcunit/model/ParameterSpec.java
@@ -53,10 +53,10 @@ default List<String> dependencies() {
    */
   List<ValueResolver<E>> valueResolvers();
 
-  default Parameter<List<ValueResolver<E>>> toParameter(ParameterSpaceSpec parameterSpaceSpec) {
+  default Parameter<List<ValueResolver<E>>> toParameter(ParameterSpaceSpec parameterSpaceSpec, boolean optional) {
     switch (type()) {
       case SIMPLE:
-        return Type.createListSimple(this, parameterSpaceSpec);
+        return Type.createListSimple(this, parameterSpaceSpec, optional);
       case REGEX:
         boolean isSeed = Utils.isRequired(parameterSpaceSpec, this.name(), parameterSpaceSpec.parameterNames());
         return Type.createRegex(isSeed, this);
diff --git a/src/main/java/com/github/jcunit/pipeline/Pipeline.java b/src/main/java/com/github/jcunit/pipeline/Pipeline.java
index 55351fde6..40a54362f 100644
--- a/src/main/java/com/github/jcunit/pipeline/Pipeline.java
+++ b/src/main/java/com/github/jcunit/pipeline/Pipeline.java
@@ -34,7 +34,7 @@ public interface Pipeline {
   @ParseConfigArgumentsWith(Standard.ConfigArgumentsParser.class)
   class Standard implements Pipeline {
     public static class ConfigArgumentsParser implements ConfigurePipelineWith.PipelineConfigArgumentsParser {
-      enum Keyword {
+      public enum Keyword {
         STRENGTH("strength"),
         NEGATIVE_TEST_GENERATION("negativeTestGeneration"),
         SEED_GENERATOR_METHOD("seedGeneratorMethod");
diff --git a/src/main/java/com/github/jcunit/runners/junit5/JCUnitTestEngine.java b/src/main/java/com/github/jcunit/runners/junit5/JCUnitTestEngine.java
index a65807644..0a26c2cba 100644
--- a/src/main/java/com/github/jcunit/runners/junit5/JCUnitTestEngine.java
+++ b/src/main/java/com/github/jcunit/runners/junit5/JCUnitTestEngine.java
@@ -31,6 +31,7 @@
 import static com.github.jcunit.runners.junit5.JCUnitTestEngineUtils.*;
 import static com.github.valid8j.fluent.Expectations.require;
 import static com.github.valid8j.fluent.Expectations.value;
+import static java.util.Arrays.asList;
 import static java.util.Collections.emptyList;
 import static java.util.Collections.singletonList;
 import static java.util.stream.Collectors.toList;
@@ -79,7 +80,7 @@ public void beforeAll(ExtensionContext context) {
       validateReferencesOfConstraints(errors, parameterSpaceSpec, knownNames);
       require(value(errors).satisfies().empty());
 
-      List<TestData> testDataSet = Utils.generateTestDataSet(pipelineSpec, parameterSpaceSpec.toParameterSpace());
+      List<TestData> testDataSet = Utils.generateTestDataSet(pipelineSpec, parameterSpaceSpec.toParameterSpace(asList("param2", "param2")));
       context.getStore(namespace).put("testDataSet", testDataSet);
       context.getStore(namespace).put("parameterSpaceSpec", parameterSpaceSpec);
       context.getStore(namespace).put("definedPredicates", definedPredicates);
diff --git a/src/test/java/com/github/dakusui/jcunit8/examples/bankaccount/BankAccount.java b/src/test/java/com/github/dakusui/jcunit8/examples/bankaccount/BankAccount.java
index d309a4468..711917cb6 100644
--- a/src/test/java/com/github/dakusui/jcunit8/examples/bankaccount/BankAccount.java
+++ b/src/test/java/com/github/dakusui/jcunit8/examples/bankaccount/BankAccount.java
@@ -19,7 +19,7 @@ void withdraw(int amount) {
       throw new IllegalArgumentException("Invalid amount (non-positive): " + amount);
     }
     if (amount > balance)
-      throw new InsufficientBalance();
+      throw new InsufficientBalance("Tried to: " + balance + "-" + amount);
     balance -= amount;
   }
 
@@ -36,5 +36,8 @@ int getBalance() {
   }
 
   static class InsufficientBalance extends RuntimeException {
+    public InsufficientBalance(String message) {
+      super(message);
+    }
   }
 }
diff --git a/src/test/java/com/github/dakusui/jcunit8/sandbox/example/TestExample2.java b/src/test/java/com/github/dakusui/jcunit8/sandbox/example/TestExample2.java
index 20ffffc02..025ae119e 100644
--- a/src/test/java/com/github/dakusui/jcunit8/sandbox/example/TestExample2.java
+++ b/src/test/java/com/github/dakusui/jcunit8/sandbox/example/TestExample2.java
@@ -60,7 +60,7 @@ public static boolean startingWithSalute(@From("param1") String param1) {
   }
 
   @JCUnitTest
-  @Given("startingWithSalute")
+  //@Given("startingWithSalute")
   public void testMethod(@From("param1") String param1, @From("param2") Map<String, List<String>> param2) {
     System.out.println("param1:" + param1 + ", param2:" + param2);
   }
diff --git a/src/test/java/com/github/dakusui/jcunit8/sandbox/example/TestExample5.java b/src/test/java/com/github/dakusui/jcunit8/sandbox/example/TestExample5.java
index c2e530db0..8075453ac 100644
--- a/src/test/java/com/github/dakusui/jcunit8/sandbox/example/TestExample5.java
+++ b/src/test/java/com/github/dakusui/jcunit8/sandbox/example/TestExample5.java
@@ -3,6 +3,7 @@
 import com.github.jcunit.annotations.*;
 import com.github.jcunit.annotations.ConfigurePipelineWith.Entry;
 import com.github.jcunit.model.ValueResolver;
+import com.github.jcunit.pipeline.Pipeline;
 import com.github.jcunit.runners.junit5.JCUnitTestEngine;
 import org.junit.jupiter.api.extension.ExtendWith;
 
diff --git a/src/test/java/com/github/jcunitx/parameterspace/ParameterSpaceSpecTest.java b/src/test/java/com/github/jcunitx/parameterspace/ParameterSpaceSpecTest.java
index 9c5576eea..f5d2db8fa 100644
--- a/src/test/java/com/github/jcunitx/parameterspace/ParameterSpaceSpecTest.java
+++ b/src/test/java/com/github/jcunitx/parameterspace/ParameterSpaceSpecTest.java
@@ -1,16 +1,25 @@
 package com.github.jcunitx.parameterspace;
 
 import com.github.dakusui.jcunit8.testutils.TestBase;
+import com.github.dakusui.jcunit8.ututiles.PipelineConfigBuilder;
+import com.github.jcunit.factorspace.Constraint;
 import com.github.jcunit.factorspace.ParameterSpace;
 import com.github.jcunit.model.ParameterSpaceSpec;
+import com.github.jcunit.model.ParameterSpec;
+import com.github.jcunit.model.ValueResolver;
 import com.github.jcunit.pipeline.Pipeline;
-import com.github.dakusui.jcunit8.ututiles.PipelineConfigBuilder;
 import com.github.jcunit.pipeline.PipelineSpec;
 import com.github.jcunit.testsuite.TestSuite;
+import com.github.valid8j.pcond.forms.Printables;
 import org.junit.jupiter.api.Test;
 
+import java.util.List;
+import java.util.function.Function;
+
 import static com.github.valid8j.fluent.Expectations.assertStatement;
 import static com.github.valid8j.fluent.Expectations.value;
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
 
 /**
  * // @formatter:off 
@@ -19,47 +28,153 @@
 public class ParameterSpaceSpecTest extends TestBase {
   @Test
   public void testParameterSpaceSpec() {
-    ParameterSpaceSpec spaceSpec = SpecTestUtils.createTestParameterSpaceSpec();
-
-    assertStatement(value(spaceSpec).satisfies(spec -> spec.invoke("parameterNames")
-                                                           .asListOf(String.class)
-                                                           .satisfies(names -> names.size()
-                                                                                    .toBe()
-                                                                                    .equalTo(2))
-                                                           .satisfies(names -> names.elementAt(0)
-                                                                                    .satisfies()
-                                                                                    .equalTo("p1"))
-                                                           .satisfies(names -> names.elementAt(1)
-                                                                                    .toBe()
-                                                                                    .equalTo("p2")))
-                                    .satisfies(spec -> spec.invoke("parameterSpecFor", "p1")
-                                                           .invoke("valueResolvers")
-                                                           .asList()
-                                                           .size()
-                                                           .toBe()
-                                                           .equalTo(2))
-                                    .satisfies(spec -> spec.invoke("parameterSpecFor", "p2")
-                                                           .invoke("valueResolvers")
-                                                           .asList()
-                                                           .size()
-                                                           .toBe()
-                                                           .equalTo(2)));
+    List<ParameterSpec<?>> parameterSpecs = parameterParameterSpecs();
+    List<Constraint> constraints = parameterConstraints();
+    {
+      ParameterSpaceSpec spaceSpec = ParameterSpaceSpec.create(parameterSpecs, constraints);
+      {
+        int parameterSpecsSize = parameterSpecs.size();
+        ParameterSpec<?> firstParameterSpec = parameterSpecs.get(0);
+        ParameterSpec<?> lastParameterSpec = parameterSpecs.get(parameterSpecsSize - 1);
+        {
+          assertStatement(value(spaceSpec).satisfies(spec -> spec.function(functionParameterNames())
+                                                                 .asListOf(String.class)
+                                                                 .satisfies(names -> names.size()
+                                                                                          .toBe()
+                                                                                          .equalTo(parameterSpecsSize))
+                                                                 .satisfies(names -> names.elementAt(0)
+                                                                                          .satisfies()
+                                                                                          .equalTo(firstParameterSpec.name()))
+                                                                 .satisfies(names -> names.elementAt(parameterSpecsSize - 1)
+                                                                                          .toBe()
+                                                                                          .equalTo(lastParameterSpec.name())))
+                                          .satisfies(spec -> spec.function(functionParameterSpecFor(firstParameterSpec.name()))
+                                                                 .function(functionValueResolvers())
+                                                                 .asList()
+                                                                 .size()
+                                                                 .toBe()
+                                                                 .equalTo(firstParameterSpec.valueResolvers().size()))
+                                          .satisfies(spec -> spec.function(functionParameterSpecFor(lastParameterSpec.name()))
+                                                                 .function(functionValueResolvers())
+                                                                 .asList()
+                                                                 .size()
+                                                                 .toBe()
+                                                                 .equalTo(lastParameterSpec.valueResolvers().size())));
+        }
+      }
+    }
   }
 
   @Test
   public void testToParameterSpace() {
-    ParameterSpace parameterSpace = SpecTestUtils.createTestParameterSpaceSpec().toParameterSpace();
-    assertStatement(value(parameterSpace).invoke("getParameterNames")
-                                         .asListOf(String.class)
-                                         .elementAt(0).toBe().equalTo("p1"));
+    List<ParameterSpec<?>> parameterSpecs = parameterParameterSpecs();
+    List<Constraint> constraints = parameterConstraints();
+    Function<ParameterSpaceSpec, List<String>> parameterSeedParameterNamesGenerator = parameterSeedParameterNamesGenerator();
+    {
+      ParameterSpaceSpec testParameterSpaceSpec = ParameterSpaceSpec.create(parameterSpecs, constraints);
+      List<String> seedParameterNames = parameterSeedParameterNamesGenerator.apply(testParameterSpaceSpec);
+      {
+        ParameterSpace parameterSpace = testParameterSpaceSpec.toParameterSpace(seedParameterNames);
+        {
+          int parameterSpecsSize = parameterSpecs.size();
+          ParameterSpec<?> firstParameterSpec = parameterSpecs.get(0);
+          ParameterSpec<?> lastParameterSpec = parameterSpecs.get(parameterSpecsSize - 1);
+          {
+            assertStatement(value(parameterSpace).satisfies(s -> s.function(functionGetParameterNames())
+                                                                  .asListOf(String.class)
+                                                                  .elementAt(0)
+                                                                  .toBe()
+                                                                  .equalTo(firstParameterSpec.name()))
+                                                 .satisfies(s -> s.function(functionGetParameterNames())
+                                                                  .asListOf(String.class)
+                                                                  .elementAt(parameterSpecsSize - 1)
+                                                                  .toBe()
+                                                                  .equalTo(lastParameterSpec.name())));
+          }
+        }
+      }
+    }
+  }
+
+  @Test
+  public void testToParameterSpaceEmpty() {
+    List<ParameterSpec<?>> parameterSpecs = parameterParameterSpecs_empty();
+    List<Constraint> constraints = parameterConstraints();
+    Function<ParameterSpaceSpec, List<String>> parameterSpaceSpecListFunction = parameterSeedParameterNamesGenerator();
+    {
+      ParameterSpaceSpec testParameterSpaceSpec = ParameterSpaceSpec.create(parameterSpecs, constraints);
+      List<String> seedParameterNames = parameterSpaceSpecListFunction.apply(testParameterSpaceSpec);
+      {
+        ParameterSpace parameterSpace = testParameterSpaceSpec.toParameterSpace(seedParameterNames);
+        {
+          assertStatement(value(parameterSpace).satisfies(s -> s.function(functionGetParameterNames())
+                                                                .asListOf(String.class)
+                                                                .toBe()
+                                                                .empty()));
+        }
+      }
+    }
   }
 
   @Test
   public void testToTestSuite() {
-    TestSuite testSuite = Pipeline.Standard.create(new PipelineSpec.Builder(new PipelineConfigBuilder()
-                                                                                  .build())
-                                                       .build())
-                                           .execute(SpecTestUtils.createTestParameterSpaceSpec().toParameterSpace());
-    testSuite.forEach(System.out::println);
+    List<ParameterSpec<?>> parameterSpecs = parameterParameterSpecs();
+    List<Constraint> constraints = parameterConstraints();
+    boolean negativeTestGenerationEnabled = parameterNegativeTestGenerationEnabled();
+    Function<ParameterSpaceSpec, List<String>> parameterFunctionParamaterSpaceSpecToSeedParameterNames = parameterSeedParameterNamesGenerator();
+    {
+      ParameterSpaceSpec testParameterSpaceSpec = ParameterSpaceSpec.create(parameterSpecs, constraints);
+      PipelineSpec pipelineSpec = new PipelineSpec.Builder(new PipelineConfigBuilder().withNegativeTestGeneration(negativeTestGenerationEnabled)
+                                                                                      .build())
+          .build();
+      List<String> seedParameterNames = parameterFunctionParamaterSpaceSpecToSeedParameterNames.apply(testParameterSpaceSpec);
+      {
+        TestSuite testSuite = Pipeline.Standard.create(pipelineSpec).execute(testParameterSpaceSpec.toParameterSpace(seedParameterNames));
+        {
+          testSuite.forEach(System.out::println);
+        }
+      }
+    }
+  }
+
+  private static boolean parameterNegativeTestGenerationEnabled() {
+    return false;
+  }
+
+  private static Function<ParameterSpaceSpec, List<String>> parameterSeedParameterNamesGenerator() {
+    return ParameterSpaceSpecTest::parameterSeedParameterNames;
+  }
+
+  private static List<ParameterSpec<?>> parameterParameterSpecs_empty() {
+    return emptyList();
+  }
+
+  private static List<ParameterSpec<?>> parameterParameterSpecs() {
+    return asList(SpecTestUtils.createTestParameterSpecP1(),
+                  SpecTestUtils.createTestParameterSpecP2());
+  }
+
+  private static List<String> parameterSeedParameterNames(ParameterSpaceSpec testParameterSpaceSpec) {
+    return testParameterSpaceSpec.parameterNames();
+  }
+
+  private static List<Constraint> parameterConstraints() {
+    return emptyList();
+  }
+
+  private static Function<ParameterSpaceSpec, List<String>> functionParameterNames() {
+    return Printables.function("parameterNames", ParameterSpaceSpec::parameterNames);
+  }
+
+  private static Function<ParameterSpaceSpec, ParameterSpec<Object>> functionParameterSpecFor(String parameterSpecName) {
+    return Printables.function("parameterSpecFor[" + parameterSpecName + "]", s -> s.parameterSpecFor(parameterSpecName));
+  }
+
+  private static Function<ParameterSpace, List<String>> functionGetParameterNames() {
+    return Printables.function("getParameterNames", ParameterSpace::getParameterNames);
+  }
+
+  private static Function<ParameterSpec<Object>, List<ValueResolver<Object>>> functionValueResolvers() {
+    return Printables.function("valueResolvers", ParameterSpec::valueResolvers);
   }
 }
diff --git a/src/test/java/com/github/jcunitx/parameterspace/ParameterSpecTest.java b/src/test/java/com/github/jcunitx/parameterspace/ParameterSpecTest.java
index 5d81aa645..1f8ca3907 100644
--- a/src/test/java/com/github/jcunitx/parameterspace/ParameterSpecTest.java
+++ b/src/test/java/com/github/jcunitx/parameterspace/ParameterSpecTest.java
@@ -10,6 +10,8 @@
 
 import static com.github.valid8j.fluent.Expectations.assertStatement;
 import static com.github.valid8j.fluent.Expectations.value;
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
 
 /**
  * // @formatter:off 
@@ -34,8 +36,9 @@ public void testParameterSpace() {
   @Test
   public void testParameterSpecToParameter() {
     ParameterSpec<String> testParameterSpecP1 = SpecTestUtils.createTestParameterSpecP1();
-    ParameterSpaceSpec parameterSpaceSpec = SpecTestUtils.createParameterSpaceSpec(testParameterSpecP1, SpecTestUtils.createTestParameterSpecP2());
-    Parameter<List<ValueResolver<String>>> parameter = testParameterSpecP1.toParameter(parameterSpaceSpec);
+    List<ParameterSpec<?>> parameterSpecs = asList(testParameterSpecP1, SpecTestUtils.createTestParameterSpecP2());
+    ParameterSpaceSpec parameterSpaceSpec = ParameterSpaceSpec.create(parameterSpecs, emptyList());
+    Parameter<List<ValueResolver<String>>> parameter = testParameterSpecP1.toParameter(parameterSpaceSpec, false);
 
     assertStatement(
         value(parameter).satisfies(p -> p.invoke("getName").asString().satisfies().equalTo("p1"))
diff --git a/src/test/java/com/github/jcunitx/parameterspace/SpecTestUtils.java b/src/test/java/com/github/jcunitx/parameterspace/SpecTestUtils.java
index a6e23c051..6944fe081 100644
--- a/src/test/java/com/github/jcunitx/parameterspace/SpecTestUtils.java
+++ b/src/test/java/com/github/jcunitx/parameterspace/SpecTestUtils.java
@@ -1,13 +1,10 @@
 package com.github.jcunitx.parameterspace;
 
 import com.github.jcunit.annotations.JCUnitParameter;
-import com.github.jcunit.model.ParameterSpaceSpec;
+import com.github.jcunit.core.Invokable;
 import com.github.jcunit.model.ParameterSpec;
 import com.github.jcunit.model.ValueResolver;
 
-import static java.util.Arrays.asList;
-import static java.util.Collections.emptyList;
-
 /**
  * // @formatter:off 
  * // @formatter:on 
@@ -15,19 +12,29 @@
 public enum SpecTestUtils {
   ;
 
-  static ParameterSpaceSpec createTestParameterSpaceSpec() {
-    return createParameterSpaceSpec(createTestParameterSpecP1(), createTestParameterSpecP2());
-  }
-
-  static ParameterSpaceSpec createParameterSpaceSpec(ParameterSpec<String> p1, ParameterSpec<String> p2) {
-    return ParameterSpaceSpec.create(asList(p1, p2), emptyList());
-  }
-
+  @SuppressWarnings("unchecked")
   static ParameterSpec<String> createTestParameterSpecP1() {
-    return ParameterSpec.create("p1", JCUnitParameter.Type.SIMPLE, new String[0], ValueResolver.from("p1v1").$(), ValueResolver.from("p1v2").$());
+    return ParameterSpec.create("p1",
+                                JCUnitParameter.Type.SIMPLE,
+                                new String[0],
+                                ValueResolver.from("p1v1").$(),
+                                ValueResolver.from("p1v2").$());
   }
 
+  static ParameterSpec<String> createTestParameterSpecP1_referenceP2() {
+    return ParameterSpec.create("p1",
+                                JCUnitParameter.Type.SIMPLE,
+                                new String[0],
+                                ValueResolver.from("p1v1").$(),
+                                ValueResolver.fromInvokable(Invokable.referenceTo("p2", 0)));
+  }
+  @SuppressWarnings("unchecked")
   static ParameterSpec<String> createTestParameterSpecP2() {
-    return ParameterSpec.create("p2", JCUnitParameter.Type.SIMPLE, new String[0], ValueResolver.from("p2v1").$(), ValueResolver.from("p2v2").$());
+    return ParameterSpec.create("p2",
+                                JCUnitParameter.Type.SIMPLE,
+                                new String[0],
+                                ValueResolver.from("p2v1").$(),
+                                ValueResolver.from("p2v2").$());
   }
+
 }