textedit/replace_test.go

package textedit_test

import (
	"bytes"
	"code.squareroundforest.org/arpio/textedit"
	"testing"
)

func TestReplace(t *testing.T) {
	t.Run("empty and no match", func(t *testing.T) {
		var b bytes.Buffer
		w := textedit.New(&b, textedit.Replace())
		if _, err := w.Write(nil); err != nil {
			t.Fatal(err)
		}

		if err := w.Flush(); err != nil {
			t.Fatal(err)
		}

		if b.String() != "" {
			t.Fatal(b.String())
		}
	})

	t.Run("empty and empty match", func(t *testing.T) {
		var b bytes.Buffer
		w := textedit.New(&b, textedit.Replace("r"))
		if _, err := w.Write(nil); err != nil {
			t.Fatal(err)
		}

		if err := w.Flush(); err != nil {
			t.Fatal(err)
		}

		if b.String() != "" {
			t.Fatal(b.String())
		}
	})

	t.Run("empty one single char match", func(t *testing.T) {
		var b bytes.Buffer
		w := textedit.New(&b, textedit.Replace("r", "z"))
		if _, err := w.Write(nil); err != nil {
			t.Fatal(err)
		}

		if err := w.Flush(); err != nil {
			t.Fatal(err)
		}

		if b.String() != "" {
			t.Fatal(b.String())
		}
	})

	t.Run("empty multiple single char matches", func(t *testing.T) {
		var b bytes.Buffer
		w := textedit.New(&b, textedit.Replace("o", "e", "r", "z"))
		if _, err := w.Write(nil); err != nil {
			t.Fatal(err)
		}

		if err := w.Flush(); err != nil {
			t.Fatal(err)
		}

		if b.String() != "" {
			t.Fatal(b.String())
		}
	})

	t.Run("empty one multi-char match", func(t *testing.T) {
		var b bytes.Buffer
		w := textedit.New(&b, textedit.Replace("oo", "ee"))
		if _, err := w.Write(nil); err != nil {
			t.Fatal(err)
		}

		if err := w.Flush(); err != nil {
			t.Fatal(err)
		}

		if b.String() != "" {
			t.Fatal(b.String())
		}
	})

	t.Run("empty multiple multi-char matches", func(t *testing.T) {
		var b bytes.Buffer
		w := textedit.New(&b, textedit.Replace("oo", "ee", "ar", "az"))
		if _, err := w.Write(nil); err != nil {
			t.Fatal(err)
		}

		if err := w.Flush(); err != nil {
			t.Fatal(err)
		}

		if b.String() != "" {
			t.Fatal(b.String())
		}
	})

	t.Run("no match empty match", func(t *testing.T) {
		var b bytes.Buffer
		w := textedit.New(&b, textedit.Replace("r"))
		if _, err := w.Write([]byte("foo")); err != nil {
			t.Fatal(err)
		}

		if err := w.Flush(); err != nil {
			t.Fatal(err)
		}

		if b.String() != "foo" {
			t.Fatal(b.String())
		}
	})

	t.Run("no match one single char match", func(t *testing.T) {
		var b bytes.Buffer
		w := textedit.New(&b, textedit.Replace("r", "z"))
		if _, err := w.Write([]byte("foo")); err != nil {
			t.Fatal(err)
		}

		if err := w.Flush(); err != nil {
			t.Fatal(err)
		}

		if b.String() != "foo" {
			t.Fatal(b.String())
		}
	})

	t.Run("no match multiple single char matches", func(t *testing.T) {
		var b bytes.Buffer
		w := textedit.New(&b, textedit.Replace("b", "f", "r", "z"))
		if _, err := w.Write([]byte("foo")); err != nil {
			t.Fatal(err)
		}

		if err := w.Flush(); err != nil {
			t.Fatal(err)
		}

		if b.String() != "foo" {
			t.Fatal(b.String())
		}
	})

	t.Run("no match one multi-char match", func(t *testing.T) {
		var b bytes.Buffer
		w := textedit.New(&b, textedit.Replace("bar", "baz"))
		if _, err := w.Write([]byte("foo")); err != nil {
			t.Fatal(err)
		}

		if err := w.Flush(); err != nil {
			t.Fatal(err)
		}

		if b.String() != "foo" {
			t.Fatal(b.String())
		}
	})

	t.Run("no match multiple multi-char matches", func(t *testing.T) {
		var b bytes.Buffer
		w := textedit.New(&b, textedit.Replace("bar", "baz", "qux", "quuz"))
		if _, err := w.Write([]byte("foo")); err != nil {
			t.Fatal(err)
		}

		if err := w.Flush(); err != nil {
			t.Fatal(err)
		}

		if b.String() != "foo" {
			t.Fatal(b.String())
		}
	})

	t.Run("match empty match", func(t *testing.T) {
		var b bytes.Buffer
		w := textedit.New(&b, textedit.Replace("a"))
		if _, err := w.Write([]byte("bar")); err != nil {
			t.Fatal(err)
		}

		if err := w.Flush(); err != nil {
			t.Fatal(err)
		}

		if b.String() != "br" {
			t.Fatal(b.String())
		}
	})

	t.Run("match one single char match", func(t *testing.T) {
		var b bytes.Buffer
		w := textedit.New(&b, textedit.Replace("r", "z"))
		if _, err := w.Write([]byte("bar")); err != nil {
			t.Fatal(err)
		}

		if err := w.Flush(); err != nil {
			t.Fatal(err)
		}

		if b.String() != "baz" {
			t.Fatal(b.String())
		}
	})

	t.Run("match multiple single char matches", func(t *testing.T) {
		var b bytes.Buffer
		w := textedit.New(&b, textedit.Replace("o", "e", "r", "z"))
		if _, err := w.Write([]byte("foo bar")); err != nil {
			t.Fatal(err)
		}

		if err := w.Flush(); err != nil {
			t.Fatal(err)
		}

		if b.String() != "fee baz" {
			t.Fatal(b.String())
		}
	})

	t.Run("match one multi-char match", func(t *testing.T) {
		var b bytes.Buffer
		w := textedit.New(&b, textedit.Replace("oo", "ee"))
		if _, err := w.Write([]byte("foo bar")); err != nil {
			t.Fatal(err)
		}

		if err := w.Flush(); err != nil {
			t.Fatal(err)
		}

		if b.String() != "fee bar" {
			t.Fatal(b.String())
		}
	})

	t.Run("match multiple multi-char matches", func(t *testing.T) {
		var b bytes.Buffer
		w := textedit.New(&b, textedit.Replace("oo", "ee", "ar", "az"))
		if _, err := w.Write([]byte("foo bar")); err != nil {
			t.Fatal(err)
		}

		if err := w.Flush(); err != nil {
			t.Fatal(err)
		}

		if b.String() != "fee baz" {
			t.Fatal(b.String())
		}
	})

	t.Run("inverse order", func(t *testing.T) {
		var b bytes.Buffer
		w := textedit.New(&b, textedit.Replace("ar", "az", "oo", "ee"))
		if _, err := w.Write([]byte("foo bar")); err != nil {
			t.Fatal(err)
		}

		if err := w.Flush(); err != nil {
			t.Fatal(err)
		}

		if b.String() != "fee baz" {
			t.Fatal(b.String())
		}
	})

	t.Run("mismatch after partial match", func(t *testing.T) {
		var b bytes.Buffer
		w := textedit.New(&b, textedit.Replace("foo", "bar"))
		if _, err := w.Write([]byte("fox baz")); err != nil {
			t.Fatal(err)
		}

		if err := w.Flush(); err != nil {
			t.Fatal(err)
		}

		if b.String() != "fox baz" {
			t.Fatal(b.String())
		}
	})

	t.Run("empty match", func(t *testing.T) {
		var b bytes.Buffer
		w := textedit.New(&b, textedit.Replace("", "bar"))
		if _, err := w.Write([]byte("foo baz")); err != nil {
			t.Fatal(err)
		}

		if err := w.Flush(); err != nil {
			t.Fatal(err)
		}

		if b.String() != "foo baz" {
			t.Fatal(b.String())
		}
	})

	t.Run("delete", func(t *testing.T) {
		var b bytes.Buffer
		w := textedit.New(&b, textedit.Replace("bar", ""))
		if _, err := w.Write([]byte("foo bar")); err != nil {
			t.Fatal(err)
		}

		if err := w.Flush(); err != nil {
			t.Fatal(err)
		}

		if b.String() != "foo " {
			t.Fatal(b.String())
		}
	})
}