diff --git a/msgpack/decode.go b/msgpack/decode.go
index b055dac2..e96cb716 100644
--- a/msgpack/decode.go
+++ b/msgpack/decode.go
@@ -321,6 +321,8 @@ func stringDecoder(ds *decodeState, v reflect.Value) {
 	var x string
 
 	switch ds.Type() {
+	case Nil:
+		x = ""
 	case Binary, String:
 		x = ds.String()
 	default:
diff --git a/msgpack/decode_test.go b/msgpack/decode_test.go
index deaec364..a1abdcea 100644
--- a/msgpack/decode_test.go
+++ b/msgpack/decode_test.go
@@ -964,6 +964,16 @@ func Test_stringDecoder(t *testing.T) {
 		want    string
 		wantErr bool
 	}{
+		"Nil": {
+			ds: &decodeState{
+				Decoder: &Decoder{
+					p: nil,
+					t: Nil,
+				},
+			},
+			want: string(""),
+			wantErr: false,
+		},
 		"Binary": {
 			ds: &decodeState{
 				Decoder: &Decoder{
diff --git a/nvim/api_test.go b/nvim/api_test.go
index 81a2d861..5c00ad2e 100644
--- a/nvim/api_test.go
+++ b/nvim/api_test.go
@@ -2250,8 +2250,19 @@ func testCommand(v *Nvim) func(*testing.T) {
 				if err != nil {
 					t.Fatal(err)
 				}
-				if len(cmds) > 0 {
-					t.Fatalf("expected 0 length but got %#v", cmds)
+
+				var want int
+				switch nvimVersion.Minor {
+				case 9:
+					want = 0
+				case 10:
+					want = 3
+				default:
+					want = 4
+				}
+
+				if len(cmds) > want {
+					t.Fatalf("expected %d length but got %#v", want, cmds)
 				}
 			})
 
@@ -2266,8 +2277,17 @@ func testCommand(v *Nvim) func(*testing.T) {
 				if err := b.Execute(); err != nil {
 					t.Fatal(err)
 				}
-				if len(cmds) > 0 {
-					t.Fatalf("expected 0 length but got %#v", cmds)
+				var want int
+				switch nvimVersion.Minor {
+				case 9:
+					want = 0
+				case 10:
+					want = 3
+				default:
+					want = 4
+				}
+				if len(cmds) > want {
+					t.Fatalf("expected %d length but got %#v", want, cmds)
 				}
 			})
 		})
@@ -3015,195 +3035,49 @@ func testKey(v *Nvim) func(*testing.T) {
 				skipBetweenVersion(t, "v0.7.0", "v0.8.0")
 
 				mode := "n"
-				if err := v.SetKeyMap(mode, "y", "yy", make(map[string]bool)); err != nil {
+				original, err := v.KeyMap(mode)
+				if err != nil {
 					t.Fatal(err)
 				}
 
-				var wantMaps []*Mapping
-				wantMapsLen := 0
-				switch nvimVersion.Minor {
-				case 6:
-					wantMaps = []*Mapping{
-						{
-							LHS:     "<C-L>",
-							RHS:     "<Cmd>nohlsearch|diffupdate<CR><C-L>",
-							Silent:  0,
-							NoRemap: 1,
-							Expr:    0,
-							Buffer:  0,
-							SID:     0,
-							NoWait:  0,
-						},
-						{
-							LHS:     "Y",
-							RHS:     "y$",
-							Silent:  0,
-							NoRemap: 1,
-							Expr:    0,
-							Buffer:  0,
-							SID:     0,
-							NoWait:  0,
-						},
-						{
-							LHS:     "y",
-							RHS:     "yy",
-							Silent:  0,
-							NoRemap: 0,
-							Expr:    0,
-							Buffer:  0,
-							SID:     0,
-							NoWait:  0,
-						},
-					}
-					wantMapsLen = 2
-				case 7:
-					wantMaps = []*Mapping{
-						{
-							LHS:     "<C-L>",
-							RHS:     "<Cmd>nohlsearch|diffupdate|normal! <C-L><CR>",
-							Silent:  0,
-							NoRemap: 1,
-							Expr:    0,
-							Buffer:  0,
-							SID:     0,
-							NoWait:  0,
-						},
-						{
-							LHS:     "Y",
-							RHS:     "y$",
-							Silent:  0,
-							NoRemap: 1,
-							Expr:    0,
-							Buffer:  0,
-							SID:     0,
-							NoWait:  0,
-						},
-						{
-							LHS:     "y",
-							RHS:     "yy",
-							Silent:  0,
-							NoRemap: 0,
-							Expr:    0,
-							Buffer:  0,
-							SID:     -9,
-							NoWait:  0,
-						},
-					}
-					wantMapsLen = 2
-				case 8:
-					wantMaps = []*Mapping{
-						{
-							LHS:     "&",
-							RHS:     ":&&<CR>",
-							Silent:  0,
-							NoRemap: 1,
-							Expr:    0,
-							Buffer:  0,
-							SID:     -8,
-							NoWait:  0,
-						},
-						{
-							LHS:     "Y",
-							RHS:     "y$",
-							Silent:  0,
-							NoRemap: 1,
-							Expr:    0,
-							Buffer:  0,
-							SID:     -8,
-							NoWait:  0,
-						},
-						{
-							LHS:     "y",
-							RHS:     "yy",
-							Silent:  0,
-							NoRemap: 0,
-							Expr:    0,
-							Buffer:  0,
-							SID:     -9,
-							NoWait:  0,
-						},
-						{
-							LHS:     "<C-L>",
-							RHS:     "<Cmd>nohlsearch|diffupdate|normal! <C-L><CR>",
-							Silent:  0,
-							NoRemap: 1,
-							Expr:    0,
-							Buffer:  0,
-							SID:     -8,
-							NoWait:  0,
-						},
-					}
-					wantMapsLen = 3
-				default:
-					wantMaps = []*Mapping{
-						{
-							LHS:     "&",
-							RHS:     ":&&<CR>",
-							Silent:  0,
-							NoRemap: 1,
-							Expr:    0,
-							Buffer:  0,
-							SID:     -8,
-							NoWait:  0,
-						},
-						{
-							LHS:     "Y",
-							RHS:     "y$",
-							Silent:  0,
-							NoRemap: 1,
-							Expr:    0,
-							Buffer:  0,
-							SID:     -8,
-							NoWait:  0,
-						},
-						{
-							LHS:     "y",
-							RHS:     "yy",
-							Silent:  0,
-							NoRemap: 0,
-							Expr:    0,
-							Buffer:  0,
-							SID:     -9,
-							NoWait:  0,
-						},
-						{
-							LHS:     "<C-L>",
-							RHS:     "<Cmd>nohlsearch|diffupdate|normal! <C-L><CR>",
-							Silent:  0,
-							NoRemap: 1,
-							Expr:    0,
-							Buffer:  0,
-							SID:     -8,
-							NoWait:  0,
-						},
-					}
-					wantMapsLen = 3
+				lhs := "y"
+				rhs := "yy"
+				if err := v.SetKeyMap(mode, lhs, rhs, make(map[string]bool)); err != nil {
+					t.Fatal(err)
 				}
 
-				got, err := v.KeyMap(mode)
+				added, err := v.KeyMap(mode)
 				if err != nil {
 					t.Fatal(err)
 				}
-				if !reflect.DeepEqual(got, wantMaps) {
-					for i, gotmap := range got {
-						t.Logf(" got[%d]: %#v", i, gotmap)
-					}
-					for i, wantmap := range wantMaps {
-						t.Logf("want[%d]: %#v", i, wantmap)
+
+				if len(added) != len(original)+1 {
+					t.Fatalf("want %d but got %d", len(original)+1, len(added))
+				}
+
+				var keymap *Mapping
+				for _, m := range added {
+					if m.LHS == "y" {
+						keymap = m
+						break
 					}
-					t.Fatalf("KeyMap(%s) = %#v, want: %#v", mode, got, wantMaps)
 				}
 
-				if err := v.DeleteKeyMap(mode, "y"); err != nil {
+				if keymap.LHS != lhs && keymap.RHS != rhs {
+					t.Fatalf("want { LHS = %s, RHS = %s } but got { LHS = %s, RHS = %s }", lhs, rhs, keymap.LHS, keymap.RHS)
+				}
+
+				if err := v.DeleteKeyMap(mode, lhs); err != nil {
 					t.Fatal(err)
 				}
 
-				got2, err := v.KeyMap(mode)
+				deleted, err := v.KeyMap(mode)
 				if err != nil {
 					t.Fatal(err)
 				}
-				if len(got2) != wantMapsLen {
-					t.Fatalf("expected %d but got %#v", wantMapsLen, got2)
+
+				if len(deleted) != len(original) {
+					t.Fatalf("want %d but got %d", len(original), len(added))
 				}
 			})
 
@@ -3398,202 +3272,58 @@ func testKey(v *Nvim) func(*testing.T) {
 			t.Run("KeyMap", func(t *testing.T) {
 				skipBetweenVersion(t, "v0.7.0", "v0.8.0")
 
+				mode := "n"
 				b := v.NewBatch()
 
-				mode := "n"
-				b.SetKeyMap(mode, "y", "yy", make(map[string]bool))
+				var original []*Mapping
+				b.KeyMap(mode, &original)
 				if err := b.Execute(); err != nil {
 					t.Fatal(err)
 				}
 
-				var wantMaps []*Mapping
-				wantMapsLen := 0
-				switch nvimVersion.Minor {
-				case 6:
-					wantMaps = []*Mapping{
-						{
-							LHS:     "<C-L>",
-							RHS:     "<Cmd>nohlsearch|diffupdate<CR><C-L>",
-							Silent:  0,
-							NoRemap: 1,
-							Expr:    0,
-							Buffer:  0,
-							SID:     0,
-							NoWait:  0,
-						},
-						{
-							LHS:     "Y",
-							RHS:     "y$",
-							Silent:  0,
-							NoRemap: 1,
-							Expr:    0,
-							Buffer:  0,
-							SID:     0,
-							NoWait:  0,
-						},
-						{
-							LHS:     "y",
-							RHS:     "yy",
-							Silent:  0,
-							NoRemap: 0,
-							Expr:    0,
-							Buffer:  0,
-							SID:     0,
-							NoWait:  0,
-						},
-					}
-					wantMapsLen = 2
-				case 7:
-					wantMaps = []*Mapping{
-						{
-							LHS:     "<C-L>",
-							RHS:     "<Cmd>nohlsearch|diffupdate|normal! <C-L><CR>",
-							Silent:  0,
-							NoRemap: 1,
-							Expr:    0,
-							Buffer:  0,
-							SID:     0,
-							NoWait:  0,
-						},
-						{
-							LHS:     "Y",
-							RHS:     "y$",
-							Silent:  0,
-							NoRemap: 1,
-							Expr:    0,
-							Buffer:  0,
-							SID:     0,
-							NoWait:  0,
-						},
-						{
-							LHS:     "y",
-							RHS:     "yy",
-							Silent:  0,
-							NoRemap: 0,
-							Expr:    0,
-							Buffer:  0,
-							SID:     -9,
-							NoWait:  0,
-						},
-					}
-					wantMapsLen = 2
-				case 8:
-					wantMaps = []*Mapping{
-						{
-							LHS:     "&",
-							RHS:     ":&&<CR>",
-							Silent:  0,
-							NoRemap: 1,
-							Expr:    0,
-							Buffer:  0,
-							SID:     -8,
-							NoWait:  0,
-						},
-						{
-							LHS:     "Y",
-							RHS:     "y$",
-							Silent:  0,
-							NoRemap: 1,
-							Expr:    0,
-							Buffer:  0,
-							SID:     -8,
-							NoWait:  0,
-						},
-						{
-							LHS:     "y",
-							RHS:     "yy",
-							Silent:  0,
-							NoRemap: 0,
-							Expr:    0,
-							Buffer:  0,
-							SID:     -9,
-							NoWait:  0,
-						},
-						{
-							LHS:     "<C-L>",
-							RHS:     "<Cmd>nohlsearch|diffupdate|normal! <C-L><CR>",
-							Silent:  0,
-							NoRemap: 1,
-							Expr:    0,
-							Buffer:  0,
-							SID:     -8,
-							NoWait:  0,
-						},
-					}
-					wantMapsLen = 3
-				default:
-					wantMaps = []*Mapping{
-						{
-							LHS:     "&",
-							RHS:     ":&&<CR>",
-							Silent:  0,
-							NoRemap: 1,
-							Expr:    0,
-							Buffer:  0,
-							SID:     -8,
-							NoWait:  0,
-						},
-						{
-							LHS:     "Y",
-							RHS:     "y$",
-							Silent:  0,
-							NoRemap: 1,
-							Expr:    0,
-							Buffer:  0,
-							SID:     -8,
-							NoWait:  0,
-						},
-						{
-							LHS:     "y",
-							RHS:     "yy",
-							Silent:  0,
-							NoRemap: 0,
-							Expr:    0,
-							Buffer:  0,
-							SID:     -9,
-							NoWait:  0,
-						},
-						{
-							LHS:     "<C-L>",
-							RHS:     "<Cmd>nohlsearch|diffupdate|normal! <C-L><CR>",
-							Silent:  0,
-							NoRemap: 1,
-							Expr:    0,
-							Buffer:  0,
-							SID:     -8,
-							NoWait:  0,
-						},
-					}
-					wantMapsLen = 3
+				lhs := "y"
+				rhs := "yy"
+
+				b.SetKeyMap(mode, lhs, rhs, make(map[string]bool))
+				if err := b.Execute(); err != nil {
+					t.Fatal(err)
 				}
 
-				var got []*Mapping
-				b.KeyMap(mode, &got)
+				var added []*Mapping
+				b.KeyMap(mode, &added)
 				if err := b.Execute(); err != nil {
 					t.Fatal(err)
 				}
-				if !reflect.DeepEqual(got, wantMaps) {
-					for i, gotmap := range got {
-						t.Logf(" got[%d]: %#v", i, gotmap)
-					}
-					for i, wantmap := range wantMaps {
-						t.Logf("want[%d]: %#v", i, wantmap)
+
+				if len(added) != len(original)+1 {
+					t.Fatalf("want %d but got %d", len(original)+1, len(added))
+				}
+
+				var keymap *Mapping
+				for _, m := range added {
+					if m.LHS == "y" {
+						keymap = m
+						break
 					}
-					t.Fatalf("KeyMap(%s) = %#v, want: %#v", mode, got, wantMaps)
 				}
 
-				b.DeleteKeyMap(mode, "y")
+				if keymap.LHS != lhs && keymap.RHS != rhs {
+					t.Fatalf("want { LHS = %s, RHS = %s } but got { LHS = %s, RHS = %s }", lhs, rhs, keymap.LHS, keymap.RHS)
+				}
+
+				b.DeleteKeyMap(mode, lhs)
 				if err := b.Execute(); err != nil {
 					t.Fatal(err)
 				}
 
-				var got2 []*Mapping
-				b.KeyMap(mode, &got2)
+				var deleted []*Mapping
+				b.KeyMap(mode, &deleted)
 				if err := b.Execute(); err != nil {
 					t.Fatal(err)
 				}
-				if len(got2) != wantMapsLen {
-					t.Fatalf("expected %d but got %#v", wantMapsLen, got2)
+
+				if len(deleted) != len(original) {
+					t.Fatalf("want %d but got %d", len(original), len(added))
 				}
 			})