fix ci failures on master

Author: medvednikov

vlib/net/http/server_tls_test.v

@@ -1,3 +1,4 @@
+// vtest build: !sanitize-memory-clang
 // Hermetic TLS-termination test for net.http.Server: spin up a local HTTPS
 // server with an in-memory cert/key, hit it with http.fetch (validate: false),
 // and assert the round-trip.

vlib/net/ssl/ssl_alpn_test.v

@@ -1,3 +1,4 @@
+// vtest build: !sanitize-memory-clang
 module main
 
 import net

vlib/v/builder/cc.v

@@ -325,19 +325,58 @@ fn c_error_looks_like_missing_libatomic(c_output string) bool {
 	return c_error_missing_libatomic_marker(c_output) != ''
 }
 
+fn normalized_linker_library_file_name(lib_name string) string {
+	for suffix in ['.dll.a', '.lib', '.a', '.dll'] {
+		if lib_name.ends_with(suffix) {
+			mut normalized := lib_name[..lib_name.len - suffix.len]
+			if normalized.starts_with('lib') {
+				normalized = normalized[3..]
+			}
+			return normalized
+		}
+	}
+	return lib_name
+}
+
+fn normalized_missing_library_name(raw_name string, allow_plain_name bool) string {
+	mut lib_name := raw_name.trim_space().trim('`\'"')
+	for delimiter in ['`', "'", '"', ' ', ':'] {
+		lib_name = lib_name.all_before(delimiter)
+	}
+	lib_name = lib_name.trim_space().trim('`\'"')
+	if lib_name.starts_with('-l') {
+		return normalized_linker_library_file_name(lib_name[2..])
+	}
+	normalized := normalized_linker_library_file_name(lib_name)
+	if normalized != lib_name {
+		return normalized
+	}
+	if allow_plain_name {
+		return lib_name
+	}
+	return ''
+}
+
 fn c_error_missing_library_name(c_output string) string {
 	for line in c_output.split_into_lines() {
 		if line.contains("library '") && line.contains("' not found") {
-			return line.all_after("library '").all_before("' not found")
+			return normalized_missing_library_name(line.all_after("library '").all_before("' not found"),
+				true)
 		}
+		lower_line := line.to_lower()
 		for marker in [
 			'cannot find -l',
 			'unable to find library -l',
 			'library not found for -l',
 		] {
-			if line.contains(marker) {
-				lib_name := line.all_after(marker).trim_space()
-				return lib_name.all_before('`').all_before("'").all_before('"').all_before(' ').all_before(':')
+			if start := lower_line.index(marker) {
+				return normalized_missing_library_name(line[start + marker.len..], true)
+			}
+		}
+		if start := lower_line.index('cannot find ') {
+			lib_name := normalized_missing_library_name(line[start + 'cannot find '.len..], false)
+			if lib_name != '' {
+				return lib_name
 			}
 		}
 	}

vlib/v/builder/cc_test.v

@@ -755,6 +755,16 @@ fn test_c_error_missing_library_name_with_gnu_ld_output() {
 	assert c_error_missing_library_name(c_output) == 'ssl'
 }
 
+fn test_c_error_missing_library_name_with_mingw_ld_output() {
+	c_output := 'C:/msys64/ucrt64/bin/ld.exe: cannot find libv_missing_lib_25499.dll.a: No such file or directory\ncollect2.exe: error: ld returned 1 exit status\n'
+	assert c_error_missing_library_name(c_output) == 'v_missing_lib_25499'
+}
+
+fn test_c_error_missing_library_name_with_mingw_lflag_suffix_output() {
+	c_output := 'C:/msys64/ucrt64/bin/ld.exe: cannot find -lv_missing_lib_25499.dll.a: No such file or directory\ncollect2.exe: error: ld returned 1 exit status\n'
+	assert c_error_missing_library_name(c_output) == 'v_missing_lib_25499'
+}
+
 fn test_c_error_missing_library_name_with_regular_c_error() {
 	c_output := "error: unknown type name 'my_missing_type'"
 	assert c_error_missing_library_name(c_output) == ''

vlib/veb/tests/graceful_shutdown_test.v

@@ -5,6 +5,7 @@ import time
 import veb
 
 const graceful_shutdown_host = '127.0.0.1'
+const graceful_shutdown_wait_timeout = 10 * time.second
 
 struct GracefulShutdownContext {
 	veb.Context
@@ -31,19 +32,6 @@ pub fn (mut app GracefulShutdownApp) slow(mut ctx GracefulShutdownContext) veb.R
 	return ctx.text('slow done')
 }
 
-pub fn (mut app GracefulShutdownApp) shutdown(mut ctx GracefulShutdownContext) veb.Result {
-	spawn app.shutdown_now()
-	return ctx.text('shutting down')
-}
-
-fn (app &GracefulShutdownApp) shutdown_now() {
-	mut server := app.server
-	if server == unsafe { nil } {
-		panic('veb server was not initialized')
-	}
-	server.shutdown(timeout: 5 * time.second) or { panic(err) }
-}
-
 fn run_graceful_shutdown_app(mut app GracefulShutdownApp, port int) {
 	veb.run_at[GracefulShutdownApp, GracefulShutdownContext](mut app,
 		host:                 graceful_shutdown_host
@@ -58,6 +46,51 @@ fn send_slow_request(port int, responses chan http.Response) {
 	responses <- response
 }
 
+fn shutdown_graceful_server(server &veb.Server, done chan string) {
+	server.shutdown(timeout: 5 * time.second) or {
+		done <- err.msg()
+		return
+	}
+	done <- ''
+}
+
+fn wait_for_slow_request(started chan bool) ! {
+	select {
+		_ := <-started {
+			return
+		}
+		graceful_shutdown_wait_timeout {
+			return error('slow request did not start')
+		}
+	}
+}
+
+fn wait_for_slow_response(responses chan http.Response) !http.Response {
+	select {
+		response := <-responses {
+			return response
+		}
+		graceful_shutdown_wait_timeout {
+			return error('slow request did not finish')
+		}
+	}
+	return error('slow request did not finish')
+}
+
+fn wait_for_shutdown(done chan string) ! {
+	select {
+		shutdown_error := <-done {
+			if shutdown_error != '' {
+				return error(shutdown_error)
+			}
+			return
+		}
+		graceful_shutdown_wait_timeout {
+			return error('server shutdown did not finish')
+		}
+	}
+}
+
 fn wait_for_server(port int) ! {
 	url := 'http://${graceful_shutdown_host}:${port}/'
 	for _ in 0 .. 100 {
@@ -88,25 +121,30 @@ fn test_veb_graceful_shutdown_waits_for_in_flight_requests() {
 
 	slow_responses := chan http.Response{cap: 1}
 	spawn send_slow_request(int(port), slow_responses)
-	_ := <-app.slow_started or {
-		assert false, 'slow request did not start'
+	wait_for_slow_request(app.slow_started) or {
+		assert false, err.msg()
 		return
 	}
 
-	shutdown_response := http.get('http://${graceful_shutdown_host}:${port}/shutdown') or {
-		assert false, err.msg()
+	mut server := app.server
+	if server == unsafe { nil } {
+		assert false, 'veb server was not initialized'
 		return
 	}
-	assert shutdown_response.status() == .ok
-	assert shutdown_response.body == 'shutting down'
+	shutdown_done := chan string{cap: 1}
+	spawn shutdown_graceful_server(server, shutdown_done)
 
-	slow_response := <-slow_responses or {
+	slow_response := wait_for_slow_response(slow_responses) or {
 		assert false, err.msg()
 		return
 	}
 	assert slow_response.status() == .ok
 	assert slow_response.body == 'slow done'
 
+	wait_for_shutdown(shutdown_done) or {
+		assert false, err.msg()
+		return
+	}
 	server_thread.wait()
 
 	http.get('http://${graceful_shutdown_host}:${port}/') or {