[Libguestfs] [libnbd PATCH v2 12/12] tests: Language port of nbd_opt_set_meta_context() tests

Eric Blake
Wed, 31 Aug 2022 14:39:28 -0000

As promised in the previous patch, also test the new
nbd_opt_set_meta_context() API in Python, OCaml, and Golang.

The fact that Go slams all unit tests into the same namespace is
somewhat annoying; it required munging test 240 now that 250 wants to
use similar global variables.
---
 python/t/250-opt-set-meta.py            | 126 ++++++++++++
 ocaml/tests/Makefile.am                 |   5 +-
 ocaml/tests/test_250_opt_set_meta.ml    | 150 ++++++++++++++
 tests/opt-set-meta.c                    |   1 +
 golang/Makefile.am                      |   3 +-
 golang/libnbd_240_opt_list_meta_test.go |  54 +++---
 golang/libnbd_250_opt_set_meta_test.go  | 248 ++++++++++++++++++++++++
 7 files changed, 558 insertions(+), 29 deletions(-)
 create mode 100644 python/t/250-opt-set-meta.py
 create mode 100644 ocaml/tests/test_250_opt_set_meta.ml
 create mode 100644 golang/libnbd_250_opt_set_meta_test.go

diff --git a/python/t/250-opt-set-meta.py b/python/t/250-opt-set-meta.py
new file mode 100644
index 0000000..eb27998
--- /dev/null
+++ b/python/t/250-opt-set-meta.py
@@ -0,0 +1,126 @@
+# libnbd Python bindings
+# Copyright (C) 2010-2022 Red Hat Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+import nbd
+
+
+count = 0
+seen = False
+
+
+def f(user_data, name):
+    global count
+    global seen
+    assert user_data == 42
+    count = count + 1
+    if name == nbd.CONTEXT_BASE_ALLOCATION:
+        seen = True
+
+
+def must_fail(f, *args, **kwds):
+    try:
+        f(*args, **kwds)
+        assert False
+    except nbd.Error:
+        pass
+
+
+# First process, with structured replies. Get into negotiating state.
+h = nbd.NBD()
+h.set_opt_mode(True)
+h.connect_command(["nbdkit", "-s",
"--exit-with-parent", "-v",
+                   "memory", "size=1M"])
+
+# No contexts negotiated yet; can_meta should be error if any requested */
+assert h.get_structured_replies_negotiated() is True
+assert h.can_meta_context(nbd.CONTEXT_BASE_ALLOCATION) is False
+h.add_meta_context(nbd.CONTEXT_BASE_ALLOCATION)
+must_fail(h.can_meta_context, nbd.CONTEXT_BASE_ALLOCATION)
+
+# FIXME: Once nbd_opt_structured_reply exists, check that set before
+# SR fails server-side, then enable SR for rest of process.
+
+# nbdkit does not match wildcard for SET, even though it does for LIST
+count = 0
+seen = False
+h.clear_meta_contexts()
+h.add_meta_context("base:")
+r = h.opt_set_meta_context(lambda *args: f(42, *args))
+assert r == count
+assert r == 0
+assert not seen
+assert h.can_meta_context(nbd.CONTEXT_BASE_ALLOCATION) is False
+
+# Negotiating with no contexts is not an error, but selects nothing
+count = 0
+seen = False
+h.clear_meta_contexts()
+r = h.opt_set_meta_context(lambda *args: f(42, *args))
+assert r == 0
+assert r == count
+assert not seen
+assert h.can_meta_context(nbd.CONTEXT_BASE_ALLOCATION) is False
+
+# Request 2 with expectation of 1; with set_request_meta_context off
+count = 0
+seen = False
+h.add_meta_context("x-nosuch:context")
+h.add_meta_context(nbd.CONTEXT_BASE_ALLOCATION)
+h.set_request_meta_context(False)
+r = h.opt_set_meta_context(lambda *args: f(42, *args))
+assert r == 1
+assert count == 1
+assert seen
+assert h.can_meta_context(nbd.CONTEXT_BASE_ALLOCATION) is True
+
+# Transition to transmission phase; our last set should remain active
+h.clear_meta_contexts()
+h.add_meta_context("x-nosuch:context")
+h.opt_go()
+assert h.can_meta_context(nbd.CONTEXT_BASE_ALLOCATION) is True
+
+# Now too late to set; but should not lose earlier state
+count = 0
+seen = False
+must_fail(h.opt_set_meta_context, lambda *args: f(42, *args))
+assert count == 0
+assert not seen
+assert h.can_meta_context(nbd.CONTEXT_BASE_ALLOCATION) is True
+
+h.shutdown()
+
+# Second process, this time without structured replies server-side.
+h = nbd.NBD()
+h.set_opt_mode(True)
+h.add_meta_context(nbd.CONTEXT_BASE_ALLOCATION)
+h.connect_command(["nbdkit", "-s",
"--exit-with-parent", "-v",
+                   "memory", "size=1M",
"--no-sr"])
+assert h.get_structured_replies_negotiated() is False
+
+# Expect server-side failure here
+count = 0
+seen = False
+must_fail(h.opt_set_meta_context, lambda *args: f(42, *args))
+assert count == 0
+assert not seen
+must_fail(h.can_meta_context, nbd.CONTEXT_BASE_ALLOCATION)
+
+# Even though can_meta fails after failed SET, it returns 0 after go
+h.opt_go()
+assert h.can_meta_context(nbd.CONTEXT_BASE_ALLOCATION) is False
+
+h.shutdown()
diff --git a/ocaml/tests/Makefile.am b/ocaml/tests/Makefile.am
index 24f626d..f8ce810 100644
--- a/ocaml/tests/Makefile.am
+++ b/ocaml/tests/Makefile.am
@@ -1,5 +1,5 @@
 # nbd client library in userspace
-# Copyright (C) 2013-2020 Red Hat Inc.
+# Copyright (C) 2013-2022 Red Hat Inc.
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -31,6 +31,7 @@ EXTRA_DIST = \
 	test_220_opt_list.ml \
 	test_230_opt_info.ml \
 	test_240_opt_list_meta.ml \
+	test_250_opt_set_meta.ml \
 	test_300_get_size.ml \
 	test_400_pread.ml \
 	test_405_pread_structured.ml \
@@ -59,6 +60,7 @@ tests_bc = \
 	test_220_opt_list.bc \
 	test_230_opt_info.bc \
 	test_240_opt_list_meta.bc \
+	test_250_opt_set_meta.bc \
 	test_300_get_size.bc \
 	test_400_pread.bc \
 	test_405_pread_structured.bc \
@@ -84,6 +86,7 @@ tests_opt = \
 	test_220_opt_list.opt \
 	test_230_opt_info.opt \
 	test_240_opt_list_meta.opt \
+	test_250_opt_set_meta.opt \
 	test_300_get_size.opt \
 	test_400_pread.opt \
 	test_405_pread_structured.opt \
diff --git a/ocaml/tests/test_250_opt_set_meta.ml
b/ocaml/tests/test_250_opt_set_meta.ml
new file mode 100644
index 0000000..d74e9e0
--- /dev/null
+++ b/ocaml/tests/test_250_opt_set_meta.ml
@@ -0,0 +1,150 @@
+(* hey emacs, this is OCaml code: -*- tuareg -*- *)
+(* libnbd OCaml test case
+ * Copyright (C) 2013-2022 Red Hat Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *)
+
+let count = ref 0
+let seen = ref false
+let f user_data name +  assert (user_data = 42);
+  count := !count + 1;
+  if name = NBD.context_base_allocation then
+    seen := true;
+  0
+
+let () +  let nbd = NBD.create () in
+  NBD.set_opt_mode nbd true;
+  NBD.connect_command nbd
+                      ["nbdkit"; "-s";
"--exit-with-parent"; "-v";
+                       "memory"; "size=1M"];
+
+  (* No contexts negotiated yet; can_meta should be error if any requested *)
+  let sr = NBD.get_structured_replies_negotiated nbd in
+  assert sr;
+  let m = NBD.can_meta_context nbd NBD.context_base_allocation in
+  assert (not m);
+  NBD.add_meta_context nbd NBD.context_base_allocation;
+  (try
+     let _ = NBD.can_meta_context nbd NBD.context_base_allocation in
+     assert false
+   with
+     NBD.Error (errstr, errno) -> ()
+  );
+
+  (* FIXME: Once nbd_opt_structured_reply exists, check that set before
+   * SR fails server-side, then enable SR for rest of process.
+   *)
+
+  (* nbdkit does not match wildcard for SET, even though it does for LIST *)
+  count := 0;
+  seen := false;
+  NBD.clear_meta_contexts nbd;
+  NBD.add_meta_context nbd "base:";
+  let r = NBD.opt_set_meta_context nbd (f 42) in
+  assert (r = !count);
+  assert (r = 0);
+  assert (not !seen);
+  let m = NBD.can_meta_context nbd NBD.context_base_allocation in
+  assert (not m);
+
+  (* Negotiating with no contexts is not an error, but selects nothing *)
+  count := 0;
+  seen := false;
+  NBD.clear_meta_contexts nbd;
+  let r = NBD.opt_set_meta_context nbd (f 42) in
+  assert (r = 0);
+  assert (r = !count);
+  assert (not !seen);
+  let m = NBD.can_meta_context nbd NBD.context_base_allocation in
+  assert (not m);
+
+  (* Request 2 with expectation of 1; with set_request_meta_context off *)
+  count := 0;
+  seen := false;
+  NBD.add_meta_context nbd "x-nosuch:context";
+  NBD.add_meta_context nbd NBD.context_base_allocation;
+  NBD.set_request_meta_context nbd false;
+  let r = NBD.opt_set_meta_context nbd (f 42) in
+  assert (r = 1);
+  assert (r = !count);
+  assert !seen;
+  let m = NBD.can_meta_context nbd NBD.context_base_allocation in
+  assert m;
+
+  (* Transition to transmission phase; our last set should remain active *)
+  NBD.clear_meta_contexts nbd;
+  NBD.add_meta_context nbd "x-nosuch:context";
+  NBD.opt_go nbd;
+  let m = NBD.can_meta_context nbd NBD.context_base_allocation in
+  assert m;
+
+  (* Now too late to set; but should not lose earlier state *)
+  count := 0;
+  seen := false;
+  (try
+     let _ = NBD.opt_set_meta_context nbd (f 42) in
+     assert false
+   with
+     NBD.Error (errstr, errno) -> ()
+  );
+  assert (0 = !count);
+  assert (not !seen);
+  let s = NBD.get_size nbd in
+  assert (s = 1048576_L);
+  let m = NBD.can_meta_context nbd NBD.context_base_allocation in
+  assert m;
+
+  NBD.shutdown nbd;
+
+  (* Second process, this time without structured replies server-side. *)
+  let nbd = NBD.create () in
+  NBD.set_opt_mode nbd true;
+  NBD.add_meta_context nbd NBD.context_base_allocation;
+  NBD.connect_command nbd
+                      ["nbdkit"; "-s";
"--exit-with-parent"; "-v";
+                       "memory"; "size=1M";
"--no-sr"];
+  let sr = NBD.get_structured_replies_negotiated nbd in
+  assert (not sr);
+
+  (* Expect server-side failure here *)
+  count := 0;
+  seen := false;
+  NBD.add_meta_context nbd "base:";
+  (try
+     let _ = NBD.opt_set_meta_context nbd (f 42) in
+     assert false
+   with
+     NBD.Error (errstr, errno) -> ()
+  );
+  assert (0 = !count);
+  assert (not !seen);
+  (try
+     let _ = NBD.can_meta_context nbd NBD.context_base_allocation in
+     assert false
+   with
+     NBD.Error (errstr, errno) -> ()
+  );
+
+  (* Even though can_meta fails after failed SET, it returns 0 after go *)
+  NBD.opt_go nbd;
+  let m = NBD.can_meta_context nbd NBD.context_base_allocation in
+  assert (not m);
+
+  NBD.shutdown nbd
+
+let () = Gc.compact ()
diff --git a/tests/opt-set-meta.c b/tests/opt-set-meta.c
index 01c9604..bd00276 100644
--- a/tests/opt-set-meta.c
+++ b/tests/opt-set-meta.c
@@ -17,6 +17,7 @@
  */

 /* Test behavior of nbd_opt_set_meta_context. */
+/* See also unit test 250 in the various language ports. */

 #include <config.h>

diff --git a/golang/Makefile.am b/golang/Makefile.am
index f170cbc..f6e6f91 100644
--- a/golang/Makefile.am
+++ b/golang/Makefile.am
@@ -1,5 +1,5 @@
 # nbd client library in userspace
-# Copyright (C) 2013-2020 Red Hat Inc.
+# Copyright (C) 2013-2022 Red Hat Inc.
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -35,6 +35,7 @@ source_files = \
 	libnbd_220_opt_list_test.go \
 	libnbd_230_opt_info_test.go \
 	libnbd_240_opt_list_meta_test.go \
+	libnbd_250_opt_set_meta_test.go \
 	libnbd_300_get_size_test.go \
 	libnbd_400_pread_test.go \
 	libnbd_405_pread_structured_test.go \
diff --git a/golang/libnbd_240_opt_list_meta_test.go
b/golang/libnbd_240_opt_list_meta_test.go
index 47df787..4af1008 100644
--- a/golang/libnbd_240_opt_list_meta_test.go
+++ b/golang/libnbd_240_opt_list_meta_test.go
@@ -22,16 +22,16 @@ import (
 	"testing"
 )

-var count uint
-var seen bool
+var list_count uint
+var list_seen bool

 func listmetaf(user_data int, name string) int {
 	if user_data != 42 {
 		panic("expected user_data == 42")
 	}
-	count++
+	list_count++
 	if (name == context_base_allocation) {
-		seen = true
+		list_seen = true
 	}
 	return 0
 }
@@ -57,22 +57,22 @@ func Test240OptListMeta(t *testing.T) {
 	}

 	/* First pass: empty query should give at least "base:allocation".
*/
-	count = 0
-	seen = false
+	list_count = 0
+	list_seen = false
 	r, err := h.OptListMetaContext(func(name string) int {
 	        return listmetaf(42, name)
 	})
 	if err != nil {
 		t.Fatalf("could not request opt_list_meta_context: %s", err)
 	}
-	if r != count || r < 1 || !seen {
-		t.Fatalf("unexpected count after opt_list_meta_context")
+	if r != list_count || r < 1 || !list_seen {
+		t.Fatalf("unexpected list_count after opt_list_meta_context")
 	}
-	max := count
+	max := list_count

 	/* Second pass: bogus query has no response. */
-	count = 0
-	seen = false
+	list_count = 0
+	list_seen = false
 	err = h.AddMetaContext("x-nosuch:")
 	if err != nil {
 		t.Fatalf("could not request add_meta_context: %s", err)
@@ -83,13 +83,13 @@ func Test240OptListMeta(t *testing.T) {
 	if err != nil {
 		t.Fatalf("could not request opt_list_meta_context: %s", err)
 	}
-	if r != 0 || r != count || seen {
-		t.Fatalf("unexpected count after opt_list_meta_context")
+	if r != 0 || r != list_count || list_seen {
+		t.Fatalf("unexpected list_count after opt_list_meta_context")
 	}

 	/* Third pass: specific query should have one match. */
-	count = 0
-	seen = false
+	list_count = 0
+	list_seen = false
 	err = h.AddMetaContext(context_base_allocation)
 	if err != nil {
 		t.Fatalf("could not request add_meta_context: %s", err)
@@ -114,15 +114,15 @@ func Test240OptListMeta(t *testing.T) {
 	if err != nil {
 		t.Fatalf("could not request opt_list_meta_context: %s", err)
 	}
-	if r != 1 || r != count || !seen {
-		t.Fatalf("unexpected count after opt_list_meta_context")
+	if r != 1 || r != list_count || !list_seen {
+		t.Fatalf("unexpected list_count after opt_list_meta_context")
 	}

 	/* Fourth pass: opt_list_meta_context is stateless, so it should
      * not wipe status learned during opt_info
 	 */
-	count = 0
-	seen = false
+	list_count = 0
+	list_seen = false
         _, err = h.GetSize()
 	if err == nil {
 		t.Fatalf("expected error")
@@ -147,7 +147,7 @@ func Test240OptListMeta(t *testing.T) {
 		t.Fatalf("can_meta_context failed unexpectedly: %s", err)
 	}
 	if !meta {
-		t.Fatalf("unexpected count after can_meta_context")
+		t.Fatalf("unexpected list_count after can_meta_context")
 	}
 	err = h.ClearMetaContexts()
 	if err != nil {
@@ -163,8 +163,8 @@ func Test240OptListMeta(t *testing.T) {
 	if err != nil {
 		t.Fatalf("could not request opt_list_meta_context: %s", err)
 	}
-	if r != 0 || r != count || seen {
-		t.Fatalf("unexpected count after opt_list_meta_context")
+	if r != 0 || r != list_count || list_seen {
+		t.Fatalf("unexpected list_count after opt_list_meta_context")
 	}
         size, err = h.GetSize()
 	if err != nil {
@@ -178,13 +178,13 @@ func Test240OptListMeta(t *testing.T) {
 		t.Fatalf("can_meta_context failed unexpectedly: %s", err)
 	}
 	if !meta {
-		t.Fatalf("unexpected count after can_meta_context")
+		t.Fatalf("unexpected list_count after can_meta_context")
 	}
 	err = h.ClearMetaContexts()

 	/* Final pass: "base:" query should get at least
"base:allocation" */
-	count = 0
-	seen = false
+	list_count = 0
+	list_seen = false
 	err = h.AddMetaContext("base:")
 	if err != nil {
 		t.Fatalf("could not request add_meta_context: %s", err)
@@ -195,8 +195,8 @@ func Test240OptListMeta(t *testing.T) {
 	if err != nil {
 		t.Fatalf("could not request opt_list_meta_context: %s", err)
 	}
-	if r < 1 || r > max || r != count || !seen {
-		t.Fatalf("unexpected count after opt_list_meta_context")
+	if r < 1 || r > max || r != list_count || !list_seen {
+		t.Fatalf("unexpected list_count after opt_list_meta_context")
 	}

 	err = h.OptAbort()
diff --git a/golang/libnbd_250_opt_set_meta_test.go
b/golang/libnbd_250_opt_set_meta_test.go
new file mode 100644
index 0000000..c29b7f4
--- /dev/null
+++ b/golang/libnbd_250_opt_set_meta_test.go
@@ -0,0 +1,248 @@
+/* libnbd golang tests
+ * Copyright (C) 2013-2022 Red Hat Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package libnbd
+
+import (
+	"testing"
+)
+
+var set_count uint
+var set_seen bool
+
+func setmetaf(user_data int, name string) int {
+	if user_data != 42 {
+		panic("expected user_data == 42")
+	}
+	set_count++
+	if (name == context_base_allocation) {
+		set_seen = true
+	}
+	return 0
+}
+
+func Test250OptSetMeta(t *testing.T) {
+	h, err := Create()
+	if err != nil {
+		t.Fatalf("could not create handle: %s", err)
+	}
+	defer h.Close()
+
+	err = h.SetOptMode(true)
+	if err != nil {
+		t.Fatalf("could not set opt mode: %s", err)
+	}
+
+	err = h.ConnectCommand([]string{
+		"nbdkit", "-s", "--exit-with-parent",
"-v",
+		"memory", "size=1M",
+	})
+	if err != nil {
+		t.Fatalf("could not connect: %s", err)
+	}
+
+        /* No contexts negotiated yet; CanMeta should be error if any requested
*/
+        sr, err := h.GetStructuredRepliesNegotiated()
+	if err != nil {
+		t.Fatalf("could not check structured replies negotiated: %s", err)
+	}
+        if !sr {
+        	t.Fatalf("unexpected structured replies state")
+        }
+        meta, err := h.CanMetaContext(context_base_allocation)
+	if err != nil {
+		t.Fatalf("could not check can meta context: %s", err)
+	}
+        if meta {
+        	t.Fatalf("unexpected can meta context state")
+        }
+	err = h.AddMetaContext(context_base_allocation)
+	if err != nil {
+		t.Fatalf("could not request add_meta_context: %s", err)
+	}
+        _, err = h.CanMetaContext(context_base_allocation)
+	if err == nil {
+		t.Fatalf("expected error")
+	}
+
+        /* FIXME: Once OptStructuredReply exists, check that set before
+         * SR fails server-side, then enable SR for rest of process.
+         */
+
+	/* nbdkit does not match wildcard for SET, even though it does for LIST */
+	set_count = 0
+	set_seen = false
+        err = h.ClearMetaContexts()
+	if err != nil {
+		t.Fatalf("could not request clear_meta_contexts: %s", err)
+	}
+	err = h.AddMetaContext("base:")
+	if err != nil {
+		t.Fatalf("could not request add_meta_context: %s", err)
+	}
+	r, err := h.OptSetMetaContext(func(name string) int {
+	        return setmetaf(42, name)
+	})
+	if err != nil {
+		t.Fatalf("could not request opt_set_meta_context: %s", err)
+	}
+	if r != set_count || r != 0 || set_seen {
+		t.Fatalf("unexpected set_count after opt_set_meta_context")
+	}
+
+	/* Request 2 with expectation of 1; with SetRequestMetaContext off */
+	set_count = 0
+	set_seen = false
+	err = h.AddMetaContext("x-nosuch:context")
+	if err != nil {
+		t.Fatalf("could not request add_meta_context: %s", err)
+	}
+	err = h.AddMetaContext(context_base_allocation)
+	if err != nil {
+		t.Fatalf("could not request add_meta_context: %s", err)
+	}
+        err = h.SetRequestMetaContext(false)
+	if err != nil {
+		t.Fatalf("could not set_request_meta_context: %s", err)
+	}
+	r, err = h.OptSetMetaContext(func(name string) int {
+	        return setmetaf(42, name)
+	})
+	if err != nil {
+		t.Fatalf("could not request opt_set_meta_context: %s", err)
+	}
+	if r != 1 || r != set_count || !set_seen {
+		t.Fatalf("unexpected set_count after opt_set_meta_context")
+	}
+        meta, err = h.CanMetaContext(context_base_allocation)
+	if err != nil {
+		t.Fatalf("could not check can meta context: %s", err)
+	}
+        if !meta {
+        	t.Fatalf("unexpected can meta context state")
+        }
+
+	/* Transition to transmission phase; our last set should remain active */
+        err = h.ClearMetaContexts()
+	if err != nil {
+		t.Fatalf("could not request clear_meta_contexts: %s", err)
+	}
+	err = h.AddMetaContext("x-nosuch:context")
+	if err != nil {
+		t.Fatalf("could not request add_meta_context: %s", err)
+	}
+        err = h.OptGo()
+	if err != nil {
+		t.Fatalf("could not request opt_go: %s", err)
+	}
+        meta, err = h.CanMetaContext(context_base_allocation)
+	if err != nil {
+		t.Fatalf("could not check can meta context: %s", err)
+	}
+        if !meta {
+        	t.Fatalf("unexpected can meta context state")
+        }
+
+        /* Now too late to set; but should not lose earlier state */
+	set_count = 0
+	set_seen = false
+	_, err = h.OptSetMetaContext(func(name string) int {
+	        return setmetaf(42, name)
+	})
+	if err == nil {
+		t.Fatalf("expected error")
+	}
+	if set_count != 0 || set_seen {
+		t.Fatalf("unexpected set_count after opt_set_meta_context")
+	}
+        meta, err = h.CanMetaContext(context_base_allocation)
+	if err != nil {
+		t.Fatalf("could not check can meta context: %s", err)
+	}
+        if !meta {
+        	t.Fatalf("unexpected can meta context state")
+        }
+
+	err = h.Shutdown(nil)
+	if err != nil {
+		t.Fatalf("could not request shutdown: %s", err)
+	}
+
+        /* Second process, this time without structured replies server-side. */
+	h, err = Create()
+	if err != nil {
+		t.Fatalf("could not create handle: %s", err)
+	}
+	defer h.Close()
+
+	err = h.SetOptMode(true)
+	if err != nil {
+		t.Fatalf("could not set opt mode: %s", err)
+	}
+
+	err = h.AddMetaContext(context_base_allocation)
+	if err != nil {
+		t.Fatalf("could not request add_meta_context: %s", err)
+	}
+
+        err = h.ConnectCommand([]string{
+		"nbdkit", "-s", "--exit-with-parent",
"-v",
+		"memory", "size=1M", "--no-sr",
+	})
+	if err != nil {
+		t.Fatalf("could not connect: %s", err)
+	}
+
+        sr, err = h.GetStructuredRepliesNegotiated()
+	if err != nil {
+		t.Fatalf("could not check structured replies negotiated: %s", err)
+	}
+        if sr {
+        	t.Fatalf("unexpected structured replies state")
+        }
+
+        /* Expect server-side failure here */
+	set_count = 0
+	set_seen = false
+	_, err = h.OptSetMetaContext(func(name string) int {
+	        return setmetaf(42, name)
+	})
+	if err == nil {
+		t.Fatalf("expected error")
+	}
+	if set_count != 0 || set_seen {
+		t.Fatalf("unexpected set_count after opt_set_meta_context")
+	}
+        _, err = h.CanMetaContext(context_base_allocation)
+	if err == nil {
+		t.Fatalf("expected error")
+	}
+
+        /* Even though CanMeta fails after failed SET, it returns 0 after go */
+        err = h.OptGo()
+	if err != nil {
+		t.Fatalf("could not request opt_go: %s", err)
+	}
+        meta, err = h.CanMetaContext(context_base_allocation)
+	if err != nil {
+		t.Fatalf("could not check can meta context: %s", err)
+	}
+        if meta {
+        	t.Fatalf("unexpected can meta context state")
+        }
+}
--
2.37.2