Giant blob of minor changes

[dotfiles/.git] / .config / coc / extensions / coc-go-data / tools / pkg / mod / github.com / sergi / go-diff@v1.1.0 / diffmatchpatch / stringutil_test.go

diff --git a/.config/coc/extensions/coc-go-data/tools/pkg/mod/github.com/sergi/go-diff@v1.1.0/diffmatchpatch/stringutil_test.go b/.config/coc/extensions/coc-go-data/tools/pkg/mod/github.com/sergi/go-diff@v1.1.0/diffmatchpatch/stringutil_test.go
new file mode 100644 (file)
index 0000000..ab2bc10
--- /dev/null
+++ b/.config/coc/extensions/coc-go-data/tools/pkg/mod/github.com/sergi/go-diff@v1.1.0/diffmatchpatch/stringutil_test.go
@@ -0,0 +1,116 @@
+// Copyright (c) 2012-2016 The go-diff authors. All rights reserved.
+// https://github.com/sergi/go-diff
+// See the included LICENSE file for license details.
+//
+// go-diff is a Go implementation of Google's Diff, Match, and Patch library
+// Original library is Copyright (c) 2006 Google Inc.
+// http://code.google.com/p/google-diff-match-patch/
+
+package diffmatchpatch
+
+import (
+       "fmt"
+       "testing"
+
+       "github.com/stretchr/testify/assert"
+)
+
+func TestRunesIndexOf(t *testing.T) {
+       type TestCase struct {
+               Pattern string
+               Start   int
+
+               Expected int
+       }
+
+       for i, tc := range []TestCase{
+               {"abc", 0, 0},
+               {"cde", 0, 2},
+               {"e", 0, 4},
+               {"cdef", 0, -1},
+               {"abcdef", 0, -1},
+               {"abc", 2, -1},
+               {"cde", 2, 2},
+               {"e", 2, 4},
+               {"cdef", 2, -1},
+               {"abcdef", 2, -1},
+               {"e", 6, -1},
+       } {
+               actual := runesIndexOf([]rune("abcde"), []rune(tc.Pattern), tc.Start)
+               assert.Equal(t, tc.Expected, actual, fmt.Sprintf("Test case #%d, %#v", i, tc))
+       }
+}
+
+func TestIndexOf(t *testing.T) {
+       type TestCase struct {
+               String   string
+               Pattern  string
+               Position int
+
+               Expected int
+       }
+
+       for i, tc := range []TestCase{
+               {"hi world", "world", -1, 3},
+               {"hi world", "world", 0, 3},
+               {"hi world", "world", 1, 3},
+               {"hi world", "world", 2, 3},
+               {"hi world", "world", 3, 3},
+               {"hi world", "world", 4, -1},
+               {"abbc", "b", -1, 1},
+               {"abbc", "b", 0, 1},
+               {"abbc", "b", 1, 1},
+               {"abbc", "b", 2, 2},
+               {"abbc", "b", 3, -1},
+               {"abbc", "b", 4, -1},
+               // The greek letter beta is the two-byte sequence of "\u03b2".
+               {"a\u03b2\u03b2c", "\u03b2", -1, 1},
+               {"a\u03b2\u03b2c", "\u03b2", 0, 1},
+               {"a\u03b2\u03b2c", "\u03b2", 1, 1},
+               {"a\u03b2\u03b2c", "\u03b2", 3, 3},
+               {"a\u03b2\u03b2c", "\u03b2", 5, -1},
+               {"a\u03b2\u03b2c", "\u03b2", 6, -1},
+       } {
+               actual := indexOf(tc.String, tc.Pattern, tc.Position)
+               assert.Equal(t, tc.Expected, actual, fmt.Sprintf("Test case #%d, %#v", i, tc))
+       }
+}
+
+func TestLastIndexOf(t *testing.T) {
+       type TestCase struct {
+               String   string
+               Pattern  string
+               Position int
+
+               Expected int
+       }
+
+       for i, tc := range []TestCase{
+               {"hi world", "world", -1, -1},
+               {"hi world", "world", 0, -1},
+               {"hi world", "world", 1, -1},
+               {"hi world", "world", 2, -1},
+               {"hi world", "world", 3, -1},
+               {"hi world", "world", 4, -1},
+               {"hi world", "world", 5, -1},
+               {"hi world", "world", 6, -1},
+               {"hi world", "world", 7, 3},
+               {"hi world", "world", 8, 3},
+               {"abbc", "b", -1, -1},
+               {"abbc", "b", 0, -1},
+               {"abbc", "b", 1, 1},
+               {"abbc", "b", 2, 2},
+               {"abbc", "b", 3, 2},
+               {"abbc", "b", 4, 2},
+               // The greek letter beta is the two-byte sequence of "\u03b2".
+               {"a\u03b2\u03b2c", "\u03b2", -1, -1},
+               {"a\u03b2\u03b2c", "\u03b2", 0, -1},
+               {"a\u03b2\u03b2c", "\u03b2", 1, 1},
+               {"a\u03b2\u03b2c", "\u03b2", 3, 3},
+               {"a\u03b2\u03b2c", "\u03b2", 5, 3},
+               {"a\u03b2\u03b2c", "\u03b2", 6, 3},
+       } {
+               actual := lastIndexOf(tc.String, tc.Pattern, tc.Position)
+               assert.Equal(t, tc.Expected, actual, fmt.Sprintf("Test case #%d, %#v", i, tc))
+       }
+}