diff --git a/extras/hs-test/http_test.go b/extras/hs-test/http_test.go
index 875d489..f7a160c 100644
--- a/extras/hs-test/http_test.go
+++ b/extras/hs-test/http_test.go
@@ -90,6 +90,7 @@
 	args := fmt.Sprintf("curl --noproxy '*' --local-port 55444 --http3-only -k https://%s:8443/%s", serverAddress, query)
 	curlCont.extraRunningArgs = args
 	o, err := curlCont.combinedOutput()
+	s.log(o)
 	s.assertNil(err, fmt.Sprint(err))
 	s.assertContains(o, "<http>", "<http> not found in the result!")
 }
diff --git a/extras/hs-test/script/nginx_ldp.sh b/extras/hs-test/script/nginx_ldp.sh
index 4a22e14..a6b0a20 100755
--- a/extras/hs-test/script/nginx_ldp.sh
+++ b/extras/hs-test/script/nginx_ldp.sh
@@ -1,3 +1,3 @@
 #!/usr/bin/env bash
 
-LD_PRELOAD=$LDP $@ 2>&1 > /proc/1/fd/1
+$1 -v && LD_PRELOAD=$LDP $@ 2>&1 > /proc/1/fd/1
