milo: Enable Swarming LogDog log loading.

logdog/common/types/streamname_test.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package types
 
 import (
         "flag"
         "fmt"
         "strings"
         "testing"
 
         . "github.com/smartystreets/goconvey/convey"
 )
 
 func TestStreamNameAsFlag(t *testing.T) {
+        t.Parallel()
+
         Convey(`Given an FlagSet configured with a StreamName flag`, t, func() {
                 var stream StreamName
                 fs := flag.NewFlagSet("test", flag.ContinueOnError)
                 fs.Var(&stream, "stream", "The stream name.")
 
                 Convey(`When the stream flag is set to "test"`, func() {
                         err := fs.Parse([]string{"-stream", "test"})
                         So(err, ShouldBeNil)
 
                         Convey(`The stream variable should be populated with "test".`, func() {
                                 So(stream, ShouldEqual, "test")
                         })
                 })
 
                 Convey(`An invalid stream name should fail to parse.`, func() {
                         err := fs.Parse([]string{"-stream", "_beginsWithUnderscore"})
                         So(err, ShouldNotBeNil)
                 })
         })
 }
 
 func TestStreamName(t *testing.T) {
+        t.Parallel()
+
         Convey(`MakeStreamName`, t, func() {
                 type e struct {
                         t []string // Test value.
                         e string   // Expected value.
                 }
                 for _, entry := range []e{
                         {[]string{""}, "FILL"},
                         {[]string{"", ""}, "FILL/FILL"},
                         {[]string{"", "foo", "ba!r", "¿baz"}, "FILL/foo/ba_r/FILL_baz"},
                         {[]string{"foo", "bar baz"}, "foo/bar_baz"},
@@ skipping 105 matching lines @@
                         Convey(fmt.Sprintf(`Stream Name "%s" has %d segments: %v`, entry.s, entry.n, entry.p), func() {
                                 So(entry.s.Segments(), ShouldResemble, entry.p)
                                 So(len(entry.s.Segments()), ShouldEqual, entry.s.SegmentCount())
                                 So(len(entry.s.Segments()), ShouldEqual, entry.n)
                         })
                 }
         })
 }
 
 func TestStreamPath(t *testing.T) {
+        t.Parallel()
+
         Convey(`StreamPath.Split, StreamPath.Validate`, t, func() {
                 type e struct {
                         p      string // The stream path.
                         prefix string // The split prefix.
                         name   string // The split name.
                         sep    bool
                         valid  bool
                 }
                 for _, entry := range []e{
                         {"", "", "", false, false},
@@ skipping 48 matching lines @@
 
                                         if p == "" {
                                                 break
                                         }
                                 }
                                 So(parts, ShouldResemble, tc.c)
                         })
                 }
         })
 }