How to use Narrow method of diff Package

...13	"github.com/influxdata/flux/mock"14	"github.com/influxdata/flux/values"15	"github.com/stretchr/testify/assert"16)17func TestNarrowStateTransformation_ProcessChunk(t *testing.T) {18	// Ensure we allocate and free all memory correctly.19	mem := memory.NewCheckedAllocator(memory.DefaultAllocator)20	defer mem.AssertSize(t, 0)21	// Generate one table chunk using static.Table.22	// This will only produce one column reader, so we are23	// extracting that value from the nested iterators.24	want := static.Table{25		static.Times("_time", 0, 10, 20),26		static.Floats("_value", 1, 2, 3),27	}28	isProcessed, hasState := false, false29	tr, _, err := execute.NewNarrowStateTransformation(30		executetest.RandomDatasetID(),31		&mock.NarrowStateTransformation{32			ProcessFn: func(chunk table.Chunk, state interface{}, d *execute.TransportDataset, _ memory.Allocator) (interface{}, bool, error) {33				if state != nil {34					if want, got := int64(4), state.(int64); want != got {35						t.Errorf("unexpected state on second call -want/+got:\n\t- %d\n\t+ %d", want, got)36					}37					hasState = true38				}39				// Memory should be allocated and should not have been improperly freed.40				// This accounts for 64 bytes (data) + 64 bytes (null bitmap) for each column41				// of which there are two. 64 bytes is the minimum that arrow will allocate42				// for a particular data buffer.43				assert.Equal(t, 256, mem.CurrentAlloc(), "unexpected memory allocation.")44				// Compare the buffer contents to the table we wanted.45				// Because we should have produced only one table chunk,46				// we are comparing the entirety of the chunk to the entirety47				// of the wanted output.48				buffer := chunk.Buffer()49				buffer.Retain()50				got := table.Iterator{51					table.FromBuffer(&buffer),52				}53				if diff := table.Diff(want, got); diff != "" {54					t.Errorf("unexpected diff -want/+got:\n%s", diff)55				}56				isProcessed = true57				return int64(4), true, nil58			},59		},60		mem,61	)62	if err != nil {63		t.Fatal(err)64	}65	// We can use a TransportDataset as a mock source66	// to send messages to the transformation we are testing.67	source := execute.NewTransportDataset(executetest.RandomDatasetID(), mem)68	source.AddTransformation(tr)69	tbl := want.Table(mem)70	if err := tbl.Do(func(cr flux.ColReader) error {71		chunk := table.ChunkFromReader(cr)72		chunk.Retain()73		if err := source.Process(chunk); err != nil {74			return err75		}76		chunk.Retain()77		return source.Process(chunk)78	}); err != nil {79		t.Fatal(err)80	}81	if !isProcessed {82		t.Error("message was never processed")83	}84	if !hasState {85		t.Error("process was never invoked with state")86	}87}88func TestNarrowStateTransformation_FlushKey(t *testing.T) {89	mem := memory.NewCheckedAllocator(memory.DefaultAllocator)90	defer mem.AssertSize(t, 0)91	want := static.Table{92		static.StringKey("t0", "a"),93		static.Times("_time", 0, 10, 20),94		static.Floats("_value", 1, 2, 3),95	}96	var disposeCount int97	tr, d, err := execute.NewNarrowStateTransformation(98		executetest.RandomDatasetID(),99		&mock.NarrowStateTransformation{100			ProcessFn: func(chunk table.Chunk, state interface{}, d *execute.TransportDataset, mem memory.Allocator) (interface{}, bool, error) {101				if state != nil {102					t.Error("process unexpectedly invoked with state")103				}104				chunk.Retain()105				if err := d.Process(chunk); err != nil {106					return nil, false, err107				}108				return &mockState{109					disposeCount: &disposeCount,110				}, true, nil111			},112		},113		mem,114	)115	if err != nil {116		t.Fatal(err)117	}118	isProcessed, isFlushed := false, false119	d.AddTransformation(120		&mock.Transport{121			ProcessMessageFn: func(m execute.Message) error {122				defer m.Ack()123				switch m := m.(type) {124				case execute.ProcessChunkMsg:125					isProcessed = true126				case execute.FlushKeyMsg:127					want := execute.NewGroupKey(128						[]flux.ColMeta{{Label: "t0", Type: flux.TString}},129						[]values.Value{values.NewString("a")},130					)131					if got := m.Key(); !want.Equal(got) {132						t.Errorf("unexpected group key -want/+got:\n%s", cmp.Diff(want, got))133					}134					isFlushed = true135				}136				return nil137			},138		},139	)140	// Flush key should flush the state so the second call to process141	// should not have any state.142	parentID := executetest.RandomDatasetID()143	for i := 0; i < 2; i++ {144		tbl := want.Table(mem)145		if err := tr.Process(parentID, tbl); err != nil {146			t.Fatal(err)147		}148	}149	if !isProcessed {150		t.Error("process message was never processed")151	}152	if !isFlushed {153		t.Error("flush key message was never processed")154	}155	// The state should have been disposed of twice.156	if want, got := 2, disposeCount; want != got {157		t.Errorf("unexpected dispose count -want/+got:\n\t- %d\n\t+ %d", want, got)158	}159}160func TestNarrowStateTransformation_Process(t *testing.T) {161	// Ensure we allocate and free all memory correctly.162	mem := memory.NewCheckedAllocator(memory.DefaultAllocator)163	defer mem.AssertSize(t, 0)164	// Generate one table chunk using static.Table.165	// This will only produce one column reader, so we are166	// extracting that value from the nested iterators.167	want := static.Table{168		static.Times("_time", 0, 10, 20),169		static.Floats("_value", 1, 2, 3),170	}171	isProcessed := false172	tr, _, err := execute.NewNarrowStateTransformation(173		executetest.RandomDatasetID(),174		&mock.NarrowStateTransformation{175			ProcessFn: func(chunk table.Chunk, state interface{}, d *execute.TransportDataset, _ memory.Allocator) (interface{}, bool, error) {176				// Memory should be allocated and should not have been improperly freed.177				// This accounts for 64 bytes (data) + 64 bytes (null bitmap) for each column178				// of which there are two. 64 bytes is the minimum that arrow will allocate179				// for a particular data buffer.180				assert.Equal(t, 256, mem.CurrentAlloc(), "unexpected memory allocation.")181				// Compare the buffer contents to the table we wanted.182				// Because we should have produced only one table chunk,183				// we are comparing the entirety of the chunk to the entirety184				// of the wanted output.185				buffer := chunk.Buffer()186				buffer.Retain()187				got := table.Iterator{188					table.FromBuffer(&buffer),189				}190				if diff := table.Diff(want, got); diff != "" {191					t.Errorf("unexpected diff -want/+got:\n%s", diff)192				}193				isProcessed = true194				return int64(4), true, nil195			},196		},197		mem,198	)199	if err != nil {200		t.Fatal(err)201	}202	// Process the table and ensure it gets converted to a table chunk,203	// memory is still allocated for it, and the actual data is correct.204	//205	// Instead of using public methods, we simulate sending a process message.206	// We want to test a transport's ability to forward the process message,207	// but the only transport that has this capability is the consecutive transport.208	// As we don't want to add the dispatcher or concurrency to this test, we manually209	// construct the message and send it ourselves.210	//211	// This test is identical to the version for narrow transformation212	// so we don't have anything special regarding state. The tests for213	// state are around the individual messages rather than this test and214	// this test is mostly for verifying that process is still equivalent to215	// process chunk and flush key.216	m := execute.NewProcessMsg(want.Table(mem))217	if err := tr.(execute.Transport).ProcessMessage(m); err != nil {218		t.Fatal(err)219	}220	if !isProcessed {221		t.Error("message was never processed")222	}223}224func TestNarrowStateTransformation_Finish(t *testing.T) {225	// Ensure we allocate and free all memory correctly.226	mem := memory.NewCheckedAllocator(memory.DefaultAllocator)227	defer mem.AssertSize(t, 0)228	isFinished := []bool{false, false}229	want := errors.New(codes.Internal, "expected")230	var (231		disposeCount int232		isDisposed   bool233	)234	tr, d, err := execute.NewNarrowStateTransformation(235		executetest.RandomDatasetID(),236		&mock.NarrowStateTransformation{237			ProcessFn: func(chunk table.Chunk, state interface{}, d *execute.TransportDataset, mem memory.Allocator) (interface{}, bool, error) {238				return &mockState{239					disposeCount: &disposeCount,240				}, true, nil241			},242			CloseFn: func() error {243				isDisposed = true244				return nil245			},246		},247		memory.DefaultAllocator,248	)249	if err != nil {250		t.Fatal(err)251	}252	d.AddTransformation(253		&mock.Transport{254			ProcessMessageFn: func(m execute.Message) error {255				msg, ok := m.(execute.FinishMsg)256				if !ok {257					t.Fatalf("expected finish message, got %T", m)258				}259				if got := msg.Error(); !cmp.Equal(want, got) {260					t.Fatalf("unexpected error -want/+got:\n%s", cmp.Diff(want, got))261				}262				isFinished[0] = true263				return nil264			},265		},266	)267	d.AddTransformation(268		&mock.Transformation{269			FinishFn: func(id execute.DatasetID, err error) {270				if got := err; !cmp.Equal(want, got) {271					t.Fatalf("unexpected error -want/+got:\n%s", cmp.Diff(want, got))272				}273				isFinished[1] = true274			},275		},276	)277	// We can use a TransportDataset as a mock source278	// to send messages to the transformation we are testing.279	source := execute.NewTransportDataset(executetest.RandomDatasetID(), mem)280	source.AddTransformation(tr)281	// Generate one table chunk using static.Table.282	// This will only produce one column reader, so we are283	// extracting that value from the nested iterators.284	gen := static.Table{285		static.Times("_time", 0, 10, 20),286		static.Floats("_value", 1, 2, 3),287	}288	// Process the table but do not flush the key.289	tbl := gen.Table(mem)290	if err := tbl.Do(func(cr flux.ColReader) error {291		chunk := table.ChunkFromReader(cr)292		chunk.Retain()293		return source.Process(chunk)294	}); err != nil {295		t.Fatal(err)296	}297	// We want to check that finish is forwarded correctly.298	source.Finish(want)299	if !isFinished[0] {300		t.Error("transport did not receive finish message")301	}302	if !isFinished[1] {303		t.Error("transformation did not receive finish message")304	}305	// The state should have been disposed.306	if want, got := 1, disposeCount; want != got {307		t.Errorf("unexpected dispose count -want/+got:\n\t- %d\n\t+ %d", want, got)308	}309	// So should the transformation.310	if !isDisposed {311		t.Error("transformation was not disposed")312	}313}314// Ensure that we report the operation type of the type we wrap315// and ensure that we don't report ourselves as the operation type.316//317// This is to prevent opentracing from showing narrowTransformation318// as the operation.319func TestNarrowStateTransformation_OperationType(t *testing.T) {320	tr, _, err := execute.NewNarrowStateTransformation(321		executetest.RandomDatasetID(),322		&mock.NarrowStateTransformation{},323		memory.DefaultAllocator,324	)325	if err != nil {326		t.Fatal(err)327	}328	if want, got := "*mock.NarrowStateTransformation", execute.OperationType(tr); want != got {329		t.Errorf("unexpected operation type -want/+got:\n\t- %s\n\t+ %s", want, got)330	}331}...

...13	"github.com/influxdata/flux/mock"14	"github.com/influxdata/flux/values"15	"github.com/stretchr/testify/assert"16)17func TestNarrowTransformation_ProcessChunk(t *testing.T) {18	// Ensure we allocate and free all memory correctly.19	mem := memory.NewCheckedAllocator(memory.DefaultAllocator)20	defer mem.AssertSize(t, 0)21	// Generate one table chunk using static.Table.22	// This will only produce one column reader, so we are23	// extracting that value from the nested iterators.24	want := static.Table{25		static.Times("_time", 0, 10, 20),26		static.Floats("_value", 1, 2, 3),27	}28	isProcessed := false29	tr, _, err := execute.NewNarrowTransformation(30		executetest.RandomDatasetID(),31		&mock.NarrowTransformation{32			ProcessFn: func(chunk table.Chunk, d *execute.TransportDataset, _ memory.Allocator) error {33				// Memory should be allocated and should not have been improperly freed.34				// This accounts for 64 bytes (data) + 64 bytes (null bitmap) for each column35				// of which there are two. 64 bytes is the minimum that arrow will allocate36				// for a particular data buffer.37				assert.Equal(t, 256, mem.CurrentAlloc(), "unexpected memory allocation.")38				// Compare the buffer contents to the table we wanted.39				// Because we should have produced only one table chunk,40				// we are comparing the entirety of the chunk to the entirety41				// of the wanted output.42				buffer := chunk.Buffer()43				buffer.Retain()44				got := table.Iterator{45					table.FromBuffer(&buffer),46				}47				if diff := table.Diff(want, got); diff != "" {48					t.Errorf("unexpected diff -want/+got:\n%s", diff)49				}50				isProcessed = true51				return nil52			},53		},54		mem,55	)56	if err != nil {57		t.Fatal(err)58	}59	// We can use a TransportDataset as a mock source60	// to send messages to the transformation we are testing.61	source := execute.NewTransportDataset(executetest.RandomDatasetID(), mem)62	source.AddTransformation(tr)63	tbl := want.Table(mem)64	if err := tbl.Do(func(cr flux.ColReader) error {65		chunk := table.ChunkFromReader(cr)66		chunk.Retain()67		return source.Process(chunk)68	}); err != nil {69		t.Fatal(err)70	}71	if !isProcessed {72		t.Error("message was never processed")73	}74}75func TestNarrowTransformation_FlushKey(t *testing.T) {76	mem := memory.NewCheckedAllocator(memory.DefaultAllocator)77	defer mem.AssertSize(t, 0)78	want := static.Table{79		static.StringKey("t0", "a"),80		static.Times("_time", 0, 10, 20),81		static.Floats("_value", 1, 2, 3),82	}83	tr, d, err := execute.NewNarrowTransformation(84		executetest.RandomDatasetID(),85		&mock.NarrowTransformation{86			ProcessFn: func(chunk table.Chunk, d *execute.TransportDataset, mem memory.Allocator) error {87				chunk.Retain()88				return d.Process(chunk)89			},90		},91		mem,92	)93	if err != nil {94		t.Fatal(err)95	}96	isProcessed, isFlushed := false, false97	d.AddTransformation(98		&mock.Transport{99			ProcessMessageFn: func(m execute.Message) error {100				defer m.Ack()101				switch m := m.(type) {102				case execute.ProcessChunkMsg:103					isProcessed = true104				case execute.FlushKeyMsg:105					want := execute.NewGroupKey(106						[]flux.ColMeta{{Label: "t0", Type: flux.TString}},107						[]values.Value{values.NewString("a")},108					)109					if got := m.Key(); !want.Equal(got) {110						t.Errorf("unexpected group key -want/+got:\n%s", cmp.Diff(want, got))111					}112					isFlushed = true113				}114				return nil115			},116		},117	)118	tbl := want.Table(mem)119	parentID := executetest.RandomDatasetID()120	if err := tr.Process(parentID, tbl); err != nil {121		t.Fatal(err)122	}123	if !isProcessed {124		t.Error("process message was never processed")125	}126	if !isFlushed {127		t.Error("flush key message was never processed")128	}129}130func TestNarrowTransformation_Process(t *testing.T) {131	// Ensure we allocate and free all memory correctly.132	mem := memory.NewCheckedAllocator(memory.DefaultAllocator)133	defer mem.AssertSize(t, 0)134	// Generate one table chunk using static.Table.135	// This will only produce one column reader, so we are136	// extracting that value from the nested iterators.137	want := static.Table{138		static.Times("_time", 0, 10, 20),139		static.Floats("_value", 1, 2, 3),140	}141	isProcessed := false142	tr, _, err := execute.NewNarrowTransformation(143		executetest.RandomDatasetID(),144		&mock.NarrowTransformation{145			ProcessFn: func(chunk table.Chunk, d *execute.TransportDataset, _ memory.Allocator) error {146				// Memory should be allocated and should not have been improperly freed.147				// This accounts for 64 bytes (data) + 64 bytes (null bitmap) for each column148				// of which there are two. 64 bytes is the minimum that arrow will allocate149				// for a particular data buffer.150				assert.Equal(t, 256, mem.CurrentAlloc(), "unexpected memory allocation.")151				// Compare the buffer contents to the table we wanted.152				// Because we should have produced only one table chunk,153				// we are comparing the entirety of the chunk to the entirety154				// of the wanted output.155				buffer := chunk.Buffer()156				buffer.Retain()157				got := table.Iterator{158					table.FromBuffer(&buffer),159				}160				if diff := table.Diff(want, got); diff != "" {161					t.Errorf("unexpected diff -want/+got:\n%s", diff)162				}163				isProcessed = true164				return nil165			},166		},167		mem,168	)169	if err != nil {170		t.Fatal(err)171	}172	// Process the table and ensure it gets converted to a table chunk,173	// memory is still allocated for it, and the actual data is correct.174	//175	// Instead of using public methods, we simulate sending a process message.176	// We want to test a transport's ability to forward the process message,177	// but the only transport that has this capability is the consecutive transport.178	// As we don't want to add the dispatcher or concurrency to this test, we manually179	// construct the message and send it ourselves.180	m := execute.NewProcessMsg(want.Table(mem))181	if err := tr.(execute.Transport).ProcessMessage(m); err != nil {182		t.Fatal(err)183	}184	if !isProcessed {185		t.Error("message was never processed")186	}187}188func TestNarrowTransformation_Finish(t *testing.T) {189	isFinished := []bool{false, false}190	want := errors.New(codes.Internal, "expected")191	isDisposed := false192	tr, d, err := execute.NewNarrowTransformation(193		executetest.RandomDatasetID(),194		&mock.NarrowTransformation{195			CloseFn: func() error {196				isDisposed = true197				return nil198			},199		},200		memory.DefaultAllocator,201	)202	if err != nil {203		t.Fatal(err)204	}205	d.AddTransformation(206		&mock.Transport{207			ProcessMessageFn: func(m execute.Message) error {208				msg, ok := m.(execute.FinishMsg)209				if !ok {210					t.Fatalf("expected finish message, got %T", m)211				}212				if got := msg.Error(); !cmp.Equal(want, got) {213					t.Fatalf("unexpected error -want/+got:\n%s", cmp.Diff(want, got))214				}215				isFinished[0] = true216				return nil217			},218		},219	)220	d.AddTransformation(221		&mock.Transformation{222			FinishFn: func(id execute.DatasetID, err error) {223				if got := err; !cmp.Equal(want, got) {224					t.Fatalf("unexpected error -want/+got:\n%s", cmp.Diff(want, got))225				}226				isFinished[1] = true227			},228		},229	)230	// We want to check that finish is forwarded correctly.231	// We construct the finish message and then send it directly232	// to the process message method.233	if err := tr.(execute.Transport).ProcessMessage(234		execute.NewFinishMsg(want),235	); err != nil {236		t.Fatal(err)237	}238	d.Finish(want)239	if !isDisposed {240		t.Error("transformation was not disposed")241	}242	if !isFinished[0] {243		t.Error("downstream transport did not receive finish message")244	}245	if !isFinished[1] {246		t.Error("downstream transformation did not receive finish message")247	}248}249// Ensure that we report the operation type of the type we wrap250// and ensure that we don't report ourselves as the operation type.251//252// This is to prevent opentracing from showing narrowTransformation253// as the operation.254func TestNarrowTransformation_OperationType(t *testing.T) {255	tr, _, err := execute.NewNarrowTransformation(256		executetest.RandomDatasetID(),257		&mock.NarrowTransformation{},258		memory.DefaultAllocator,259	)260	if err != nil {261		t.Fatal(err)262	}263	if want, got := "*mock.NarrowTransformation", execute.OperationType(tr); want != got {264		t.Errorf("unexpected operation type -want/+got:\n\t- %s\n\t+ %s", want, got)265	}266}...

1package narrow_test2import (3	"context"4	"database/sql"5	"fmt"6	"log"7	"os"8	"testing"9	"github.com/clarke94/go-testing-examples/narrow"10	"github.com/google/go-cmp/cmp"11	"github.com/google/go-cmp/cmp/cmpopts"12	"github.com/google/uuid"13	_ "github.com/lib/pq"14	"github.com/ory/dockertest/v3"15	"github.com/ory/dockertest/v3/docker"16)17var db *sql.DB18func TestStorage_Insert(t *testing.T) {19	tests := []struct {20		name    string21		db      *sql.DB22		ctx     context.Context23		user    narrow.User24		want    uuid.UUID25		wantErr error26	}{27		{28			name: "expect success when inserting a new User",29			db:   db,30			ctx:  context.Background(),31			user: narrow.User{32				ID:    uuid.Must(uuid.Parse("5db0da2f-170f-4912-b43c-e2e2da009bdd")),33				Name:  "foo",34				Email: "new@bar.com",35			},36			want:    uuid.Must(uuid.Parse("5db0da2f-170f-4912-b43c-e2e2da009bdd")),37			wantErr: nil,38		},39		{40			name: "expect fail when inserting an email that already exists",41			db:   db,42			ctx:  context.Background(),43			user: narrow.User{44				ID:    uuid.New(),45				Name:  "foo",46				Email: "foo@bar.com",47			},48			want:    uuid.Nil,49			wantErr: narrow.ErrUnableToExecuteQuery,50		},51		{52			name: "expect fail when inserting an ID that already exists",53			db:   db,54			ctx:  context.Background(),55			user: narrow.User{56				ID:    uuid.Must(uuid.Parse("a6acab82-2b2e-484c-8e2b-f3f7736a26ed")),57				Name:  "foo",58				Email: "id@bar.com",59			},60			want:    uuid.Nil,61			wantErr: narrow.ErrUnableToExecuteQuery,62		},63	}64	for _, tt := range tests {65		t.Run(tt.name, func(t *testing.T) {66			s := narrow.New(tt.db)67			got, gotErr := s.Insert(tt.ctx, tt.user)68			if !cmp.Equal(got, tt.want) {69				t.Error(cmp.Diff(got, tt.want))70			}71			if !cmp.Equal(gotErr, tt.wantErr, cmpopts.EquateErrors()) {72				t.Error(cmp.Diff(gotErr, tt.wantErr, cmpopts.EquateErrors()))73			}74		})75	}76}77func TestMain(m *testing.M) {78	pool, err := dockertest.NewPool("")79	if err != nil {80		log.Fatalf("Could not connect to docker: %s", err)81	}82	path, err := os.Getwd()83	if err != nil {84		log.Fatal(err)85	}86	options := &dockertest.RunOptions{87		Repository: "postgres",88		Tag:        "12.3",89		Env: []string{90			"POSTGRES_USER=user",91			"POSTGRES_PASSWORD=secret",92			"listen_addresses = '*'",93		},94		ExposedPorts: []string{"5432"},95		PortBindings: map[docker.Port][]docker.PortBinding{96			"5432": {97				{HostIP: "0.0.0.0", HostPort: "5432"},98			},99		},100		Mounts: []string{fmt.Sprintf("%s/stub:/docker-entrypoint-initdb.d", path)},101	}102	resource, err := pool.RunWithOptions(options, func(config *docker.HostConfig) {103		config.AutoRemove = true104		config.RestartPolicy = docker.RestartPolicy{Name: "no"}105	})106	if err != nil {107		log.Fatalf("Could not start resource: %s", err)108	}109	err = resource.Expire(30)110	if err != nil {111		log.Fatalf("Could not expire resource: %s", err)112	}113	if err := pool.Retry(func() error {114		var err error115		db, err = sql.Open(116			"postgres",117			"postgres://user:secret@localhost:5432?sslmode=disable",118		)119		if err != nil {120			return err121		}122		return db.Ping()123	}); err != nil {124		log.Fatalf("Could not connect to narrow: %s", err)125	}126	code := m.Run()127	if err := pool.Purge(resource); err != nil {128		log.Fatalf("Could not purge resource: %s", err)129	}130	os.Exit(code)131}...

1import (2func main() {3    dmp := diffmatchpatch.New()4    d := dmp.DiffMain(a, b, false)5    fmt.Println(dmp.DiffPrettyText(d))6    d = dmp.DiffNarrow(d)7    fmt.Println(dmp.DiffPrettyText(d))8}9import (10func main() {11    dmp := diffmatchpatch.New()12    d := dmp.DiffMain(a, b, false)13    fmt.Println(dmp.DiffPrettyText(d))14    d = dmp.DiffNarrow(d)15    fmt.Println(dmp.DiffPrettyText(d))16}17import (18func main() {19    dmp := diffmatchpatch.New()20    d := dmp.DiffMain(a, b, false)21    fmt.Println(dmp.DiffPrettyText(d))22    d = dmp.DiffNarrow(d)23    fmt.Println(d

1import (2func main() {3	dmp := diffmatchpatch.New()4	diffs := dmp.DiffMain(a, b, false)5	fmt.Println(dmp.DiffPrettyText(diffs))6	diffs = dmp.DiffMain(a, b, true)7	fmt.Println(dmp.DiffPrettyText(diffs))8	diffs = dmp.DiffMain(a, b, false)9	diffs = dmp.DiffNarrow(diffs)10	fmt.Println(dmp.DiffPrettyText(diffs))11}

1import (2func main() {3	dmp := diffmatchpatch.New()4	a := dmp.DiffMain("Hello World", "Goodbye World", false)5	fmt.Println(dmp.DiffPrettyText(a))6	b := dmp.DiffNarrow(a)7	fmt.Println(dmp.DiffPrettyText(b))8}

1import (2func main() {3	dmp := diffmatchpatch.New()4	diffs := dmp.DiffMain(text1, text2, false)5	diffs = dmp.DiffNarrow(text1, text2, diffs)6	fmt.Println(diffs)7}8[{+Goodbye+} {-Hello-} {+World+}]9import (10func main() {11	dmp := diffmatchpatch.New()12	diffs := dmp.DiffMain(text1, text2, false)13	fmt.Println(diffs)14}15[{+Goodbye+} {-Hello-} {+World+}]16import (17func main() {18	dmp := diffmatchpatch.New()19	diffs := dmp.DiffMain(text1, text2, false)20	dmp.DiffCleanupEfficiency(diffs)21	fmt.Println(diffs)22}23[{+Goodbye+} {-Hello-} {+World+}]24import (25func main() {

1import (2type Struct1 struct {3}4type Address struct {5}6func main() {7    a := Struct1{8        Address: Address{9        },10    }11    b := Struct1{12        Address: Address{13        },14    }15    diff := messagediff.PrettyDiff(a, b)16    fmt.Printf("17}18[{19    {20    },21    {22    },23    {24        {25        },26        {27        }28    }29}]30import (31type Struct1 struct {32}33type Address struct {34}35func main() {