diff --git a/bootstrap_test.go b/bootstrap_test.go
index de93b6d..e50d9ea 100644
--- a/bootstrap_test.go
+++ b/bootstrap_test.go
@@ -13,9 +13,9 @@
 package gocheck_test
 
 import (
+	"fmt"
 	"launchpad.net/gocheck"
 	"strings"
-	"fmt"
 )
 
 type BootstrapS struct{}
diff --git a/checkers.go b/checkers.go
index e6e72c4..5c91200 100644
--- a/checkers.go
+++ b/checkers.go
@@ -1,9 +1,9 @@
 package gocheck
 
 import (
+	"fmt"
 	"reflect"
 	"regexp"
-	"fmt"
 )
 
 // -----------------------------------------------------------------------
@@ -238,7 +238,6 @@
 	return value.Len() == n, ""
 }
 
-
 // -----------------------------------------------------------------------
 // ErrorMatches checker.
 
diff --git a/foundation_test.go b/foundation_test.go
index d59b99e..9f89150 100644
--- a/foundation_test.go
+++ b/foundation_test.go
@@ -7,12 +7,12 @@
 package gocheck_test
 
 import (
-	"launchpad.net/gocheck"
-	"strings"
-	"regexp"
 	"fmt"
+	"launchpad.net/gocheck"
 	"log"
 	"os"
+	"regexp"
+	"strings"
 )
 
 // -----------------------------------------------------------------------
diff --git a/gocheck.go b/gocheck.go
index e26e7cb..c353b3e 100644
--- a/gocheck.go
+++ b/gocheck.go
@@ -53,6 +53,24 @@
 	return method.Info.Func.Pointer()
 }
 
+func (method *methodType) suiteName() string {
+	t := method.Info.Type.In(0)
+	if t.Kind() == reflect.Ptr {
+		t = t.Elem()
+	}
+	return t.Name()
+}
+
+func (method *methodType) String() string {
+	return method.suiteName()+"."+method.Info.Name
+}
+
+func (method *methodType) matches(re *regexp.Regexp) bool {
+	return (re.MatchString(method.Info.Name) ||
+		re.MatchString(method.suiteName()) ||
+		re.MatchString(method.String()))
+}
+
 type C struct {
 	method   *methodType
 	kind     funcKind
@@ -504,24 +522,8 @@
 		}
 	}
 
-	// This map will be used to filter out duplicated methods.  This
-	// looks like a bug in Go, described on issue 906:
-	// http://code.google.com/p/go/issues/detail?id=906
-	seen := make(map[uintptr]bool, suiteNumMethods)
-
-	// XXX Shouldn't Name() work here? Why does it return an empty string?
-	suiteName := suiteType.String()
-	if index := strings.LastIndex(suiteName, "."); index != -1 {
-		suiteName = suiteName[index+1:]
-	}
-
 	for i := 0; i != suiteNumMethods; i++ {
 		method := newMethod(suiteValue, i)
-		methodPC := method.PC()
-		if _, found := seen[methodPC]; found {
-			continue
-		}
-		seen[methodPC] = true
 		switch method.Info.Name {
 		case "SetUpSuite":
 			runner.setUpSuite = method
@@ -532,7 +534,14 @@
 		case "TearDownTest":
 			runner.tearDownTest = method
 		default:
-			if isWanted(conf.Benchmark, suiteName, method.Info.Name, filterRegexp) {
+			prefix := "Test"
+			if conf.Benchmark {
+				prefix = "Benchmark"
+			}
+			if !strings.HasPrefix(method.Info.Name, prefix) {
+				continue
+			}
+			if filterRegexp == nil || method.matches(filterRegexp) {
 				runner.tests = append(runner.tests, method)
 			}
 		}
@@ -540,25 +549,6 @@
 	return runner
 }
 
-// isWanted returns true if the given suite and method names should be run.
-// The bench result indicates whether the method is a benchmark rather than
-// a test.
-func isWanted(benchmark bool, suiteName, methodName string, filterRegexp *regexp.Regexp) bool {
-	prefix := "Test"
-	if benchmark {
-		prefix = "Benchmark"
-	}
-	if !strings.HasPrefix(methodName, prefix) {
-		return false
-	}
-	if filterRegexp == nil {
-		return true
-	}
-	return (filterRegexp.MatchString(methodName) ||
-		filterRegexp.MatchString(suiteName) ||
-		filterRegexp.MatchString(suiteName+"."+methodName))
-}
-
 // Run all methods in the given suite.
 func (runner *suiteRunner) run() *Result {
 	if runner.tracker.result.RunError == nil && len(runner.tests) > 0 {
diff --git a/gocheck_test.go b/gocheck_test.go
index e4bf4d4..aad261a 100644
--- a/gocheck_test.go
+++ b/gocheck_test.go
@@ -4,13 +4,13 @@
 package gocheck_test
 
 import (
-	"launchpad.net/gocheck"
-	"testing"
-	"runtime"
-	"regexp"
 	"flag"
 	"fmt"
+	"launchpad.net/gocheck"
 	"os"
+	"regexp"
+	"runtime"
+	"testing"
 	"time"
 )
 
diff --git a/helpers_test.go b/helpers_test.go
index 0469426..79348bc 100644
--- a/helpers_test.go
+++ b/helpers_test.go
@@ -126,7 +126,7 @@
 	testHelperFailure(c, "Check(1, checker, 2, msg)", false, false, log,
 		func() interface{} {
 			// Nice leading comment.
-			return c.Check(1, checker, 2)  // Hello there
+			return c.Check(1, checker, 2) // Hello there
 		})
 }
 
@@ -379,7 +379,6 @@
 		})
 }
 
-
 // -----------------------------------------------------------------------
 // MakeDir() tests.
 
diff --git a/run.go b/run.go
index 6d6393c..dc75d77 100644
--- a/run.go
+++ b/run.go
@@ -1,8 +1,10 @@
 package gocheck
 
 import (
+	"bufio"
 	"flag"
 	"fmt"
+	"os"
 	"testing"
 	"time"
 )
@@ -24,11 +26,12 @@
 // Public running interface.
 
 var (
-	filterFlag  = flag.String("gocheck.f", "", "Regular expression selecting what to run")
+	filterFlag  = flag.String("gocheck.f", "", "Regular expression selecting which tests and/or suites to run")
 	verboseFlag = flag.Bool("gocheck.v", false, "Verbose mode")
 	streamFlag  = flag.Bool("gocheck.vv", false, "Super verbose mode (disables output caching)")
 	benchFlag   = flag.Bool("gocheck.b", false, "Run benchmarks")
 	benchTime   = flag.Duration("gocheck.btime", 1 * time.Second, "approximate run time for each benchmark")
+	listFlag    = flag.Bool("gocheck.list", false, "List the names of all tests that will be run")
 )
 
 // Run all test suites registered with the Suite() function, printing
@@ -42,6 +45,14 @@
 		Benchmark: *benchFlag,
 		BenchmarkTime: *benchTime,
 	}
+	if *listFlag {
+		w := bufio.NewWriter(os.Stdout)
+		for _, name := range ListAll(conf) {
+			fmt.Fprintln(w, name)
+		}
+		w.Flush()
+		return
+	}
 	result := RunAll(conf)
 	println(result.String())
 	if !result.Passed() {
@@ -49,7 +60,7 @@
 	}
 }
 
-// Run all test suites registered with the Suite() function, using the
+// RunAll runs all test suites registered with the Suite() function, using the
 // given run configuration.
 func RunAll(runConf *RunConf) *Result {
 	result := Result{}
@@ -59,12 +70,34 @@
 	return &result
 }
 
-// Run the given test suite using the provided run configuration.
+// Run runs the given test suite using the provided run configuration.
 func Run(suite interface{}, runConf *RunConf) *Result {
 	runner := newSuiteRunner(suite, runConf)
 	return runner.run()
 }
 
+// ListAll returns the names of all the test functions registered with the
+// Suite function that will be run with the provided run configuration.
+func ListAll(runConf *RunConf) []string {
+	var names []string
+	for _, suite := range allSuites {
+		names = append(names, List(suite, runConf)...)
+	}
+	return names
+}
+
+// List prints the names of the test functions in the given
+// suite that will be run with the provided run configuration
+// to the given Writer.
+func List(suite interface{}, runConf *RunConf) []string {
+	var names []string
+	runner := newSuiteRunner(suite, runConf)
+	for _, t := range runner.tests {
+		names = append(names, t.String())
+	}
+	return names
+}
+
 // -----------------------------------------------------------------------
 // Result methods.
 
diff --git a/run_test.go b/run_test.go
index 081d3af..3700ac7 100644
--- a/run_test.go
+++ b/run_test.go
@@ -2,6 +2,7 @@
 
 package gocheck_test
 
+
 import (
 	"errors"
 	. "launchpad.net/gocheck"
@@ -99,21 +100,21 @@
 
 func (s *RunS) TestAdd(c *C) {
 	result := &Result{
-		Succeeded: 1,
-		Skipped: 2,
-		Failed: 3,
-		Panicked: 4,
-		FixturePanicked: 5,
-		Missed: 6,
+		Succeeded:        1,
+		Skipped:          2,
+		Failed:           3,
+		Panicked:         4,
+		FixturePanicked:  5,
+		Missed:           6,
 		ExpectedFailures: 7,
 	}
 	result.Add(&Result{
-		Succeeded: 10,
-		Skipped: 20,
-		Failed: 30,
-		Panicked: 40,
-		FixturePanicked: 50,
-		Missed: 60,
+		Succeeded:        10,
+		Skipped:          20,
+		Failed:           30,
+		Panicked:         40,
+		FixturePanicked:  50,
+		Missed:           60,
 		ExpectedFailures: 70,
 	})
 	c.Check(result.Succeeded, Equals, 11)
@@ -280,6 +281,24 @@
 }
 
 // -----------------------------------------------------------------------
+// Verify that List works correctly.
+
+func (s *RunS) TestListFiltered(c *C) {
+	names := List(&FixtureHelper{}, &RunConf{Filter: "1"})
+	c.Assert(names, DeepEquals, []string{
+		"FixtureHelper.Test1",
+	})
+}
+
+func (s *RunS) TestList(c *C) {
+	names := List(&FixtureHelper{}, &RunConf{})
+	c.Assert(names, DeepEquals, []string{
+		"FixtureHelper.Test1",
+		"FixtureHelper.Test2",
+	})
+}
+
+// -----------------------------------------------------------------------
 // Verify that verbose mode prints tests which pass as well. 
 
 func (s *RunS) TestVerboseMode(c *C) {