diff --git a/ssl/test/bssl_shim.cc b/ssl/test/bssl_shim.cc
index ea9516b..89b4ba5 100644
--- a/ssl/test/bssl_shim.cc
+++ b/ssl/test/bssl_shim.cc
@@ -279,23 +279,23 @@
 // after a renegotiation, that authentication-related properties match |config|.
 static bool CheckAuthProperties(SSL *ssl, bool is_resume,
                                 const TestConfig *config) {
-  if (!config->expected_ocsp_response.empty()) {
+  if (!config->expect_ocsp_response.empty()) {
     const uint8_t *data;
     size_t len;
     SSL_get0_ocsp_response(ssl, &data, &len);
-    if (config->expected_ocsp_response.size() != len ||
-        OPENSSL_memcmp(config->expected_ocsp_response.data(), data, len) != 0) {
+    if (config->expect_ocsp_response.size() != len ||
+        OPENSSL_memcmp(config->expect_ocsp_response.data(), data, len) != 0) {
       fprintf(stderr, "OCSP response mismatch\n");
       return false;
     }
   }
 
-  if (!config->expected_signed_cert_timestamps.empty()) {
+  if (!config->expect_signed_cert_timestamps.empty()) {
     const uint8_t *data;
     size_t len;
     SSL_get0_signed_cert_timestamp_list(ssl, &data, &len);
-    if (config->expected_signed_cert_timestamps.size() != len ||
-        OPENSSL_memcmp(config->expected_signed_cert_timestamps.data(), data,
+    if (config->expect_signed_cert_timestamps.size() != len ||
+        OPENSSL_memcmp(config->expect_signed_cert_timestamps.data(), data,
                        len) != 0) {
       fprintf(stderr, "SCT list mismatch\n");
       return false;
@@ -492,23 +492,23 @@
     return false;
   }
 
-  if (!config->expected_server_name.empty()) {
+  if (!config->expect_server_name.empty()) {
     const char *server_name =
         SSL_get_servername(ssl, TLSEXT_NAMETYPE_host_name);
     if (server_name == nullptr ||
-        server_name != config->expected_server_name) {
+        server_name != config->expect_server_name) {
       fprintf(stderr, "servername mismatch (got %s; want %s)\n",
-              server_name, config->expected_server_name.c_str());
+              server_name, config->expect_server_name.c_str());
       return false;
     }
   }
 
-  if (!config->expected_next_proto.empty()) {
+  if (!config->expect_next_proto.empty()) {
     const uint8_t *next_proto;
     unsigned next_proto_len;
     SSL_get0_next_proto_negotiated(ssl, &next_proto, &next_proto_len);
-    if (next_proto_len != config->expected_next_proto.size() ||
-        OPENSSL_memcmp(next_proto, config->expected_next_proto.data(),
+    if (next_proto_len != config->expect_next_proto.size() ||
+        OPENSSL_memcmp(next_proto, config->expect_next_proto.data(),
                        next_proto_len) != 0) {
       fprintf(stderr, "negotiated next proto mismatch\n");
       return false;
@@ -519,48 +519,48 @@
     const uint8_t *alpn_proto;
     unsigned alpn_proto_len;
     SSL_get0_alpn_selected(ssl, &alpn_proto, &alpn_proto_len);
-    if (alpn_proto_len != config->expected_alpn.size() ||
-        OPENSSL_memcmp(alpn_proto, config->expected_alpn.data(),
+    if (alpn_proto_len != config->expect_alpn.size() ||
+        OPENSSL_memcmp(alpn_proto, config->expect_alpn.data(),
                        alpn_proto_len) != 0) {
       fprintf(stderr, "negotiated alpn proto mismatch\n");
       return false;
     }
   }
 
-  if (!config->expected_quic_transport_params.empty()) {
+  if (!config->expect_quic_transport_params.empty()) {
     const uint8_t *peer_params;
     size_t peer_params_len;
     SSL_get_peer_quic_transport_params(ssl, &peer_params, &peer_params_len);
-    if (peer_params_len != config->expected_quic_transport_params.size() ||
+    if (peer_params_len != config->expect_quic_transport_params.size() ||
         OPENSSL_memcmp(peer_params,
-                       config->expected_quic_transport_params.data(),
+                       config->expect_quic_transport_params.data(),
                        peer_params_len) != 0) {
       fprintf(stderr, "QUIC transport params mismatch\n");
       return false;
     }
   }
 
-  if (!config->expected_channel_id.empty()) {
+  if (!config->expect_channel_id.empty()) {
     uint8_t channel_id[64];
     if (!SSL_get_tls_channel_id(ssl, channel_id, sizeof(channel_id))) {
       fprintf(stderr, "no channel id negotiated\n");
       return false;
     }
-    if (config->expected_channel_id.size() != 64 ||
-        OPENSSL_memcmp(config->expected_channel_id.data(), channel_id, 64) !=
+    if (config->expect_channel_id.size() != 64 ||
+        OPENSSL_memcmp(config->expect_channel_id.data(), channel_id, 64) !=
             0) {
       fprintf(stderr, "channel id mismatch\n");
       return false;
     }
   }
 
-  if (config->expected_token_binding_param != -1) {
+  if (config->expect_token_binding_param != -1) {
     if (!SSL_is_token_binding_negotiated(ssl)) {
       fprintf(stderr, "no Token Binding negotiated\n");
       return false;
     }
     if (SSL_get_negotiated_token_binding_param(ssl) !=
-        static_cast<uint8_t>(config->expected_token_binding_param)) {
+        static_cast<uint8_t>(config->expect_token_binding_param)) {
       fprintf(stderr, "Token Binding param mismatch\n");
       return false;
     }
diff --git a/ssl/test/runner/runner.go b/ssl/test/runner/runner.go
index 12658c1..fee7c16 100644
--- a/ssl/test/runner/runner.go
+++ b/ssl/test/runner/runner.go
@@ -6669,7 +6669,7 @@
 			flags: []string{
 				"-token-binding-params",
 				base64.StdEncoding.EncodeToString([]byte{2, 1, 0}),
-				"-expected-token-binding-param",
+				"-expect-token-binding-param",
 				"2",
 			},
 		})
@@ -6718,7 +6718,7 @@
 			flags: []string{
 				"-token-binding-params",
 				base64.StdEncoding.EncodeToString([]byte{2, 1, 0}),
-				"-expected-token-binding-param",
+				"-expect-token-binding-param",
 				"2",
 			},
 		})
@@ -6754,7 +6754,7 @@
 			flags: []string{
 				"-token-binding-params",
 				base64.StdEncoding.EncodeToString([]byte{2, 1, 0}),
-				"-expected-token-binding-param",
+				"-expect-token-binding-param",
 				"2",
 			},
 		})
@@ -6772,7 +6772,7 @@
 			flags: []string{
 				"-token-binding-params",
 				base64.StdEncoding.EncodeToString([]byte{0, 1, 2}),
-				"-expected-token-binding-param",
+				"-expect-token-binding-param",
 				"2",
 			},
 		})
@@ -6803,7 +6803,7 @@
 			flags: []string{
 				"-token-binding-params",
 				base64.StdEncoding.EncodeToString([]byte{0, 1, 2}),
-				"-expected-token-binding-param",
+				"-expect-token-binding-param",
 				"2",
 			},
 			shouldFail:    true,
@@ -6823,7 +6823,7 @@
 			flags: []string{
 				"-token-binding-params",
 				base64.StdEncoding.EncodeToString([]byte{0, 1, 2}),
-				"-expected-token-binding-param",
+				"-expect-token-binding-param",
 				"2",
 			},
 			shouldFail:    true,
@@ -6843,7 +6843,7 @@
 			flags: []string{
 				"-token-binding-params",
 				base64.StdEncoding.EncodeToString([]byte{0, 1, 2}),
-				"-expected-token-binding-param",
+				"-expect-token-binding-param",
 				"2",
 			},
 			shouldFail:    true,
@@ -6879,7 +6879,7 @@
 			flags: []string{
 				"-token-binding-params",
 				base64.StdEncoding.EncodeToString([]byte{0, 1, 2}),
-				"-expected-token-binding-param",
+				"-expect-token-binding-param",
 				"2",
 			},
 		})
@@ -7044,7 +7044,7 @@
 				flags: []string{
 					"-quic-transport-params",
 					base64.StdEncoding.EncodeToString([]byte{3, 4}),
-					"-expected-quic-transport-params",
+					"-expect-quic-transport-params",
 					base64.StdEncoding.EncodeToString([]byte{1, 2}),
 				},
 				expectedQUICTransportParams: []byte{3, 4},
@@ -7061,7 +7061,7 @@
 				flags: []string{
 					"-quic-transport-params",
 					base64.StdEncoding.EncodeToString([]byte{3, 4}),
-					"-expected-quic-transport-params",
+					"-expect-quic-transport-params",
 					base64.StdEncoding.EncodeToString([]byte{1, 2}),
 				},
 				expectedQUICTransportParams: []byte{3, 4},
@@ -7105,7 +7105,7 @@
 					QUICTransportParams: []byte{1, 2},
 				},
 				flags: []string{
-					"-expected-quic-transport-params",
+					"-expect-quic-transport-params",
 					base64.StdEncoding.EncodeToString([]byte{1, 2}),
 				},
 				shouldFail:    true,
diff --git a/ssl/test/test_config.cc b/ssl/test/test_config.cc
index 5c035d3..7b4f2c4 100644
--- a/ssl/test/test_config.cc
+++ b/ssl/test/test_config.cc
@@ -154,16 +154,16 @@
     {"-write-settings", &TestConfig::write_settings},
     {"-key-file", &TestConfig::key_file},
     {"-cert-file", &TestConfig::cert_file},
-    {"-expect-server-name", &TestConfig::expected_server_name},
+    {"-expect-server-name", &TestConfig::expect_server_name},
     {"-advertise-npn", &TestConfig::advertise_npn},
-    {"-expect-next-proto", &TestConfig::expected_next_proto},
+    {"-expect-next-proto", &TestConfig::expect_next_proto},
     {"-select-next-proto", &TestConfig::select_next_proto},
     {"-send-channel-id", &TestConfig::send_channel_id},
     {"-host-name", &TestConfig::host_name},
     {"-advertise-alpn", &TestConfig::advertise_alpn},
-    {"-expect-alpn", &TestConfig::expected_alpn},
-    {"-expect-late-alpn", &TestConfig::expected_late_alpn},
-    {"-expect-advertised-alpn", &TestConfig::expected_advertised_alpn},
+    {"-expect-alpn", &TestConfig::expect_alpn},
+    {"-expect-late-alpn", &TestConfig::expect_late_alpn},
+    {"-expect-advertised-alpn", &TestConfig::expect_advertised_alpn},
     {"-select-alpn", &TestConfig::select_alpn},
     {"-psk", &TestConfig::psk},
     {"-psk-identity", &TestConfig::psk_identity},
@@ -173,7 +173,7 @@
     {"-export-context", &TestConfig::export_context},
     {"-expect-peer-cert-file", &TestConfig::expect_peer_cert_file},
     {"-use-client-ca-list", &TestConfig::use_client_ca_list},
-    {"-expect-client-ca-list", &TestConfig::expected_client_ca_list},
+    {"-expect-client-ca-list", &TestConfig::expect_client_ca_list},
     {"-expect-msg-callback", &TestConfig::expect_msg_callback},
     {"-handshaker-path", &TestConfig::handshaker_path},
     {"-delegated-credential", &TestConfig::delegated_credential},
@@ -181,25 +181,24 @@
 };
 
 const Flag<std::string> kBase64Flags[] = {
-    {"-expect-certificate-types", &TestConfig::expected_certificate_types},
-    {"-expect-channel-id", &TestConfig::expected_channel_id},
+    {"-expect-certificate-types", &TestConfig::expect_certificate_types},
+    {"-expect-channel-id", &TestConfig::expect_channel_id},
     {"-token-binding-params", &TestConfig::send_token_binding_params},
-    {"-expect-ocsp-response", &TestConfig::expected_ocsp_response},
+    {"-expect-ocsp-response", &TestConfig::expect_ocsp_response},
     {"-expect-signed-cert-timestamps",
-     &TestConfig::expected_signed_cert_timestamps},
+     &TestConfig::expect_signed_cert_timestamps},
     {"-ocsp-response", &TestConfig::ocsp_response},
     {"-signed-cert-timestamps", &TestConfig::signed_cert_timestamps},
     {"-ticket-key", &TestConfig::ticket_key},
     {"-quic-transport-params", &TestConfig::quic_transport_params},
-    {"-expected-quic-transport-params",
-     &TestConfig::expected_quic_transport_params},
+    {"-expect-quic-transport-params",
+     &TestConfig::expect_quic_transport_params},
 };
 
 const Flag<int> kIntFlags[] = {
     {"-port", &TestConfig::port},
     {"-resume-count", &TestConfig::resume_count},
-    {"-expected-token-binding-param",
-     &TestConfig::expected_token_binding_param},
+    {"-expect-token-binding-param", &TestConfig::expect_token_binding_param},
     {"-min-version", &TestConfig::min_version},
     {"-max-version", &TestConfig::max_version},
     {"-expect-version", &TestConfig::expect_version},
@@ -224,7 +223,7 @@
 const Flag<std::vector<int>> kIntVectorFlags[] = {
     {"-signing-prefs", &TestConfig::signing_prefs},
     {"-verify-prefs", &TestConfig::verify_prefs},
-    {"-expect-peer-verify-pref", &TestConfig::expected_peer_verify_prefs},
+    {"-expect-peer-verify-pref", &TestConfig::expect_peer_verify_prefs},
     {"-curves", &TestConfig::curves},
 };
 
@@ -402,9 +401,9 @@
   const TestConfig *config = GetTestConfig(ssl);
   const char *server_name = SSL_get_servername(ssl, TLSEXT_NAMETYPE_host_name);
   if (server_name == nullptr ||
-      std::string(server_name) != config->expected_server_name) {
+      std::string(server_name) != config->expect_server_name) {
     fprintf(stderr, "servername mismatch (got %s; want %s)\n", server_name,
-            config->expected_server_name.c_str());
+            config->expect_server_name.c_str());
     return SSL_TLSEXT_ERR_ALERT_FATAL;
   }
 
@@ -617,9 +616,9 @@
     return SSL_TLSEXT_ERR_NOACK;
   }
 
-  if (!config->expected_advertised_alpn.empty() &&
-      (config->expected_advertised_alpn.size() != inlen ||
-       OPENSSL_memcmp(config->expected_advertised_alpn.data(), in, inlen) !=
+  if (!config->expect_advertised_alpn.empty() &&
+      (config->expect_advertised_alpn.size() != inlen ||
+       OPENSSL_memcmp(config->expect_advertised_alpn.data(), in, inlen) !=
            0)) {
     fprintf(stderr, "bad ALPN select callback inputs\n");
     exit(1);
@@ -633,7 +632,7 @@
 
 static bool CheckVerifyCallback(SSL *ssl) {
   const TestConfig *config = GetTestConfig(ssl);
-  if (!config->expected_ocsp_response.empty()) {
+  if (!config->expect_ocsp_response.empty()) {
     const uint8_t *data;
     size_t len;
     SSL_get0_ocsp_response(ssl, &data, &len);
@@ -846,22 +845,22 @@
 
 static bool CheckPeerVerifyPrefs(SSL *ssl) {
   const TestConfig *config = GetTestConfig(ssl);
-  if (!config->expected_peer_verify_prefs.empty()) {
+  if (!config->expect_peer_verify_prefs.empty()) {
     const uint16_t *peer_sigalgs;
     size_t num_peer_sigalgs =
         SSL_get0_peer_verify_algorithms(ssl, &peer_sigalgs);
-    if (config->expected_peer_verify_prefs.size() != num_peer_sigalgs) {
+    if (config->expect_peer_verify_prefs.size() != num_peer_sigalgs) {
       fprintf(stderr,
               "peer verify preferences length mismatch (got %zu, wanted %zu)\n",
-              num_peer_sigalgs, config->expected_peer_verify_prefs.size());
+              num_peer_sigalgs, config->expect_peer_verify_prefs.size());
       return false;
     }
     for (size_t i = 0; i < num_peer_sigalgs; i++) {
       if (static_cast<int>(peer_sigalgs[i]) !=
-          config->expected_peer_verify_prefs[i]) {
+          config->expect_peer_verify_prefs[i]) {
         fprintf(stderr,
                 "peer verify preference %zu mismatch (got %04x, wanted %04x\n",
-                i, peer_sigalgs[i], config->expected_peer_verify_prefs[i]);
+                i, peer_sigalgs[i], config->expect_peer_verify_prefs[i]);
         return false;
       }
     }
@@ -876,22 +875,22 @@
     return false;
   }
 
-  if (!config->expected_certificate_types.empty()) {
+  if (!config->expect_certificate_types.empty()) {
     const uint8_t *certificate_types;
     size_t certificate_types_len =
         SSL_get0_certificate_types(ssl, &certificate_types);
-    if (certificate_types_len != config->expected_certificate_types.size() ||
+    if (certificate_types_len != config->expect_certificate_types.size() ||
         OPENSSL_memcmp(certificate_types,
-                       config->expected_certificate_types.data(),
+                       config->expect_certificate_types.data(),
                        certificate_types_len) != 0) {
       fprintf(stderr, "certificate types mismatch\n");
       return false;
     }
   }
 
-  if (!config->expected_client_ca_list.empty()) {
+  if (!config->expect_client_ca_list.empty()) {
     bssl::UniquePtr<STACK_OF(X509_NAME)> expected =
-        DecodeHexX509Names(config->expected_client_ca_list);
+        DecodeHexX509Names(config->expect_client_ca_list);
     const size_t num_expected = sk_X509_NAME_num(expected.get());
 
     const STACK_OF(X509_NAME) *received = SSL_get_client_CA_list(ssl);
@@ -1098,7 +1097,7 @@
   const TestConfig *config = GetTestConfig(client_hello->ssl);
   GetTestState(client_hello->ssl)->early_callback_called = true;
 
-  if (!config->expected_server_name.empty()) {
+  if (!config->expect_server_name.empty()) {
     const uint8_t *extension_data;
     size_t extension_len;
     CBS extension, server_name_list, host_name;
@@ -1123,8 +1122,8 @@
     }
 
     if (!CBS_mem_equal(&host_name,
-                       (const uint8_t *)config->expected_server_name.data(),
-                       config->expected_server_name.size())) {
+                       (const uint8_t *)config->expect_server_name.data(),
+                       config->expect_server_name.size())) {
       fprintf(stderr, "Server name mismatch.\n");
     }
   }
@@ -1239,7 +1238,7 @@
     SSL_CTX_set_grease_enabled(ssl_ctx.get(), 1);
   }
 
-  if (!expected_server_name.empty()) {
+  if (!expect_server_name.empty()) {
     SSL_CTX_set_tlsext_servername_callback(ssl_ctx.get(), ServerNameCallback);
   }
 
@@ -1519,7 +1518,7 @@
   if (no_ticket) {
     SSL_set_options(ssl.get(), SSL_OP_NO_TICKET);
   }
-  if (!expected_channel_id.empty() || enable_channel_id) {
+  if (!expect_channel_id.empty() || enable_channel_id) {
     SSL_set_tls_channel_id_enabled(ssl.get(), 1);
   }
   if (!send_channel_id.empty()) {
diff --git a/ssl/test/test_config.h b/ssl/test/test_config.h
index e0ea7a7..195ffc9 100644
--- a/ssl/test/test_config.h
+++ b/ssl/test/test_config.h
@@ -32,15 +32,15 @@
   bool fallback_scsv = false;
   std::vector<int> signing_prefs;
   std::vector<int> verify_prefs;
-  std::vector<int> expected_peer_verify_prefs;
+  std::vector<int> expect_peer_verify_prefs;
   std::vector<int> curves;
   std::string key_file;
   std::string cert_file;
-  std::string expected_server_name;
-  std::string expected_certificate_types;
+  std::string expect_server_name;
+  std::string expect_certificate_types;
   bool require_any_client_certificate = false;
   std::string advertise_npn;
-  std::string expected_next_proto;
+  std::string expect_next_proto;
   bool false_start = false;
   std::string select_next_proto;
   bool async = false;
@@ -52,31 +52,31 @@
   bool no_tls11 = false;
   bool no_tls1 = false;
   bool no_ticket = false;
-  std::string expected_channel_id;
+  std::string expect_channel_id;
   bool enable_channel_id = false;
   std::string send_channel_id;
-  int expected_token_binding_param = -1;
+  int expect_token_binding_param = -1;
   std::string send_token_binding_params;
   bool shim_writes_first = false;
   std::string host_name;
   std::string advertise_alpn;
-  std::string expected_alpn;
-  std::string expected_late_alpn;
-  std::string expected_advertised_alpn;
+  std::string expect_alpn;
+  std::string expect_late_alpn;
+  std::string expect_advertised_alpn;
   std::string select_alpn;
   bool decline_alpn = false;
   bool select_empty_alpn = false;
   std::string quic_transport_params;
-  std::string expected_quic_transport_params;
+  std::string expect_quic_transport_params;
   bool expect_session_miss = false;
   bool expect_extended_master_secret = false;
   std::string psk;
   std::string psk_identity;
   std::string srtp_profiles;
   bool enable_ocsp_stapling = false;
-  std::string expected_ocsp_response;
+  std::string expect_ocsp_response;
   bool enable_signed_cert_timestamps = false;
-  std::string expected_signed_cert_timestamps;
+  std::string expect_signed_cert_timestamps;
   int min_version = 0;
   int max_version = 0;
   int expect_version = 0;
@@ -127,7 +127,7 @@
   bool use_old_client_cert_callback = false;
   int initial_timeout_duration_ms = 0;
   std::string use_client_ca_list;
-  std::string expected_client_ca_list;
+  std::string expect_client_ca_list;
   bool send_alert = false;
   bool peek_then_read = false;
   bool enable_grease = false;