LogDog: Implement StreamName.Split.

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"
@@ skipping 144 matching lines @@
                         {StreamName("foo/bar"), []string{"foo", "bar"}, 2},
                         {StreamName("foo/bar/baz"), []string{"foo", "bar", "baz"}, 3},
                 } {
                         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)
                         })
                 }
         })
+
+        Convey(`StreamName.Split`, t, func() {
+                for _, tc := range []struct {
+                        s    StreamName
+                        base StreamName
+                        last StreamName
+                }{
+                        {"", "", ""},
+                        {"foo", "", "foo"},
+                        {"/foo", "", "foo"},
+                        {"foo/bar", "foo", "bar"},
+                        {"foo/bar/baz", "foo/bar", "baz"},
+                } {
+                        Convey(fmt.Sprintf(`Stream name %q splits into %q and %q.`, tc.s, tc.base, tc.last), func() {
+                                base, last := tc.s.Split()
+                                So(base, ShouldEqual, tc.base)
+                                So(last, ShouldEqual, tc.last)
+                        })
+                }
+        })
 }
 
 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.
@@ skipping 53 matching lines @@
 
                                         if p == "" {
                                                 break
                                         }
                                 }
                                 So(parts, ShouldResemble, tc.c)
                         })
                 }
         })
 }